Add simulation apply workflow

Reduce websocket reconnect load
Add actuator simulation tuning
2026-06-18 20:10:53 +02:00 · 2026-06-18 19:17:50 +02:00 · 2026-06-18 19:06:47 +02:00 · 2026-06-18 11:53:53 +02:00 · 2026-06-18 07:48:46 +02:00 · 2026-06-18 01:02:29 +02:00
108 changed files with 16052 additions and 77 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,16 @@
+.env
+.env.*
+!.env.example
+.venv
+.venv/*
+__pycache__
+.mypy_cache
+.pytest_cache
+.ruff_cache
+node_modules
+.idea
+.vscode
+.git
+.gitignore
+.dockerignore
+docker-compose*.yml
--- a/.env.example
+++ b/.env.example
@@ -0,0 +1,15 @@
+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/.gitea/workflows/quality.yml
+++ b/.gitea/workflows/quality.yml
@@ -0,0 +1,24 @@
+name: quality
+
+on:
+  push:
+    branches: ["main", "otto/**", "feature/**"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - run: python -m pip install --upgrade pip
+      - run: python -m pip install -e ".[dev]"
+      - run: python -m pytest
+      - run: ruff check .
+      - run: mypy
--- a/.gitignore
+++ b/.gitignore
@@ -4,9 +4,12 @@
 /.vscode
 __pycache__/
 *.pyc
+*.egg-info/
 .mypy_cache/
 .pytest_cache/
 .ruff_cache/
 .env
 .env.local
 .env.*
+/.actuator_store/
+/MagicMock/
--- 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,5 +1,375 @@
 # Changelog

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

-Modern, lokal-first und datenschutzfreundliches Smart-Home-Intelligenzsystem für Home Assistant.
+SillyHome lernt aus Home Assistant, sagt Aktorhandlungen voraus und darf sie
+nach einer ausdrücklichen Freigabe ausführen.
+
+## Schnell orientieren
+
+- Fehler finden: [`docs/DEBUGGING.md`](docs/DEBUGGING.md)
+- Berechnung verstehen: [`docs/BEHAVIOR_ENGINE.md`](docs/BEHAVIOR_ENGINE.md)
+- Steuerung übernehmen/zurückgeben:
+  [`docs/CONTROL_HANDOFF.md`](docs/CONTROL_HANDOFF.md)
+- Entwickeln, testen, veröffentlichen und installieren:
+  [`docs/OPERATIONS.md`](docs/OPERATIONS.md)
+- Version 1.0.0 bedienen und prüfen:
+  [`docs/V1_0_0_OPERATING_GUIDE.md`](docs/V1_0_0_OPERATING_GUIDE.md)
+- Version 1.0.x Abnahme und offene Punkte:
+  [`docs/V1_0_ACCEPTANCE.md`](docs/V1_0_ACCEPTANCE.md)
+- Version 1.1.0 Safety, Transparenz und Job-Queue:
+  [`docs/V1_1_0_OPERATING_GUIDE.md`](docs/V1_1_0_OPERATING_GUIDE.md)
+- Version 1.2.0 adaptive Gewichtung, Rollback und Profile:
+  [`docs/V1_2_0_OPERATING_GUIDE.md`](docs/V1_2_0_OPERATING_GUIDE.md)
+- Version 1.3.0 Anomalie- und Performance-Überwachung:
+  [`docs/V1_3_0_OPERATING_GUIDE.md`](docs/V1_3_0_OPERATING_GUIDE.md)
+- Version 1.4.0 deutsches Dashboard und gestufter Datenabruf:
+  [`docs/V1_4_0_OPERATING_GUIDE.md`](docs/V1_4_0_OPERATING_GUIDE.md)
+- Version 1.5.0 Menü-Dashboard und kompakte Detaildaten:
+  [`docs/V1_5_0_OPERATING_GUIDE.md`](docs/V1_5_0_OPERATING_GUIDE.md)
+- Version 1.5.1 Stabilisierung der Dashboard-Ladepfade:
+  [`docs/V1_5_1_OPERATING_GUIDE.md`](docs/V1_5_1_OPERATING_GUIDE.md)
+- Version 1.5.2 Rollback-Speicher und HA-Timeouts:
+  [`docs/V1_5_2_OPERATING_GUIDE.md`](docs/V1_5_2_OPERATING_GUIDE.md)
+- Version 1.5.3 SQLite-Cache fuer Ingress-Dashboard:
+  [`docs/V1_5_3_OPERATING_GUIDE.md`](docs/V1_5_3_OPERATING_GUIDE.md)
+- Version 1.7.0 Diagnose, Backup, Dry-run und Planung:
+  [`docs/V1_7_0_OPERATING_GUIDE.md`](docs/V1_7_0_OPERATING_GUIDE.md)
+- Arbeitsregeln für Coding-Agenten: [`AGENTS.md`](AGENTS.md)
+
+## Reifegrad
+
+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.
@@ -9,6 +50,115 @@ 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
+
+## Quickstart
+1. Python-Venv anlegen und Abhängigkeiten installieren:
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+2. Konfiguration aus `.env.example` übernehmen und anpassen:
+```bash
+cp .env.example .env
+```
+
+3. API starten:
+```bash
+uvicorn app.main:app --reload
+```
+
+4. Erreichbar unter:
+- `http://127.0.0.1:8000/` - lokales Dashboard
+- `http://127.0.0.1:8000/health` - Health-Check
+- `http://127.0.0.1:8000/docs/` - OpenAPI-Dokumentation
+- `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
+
+Ohne vollständige HA-Konfiguration liefert `/v1/entities` bewusst `503`.
+
+### Docker Compose
+
+```bash
+cp .env.example .env
+docker compose up --build -d
+curl --fail http://127.0.0.1:8000/health
+```
+
+Compose veröffentlicht die API standardmäßig nur auf `127.0.0.1`. Für Zugriff aus
+dem Netz muss ein authentifizierender Reverse Proxy vorgeschaltet werden.
+
+### ENV-Konfiguration (`.env.example`)
+- `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_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.
+
+### Home-Assistant-Add-on
+
+Das Repository ist zugleich ein Home-Assistant-Add-on-Repository. In Home Assistant
+unter **Einstellungen → Add-ons → Add-on-Shop → Repositories** diese URL eintragen:
+
+`http://192.168.6.31:3000/pino/sillyhome-next`
+
+Danach **SillyHome Next** installieren und starten. Das Dashboard wird per Ingress
+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 app backend tests
+```
--- a/addon/Dockerfile
+++ b/addon/Dockerfile
@@ -0,0 +1,23 @@
+FROM python:3.13-slim
+
+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 /tmp/addon-config.yaml
+
+COPY run.sh /run.sh
+RUN chmod 0755 /run.sh
+
+EXPOSE 8000
+CMD ["/run.sh"]
--- a/addon/config.yaml
+++ b/addon/config.yaml
@@ -0,0 +1,22 @@
+name: SillyHome Next
+version: "1.7.3"
+slug: sillyhome_next
+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
+map:
+  - type: addon_config
+    read_only: false
--- a/addon/run.sh
+++ b/addon/run.sh
@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+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
+
+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
--- a/app/init.py
+++ b/app/init.py
@@ -0,0 +1 @@
+"""SillyHome Next application package."""
--- 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/cache_db.py
+++ b/app/actuators/cache_db.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from threading import RLock
+
+from app.ha.models import HaEntitySummary
+
+
+class DashboardCache:
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path).resolve()
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = RLock()
+        self._init()
+
+    def load_entities_payload(self) -> dict[str, object]:
+        with self._lock, self._connect() as connection:
+            rows = connection.execute(
+                "select entity_id, payload from ha_entities order by entity_id"
+            ).fetchall()
+            updated_at = self._get_meta(connection, "ha_entities_updated_at")
+            groups_json = self._get_meta(connection, "discovery_groups") or "[]"
+        try:
+            groups = json.loads(groups_json)
+        except ValueError:
+            groups = []
+        return {
+            "updated_at": updated_at,
+            "discovery_groups": groups if isinstance(groups, list) else [],
+            "entities": [json.loads(row[1]) for row in rows],
+        }
+
+    def load_status(self) -> dict[str, object]:
+        with self._lock, self._connect() as connection:
+            updated_at = self._get_meta(connection, "ha_entities_updated_at")
+            groups_json = self._get_meta(connection, "discovery_groups") or "[]"
+            entity_count = connection.execute("select count(*) from ha_entities").fetchone()[0]
+        try:
+            groups = json.loads(groups_json)
+        except ValueError:
+            groups = []
+        return {
+            "updated_at": updated_at,
+            "discovery_groups": groups if isinstance(groups, list) else [],
+            "entity_count": int(entity_count or 0),
+        }
+
+    def load_entity_map(self, entity_ids: set[str]) -> dict[str, HaEntitySummary]:
+        if not entity_ids:
+            return {}
+        placeholders = ",".join("?" for _ in entity_ids)
+        with self._lock, self._connect() as connection:
+            rows = connection.execute(
+                f"select entity_id, payload from ha_entities where entity_id in ({placeholders})",
+                tuple(sorted(entity_ids)),
+            ).fetchall()
+        result: dict[str, HaEntitySummary] = {}
+        for entity_id, payload in rows:
+            try:
+                result[str(entity_id)] = HaEntitySummary.model_validate(json.loads(payload))
+            except (TypeError, ValueError):
+                continue
+        return result
+
+    def save_entities_payload(
+        self,
+        *,
+        entities: list[HaEntitySummary],
+        discovery_groups: list[dict[str, object]],
+    ) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+        rows = [
+            (entity.entity_id, entity.model_dump_json())
+            for entity in entities
+        ]
+        with self._lock, self._connect() as connection:
+            connection.execute("delete from ha_entities")
+            connection.executemany(
+                "insert into ha_entities(entity_id, payload) values (?, ?)",
+                rows,
+            )
+            self._set_meta(connection, "ha_entities_updated_at", now)
+            self._set_meta(
+                connection,
+                "discovery_groups",
+                json.dumps(discovery_groups, ensure_ascii=True, sort_keys=True),
+            )
+
+    def _init(self) -> None:
+        with self._connect() as connection:
+            connection.execute(
+                """
+                create table if not exists ha_entities (
+                    entity_id text primary key,
+                    payload text not null
+                )
+                """
+            )
+            connection.execute(
+                """
+                create table if not exists cache_meta (
+                    key text primary key,
+                    value text
+                )
+                """
+            )
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(self._path, timeout=30)
+
+    @staticmethod
+    def _get_meta(connection: sqlite3.Connection, key: str) -> str | None:
+        row = connection.execute(
+            "select value from cache_meta where key = ?",
+            (key,),
+        ).fetchone()
+        return str(row[0]) if row is not None and row[0] is not None else None
+
+    @staticmethod
+    def _set_meta(connection: sqlite3.Connection, key: str, value: str) -> None:
+        connection.execute(
+            """
+            insert into cache_meta(key, value) values (?, ?)
+            on conflict(key) do update set value = excluded.value
+            """,
+            (key, value),
+        )
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
--- a/app/actuators/models.py
+++ b/app/actuators/models.py
@@ -0,0 +1,409 @@
+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 SafetyStage(StrEnum):
+    OBSERVE = "observe"
+    SUGGEST = "suggest"
+    SHADOW = "shadow"
+    PARTIAL = "partial"
+    ACTIVE = "active"
+
+
+class JobStatus(StrEnum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class FeedbackKind(StrEnum):
+    CORRECT = "correct"
+    WRONG = "wrong"
+    TOO_EARLY = "too_early"
+    TOO_LATE = "too_late"
+    NEVER_AUTOMATE = "never_automate"
+
+
+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 DecisionFactor(BaseModel):
+    entity_id: str | None = None
+    label: str
+    factor_type: str = Field(max_length=40)
+    state: str | None = None
+    weight: float = Field(default=1.0, ge=0.0, le=1.0)
+    contribution: float = Field(default=0.0, ge=0.0, le=1.0)
+    evidence: list[str] = Field(default_factory=list)
+
+
+class SimulationOutcome(BaseModel):
+    scenario_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    actuator_entity_id: str
+    sensor_states: dict[str, str] = Field(default_factory=dict)
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    prediction: BehaviorPrediction | None = None
+    decision_factors: list[DecisionFactor] = Field(default_factory=list)
+    would_execute: bool = False
+    blockers: list[str] = Field(default_factory=list)
+    score: float = Field(default=0.0, ge=0.0, le=1.0)
+    recommendation: str = Field(default="", max_length=700)
+
+
+class DecisionTrace(BaseModel):
+    trace_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    trigger_entity_id: str | None = None
+    trigger_state: str | None = None
+    target_state: str | None = None
+    confidence: float | None = Field(default=None, ge=0.0, le=1.0)
+    executed: bool = False
+    blocked: bool = False
+    reason: str = Field(default="", max_length=700)
+    blockers: list[str] = Field(default_factory=list)
+    duration_ms: int | None = Field(default=None, ge=0)
+
+
+class LatencyMeasurement(BaseModel):
+    measured_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    trigger_entity_id: str | None = None
+    event_to_decision_ms: int | None = Field(default=None, ge=0)
+    decision_to_service_ms: int | None = Field(default=None, ge=0)
+    event_to_done_ms: int | None = Field(default=None, ge=0)
+    executed: bool = False
+    source: str = Field(default="manual", max_length=40)
+
+
+class AdaptiveWeightUpdate(BaseModel):
+    entity_id: str
+    previous_weight: float = Field(ge=0.0, le=1.0)
+    new_weight: float = Field(ge=0.0, le=1.0)
+    reason: str = Field(max_length=300)
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class SafetyRule(BaseModel):
+    rule_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=160)
+    enabled: bool = True
+    blocking: bool = True
+    reason: str = Field(default="", max_length=300)
+
+
+def default_safety_rules() -> list[SafetyRule]:
+    return [
+        SafetyRule(
+            rule_id="activation_ready",
+            label="Nur nach Lernfreigabe aktiv schalten",
+            reason="Der Aktor muss genug eindeutiges Verhalten gelernt haben.",
+        ),
+        SafetyRule(
+            rule_id="confidence_threshold",
+            label="Mindest-Sicherheit einhalten",
+            reason="Vorhersagen unter der Schaltschwelle bleiben im Shadow-Modus.",
+        ),
+        SafetyRule(
+            rule_id="cooldown",
+            label="Sicherheits-Cooldown gegen Hin-und-her-Schalten",
+            reason="Gleiche Zielzustände werden nicht zu schnell wiederholt.",
+        ),
+        SafetyRule(
+            rule_id="manual_block",
+            label="Manuelle Sperre respektieren",
+            reason="Nutzer können jeden Aktor sofort blockieren.",
+        ),
+    ]
+
+
+class SafetyProfile(BaseModel):
+    stage: SafetyStage = SafetyStage.SHADOW
+    manual_block: bool = False
+    min_confidence: float = Field(default=0.82, ge=0.0, le=1.0)
+    min_confidence_on: float | None = Field(default=None, ge=0.0, le=1.0)
+    min_confidence_off: float | None = Field(default=None, ge=0.0, le=1.0)
+    cooldown_seconds: int | None = Field(default=None, ge=0)
+    rules: list[SafetyRule] = Field(default_factory=default_safety_rules)
+    updated_at: datetime | None = None
+    note: str | None = Field(default=None, max_length=500)
+
+
+class ExecutionEvent(BaseModel):
+    target_state: str
+    executed_at: datetime
+
+
+class ModelSnapshot(BaseModel):
+    version_id: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    sample_count: int = Field(default=0, ge=0)
+    high_confidence_sample_count: int = Field(default=0, ge=0)
+    average_confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+    incorrect_feedback_count: int = Field(default=0, ge=0)
+    patterns: list[BehaviorPattern] = Field(default_factory=list)
+    reason: str = Field(default="", max_length=500)
+
+
+class AutomationConflict(BaseModel):
+    automation_entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    severity: str = Field(default="info", max_length=20)
+    status: str = Field(default="open", max_length=40)
+    reason: str = Field(max_length=500)
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class AnomalyEvent(BaseModel):
+    anomaly_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    severity: str = Field(default="info", max_length=20)
+    category: str = Field(max_length=40)
+    title: str = Field(min_length=1, max_length=160)
+    detail: str = Field(min_length=1, max_length=500)
+    detected_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    resolved: bool = False
+
+
+class TimeProfile(BaseModel):
+    profile_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=80)
+    sample_count: int = Field(default=0, ge=0)
+    dominant_state: str | None = None
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+
+
+class RelatedAutomation(BaseModel):
+    entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    config_id: str = Field(min_length=1, max_length=120)
+    friendly_name: str = Field(min_length=1, max_length=200)
+    enabled: bool
+
+
+class ActuatorGroup(BaseModel):
+    group_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    name: str = Field(min_length=1, max_length=120)
+    area_name: str | None = Field(default=None, max_length=120)
+    member_entity_ids: list[str] = Field(default_factory=list)
+    reason: str = Field(default="", max_length=300)
+
+
+class SceneSuggestion(BaseModel):
+    scene_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=120)
+    member_entity_ids: list[str] = Field(default_factory=list)
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+    reason: str = Field(default="", max_length=500)
+    last_seen_at: datetime | None = None
+
+
+class AgentInsight(BaseModel):
+    insight_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    severity: str = Field(default="info", max_length=20)
+    title: str = Field(min_length=1, max_length=160)
+    detail: str = Field(min_length=1, max_length=700)
+    action: str | None = Field(default=None, max_length=300)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+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."
+    safety: SafetyProfile = Field(default_factory=SafetyProfile)
+    decision_factors: list[DecisionFactor] = Field(default_factory=list)
+    knowledge: list[str] = Field(default_factory=list)
+    assumptions: list[str] = Field(default_factory=list)
+    uncertainties: list[str] = Field(default_factory=list)
+    safety_blockers: list[str] = Field(default_factory=list)
+    sample_trend: list[int] = Field(default_factory=list)
+    confidence_trend: list[float] = Field(default_factory=list)
+    correct_feedback_count: int = Field(default=0, ge=0)
+    incorrect_feedback_count: int = Field(default=0, ge=0)
+    model_snapshots: list[ModelSnapshot] = Field(default_factory=list)
+    active_model_version: str | None = None
+    adaptive_weight_updates: list[AdaptiveWeightUpdate] = Field(default_factory=list)
+    automation_conflicts: list[AutomationConflict] = Field(default_factory=list)
+    time_profiles: list[TimeProfile] = Field(default_factory=list)
+    anomalies: list[AnomalyEvent] = Field(default_factory=list)
+    decision_timeline: list[DecisionTrace] = Field(default_factory=list)
+    latency_measurements: list[LatencyMeasurement] = Field(default_factory=list)
+    feedback_log: list[FeedbackKind] = Field(default_factory=list)
+    dry_run_enabled: bool = False
+    dry_run_started_at: datetime | None = None
+    dry_run_sample_count: int = Field(default=0, ge=0)
+    dry_run_hit_count: int = Field(default=0, ge=0)
+    actuator_groups: list[ActuatorGroup] = Field(default_factory=list)
+    scene_suggestions: list[SceneSuggestion] = Field(default_factory=list)
+    agent_insights: list[AgentInsight] = Field(default_factory=list)
+
+
+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."
+
+
+class JobQueueItem(BaseModel):
+    job_id: str = Field(min_length=1, max_length=120)
+    kind: str = Field(min_length=1, max_length=40)
+    target: str | None = Field(default=None, max_length=160)
+    trigger: str = Field(default="manual", max_length=40)
+    status: JobStatus = JobStatus.PENDING
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    duration_ms: int | None = Field(default=None, ge=0)
+    error: str | None = Field(default=None, max_length=500)
+    summary: str = Field(default="", max_length=500)
+
+
+class JobQueueState(BaseModel):
+    jobs: list[JobQueueItem] = Field(default_factory=list)
+
+
+def model_id_for_actuator(actuator_entity_id: str) -> str:
+    return f"actuator.{actuator_entity_id}"
--- a/app/actuators/store.py
+++ b/app/actuators/store.py
@@ -0,0 +1,202 @@
+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,
+    JobQueueItem,
+    JobQueueState,
+    JobStatus,
+    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"
+        self._job_queue_path = self._root / "job_queue.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 load_job_queue(self) -> JobQueueState:
+        with self._lock:
+            if not self._job_queue_path.exists():
+                return JobQueueState()
+            try:
+                return JobQueueState.model_validate_json(
+                    self._job_queue_path.read_text(encoding="utf-8")
+                )
+            except ValueError as exc:
+                raise ValueError("Ungültiger Job-Queue-Status.") from exc
+
+    def save_job_queue(self, queue: JobQueueState) -> JobQueueState:
+        with self._lock:
+            self._persist_job_queue(queue)
+            return queue
+
+    def start_job(
+        self,
+        *,
+        kind: str,
+        trigger: str,
+        target: str | None = None,
+        summary: str = "",
+    ) -> JobQueueItem:
+        now = datetime.now(timezone.utc)
+        job = JobQueueItem(
+            job_id=f"{now.strftime('%Y%m%d%H%M%S%f')}-{kind}-{target or 'all'}",
+            kind=kind,
+            target=target,
+            trigger=trigger,
+            status=JobStatus.RUNNING,
+            started_at=now,
+            summary=summary,
+        )
+        with self._lock:
+            queue = self.load_job_queue()
+            queue.jobs = [*queue.jobs, job][-50:]
+            self._persist_job_queue(queue)
+        return job
+
+    def finish_job(
+        self,
+        job_id: str,
+        *,
+        status: JobStatus,
+        summary: str = "",
+        error: str | None = None,
+    ) -> JobQueueItem | None:
+        now = datetime.now(timezone.utc)
+        with self._lock:
+            queue = self.load_job_queue()
+            updated_job: JobQueueItem | None = None
+            jobs: list[JobQueueItem] = []
+            for job in queue.jobs:
+                if job.job_id != job_id:
+                    jobs.append(job)
+                    continue
+                duration_ms = None
+                if job.started_at is not None:
+                    duration_ms = max(0, int((now - job.started_at).total_seconds() * 1000))
+                updated_job = job.model_copy(
+                    update={
+                        "status": status,
+                        "completed_at": now,
+                        "duration_ms": duration_ms,
+                        "summary": summary or job.summary,
+                        "error": error,
+                    }
+                )
+                jobs.append(updated_job)
+            queue.jobs = jobs[-50:]
+            self._persist_job_queue(queue)
+            return updated_job
+
+    def _target(self, actuator_entity_id: str) -> Path:
+        if "." not in actuator_entity_id:
+            raise ValueError("Ungültige actuator_entity_id.")
+        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)
+
+    def _persist_job_queue(self, state: JobQueueState) -> None:
+        temporary = self._job_queue_path.with_suffix(".json.tmp")
+        temporary.write_text(
+            json.dumps(state.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, self._job_queue_path)
+
+    @staticmethod
+    def _load(path: Path) -> ActuatorRecord:
+        try:
+            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/init.py
+++ b/app/api/init.py
@@ -0,0 +1 @@
+"""API package."""
--- a/app/api/v1/init.py
+++ b/app/api/v1/init.py
@@ -0,0 +1 @@
+"""Version 1 API package."""
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
--- a/app/api/v1/automations.py
+++ b/app/api/v1/automations.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request, Response, status
+
+from app.automations.models import (
+    AutomationProposal,
+    ProposalDecision,
+    ProposalStatus,
+)
+from app.automations.store import AutomationStore
+
+router = APIRouter(prefix="/v1/automations", tags=["automations"])
+
+
+@router.post("/proposals", response_model=AutomationProposal, status_code=201)
+def create_proposal(payload: AutomationProposal, request: Request) -> AutomationProposal:
+    if payload.trigger.above is None and payload.trigger.below is None:
+        raise HTTPException(status_code=422, detail="Trigger benötigt above oder below.")
+    return _store(request).create(payload.model_copy(update={"status": ProposalStatus.DRAFT}))
+
+
+@router.get("/proposals", response_model=list[AutomationProposal])
+def list_proposals(request: Request) -> list[AutomationProposal]:
+    return _store(request).list()
+
+
+@router.post("/proposals/{proposal_id}/approve", response_model=AutomationProposal)
+def approve(
+    proposal_id: str,
+    payload: ProposalDecision,
+    request: Request,
+) -> AutomationProposal:
+    return _decide(request, proposal_id, ProposalStatus.APPROVED, payload.expected_revision)
+
+
+@router.post("/proposals/{proposal_id}/reject", response_model=AutomationProposal)
+def reject(
+    proposal_id: str,
+    payload: ProposalDecision,
+    request: Request,
+) -> AutomationProposal:
+    return _decide(request, proposal_id, ProposalStatus.REJECTED, payload.expected_revision)
+
+
+@router.get("/proposals/{proposal_id}/yaml")
+def export_yaml(proposal_id: str, request: Request) -> Response:
+    try:
+        content = _store(request).export_yaml(proposal_id)
+    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
+    return Response(content=content, media_type="application/yaml")
+
+
+def _decide(
+    request: Request,
+    proposal_id: str,
+    decision: ProposalStatus,
+    expected_revision: int,
+) -> AutomationProposal:
+    try:
+        return _store(request).decide(proposal_id, decision, expected_revision)
+    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
+
+
+def _store(request: Request) -> AutomationStore:
+    store = getattr(request.app.state, "automation_store", None)
+    if not isinstance(store, AutomationStore):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Automation Store nicht initialisiert.",
+        )
+    return store
--- a/app/api/v1/entities.py
+++ b/app/api/v1/entities.py
@@ -1,10 +1,15 @@
 from __future__ import annotations

-from typing import List, Sequence
+from datetime import datetime
+from typing import List

-from fastapi import APIRouter
+from fastapi import APIRouter, Depends, HTTPException, Query, status

+from app.dependencies import get_ha_reader
+from app.ha.discovery import DiscoveredEntity
+from app.ha.history import EntityHistorySeries
 from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader

 router = APIRouter(prefix="/v1", tags=["entities"])

@@ -15,5 +20,45 @@ router = APIRouter(prefix="/v1", tags=["entities"])
    description="Gibt eine kompakte Zusammenfassung aller erreichbaren HA-Entitäten zurück.",
    response_model=List[HaEntitySummary],
 )
-def list_entities() -> Sequence[HaEntitySummary]:
-    raise NotImplementedError("Integration mit dem HA-Client folgt in separatem Issue.")
+def list_entities(ha_reader: HaReader = Depends(get_ha_reader)) -> List[HaEntitySummary]:
+    return list(ha_reader.read_entities())
+
+
+@router.get(
+    "/discovery",
+    summary="Home-Assistant-Entities klassifizieren",
+    description="Klassifiziert Entities nach Lernrelevanz, Kontextquelle und Aktor-Rolle.",
+    response_model=List[DiscoveredEntity],
+)
+def discovery(
+    domain: List[str] | None = Query(default=None),
+    learnable: bool | None = None,
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> List[DiscoveredEntity]:
+    return list(
+        ha_reader.discover(
+            domains=set(domain) if domain else None,
+            learnable=learnable,
+        )
+    )
+
+
+@router.get(
+    "/history",
+    summary="Numerische Home-Assistant-Historie lesen",
+    description="Lädt und normalisiert numerische Zustände ausgewählter Entities.",
+    response_model=List[EntityHistorySeries],
+)
+def history(
+    entity_id: List[str] = Query(),
+    start_time: datetime = Query(),
+    end_time: datetime = Query(),
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> List[EntityHistorySeries]:
+    try:
+        return list(ha_reader.read_history(entity_id, start_time, end_time))
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=str(exc),
+        ) from exc
--- a/app/automations/init.py
+++ b/app/automations/init.py
@@ -0,0 +1,3 @@
+from app.automations.store import AutomationStore
+
+__all__ = ["AutomationStore"]
--- a/app/automations/models.py
+++ b/app/automations/models.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from enum import StrEnum
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+class ProposalStatus(StrEnum):
+    DRAFT = "draft"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+
+
+class NumericStateTrigger(BaseModel):
+    entity_id: str = Field(pattern=r"^sensor\.[a-z0-9_]+$")
+    above: float | None = None
+    below: float | None = None
+
+
+class ServiceAction(BaseModel):
+    service: str = Field(pattern=r"^(light|switch|climate|fan|cover)\.[a-z0-9_]+$")
+    entity_id: str = Field(pattern=r"^(light|switch|climate|fan|cover)\.[a-z0-9_]+$")
+    data: dict[str, str | int | float | bool] = Field(default_factory=dict)
+
+
+class AutomationProposal(BaseModel):
+    proposal_id: str = Field(default_factory=lambda: uuid4().hex)
+    alias: str = Field(min_length=1, max_length=120)
+    description: str = Field(min_length=1, max_length=500)
+    trigger: NumericStateTrigger
+    action: ServiceAction
+    status: ProposalStatus = ProposalStatus.DRAFT
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    revision: int = 1
+
+
+class ProposalDecision(BaseModel):
+    expected_revision: int = Field(ge=1)
--- a/app/automations/store.py
+++ b/app/automations/store.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from threading import RLock
+
+from app.automations.models import AutomationProposal, ProposalStatus
+
+
+class AutomationStore:
+    def __init__(self, root: str | Path) -> None:
+        self._root = Path(root).resolve()
+        self._root.mkdir(parents=True, exist_ok=True)
+        self._lock = RLock()
+
+    def create(self, proposal: AutomationProposal) -> AutomationProposal:
+        with self._lock:
+            target = self._target(proposal.proposal_id)
+            if target.exists():
+                raise ValueError("Automation-Vorschlag existiert bereits.")
+            self._persist(proposal)
+        return proposal
+
+    def list(self) -> list[AutomationProposal]:
+        with self._lock:
+            return [self._load(path) for path in sorted(self._root.glob("*.json"))]
+
+    def get(self, proposal_id: str) -> AutomationProposal:
+        with self._lock:
+            target = self._target(proposal_id)
+            if not target.exists():
+                raise KeyError("Automation-Vorschlag nicht gefunden.")
+            return self._load(target)
+
+    def decide(
+        self,
+        proposal_id: str,
+        status: ProposalStatus,
+        expected_revision: int,
+    ) -> AutomationProposal:
+        if status is ProposalStatus.DRAFT:
+            raise ValueError("Entscheidung darf nicht auf draft gesetzt werden.")
+        with self._lock:
+            proposal = self.get(proposal_id)
+            if proposal.revision != expected_revision:
+                raise ValueError("Revision stimmt nicht mit dem aktuellen Vorschlag überein.")
+            if proposal.status is not ProposalStatus.DRAFT:
+                raise ValueError("Über den Vorschlag wurde bereits entschieden.")
+            updated = proposal.model_copy(
+                update={
+                    "status": status,
+                    "updated_at": datetime.now(timezone.utc),
+                    "revision": proposal.revision + 1,
+                }
+            )
+            self._persist(updated)
+            return updated
+
+    def export_yaml(self, proposal_id: str) -> str:
+        proposal = self.get(proposal_id)
+        if proposal.status is not ProposalStatus.APPROVED:
+            raise ValueError("Nur freigegebene Vorschläge dürfen exportiert werden.")
+        trigger_lines = [
+            "trigger:",
+            "  - platform: numeric_state",
+            f"    entity_id: {proposal.trigger.entity_id}",
+        ]
+        if proposal.trigger.above is not None:
+            trigger_lines.append(f"    above: {proposal.trigger.above}")
+        if proposal.trigger.below is not None:
+            trigger_lines.append(f"    below: {proposal.trigger.below}")
+        action_lines = [
+            "action:",
+            f"  - service: {proposal.action.service}",
+            "    target:",
+            f"      entity_id: {proposal.action.entity_id}",
+        ]
+        if proposal.action.data:
+            action_lines.append("    data:")
+            action_lines.extend(
+                f"      {key}: {_yaml_scalar(value)}"
+                for key, value in sorted(proposal.action.data.items())
+            )
+        return "\n".join(
+            [
+                f"alias: {_yaml_scalar(proposal.alias)}",
+                f"description: {_yaml_scalar(proposal.description)}",
+                *trigger_lines,
+                *action_lines,
+                "mode: single",
+                "",
+            ]
+        )
+
+    def _target(self, proposal_id: str) -> Path:
+        if len(proposal_id) != 32 or not proposal_id.isalnum():
+            raise ValueError("Ungültige proposal_id.")
+        return self._root / f"{proposal_id}.json"
+
+    def _persist(self, proposal: AutomationProposal) -> None:
+        target = self._target(proposal.proposal_id)
+        temporary = target.with_suffix(".json.tmp")
+        temporary.write_text(
+            json.dumps(proposal.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, target)
+
+    @staticmethod
+    def _load(path: Path) -> AutomationProposal:
+        try:
+            return AutomationProposal.model_validate_json(path.read_text(encoding="utf-8"))
+        except ValueError as exc:
+            raise ValueError(f"Ungültiger Automation-Vorschlag: {path.name}") from exc
+
+
+def _yaml_scalar(value: str | int | float | bool) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    return json.dumps(value, ensure_ascii=True)
--- 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
--- a/app/config.py
+++ b/app/config.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Settings:
+    ha_url: str | None = None
+    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"
+    ha_timeout_seconds: int = 25
+    dashboard_cache_refresh_seconds: int = 3600
+
+    @property
+    def ha_configured(self) -> bool:
+        return bool(self.ha_url and self.ha_token)
+
+
+def load_settings() -> Settings:
+    return Settings(
+        ha_url=os.getenv("SILLYHOME_HA_URL") or os.getenv("HA_URL"),
+        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"),
+        ha_timeout_seconds=max(5, int(os.getenv("SILLYHOME_HA_TIMEOUT_SECONDS", "25"))),
+        dashboard_cache_refresh_seconds=max(
+            300, int(os.getenv("SILLYHOME_DASHBOARD_CACHE_REFRESH_SECONDS", "3600"))
+        ),
+    )
--- a/app/core/init.py
+++ b/app/core/init.py
@@ -0,0 +1 @@
+"""Core application helpers."""
--- a/app/core/exception_handlers.py
+++ b/app/core/exception_handlers.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from app.ha.exceptions import HaAuthError, HaClientError, HaHttpError, HaTimeoutError
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(HaClientError)
+    async def handle_ha_client_error(_: Request, exc: HaClientError) -> JSONResponse:
+        return JSONResponse(
+            status_code=_status_code_for_ha_error(exc),
+            content={"detail": exc.public_detail},
+        )
+
+
+def _status_code_for_ha_error(exc: HaClientError) -> int:
+    if isinstance(exc, HaTimeoutError):
+        return status.HTTP_504_GATEWAY_TIMEOUT
+    if isinstance(exc, (HaAuthError, HaHttpError)):
+        return status.HTTP_502_BAD_GATEWAY
+    return status.HTTP_502_BAD_GATEWAY
--- a/app/core/exceptions.py
+++ b/app/core/exceptions.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI, Request
+
+from app.ha.exceptions import HaAuthError, HaClientError, HaHttpError
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(HaClientError)
+    async def handle_ha_client_error(request: Request, exc: HaClientError) -> Any:  # pragma: no cover - einfacher Wrapper
+        if isinstance(exc, HaAuthError):
+            return {"detail": "Ungültige Authentifizierung gegenüber Home Assistant."}
+        if isinstance(exc, HaHttpError):
+            return {
+                "detail": "Home Assistant meldet einen Fehler.",
+                "upstream_status": exc.status_code,
+            }
+        return {"detail": str(exc)}
--- a/app/dependencies.py
+++ b/app/dependencies.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from fastapi import HTTPException, Request, status
+
+from app.ha.reader import HaReader
+
+
+def get_ha_reader(request: Request) -> HaReader:
+    reader = getattr(request.app.state, "ha_reader", None)
+    if not isinstance(reader, HaReader):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Home Assistant is not configured.",
+        )
+    return reader
--- a/app/ha/client.py
+++ b/app/ha/client.py
@@ -2,11 +2,28 @@ 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

+from app.ha.exceptions import (
+    HaAuthError,
+    HaHttpError,
+    HaTimeoutError,
+    HaUnexpectedPayloadError,
+)
+
 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)
 class HaClientSettings:
@@ -24,10 +41,281 @@ class HaClient:
            "Content-Type": "application/json",
        })

+    def close(self) -> None:
+        self._session.close()
+
    def list_entities(self) -> list[dict[str, object]]:
-        response = self._session.get(
-            f"{self._settings.url}/api/states",
-            timeout=self._settings.timeout_seconds,
+        payload = self._get_json("/api/states")
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant hat unerwartetes Format."
+            )
+        return payload
+
+    def get_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[object]:
+        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.")
+
+        start = quote(start_time.isoformat(), safe=":+")
+        payload = self._get_json(
+            f"/api/history/period/{start}",
+            params={
+                "filter_entity_id": ",".join(entity_ids),
+                "end_time": end_time.isoformat(),
+                "minimal_response": "1",
+                "no_attributes": "1",
+            },
        )
-        response.raise_for_status()
-        return response.json()
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "History-Antwort von Home Assistant hat unerwartetes Format."
+            )
+        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,
+        *,
+        params: dict[str, str] | None = None,
+    ) -> object:
+        try:
+            response = self._session.get(
+                f"{self._settings.url.rstrip('/')}{path}",
+                params=params,
+                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:
+            payload = response.json()
+        except ValueError as exc:
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant ist kein gültiges JSON."
+            ) 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
@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+from app.ha.models import HaEntitySummary
+
+
+class EntityRole(StrEnum):
+    MEASUREMENT = "measurement"
+    BINARY_CONTEXT = "binary_context"
+    CONTEXT = "context"
+    ACTUATOR = "actuator"
+    UNSUPPORTED = "unsupported"
+
+
+class DiscoveredEntity(BaseModel):
+    entity_id: str
+    domain: str
+    device_class: str | None = None
+    state_class: str | None = None
+    unit_of_measurement: str | None = None
+    category: str
+    role: EntityRole
+    learnable: bool
+    reason: str
+
+
+_MEASUREMENT_CLASSES = frozenset({
+    "apparent_power",
+    "atmospheric_pressure",
+    "battery",
+    "carbon_dioxide",
+    "carbon_monoxide",
+    "current",
+    "distance",
+    "duration",
+    "energy",
+    "frequency",
+    "gas",
+    "humidity",
+    "illuminance",
+    "moisture",
+    "monetary",
+    "nitrogen_dioxide",
+    "nitrogen_monoxide",
+    "nitrous_oxide",
+    "ozone",
+    "pm1",
+    "pm10",
+    "pm25",
+    "power",
+    "precipitation",
+    "pressure",
+    "reactive_power",
+    "signal_strength",
+    "sound_pressure",
+    "speed",
+    "sulphur_dioxide",
+    "temperature",
+    "volatile_organic_compounds",
+    "voltage",
+    "volume",
+    "volume_flow_rate",
+    "water",
+    "weight",
+    "wind_speed",
+})
+_BINARY_CONTEXT_CLASSES = frozenset({
+    "door",
+    "garage_door",
+    "lock",
+    "motion",
+    "occupancy",
+    "opening",
+    "presence",
+    "problem",
+    "safety",
+    "smoke",
+    "sound",
+    "vibration",
+    "window",
+})
+_ACTUATOR_DOMAINS = frozenset({
+    "button",
+    "climate",
+    "cover",
+    "fan",
+    "humidifier",
+    "input_boolean",
+    "input_button",
+    "lock",
+    "light",
+    "media_player",
+    "number",
+    "remote",
+    "scene",
+    "siren",
+    "switch",
+    "valve",
+})
+_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"})
+
+
+def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
+    if entity.domain == "sensor" and (
+        entity.state_class in _NUMERIC_STATE_CLASSES
+        or entity.device_class in _MEASUREMENT_CLASSES
+        or entity.unit_of_measurement is not None
+    ):
+        return _result(
+            entity,
+            EntityRole.MEASUREMENT,
+            category=_measurement_category(entity),
+            learnable=True,
+            reason="Numerischer Messsensor für Zeitreihen und Training.",
+        )
+
+    if entity.domain == "binary_sensor" and entity.device_class in _BINARY_CONTEXT_CLASSES:
+        return _result(
+            entity,
+            EntityRole.BINARY_CONTEXT,
+            category=_binary_category(entity),
+            learnable=True,
+            reason="Binärer Kontextsensor für Zustands- und Anwesenheitsmuster.",
+        )
+
+    if entity.domain in _CONTEXT_DOMAINS:
+        learnable = entity.domain in _LEARNABLE_CONTEXT_DOMAINS
+        return _result(
+            entity,
+            EntityRole.CONTEXT,
+            category=_context_category(entity),
+            learnable=learnable,
+            reason=(
+                "Kontextquelle für Training und Erklärungen."
+                if learnable
+                else "Kontextquelle ohne direkte Trainingsfreigabe."
+            ),
+        )
+
+    if entity.domain in _ACTUATOR_DOMAINS:
+        return _result(
+            entity,
+            EntityRole.ACTUATOR,
+            category=_actuator_category(entity),
+            learnable=False,
+            reason="Aktor ist ein mögliches Automationsziel, aber kein Trainingssensor.",
+        )
+
+    return _result(
+        entity,
+        EntityRole.UNSUPPORTED,
+        category="unsupported",
+        learnable=False,
+        reason="Entity-Typ ist noch nicht für Lernen oder Automationen klassifiziert.",
+    )
+
+
+def discover_entities(
+    entities: list[HaEntitySummary],
+    domains: set[str] | None = None,
+    learnable: bool | None = None,
+) -> list[DiscoveredEntity]:
+    normalized_domains = {domain.strip().lower() for domain in domains or set() if domain.strip()}
+    discovered = [classify_entity(entity) for entity in entities]
+    return [
+        entity
+        for entity in discovered
+        if (not normalized_domains or entity.domain in normalized_domains)
+        and (learnable is None or entity.learnable is learnable)
+    ]
+
+
+def _result(
+    entity: HaEntitySummary,
+    role: EntityRole,
+    *,
+    category: str,
+    learnable: bool,
+    reason: str,
+) -> DiscoveredEntity:
+    return DiscoveredEntity(
+        entity_id=entity.entity_id,
+        domain=entity.domain,
+        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/exceptions.py
+++ b/app/ha/exceptions.py
@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+
+class HaClientError(Exception):
+    """Basisklasse für HA-Client-Fehler."""
+
+    public_detail: str | None = None
+
+
+class HaTimeoutError(HaClientError):
+    """Zeitüberschreitung bei Request an Home Assistant."""
+
+    public_detail = "Home Assistant request timed out."
+
+
+class HaHttpError(HaClientError):
+    """Nicht erfolgreicher HTTP-Statuscode."""
+
+    public_detail = "Home Assistant request failed."
+
+    def __init__(self, status_code: int, message: str = "") -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class HaAuthError(HaHttpError):
+    """Authentifizierung oder Berechtigung fehlgeschlagen."""
+
+    public_detail = "Home Assistant authentication failed."
+
+
+class HaUnexpectedPayloadError(HaClientError):
+    """Antwort hat nicht das erwartete Format."""
+
+    public_detail = "Home Assistant returned an unexpected payload."
--- a/app/ha/history.py
+++ b/app/ha/history.py
@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import math
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from app.ha.exceptions import HaUnexpectedPayloadError
+
+
+class NumericHistoryPoint(BaseModel):
+    timestamp: datetime
+    value: float
+
+
+class EntityHistorySeries(BaseModel):
+    entity_id: str
+    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.")
+
+    normalized: list[EntityHistorySeries] = []
+    for raw_series in payload:
+        if not isinstance(raw_series, list):
+            raise HaUnexpectedPayloadError("History-Serie muss eine Liste sein.")
+        series = _normalize_series(raw_series)
+        if series is not None:
+            normalized.append(series)
+
+    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] = []
+
+    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")
+        value = _finite_float(raw_state)
+        if value is None:
+            continue
+        if entity_id is None:
+            raise HaUnexpectedPayloadError("History-Serie enthält keine entity_id.")
+
+        raw_timestamp = raw_entry.get("last_changed") or raw_entry.get("last_updated")
+        timestamp = _parse_timestamp(raw_timestamp)
+        points.append(NumericHistoryPoint(timestamp=timestamp, value=value))
+
+    if entity_id is None or not points:
+        return None
+
+    points.sort(key=lambda point: point.timestamp)
+    return EntityHistorySeries(entity_id=entity_id, points=points)
+
+
+def _finite_float(value: object) -> float | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    if not isinstance(value, (str, int, float)):
+        return None
+    try:
+        converted = float(value)
+    except (TypeError, ValueError):
+        return None
+    return converted if math.isfinite(converted) else None
+
+
+def _parse_timestamp(value: object) -> datetime:
+    if not isinstance(value, str):
+        raise HaUnexpectedPayloadError("Numerischer History-Eintrag enthält keinen Zeitstempel.")
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise HaUnexpectedPayloadError("History-Eintrag enthält ungültigen Zeitstempel.") from exc
+    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,31 +1,231 @@
 from __future__ import annotations

 from collections.abc import Sequence
+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.models import HaEntitySummary, HaState
+from app.ha.discovery import DiscoveredEntity, discover_entities
+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:
-            entity_id = item.get("entity_id", "")
-            if "." not in entity_id:
+            raw_entity_id = item.get("entity_id")
+            if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
                continue
+            entity_id = raw_entity_id
            domain = entity_id.split(".", 1)[0]
-            attributes = item.get("attributes") or {}
+            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_class=str(attributes.get("state_class") or ""),
-                    device_class=str(attributes.get("device_class") or ""),
-                    unit_of_measurement=str(attributes.get("unit_of_measurement") or ""),
+                    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
+
+    def discover(
+        self,
+        domains: set[str] | None = None,
+        learnable: bool | None = None,
+    ) -> Sequence[DiscoveredEntity]:
+        return discover_entities(list(self.read_entities()), domains=domains, learnable=learnable)
+
+    def read_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[EntityHistorySeries]:
+        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,51 +1,463 @@
-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

-from fastapi import FastAPI, Depends
+import websockets
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles

+from app.actuators.cache_db import DashboardCache
+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.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.discovery import discover_entities
+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):
-    settings = HaClientSettings(
-        url=app.state.settings.ha_url,
-        token=app.state.settings.ha_token,
+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
+    cache_refresh_task: asyncio.Task[None] | None = None
+    app.state.registry = ModelRegistry(settings.model_store)
+    app.state.actuator_store = ActuatorStore(settings.actuator_store)
+    app.state.dashboard_cache = DashboardCache(
+        Path(settings.actuator_store).resolve() / "dashboard_cache.sqlite3"
    )
-    client = HaClient(settings=settings)
-    app.state.ha_reader = HaReader(client=client)
-    yield
+    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(
+                url=cast(str, settings.ha_url),
+                token=cast(str, settings.ha_token),
+                timeout_seconds=settings.ha_timeout_seconds,
+            )
+        )
+        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))
+        cache_refresh_task = asyncio.create_task(_periodic_dashboard_cache_refresh(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 cache_refresh_task is not None:
+            cache_refresh_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await cache_refresh_task
+        if client is not None:
+            client.close()


 app = FastAPI(
    title="SillyHome Next API",
    description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.1.0",
+    version="1.7.3",
    lifespan=lifespan,
 )
+app.state.settings = load_settings()
+register_exception_handlers(app)
+app.include_router(entities_router)
+app.include_router(actuators_router)
+init_ml_routes(app, model_store=app.state.settings.model_store)

-
-class Settings:
-    ha_url: str
-    ha_token: str
-
-
-app.state.settings = Settings()
-
-
-def get_ha_reader() -> HaReader:
-    return app.state.ha_reader
-
-
-app.include_router(entities_router, dependencies=[Depends(get_ha_reader)])
+STATIC_DIR = Path(__file__).with_name("static")
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")


@app.get("/health")
 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() -> dict[str, str]:
-    return {"service": "sillyhome-next", "docs": "/docs"}
+def root() -> FileResponse:
+    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 _periodic_dashboard_cache_refresh(app: FastAPI) -> None:
+    await asyncio.sleep(2)
+    while True:
+        await _refresh_dashboard_cache(app, trigger="scheduled")
+        await asyncio.sleep(app.state.settings.dashboard_cache_refresh_seconds)
+
+
+async def _refresh_dashboard_cache(app: FastAPI, *, trigger: str) -> None:
+    ha_reader = getattr(app.state, "ha_reader", None)
+    cache = getattr(app.state, "dashboard_cache", None)
+    if not isinstance(ha_reader, HaReader) or not isinstance(cache, DashboardCache):
+        return
+    try:
+        entities = await asyncio.to_thread(ha_reader.read_entities)
+        groups = _discovery_group_payload(list(entities))
+        await asyncio.to_thread(
+            cache.save_entities_payload,
+            entities=list(entities),
+            discovery_groups=groups,
+        )
+        logger.info("Dashboard-Cache aktualisiert (%s): %d Entities", trigger, len(entities))
+    except Exception as exc:
+        logger.warning("Dashboard-Cache konnte nicht aktualisiert werden (%s): %s", trigger, exc)
+
+
+def _discovery_group_payload(entities: list[HaEntitySummary]) -> list[dict[str, object]]:
+    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
+    return [
+        {"category": category, "role": role, "count": count}
+        for (category, role), count in sorted(group_counts.items())
+    ]
+
+
+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)
+    reconnect_delay = 1.0
+    relevant_entity_ids: set[str] = set()
+    relevant_loaded_at = 0.0
+    while True:
+        if ws_status is not None:
+            ws_status.status = "connecting"
+        try:
+            async with websockets.connect(ws_url, ping_interval=None) 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)
+                relevant_entity_ids = await asyncio.to_thread(_relevant_entity_ids, store)
+                relevant_loaded_at = asyncio.get_running_loop().time()
+                reconnect_delay = 1.0
+                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
+                        loop_time = asyncio.get_running_loop().time()
+                        if loop_time - relevant_loaded_at >= 10:
+                            relevant_entity_ids = await asyncio.to_thread(_relevant_entity_ids, store)
+                            relevant_loaded_at = loop_time
+                        if entity_id not in relevant_entity_ids:
+                            continue
+                        new_state = event_data.get("new_state")
+                        _update_ha_state_cache(state_cache, entity_id, new_state)
+                        # 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:
+            delay = reconnect_delay
+            logger.warning(
+                "WebSocket-Verbindung unterbrochen: %s. Wiederholung in %.0fs...",
+                exc,
+                delay,
+            )
+            if ws_status is not None:
+                ws_status.status = "reconnecting"
+                ws_status.error = str(exc)
+            await asyncio.sleep(delay)
+            reconnect_delay = min(reconnect_delay * 2, 60.0)
+        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(reconnect_delay)
+            reconnect_delay = min(reconnect_delay * 2, 60.0)
+
+
+# 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 max(30, 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 _relevant_entity_ids(store: ActuatorStore) -> set[str]:
+    result: set[str] = set()
+    for record in store.list():
+        result.add(record.actuator_entity_id)
+        if record.assignment.selected_numeric_entity_id:
+            result.add(record.assignment.selected_numeric_entity_id)
+        result.update(record.assignment.selected_context_entity_ids)
+    return result
+
+
+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/init.py
+++ b/app/ml/init.py
@@ -0,0 +1,20 @@
+
+"""Machine-Learning-Grundbausteine für SillyHome Next."""
+__all__ = [
+    "FeatureStore",
+    "FeatureVector",
+    "FeatureModel",
+    "FeatureExplanation",
+    "PredictionResult",
+    "Predictor",
+    "RetrainingResult",
+    "RetrainingService",
+    "TrainedArtifact",
+    "TrainingPipeline",
+    "retrain_model",
+]
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.explanation import FeatureExplanation
+from app.ml.predictor import PredictionResult, Predictor
+from app.ml.retraining import RetrainingResult, RetrainingService, retrain_model
+from app.ml.training import FeatureModel, TrainedArtifact, TrainingPipeline
--- a/app/ml/evaluation.py
+++ b/app/ml/evaluation.py
@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import logging
+import math
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from app.ml.feature_store import FeatureVector
+from app.ml.predictor import Predictor
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.training import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Metric:
+    name: str
+    value: float
+    threshold: float | None = None
+
+
+@dataclass
+class EvalReport:
+    artifact_id: str
+    sample_size: int
+    metrics: list[Metric]
+
+
+class Evaluator:
+    def __init__(
+        self,
+        pipeline: TrainingPipeline | None = None,
+        registry: ModelRegistry | None = None,
+    ) -> None:
+        if isinstance(pipeline, ModelRegistry) and registry is None:
+            registry = pipeline
+            pipeline = None
+        if pipeline is None and registry is None:
+            raise ValueError("Evaluator erfordert TrainingPipeline oder ModelRegistry.")
+        self._pipeline = pipeline
+        self._registry = registry
+        self._predictor = Predictor(pipeline=pipeline, registry=registry)
+
+    def evaluate(self, artifact_id: str, samples: Sequence[FeatureVector]) -> EvalReport:
+        try:
+            if self._registry is not None:
+                self._registry.load_artifact(artifact_id)
+            elif self._pipeline is not None:
+                self._pipeline.export(artifact_id)
+        except KeyError as exc:
+            raise ValueError("Kein trainiertes Modell für Evaluation vorhanden.") from exc
+
+        absolute_errors: list[float] = []
+        squared_errors: list[float] = []
+        for sample in samples:
+            try:
+                prediction = self._predictor.predict(artifact_id, sample)
+            except ValueError:
+                continue
+            for feature_name, predicted in prediction.predictions.items():
+                actual = float(sample.values[feature_name])
+                error = predicted - actual
+                absolute_errors.append(abs(error))
+                squared_errors.append(error**2)
+
+        sample_size = len(absolute_errors)
+        mae = sum(absolute_errors) / sample_size if sample_size else 0.0
+        rmse = math.sqrt(sum(squared_errors) / sample_size) if sample_size else 0.0
+        expected_values = sum(len(sample.values) for sample in samples)
+        coverage = sample_size / expected_values if expected_values else 0.0
+
+        report = EvalReport(
+            artifact_id=artifact_id,
+            sample_size=sample_size,
+            metrics=[
+                Metric(name="mae", value=mae),
+                Metric(name="rmse", value=rmse),
+                Metric(name="coverage", value=coverage, threshold=0.8),
+            ],
+        )
+        logger.info(
+            "Evaluation %s -> mae=%.4f, rmse=%.4f, coverage=%.2f",
+            artifact_id,
+            mae,
+            rmse,
+            coverage,
+        )
+        return report
--- a/app/ml/explanation.py
+++ b/app/ml/explanation.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from app.ml.training import FeatureModel
+
+
+@dataclass(frozen=True)
+class FeatureExplanation:
+    feature: str
+    current_value: float
+    predicted_value: float
+    change: float
+    direction: str
+    sample_count: int
+    historical_mean: float
+    historical_range: tuple[float, float]
+    standard_deviation: float
+    trend_per_step: float
+    confidence: float
+    summary: str
+
+
+def explain_feature(
+    feature_name: str,
+    current_value: float,
+    predicted_value: float,
+    model: FeatureModel,
+) -> FeatureExplanation:
+    change = predicted_value - current_value
+    direction = _direction(change)
+    summary = (
+        f"{feature_name}: {direction}; Prognose {predicted_value:.3f} "
+        f"aus aktuellem Wert {current_value:.3f} und Trend {model.slope:+.3f}. "
+        f"Basis: {model.sample_count} Messwerte, Mittelwert {model.mean:.3f}, "
+        f"Confidence {model.confidence:.0%}."
+    )
+    return FeatureExplanation(
+        feature=feature_name,
+        current_value=current_value,
+        predicted_value=predicted_value,
+        change=change,
+        direction=direction,
+        sample_count=model.sample_count,
+        historical_mean=model.mean,
+        historical_range=(model.minimum, model.maximum),
+        standard_deviation=model.standard_deviation,
+        trend_per_step=model.slope,
+        confidence=model.confidence,
+        summary=summary,
+    )
+
+
+def _direction(change: float) -> str:
+    if abs(change) < 1e-12:
+        return "stabil"
+    return "steigend" if change > 0 else "fallend"
--- a/app/ml/feature_store.py
+++ b/app/ml/feature_store.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class FeatureVector:
+    sensor_id: str
+    values: dict[str, float]
+    label: str | None = None
+
+
+class FeatureStore:
+    def __init__(self) -> None:
+        self._vectors: dict[str, list[FeatureVector]] = defaultdict(list)
+
+    def add(self, vector: FeatureVector) -> None:
+        self._vectors[vector.sensor_id].append(vector)
+
+    def add_batch(self, vectors: Iterable[FeatureVector]) -> None:
+        for vector in vectors:
+            self.add(vector)
+
+    def latest(self, sensor_id: str) -> FeatureVector | None:
+        series = self._vectors.get(sensor_id)
+        return series[-1] if series else None
+
+    def all(self) -> list[FeatureVector]:
+        return [vector for vectors in self._vectors.values() for vector in vectors]
--- a/app/ml/predictor.py
+++ b/app/ml/predictor.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import logging
+import math
+from dataclasses import dataclass
+from typing import Sequence
+
+from app.ml.explanation import FeatureExplanation, explain_feature
+from app.ml.feature_store import FeatureVector
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.training import TrainedArtifact, TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PredictionResult:
+    artifact_id: str
+    sensor_id: str
+    predictions: dict[str, float]
+    confidence: float
+    model_type: str
+    explanations: dict[str, FeatureExplanation]
+
+
+class Predictor:
+    def __init__(
+        self,
+        pipeline: TrainingPipeline | None = None,
+        registry: ModelRegistry | None = None,
+    ) -> None:
+        if isinstance(pipeline, ModelRegistry) and registry is None:
+            registry = pipeline
+            pipeline = None
+        if pipeline is None and registry is None:
+            raise ValueError("Predictor erfordert TrainingPipeline oder ModelRegistry.")
+        self._pipeline = pipeline
+        self._registry = registry
+
+    def predict(self, artifact_id: str, entity: FeatureVector) -> PredictionResult:
+        artifact = self._get_artifact(artifact_id)
+        if entity.sensor_id not in artifact.supported_sensors:
+            raise ValueError(
+                f"Sensor '{entity.sensor_id}' wird vom Modell '{artifact_id}' nicht unterstützt."
+            )
+        sensor_models = artifact.feature_models.get(entity.sensor_id, {})
+        if not sensor_models:
+            raise ValueError(f"Modell '{artifact_id}' enthält keine statistischen Parameter.")
+
+        feature_names = sorted(set(sensor_models).intersection(entity.values))
+        if not feature_names:
+            raise ValueError(
+                f"Keine Eingabemerkmale werden vom Modell '{artifact_id}' unterstützt."
+            )
+
+        predictions: dict[str, float] = {}
+        explanations: dict[str, FeatureExplanation] = {}
+        confidences: list[float] = []
+        for feature_name in feature_names:
+            model = sensor_models[feature_name]
+            current_value = float(entity.values[feature_name])
+            if not math.isfinite(current_value):
+                raise ValueError("Vorhersagewerte müssen endlich sein.")
+            predicted_value = model.forecast(current_value)
+            predictions[feature_name] = predicted_value
+            explanations[feature_name] = explain_feature(
+                feature_name,
+                current_value,
+                predicted_value,
+                model,
+            )
+            confidences.append(model.confidence)
+
+        return PredictionResult(
+            artifact_id=artifact_id,
+            sensor_id=entity.sensor_id,
+            predictions=predictions,
+            confidence=sum(confidences) / len(confidences),
+            model_type=artifact.model_type,
+            explanations=explanations,
+        )
+
+    def predict_batch(
+        self,
+        artifact_id: str,
+        entities: Sequence[FeatureVector],
+    ) -> list[PredictionResult]:
+        return [self.predict(artifact_id, entity) for entity in entities]
+
+    @staticmethod
+    def default_artifact(pipeline: TrainingPipeline) -> TrainedArtifact:
+        artifacts = list(pipeline._artifacts)
+        if not artifacts:
+            raise ValueError("Kein trainiertes Modell gefunden.")
+        return pipeline.export(artifacts[-1])
+
+    def _get_artifact(self, artifact_id: str) -> TrainedArtifact:
+        if self._registry is not None:
+            return self._registry.load_artifact(artifact_id)
+        if self._pipeline is not None:
+            return self._pipeline.export(artifact_id)
+        raise RuntimeError("Predictor nicht initialisiert.")
--- a/app/ml/registry/init.py
+++ b/app/ml/registry/init.py
@@ -0,0 +1,3 @@
+from .model_registry import ModelRegistry
+
+__all__ = ["ModelRegistry"]
--- a/app/ml/registry/model_registry.py
+++ b/app/ml/registry/model_registry.py
@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import json
+import logging
+import math
+import os
+from pathlib import Path
+import re
+from threading import RLock
+from collections.abc import Iterable
+
+from app.ml.training import FeatureModel, TrainedArtifact
+
+logger = logging.getLogger(__name__)
+
+_ARTIFACT_ID_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+
+
+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()
+
+    def register(self, artifact: TrainedArtifact) -> TrainedArtifact:
+        registered, _ = self.register_with_status(artifact)
+        return registered
+
+    def register_with_status(self, artifact: TrainedArtifact) -> tuple[TrainedArtifact, bool]:
+        self._validate_artifact_id(artifact.artifact_id)
+        with self._lock:
+            replaced = artifact.artifact_id in self._artifacts
+            self._persist(artifact)
+            self._artifacts[artifact.artifact_id] = artifact
+        return artifact, replaced
+
+    def load_artifact(self, artifact_id: str) -> TrainedArtifact:
+        self._validate_artifact_id(artifact_id)
+        with self._lock:
+            if artifact_id not in self._artifacts:
+                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:
+                raw = json.loads(source.read_text(encoding="utf-8"))
+                artifact_id = raw["artifact_id"]
+                supported_sensors = raw["supported_sensors"]
+                model_type = raw.get("model_type", "metadata")
+                raw_feature_models = raw.get("feature_models", {})
+                if not isinstance(artifact_id, str) or not isinstance(supported_sensors, list):
+                    raise ValueError("invalid artifact structure")
+                if not isinstance(model_type, str):
+                    raise ValueError("model_type must be a string")
+                self._validate_artifact_id(artifact_id)
+                if source.name != f"{artifact_id}.json":
+                    raise ValueError("artifact id does not match filename")
+                if not all(isinstance(sensor, str) for sensor in supported_sensors):
+                    raise ValueError("supported_sensors must contain strings")
+                feature_models = _deserialize_feature_models(raw_feature_models)
+            except (KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
+                raise ValueError(f"Ungültiges Modell-Artefakt: {source.name}") from exc
+
+            self._artifacts[artifact_id] = TrainedArtifact(
+                artifact_id=artifact_id,
+                supported_sensors=tuple(supported_sensors),
+                feature_models=feature_models,
+                model_type=model_type,
+            )
+
+    def _persist(self, artifact: TrainedArtifact) -> None:
+        target = self._root / f"{artifact.artifact_id}.json"
+        temporary = target.with_suffix(".json.tmp")
+        payload = {
+            "artifact_id": artifact.artifact_id,
+            "supported_sensors": list(artifact.supported_sensors),
+            "model_type": artifact.model_type,
+            "feature_models": {
+                sensor_id: {
+                    feature_name: {
+                        "sample_count": model.sample_count,
+                        "mean": model.mean,
+                        "standard_deviation": model.standard_deviation,
+                        "minimum": model.minimum,
+                        "maximum": model.maximum,
+                        "slope": model.slope,
+                        "intercept": model.intercept,
+                    }
+                    for feature_name, model in sorted(models.items())
+                }
+                for sensor_id, models in sorted(artifact.feature_models.items())
+            },
+        }
+        temporary.write_text(
+            json.dumps(payload, ensure_ascii=True, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        os.replace(temporary, target)
+        logger.info("Modell gespeichert: %s", target)
+
+    @staticmethod
+    def _validate_artifact_id(artifact_id: str) -> None:
+        if not _ARTIFACT_ID_PATTERN.fullmatch(artifact_id) or ".." in artifact_id:
+            raise ValueError(
+                "artifact_id darf nur Buchstaben, Ziffern, Punkt, Unterstrich "
+                "und Bindestrich enthalten."
+            )
+
+
+def _deserialize_feature_models(raw: object) -> dict[str, dict[str, FeatureModel]]:
+    if not isinstance(raw, dict):
+        raise ValueError("feature_models must be an object")
+
+    result: dict[str, dict[str, FeatureModel]] = {}
+    for sensor_id, raw_features in raw.items():
+        if not isinstance(sensor_id, str) or not isinstance(raw_features, dict):
+            raise ValueError("invalid sensor feature models")
+        features: dict[str, FeatureModel] = {}
+        for feature_name, raw_model in raw_features.items():
+            if not isinstance(feature_name, str) or not isinstance(raw_model, dict):
+                raise ValueError("invalid feature model")
+            sample_count = raw_model.get("sample_count")
+            if not isinstance(sample_count, int) or isinstance(sample_count, bool) or sample_count < 1:
+                raise ValueError("sample_count must be a positive integer")
+            values = {
+                key: _finite_number(raw_model.get(key))
+                for key in (
+                    "mean",
+                    "standard_deviation",
+                    "minimum",
+                    "maximum",
+                    "slope",
+                    "intercept",
+                )
+            }
+            features[feature_name] = FeatureModel(
+                sample_count=sample_count,
+                mean=values["mean"],
+                standard_deviation=values["standard_deviation"],
+                minimum=values["minimum"],
+                maximum=values["maximum"],
+                slope=values["slope"],
+                intercept=values["intercept"],
+            )
+        result[sensor_id] = features
+    return result
+
+
+def _finite_number(value: object) -> float:
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise ValueError("feature model values must be finite numbers")
+    converted = float(value)
+    if not math.isfinite(converted):
+        raise ValueError("feature model values must be finite numbers")
+    return converted
--- a/app/ml/retraining.py
+++ b/app/ml/retraining.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.training import TrainedArtifact, TrainingPipeline
+
+
+@dataclass(frozen=True)
+class RetrainingResult:
+    artifact: TrainedArtifact
+    replaced: bool
+
+
+class RetrainingService:
+    """Runs one retraining cycle without owning scheduling or background threads."""
+
+    def __init__(self, registry: ModelRegistry) -> None:
+        self._registry = registry
+
+    def retrain(
+        self,
+        artifact_id: str,
+        vectors: Iterable[FeatureVector],
+    ) -> RetrainingResult:
+        store = FeatureStore()
+        store.add_batch(vectors)
+        pipeline = TrainingPipeline(store)
+        artifact = pipeline.run(artifact_id)
+        _, replaced = self._registry.register_with_status(artifact)
+        return RetrainingResult(artifact=artifact, replaced=replaced)
+
+
+def retrain_model(
+    registry: ModelRegistry,
+    artifact_id: str,
+    vectors: Iterable[FeatureVector],
+) -> RetrainingResult:
+    """Scheduler-compatible entry point for exactly one retraining run."""
+
+    return RetrainingService(registry).retrain(artifact_id, vectors)
--- a/app/ml/training.py
+++ b/app/ml/training.py
@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import logging
+import math
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+from app.ml.feature_store import FeatureStore
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class FeatureModel:
+    sample_count: int
+    mean: float
+    standard_deviation: float
+    minimum: float
+    maximum: float
+    slope: float
+    intercept: float
+
+    def forecast(self, current_value: float | None = None) -> float:
+        if current_value is not None:
+            return current_value + self.slope
+        return self.intercept + self.slope * self.sample_count
+
+    @property
+    def confidence(self) -> float:
+        sample_score = self.sample_count / (self.sample_count + 2)
+        scale = abs(self.mean) if abs(self.mean) > 1e-9 else 1.0
+        stability_score = 1.0 / (1.0 + self.standard_deviation / scale)
+        return min(0.99, max(0.05, sample_score * stability_score))
+
+
+@dataclass(frozen=True)
+class TrainedArtifact:
+    artifact_id: str
+    supported_sensors: tuple[str, ...]
+    feature_models: dict[str, dict[str, FeatureModel]] = field(default_factory=dict)
+    model_type: str = "statistical_baseline"
+
+
+class TrainingPipeline:
+    def __init__(self, store: FeatureStore) -> None:
+        self._store = store
+        self._artifacts: dict[str, TrainedArtifact] = {}
+
+    def run(self, artifact_id: str) -> TrainedArtifact:
+        vectors = self._store.all()
+        if not vectors:
+            raise ValueError("FeatureStore enthält keine Trainingsdaten.")
+
+        samples: dict[str, dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
+        for vector in vectors:
+            for feature_name, raw_value in vector.values.items():
+                value = float(raw_value)
+                if math.isfinite(value):
+                    samples[vector.sensor_id][feature_name].append(value)
+
+        feature_models = {
+            sensor_id: {
+                feature_name: _fit_feature(values)
+                for feature_name, values in sorted(features.items())
+                if values
+            }
+            for sensor_id, features in sorted(samples.items())
+        }
+        feature_models = {
+            sensor_id: models for sensor_id, models in feature_models.items() if models
+        }
+        if not feature_models:
+            raise ValueError("Trainingsdaten enthalten keine endlichen numerischen Werte.")
+
+        sensors = tuple(feature_models)
+        artifact = TrainedArtifact(
+            artifact_id=artifact_id,
+            supported_sensors=sensors,
+            feature_models=feature_models,
+        )
+        self._artifacts[artifact_id] = artifact
+        logger.info("Training abgeschlossen für %s mit %d Sensoren", artifact_id, len(sensors))
+        return artifact
+
+    def export(self, artifact_id: str) -> TrainedArtifact:
+        if artifact_id not in self._artifacts:
+            raise KeyError(f"Artifact '{artifact_id}' nicht gefunden.")
+        return self._artifacts[artifact_id]
+
+
+def _fit_feature(values: list[float]) -> FeatureModel:
+    sample_count = len(values)
+    mean = sum(values) / sample_count
+    variance = sum((value - mean) ** 2 for value in values) / sample_count
+    standard_deviation = math.sqrt(variance)
+
+    if sample_count == 1:
+        slope = 0.0
+        intercept = mean
+    else:
+        x_mean = (sample_count - 1) / 2
+        denominator = sum((index - x_mean) ** 2 for index in range(sample_count))
+        numerator = sum(
+            (index - x_mean) * (value - mean) for index, value in enumerate(values)
+        )
+        slope = numerator / denominator
+        intercept = mean - slope * x_mean
+
+    return FeatureModel(
+        sample_count=sample_count,
+        mean=mean,
+        standard_deviation=standard_deviation,
+        minimum=min(values),
+        maximum=max(values),
+        slope=slope,
+        intercept=intercept,
+    )
--- a/app/rules/heating.py
+++ b/app/rules/heating.py
@@ -7,9 +7,28 @@ from app.rules.recommender import Rule


 class HeatingRule(Rule):
+    """Heizungsregel: Nur auf heizungsrelevante Entitäten reagieren.
+
+    Triggert bei:
+    - `climate`-Entitäten direkt
+    - `sensor` mit `device_class` in {temperature, humidity}
+    - `binary_sensor` mit `device_class` in {occupancy, presence}
+
+    Alle anderen Domains/Device-Klassen bleiben ohne Effekt.
+    """
+
+    HEATING_SENSOR_CLASSES: frozenset[str] = frozenset({"temperature", "humidity"})
+    HEATING_PRESENCE_CLASSES: frozenset[str] = frozenset({"occupancy", "presence"})
+
    def matches(self, entities: Sequence[HaEntitySummary]) -> bool:
-        domains = {item.domain for item in entities}
-        return "climate" in domains or "sensor" in domains
+        for item in entities:
+            if item.domain == "climate":
+                return True
+            if item.domain == "sensor" and item.device_class in self.HEATING_SENSOR_CLASSES:
+                return True
+            if item.domain == "binary_sensor" and item.device_class in self.HEATING_PRESENCE_CLASSES:
+                return True
+        return False

    def recommendation(self, entities: Sequence[HaEntitySummary]) -> str:
        return "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
--- a/app/static/index.html
+++ b/app/static/index.html
--- a/backend/init.py
+++ b/backend/init.py
@@ -0,0 +1 @@
+"""Secondary application entry points for SillyHome Next."""
--- a/backend/app.py
+++ b/backend/app.py
@@ -0,0 +1,43 @@
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from starlette.datastructures import State
+
+from backend.routes.ml import init_ml_routes
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.training import TrainingPipeline
+from app.ml.feature_store import FeatureStore, FeatureVector
+
+
+@asynccontextmanager
+async def lifespan(application: FastAPI) -> AsyncIterator[None]:
+    application.state.registry = ModelRegistry(application.state.model_store)
+    _seed_default_model(application.state)
+    yield
+
+
+def create_app() -> FastAPI:
+    application = FastAPI(title="SillyHome Next ML", lifespan=lifespan)
+    init_ml_routes(application)
+    return application
+
+
+def _seed_default_model(state: State) -> None:
+    registry = getattr(state, "registry", None)
+    if registry is None:
+        registry = ModelRegistry(".model_store")
+        state.registry = registry
+
+    if list(registry.list_models()):
+        return
+
+    store = FeatureStore()
+    store.add(FeatureVector(sensor_id="sensor.front_door", values={"contact": 1.0}))
+    store.add(FeatureVector(sensor_id="sensor.living_room", values={"temperature": 21.0}))
+    pipeline = TrainingPipeline(store)
+    artifact = pipeline.run("default")
+    registry.register(artifact)
+
+
+app = create_app()
--- a/backend/routes/init.py
+++ b/backend/routes/init.py
@@ -0,0 +1 @@
+"""API route modules."""
--- a/backend/routes/ml.py
+++ b/backend/routes/ml.py
@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from collections.abc import Sequence
+
+from fastapi import APIRouter, FastAPI, HTTPException, Request, status
+from pydantic import BaseModel, Field
+
+from app.ml.evaluation import Evaluator
+from app.ml.feature_store import FeatureVector
+from app.ml.predictor import Predictor
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.retraining import retrain_model
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/ml", tags=["ml"])
+
+
+class HealthResponse(BaseModel):
+    status: str
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class PredictRequest(BaseModel):
+    model_id: str = Field(..., alias="modelId")
+    sensor_id: str
+    values: dict[str, float]
+
+
+class PredictResponse(BaseModel):
+    model_id: str
+    sensor_id: str
+    predictions: dict[str, float]
+    confidence: float
+    model_type: str
+    explanations: dict[str, "FeatureExplanationResponse"]
+
+
+class FeatureExplanationResponse(BaseModel):
+    feature: str
+    current_value: float
+    predicted_value: float
+    change: float
+    direction: str
+    sample_count: int
+    historical_mean: float
+    historical_range: tuple[float, float]
+    standard_deviation: float
+    trend_per_step: float
+    confidence: float
+    summary: str
+
+
+class BatchRequest(BaseModel):
+    requests: Sequence[PredictRequest]
+
+
+class BatchResponse(BaseModel):
+    predictions: Sequence[PredictResponse]
+
+
+class ModelsResponse(BaseModel):
+    models: list[str]
+
+
+class TrainingSample(BaseModel):
+    sensor_id: str = Field(min_length=1)
+    values: dict[str, float]
+    label: str | None = None
+
+
+class RetrainRequest(BaseModel):
+    model_id: str = Field(..., alias="modelId", min_length=1, max_length=128)
+    samples: list[TrainingSample] = Field(min_length=1)
+
+
+class RetrainResponse(BaseModel):
+    model_id: str
+    supported_sensors: list[str]
+    trained_features: int
+    model_type: str
+    replaced: bool
+
+
+class EvaluateRequest(BaseModel):
+    model_id: str = Field(..., alias="modelId", min_length=1, max_length=128)
+    samples: list[TrainingSample] = Field(min_length=1)
+
+
+class MetricResponse(BaseModel):
+    name: str
+    value: float
+    threshold: float | None = None
+
+
+class EvaluateResponse(BaseModel):
+    model_id: str
+    sample_size: int
+    metrics: list[MetricResponse]
+
+
+@router.get("/health", response_model=HealthResponse, status_code=200)
+def health() -> HealthResponse:
+    return HealthResponse(status="ok")
+
+
+@router.get("/models", response_model=ModelsResponse, status_code=200)
+def list_models(request: Request) -> ModelsResponse:
+    registry = _require_registry(request)
+    models = [artifact.artifact_id for artifact in registry.list_models()]
+    return ModelsResponse(models=models)
+
+
+@router.post("/retrain", response_model=RetrainResponse, status_code=200)
+def retrain(payload: RetrainRequest, request: Request) -> RetrainResponse:
+    registry = _require_registry(request)
+    vectors = [
+        FeatureVector(
+            sensor_id=sample.sensor_id,
+            values=sample.values,
+            label=sample.label,
+        )
+        for sample in payload.samples
+    ]
+    try:
+        result = retrain_model(registry, payload.model_id, vectors)
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=str(exc),
+        ) from exc
+    return RetrainResponse(
+        model_id=result.artifact.artifact_id,
+        supported_sensors=list(result.artifact.supported_sensors),
+        trained_features=sum(
+            len(feature_models)
+            for feature_models in result.artifact.feature_models.values()
+        ),
+        model_type=result.artifact.model_type,
+        replaced=result.replaced,
+    )
+
+
+@router.post("/evaluate", response_model=EvaluateResponse, status_code=200)
+def evaluate(payload: EvaluateRequest, request: Request) -> EvaluateResponse:
+    registry = _require_registry(request)
+    vectors = [
+        FeatureVector(
+            sensor_id=sample.sensor_id,
+            values=sample.values,
+            label=sample.label,
+        )
+        for sample in payload.samples
+    ]
+    try:
+        report = Evaluator(registry=registry).evaluate(payload.model_id, vectors)
+    except ValueError as exc:
+        try:
+            registry.load_artifact(payload.model_id)
+        except KeyError:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=str(exc),
+            ) from exc
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=str(exc),
+        ) from exc
+    return EvaluateResponse(
+        model_id=report.artifact_id,
+        sample_size=report.sample_size,
+        metrics=[
+            MetricResponse(name=metric.name, value=metric.value, threshold=metric.threshold)
+            for metric in report.metrics
+        ],
+    )
+
+
+@router.post("/predict", response_model=PredictResponse, status_code=200)
+def predict(payload: PredictRequest, request: Request) -> PredictResponse:
+    registry = _require_registry(request)
+    predictor = Predictor(registry=registry)
+    vector = FeatureVector(sensor_id=payload.sensor_id, values=payload.values)
+    try:
+        prediction = predictor.predict(payload.model_id, vector)
+    except KeyError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=str(exc),
+        ) from exc
+    return PredictResponse(
+        model_id=payload.model_id,
+        sensor_id=payload.sensor_id,
+        predictions=prediction.predictions,
+        confidence=prediction.confidence,
+        model_type=prediction.model_type,
+        explanations={
+            name: FeatureExplanationResponse(**explanation.__dict__)
+            for name, explanation in prediction.explanations.items()
+        },
+    )
+
+
+@router.post("/batch", response_model=BatchResponse, status_code=200)
+def predict_batch(payload: BatchRequest, request: Request) -> BatchResponse:
+    registry = _require_registry(request)
+    predictor = Predictor(registry=registry)
+    responses: list[PredictResponse] = []
+    for item in payload.requests:
+        vector = FeatureVector(sensor_id=item.sensor_id, values=item.values)
+        try:
+            prediction = predictor.predict(item.model_id, vector)
+        except KeyError as exc:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+        except ValueError as exc:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+                detail=str(exc),
+            ) from exc
+        responses.append(
+            PredictResponse(
+                model_id=item.model_id,
+                sensor_id=item.sensor_id,
+                predictions=prediction.predictions,
+                confidence=prediction.confidence,
+                model_type=prediction.model_type,
+                explanations={
+                    name: FeatureExplanationResponse(**explanation.__dict__)
+                    for name, explanation in prediction.explanations.items()
+                },
+            )
+        )
+    return BatchResponse(predictions=responses)
+
+
+def _require_registry(request: Request) -> ModelRegistry:
+    registry = getattr(request.app.state, "registry", None)
+    if not isinstance(registry, ModelRegistry):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="ML registry nicht initialisiert.",
+        )
+    return registry
+
+
+def init_ml_routes(app: FastAPI, model_store: str = ".model_store") -> None:
+    app.state.model_store = model_store
+    app.include_router(router)
+    logger.info("ML routes registered")
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,39 @@
+services:
+  api:
+    build: .
+    ports:
+      - "127.0.0.1:8000:8000"
+    env_file:
+      - path: .env
+        required: false
+    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
+    security_opt:
+      - no-new-privileges:true
+    cap_drop:
+      - ALL
+    restart: unless-stopped
+
+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/V1_1_0_OPERATING_GUIDE.md
+++ b/docs/V1_1_0_OPERATING_GUIDE.md
@@ -0,0 +1,72 @@
+# SillyHome Next v1.1.0 Operating Guide
+
+## Ziel
+
+v1.1.0 macht das Dashboard zur Zentrale fuer Visualisierung, Einrichtung,
+Sicherheit und manuelles Gegensteuern. Autonomes Schalten bleibt ein kurzer
+lokaler Pfad: Vorhersage und Safety-Profil werden aus bereits vorhandenen Daten
+bewertet, danach folgt direkt der Home-Assistant-Serviceaufruf.
+
+## Sicherheitsmodell
+
+Jeder Aktor hat ein Safety-Profil:
+
+- `stage`: Beobachten, Vorschlagen, Shadow, Teilaktiv oder Aktiv.
+- `manual_block`: harte manuelle Sperre.
+- `min_confidence`: Mindest-Sicherheit fuer autonomes Schalten.
+- `cooldown_seconds`: optionaler Aktor-Cooldown gegen schnelles Hin-und-her.
+- Safety-Regeln: Freigabe, Confidence, Cooldown und manuelle Sperre.
+
+Ein Aktor schaltet nur, wenn alle lokalen Safety-Regeln frei sind, der
+Behavior-Modus aktiv ist, die Freigabe bereit ist, die Confidence passt, der
+Zielzustand noch nicht erreicht ist und der Cooldown abgelaufen ist.
+
+## Transparenz
+
+Die Aktor-Detailansicht trennt:
+
+- Wissen: belegte Fakten aus Historie, Zuordnung und Automationen.
+- Annahmen: heuristische Schluesse wie Zeit-/Kontext-Aehnlichkeit.
+- Unsicherheiten: geringe Datenmenge, unklare Quellen, Review-Bedarf oder
+  negatives Feedback.
+- Beitragsfaktoren: Sensoren, Kontextsignale, aktive Gewichtung und Beitrag.
+- Safety-Blocker: Gruende, warum nicht geschaltet wird.
+
+## Job-Queue
+
+Das Dashboard zeigt die letzten Jobs mit Status, Dauer, Fehler und
+Zusammenfassung. Sichtbar sind:
+
+- Discovery
+- Reconciliation
+- Training
+- Evaluation
+- Automation-Refresh
+
+Die Queue ist persistent in `job_queue.json` und dient als Betriebsanzeige. Sie
+blockiert nicht den Startpfad und nicht den Schaltpfad.
+
+## Manuelles Gegensteuern
+
+Im Dashboard koennen pro Aktor gesetzt werden:
+
+- manuelle Sicherheitssperre
+- Freigabestufe
+- Mindest-Confidence
+- optionaler Cooldown
+- Sensor-Gewichtungen und Gruppen-Gewichtungen
+- Kontextauswahl
+- Feedback: Vorhersage korrekt/falsch
+- HA-Automationen pausieren/fortsetzen
+
+## Qualitaetspruefung
+
+Vor Release:
+
+```bash
+.venv/bin/pytest -q
+.venv/bin/ruff check .
+.venv/bin/mypy app backend tests
+git diff --check
+node --check /tmp/sillyhome-dashboard.js
+```
--- a/docs/V1_2_0_OPERATING_GUIDE.md
+++ b/docs/V1_2_0_OPERATING_GUIDE.md
@@ -0,0 +1,62 @@
+# SillyHome Next v1.2.0 Operating Guide
+
+## Ziel
+
+v1.2.0 erweitert die sichere v1.1-Grundlage um adaptive Lernfunktionen. Diese
+Funktionen laufen bei Feedback, Training oder Automation-Refresh und blockieren
+nicht den direkten Schaltpfad.
+
+## Adaptive Gewichtung
+
+Feedback passt die Gewichtung aktuell beteiligter Kontextsignale vorsichtig an:
+
+- korrektes Feedback: +3 Prozentpunkte bis maximal 100 %
+- falsches Feedback: -8 Prozentpunkte bis minimal 10 %
+
+Die Aenderungen werden als `adaptive_weight_updates` gespeichert und im
+Dashboard angezeigt. Manuelle Gewichtungen bleiben weiter direkt korrigierbar.
+
+## Modell-Snapshots und Rollback
+
+Bei jedem Training wird ein Snapshot gespeichert:
+
+- Version-ID
+- Sample Count
+- eindeutig zugeordnete Handlungen
+- durchschnittliche Confidence
+- negative Feedbacks
+- Musterliste
+- Begruendung
+
+Ueber das Dashboard kann auf einen frueheren Snapshot zurueckgerollt werden.
+
+## Automation-Konflikte
+
+Beim Automation-Refresh markiert SillyHome Konflikte, wenn:
+
+- SillyHome fuer einen Aktor aktiv ist
+- eine passende Home-Assistant-Automation ebenfalls aktiv bleibt
+
+Pausierte Automationen werden als kontrolliert markiert.
+
+## Zeitprofile
+
+SillyHome bildet Profile fuer:
+
+- Nacht
+- Morgen
+- Tag
+- Abend
+- Wochenende
+
+Diese Profile zeigen Sample Count, dominanten Zielzustand und Profilklarheit.
+
+## Performance-Grenze
+
+v1.2-Funktionen duerfen den Schaltmoment nicht verlangsamen. Der direkte
+Schaltpfad bleibt:
+
+1. vorhandene aktuelle States nutzen
+2. lokale Safety-Pruefung
+3. direkter Home-Assistant-Serviceaufruf
+4. Persistenz der Entscheidung
--- a/docs/V1_3_0_OPERATING_GUIDE.md
+++ b/docs/V1_3_0_OPERATING_GUIDE.md
@@ -0,0 +1,68 @@
+# SillyHome Next v1.3.0 Operating Guide
+
+v1.3.0 ergänzt die v1.2-Lernfunktionen um Anomalie-Erkennung und
+Performance-Überwachung. Das Dashboard bleibt Visualisierung und Einrichtung;
+der direkte Schaltpfad bleibt kurz und führt vor dem Home-Assistant-Service-Call
+keine Discovery, kein Training und keine Modellanalyse aus.
+
+## Performance-Budget
+
+- Dashboard-Start und `/v1/actuators/dashboard` haben ein Budget von 3000 ms.
+- Das Dashboard zeigt die eigene Ladezeit, das aktive Budget, Job-p95 und die
+  Anzahl langsamer Jobs.
+- Jobs ab 3000 ms werden in der Job-Queue als langsam markiert.
+- Der automatisierte API-Test prüft den Root- und Dashboard-Startpfad gegen das
+  3-Sekunden-Budget.
+
+## Anomalie-Erkennung
+
+Anomalien werden pro Aktor gespeichert und im Aktor-Detail angezeigt. Erkannt
+werden aktuell:
+
+- fehlender Sensor-/Kontextbezug
+- zu wenige Lernbeispiele
+- unklare Quellen historischer Schaltungen
+- veraltetes Training
+- Vorhersagen unter der Sicherheitsgrenze
+- aktive manuelle Sicherheitssperren
+- Safety-Blocker
+- parallele HA-Automationen bei aktivem SillyHome
+- hohe negative Feedbackquote
+
+Die Anomalien sind Hinweise für Setup und manuelles Gegensteuern. Sie lösen
+keine automatische Eskalation und keine langsamere Schaltung aus.
+
+## API
+
+- `GET /v1/actuators/dashboard` liefert jetzt zusätzlich:
+  - `performance_budget_ms`
+  - `job_p95_duration_ms`
+  - `slow_job_count`
+  - `performance_status`
+  - `anomaly_count`
+  - `critical_anomaly_count`
+- `GET /v1/actuators/anomalies` liefert offene Anomalien gruppiert nach Aktor.
+
+## Betrieb
+
+Bei Ladezeiten ab 3 Sekunden gilt die Seite als nicht performant. Dann zuerst
+prüfen:
+
+1. Dashboard-Statistik: Ladezeit, Job-p95, langsame Jobs.
+2. Job-Queue: welche Aktion langsam war.
+3. Aktor-Detail: Anomalien, Safety-Blocker und Automation-Konflikte.
+4. Falls Discovery oder Training langsam war: nicht in den Startpfad ziehen,
+   sondern geplant, manuell oder über Queue laufen lassen.
+
+## Qualität
+
+Vor Release/Installation ausführen:
+
+```bash
+pytest -q
+ruff check .
+mypy app backend tests
+git diff --check
+```
+
+Zusätzlich das eingebettete Dashboard-JavaScript mit `node --check` prüfen.
--- a/docs/V1_4_0_OPERATING_GUIDE.md
+++ b/docs/V1_4_0_OPERATING_GUIDE.md
@@ -0,0 +1,42 @@
+# SillyHome Next v1.4.0 Operating Guide
+
+v1.4.0 überarbeitet das Dashboard für mobile Nutzung, deutsche Verständlichkeit
+und stabileren Datenabruf.
+
+## Schneller Startpfad
+
+- Die Startseite lädt zuerst nur die Bedienoberfläche und den kompakten
+  Dashboard-Startdatensatz.
+- Neuer Start-Endpunkt: `GET /v1/actuators/dashboard/start`.
+- Der Start-Endpunkt liefert keine Discovery-Gruppen und keine Aufgabenliste.
+- Status, Aufgabenliste, Reconciliation-Zeitpunkt und Detail-Kontext werden
+  danach im Hintergrund geladen.
+- Auf der Startansicht werden zunächst nur die ersten 24 Aktoren gerendert.
+  Weitere Geräte werden auf Knopfdruck nachgerendert.
+
+## Deutsche Oberfläche
+
+Interne Protokollwerte bleiben stabil, werden in der Oberfläche aber übersetzt:
+
+- `observe` -> `Nur beobachten`
+- `suggest` -> `Vorschläge anzeigen`
+- `shadow` -> `Prüfmodus ohne Schalten`
+- `partial` -> `Teilfreigabe`
+- `active` -> `Aktiv freigegeben`
+- Job-Status wie `running`, `completed`, `failed` erscheinen als `läuft`,
+  `abgeschlossen`, `fehlgeschlagen`.
+- Anomalie-Schweregrade erscheinen als `Hinweis`, `Warnung`, `Kritisch`.
+
+## Stabilität
+
+- Startdaten und Statusdaten sind getrennt. Ein langsamer Statuscheck blockiert
+  nicht mehr die Geräteübersicht.
+- Die Aufgabenliste wird separat geladen und kann ausfallen, ohne die
+  Bedienoberfläche zu blockieren.
+- Detaildaten bleiben gestuft: zuerst Shell und gespeicherte Werte, danach
+  Kontextvorschläge.
+
+## Performance-Regel
+
+3 Sekunden bleiben die harte Grenze für den Startpfad. Alles, was schwerer ist
+als Startdaten, muss nachgelagert oder auf Nutzeraktion geladen werden.
--- a/docs/V1_5_0_OPERATING_GUIDE.md
+++ b/docs/V1_5_0_OPERATING_GUIDE.md
@@ -0,0 +1,47 @@
+# SillyHome Next v1.5.0 Operating Guide
+
+v1.5.0 trennt Dashboard-Ansichten, Datenabruf und Detaildaten weiter auf. Ziel
+ist, dass die Seite auf mobiler Datenverbindung schneller nutzbar wird und keine
+schweren Lern-, Discovery- oder Detaildaten beim Start lädt.
+
+## Menüstruktur
+
+- Startseite / System: Systemübersicht, Cache, Performance, Status.
+- Lernen: konfigurierte Aktoren und Lernstand.
+- Details: genau ein ausgewählter Aktor.
+- Discovery & Einrichtung: Geräteliste, Vorschläge und neue Aktoren.
+- Einstellungen: Sprache und Standardverhalten.
+- Ablauf: Bedienhinweise.
+
+Beim Öffnen der Seite wird immer nur die Startseite geladen. Andere Ansichten
+laden erst beim Öffnen.
+
+## Kompakte Detaildaten
+
+Neuer Endpunkt:
+
+```text
+GET /v1/actuators/{actuator_entity_id}/detail
+```
+
+Dieser Endpunkt entfernt große Musterlisten und Snapshot-Muster aus dem ersten
+Detailabruf. Geladen werden nur die Werte, die für die erste Detailansicht
+benötigt werden. Kontextvorschläge bleiben ein separater Abruf und laufen erst
+auf Nutzeraktion.
+
+## Sprache
+
+Die Sprache kann unter `Einstellungen` gewählt werden. Deutsch ist Standard.
+Technische API-Werte bleiben stabil, werden aber im Dashboard über die
+Sprachschicht angezeigt.
+
+## Performance-Regeln
+
+- Kein Discovery beim Start.
+- Keine Aufgabenliste beim Start.
+- Keine Kontextvorschläge beim Öffnen eines Aktors.
+- Keine Musterlisten im ersten Detailabruf.
+- Geräteübersicht rendert begrenzt und lädt weitere Karten per Button nach.
+
+Die Angabe „bereit in X ms“ beschreibt nur den jeweiligen API-/Ansichtsabruf.
+Sie ist nicht gleichzusetzen mit der kompletten HA/Ingress-Navigationszeit.
--- a/docs/V1_5_1_OPERATING_GUIDE.md
+++ b/docs/V1_5_1_OPERATING_GUIDE.md
@@ -0,0 +1,32 @@
+# SillyHome Next v1.5.1 Operating Guide
+
+v1.5.1 ist ein Stabilisierungshotfix für die nach v1.2.0 entstandenen
+Dashboard-Änderungen. Fachlich gehört diese Arbeit zur v1.2.x-Patchlinie; die
+höhere technische Versionsnummer ist nur nötig, weil Home Assistant bereits
+v1.5.0 installiert hat und Add-on-Updates monoton nach oben laufen.
+
+## Korrekturen
+
+- Die System-Startseite nutzt `GET /v1/actuators/dashboard/system` und lädt
+  keine Aktorenliste.
+- Sichtbare 3-Sekunden-Abbrüche mit Browsertexten wie `signal is aborted
+  without reason` wurden entfernt.
+- Startdaten und Detaildaten werden ohne künstlichen Frontend-Abbruch geladen.
+- Timeout-Meldungen werden deutsch und verständlich angezeigt, wenn sie bei
+  Nebenprüfungen auftreten.
+- `summary`-Zeilen wie `anzeigenaufklappen` haben jetzt Abstand und Layout.
+
+## Ladeverhalten
+
+- Statische Seite wird sofort gerendert.
+- Systemdaten laden im Hintergrund.
+- Lernen/Geräte laden nur im Menü `Lernen`.
+- Discovery lädt nur im Menü `Discovery & Einrichtung`.
+- Aktorwerte laden erst beim Öffnen der Detailansicht.
+- Kontextvorschläge laden erst auf Nutzeraktion.
+
+## Hinweis zur Performance-Anzeige
+
+Die App zeigt keine echte HA/Ingress-Navigationszeit an. Gemessen werden nur
+einzelne interne Abrufe nach Start der Seite. Aussagen zur gesamten Ladezeit
+müssen über Browser/Ingress oder HA-Messung geprüft werden.
--- a/docs/V1_5_2_OPERATING_GUIDE.md
+++ b/docs/V1_5_2_OPERATING_GUIDE.md
@@ -0,0 +1,32 @@
+# SillyHome Next v1.5.2 Operating Guide
+
+v1.5.2 begrenzt den Rollback-Speicher und entschärft Home-Assistant-Timeouts,
+die in den Add-on-Logs sichtbar wurden.
+
+## Rollback-Speicher
+
+- Pro Aktor bleiben maximal 3 Modell-Snapshots erhalten.
+- Pro Snapshot bleiben maximal 120 Muster erhalten.
+- Beim Speichern eines Aktors werden ältere oder zu große Snapshots automatisch
+  gekappt.
+- Der kompakte Detail-Endpunkt liefert ebenfalls maximal 3 Rollback-Snapshots
+  und keine Musterlisten.
+
+Damit bleibt Rollback nutzbar, ohne dass die JSON-Dateien mit alten Modellen
+stark wachsen.
+
+## Home-Assistant-Zugriffe
+
+- REST-Zugriffe auf Home Assistant haben jetzt standardmäßig 25 Sekunden
+  Timeout statt 10 Sekunden.
+- Der Wert ist über `SILLYHOME_HA_TIMEOUT_SECONDS` konfigurierbar.
+- WebSocket-Keepalive wurde auf 30 Sekunden Ping-Intervall und 30 Sekunden
+  Ping-Timeout entschärft.
+
+## Log-Einordnung
+
+- `GET ... HTTP/1.1` ist bei Uvicorn/HA-Ingress normal und kein Fehler.
+- `Zeitüberschreitung beim Zugriff auf Home Assistant` bedeutet, dass HA selbst
+  zu langsam geantwortet hat oder der Ingress/Netzpfad verzögert war.
+- `keepalive ping timeout` bedeutet, dass die HA-WebSocket-Verbindung nicht
+  rechtzeitig geantwortet hat. SillyHome reconnectet automatisch.
--- a/docs/V1_5_3_OPERATING_GUIDE.md
+++ b/docs/V1_5_3_OPERATING_GUIDE.md
@@ -0,0 +1,37 @@
+# SillyHome Next v1.5.3 Operating Guide
+
+v1.5.3 führt eine SQLite-Cache-Schicht für Ingress-Dashboarddaten ein.
+
+## Ziel
+
+Die Ingress-Seite soll nicht bei jedem Aufruf live Home Assistant abfragen.
+Home-Assistant-Daten werden geplant aktualisiert und lokal gelesen.
+
+## SQLite-Cache
+
+- Cache-Datei: `<actuator_store>/dashboard_cache.sqlite3`
+- Tabelle `ha_entities`: aktuelle HA-Entity-Summaries als JSON
+- Tabelle `cache_meta`: Aktualisierungszeitpunkt und Discovery-Gruppen
+
+Dashboard-APIs lesen bevorzugt aus SQLite. Der alte JSON-Cache bleibt als
+Fallback erhalten.
+
+## Aktualisierung
+
+- Beim App-Start läuft ein Hintergrund-Refresh nach kurzer Verzögerung.
+- Danach läuft der Refresh stündlich.
+- Konfiguration: `SILLYHOME_DASHBOARD_CACHE_REFRESH_SECONDS`
+- Mindestwert: 300 Sekunden.
+- Explizite Discovery aktualisiert SQLite und JSON-Fallback.
+
+## Schaltpfad
+
+Das direkte Schalten bleibt unverändert: Safety prüft lokale Daten, danach geht
+der Home-Assistant-Service-Call direkt raus. Der Dashboard-Cache liegt nicht im
+Schaltpfad.
+
+## Noch offen
+
+Diese Version verschiebt Entity-/Discovery-Daten in SQLite. Die vollständige
+Migration aller Aktor-Konfigurationen und Workflows aus JSON in relationale
+Tabellen ist ein größerer Folgeschritt und muss mit Migrationsplan erfolgen.
--- a/docs/V1_5_4_OPERATING_GUIDE.md
+++ b/docs/V1_5_4_OPERATING_GUIDE.md
@@ -0,0 +1,35 @@
+# SillyHome Next v1.5.4 Operating Guide
+
+Diese Version korrigiert Ingress-Logging und Dashboard-Navigation.
+
+## Ingress-/Access-Logs
+
+- Das Add-on startet Uvicorn ohne `--proxy-headers` und ohne
+  `--forwarded-allow-ips='*'`.
+- Vorher konnte Uvicorn LAN-Adressen aus `X-Forwarded-For` anzeigen. Diese
+  Adresse war dann der urspruengliche Client oder Home-Assistant-Proxy, nicht
+  der direkte Container-Peer.
+- Nach dem Update sollten Access-Logs den direkten Docker-/Ingress-Peer zeigen.
+  `GET ... HTTP/1.1` bleibt normal und ist kein Hinweis auf fehlendes Streaming.
+
+## Dashboard-Verhalten
+
+- Die Startseite nutzt weiter `/v1/actuators/dashboard/system`.
+- Die Lernuebersicht nutzt weiter `/v1/actuators/dashboard/start`.
+- Bereits geladene System-, Lern- und Discovery-Daten bleiben beim Wechseln der
+  Ansichten im Browser erhalten und werden nur im Hintergrund aufgefrischt.
+- Details sind kein eigener Menuepunkt mehr. Sie werden nur ueber ein
+  ausgewaehltes beobachtetes Geraet geoeffnet.
+- Ein bereits geoeffneter Aktor zeigt seine Detaildaten sofort aus dem
+  Browser-Cache. Neue Detaildaten werden erst ueber `Details aktualisieren`
+  oder nach einer Speichern-/Schaltaktion geladen.
+
+## Pruefung
+
+1. Add-on aktualisieren und neu starten.
+2. Ingress hart neu laden.
+3. Zwischen Startseite, Lernen und Discovery wechseln.
+4. Erwartung: Bereits geladene Inhalte bleiben sichtbar; keine volle
+   Neuladung bei jedem Ansichtswechsel.
+5. Details eines Aktors oeffnen, wegwechseln und wieder Details oeffnen.
+   Erwartung: Die zuletzt geladene Detailansicht steht sofort wieder da.
--- a/docs/V1_6_0_OPERATING_GUIDE.md
+++ b/docs/V1_6_0_OPERATING_GUIDE.md
@@ -0,0 +1,36 @@
+# SillyHome Next v1.6.0 Operating Guide
+
+v1.6.0 trennt Startansicht, Aktoruebersicht, Discovery und Detaildaten staerker.
+
+## API-Pfade
+
+- `GET /v1/actuators/dashboard/system`
+  - nur System- und Cache-Metadaten
+  - keine Aktorenliste
+  - kein vollstaendiges Entity-Payload aus SQLite
+- `GET /v1/actuators/dashboard/start`
+  - Aktor-Summaries
+  - Entity-Metadaten nur fuer konfigurierte Aktoren
+  - keine Discovery-Gruppen und keine Jobliste
+- `GET /v1/actuators/discovery`
+  - steuerbare HA-Entities
+  - nutzt SQLite-Cache, liest HA nur bei Cache-Miss oder `refresh=true`
+- `GET /v1/actuators/{id}/detail`
+  - genau ein ausgewaehlter Aktor
+  - kompakte Modell-/Kontextdaten
+
+## Dashboard
+
+- Frontend zeigt Daten an und loest gezielte Aktionen aus.
+- Backend liefert schlanke View-Daten.
+- Worker aktualisieren HA-Entity-/Discovery-Cache beim Start und danach
+  stündlich.
+- Die Detailansicht gehoert zu einem Aktor und hat eigene Navigation:
+  Zurueck, anderes Geraet, Aktualisieren.
+
+## Erwartete Wirkung
+
+- Systemstart muss ohne Entity-Materialisierung reagieren.
+- Lernen und Details laden nur ihren eigenen Datenkern.
+- Discovery bleibt ein eigener Bedarfspfad.
+- Texte im Dashboard sind kurz und handlungsnah.
--- a/docs/V1_7_0_OPERATING_GUIDE.md
+++ b/docs/V1_7_0_OPERATING_GUIDE.md
@@ -0,0 +1,45 @@
+# SillyHome Next v1.7.0 Operating Guide
+
+v1.7.0 erweitert den Produktivbetrieb um Diagnose, Backup, Dry-run und
+Planungshilfen.
+
+## Diagnose
+
+- Jede Auswertung speichert eine kompakte `decision_timeline` am Aktor.
+- Event-basierte Auswertungen speichern zusaetzlich `latency_measurements`.
+- Die Timeline beantwortet: was war der Ausloeser, welches Ziel wurde
+  vorhergesagt, wurde geschaltet oder blockiert, und warum.
+
+## Backup und Restore
+
+- `GET /v1/actuators/backup/export` exportiert Aktoren, Reconciliation-Status
+  und Job-Historie als JSON.
+- `POST /v1/actuators/backup/restore` spielt diesen Stand wieder ein.
+- Ohne `replace_existing=true` werden vorhandene Aktoren nicht ueberschrieben.
+
+## Dry-run
+
+- `POST /v1/actuators/{entity_id}/dry-run` aktiviert oder beendet den Testmodus.
+- Im Dry-run werden freigegebene Aktionen bewertet und protokolliert, aber nicht
+  an Home Assistant gesendet.
+
+## Feedback
+
+Feedback akzeptiert neben `correct`/`expected_state` nun optionale Typen:
+
+- `correct`
+- `wrong`
+- `too_early`
+- `too_late`
+- `never_automate`
+
+`never_automate` setzt eine manuelle Sicherheitssperre am Aktor.
+
+## Planung
+
+`POST /v1/actuators/planning/refresh` berechnet lokale Hinweise:
+
+- Aktorgruppen aus gemeinsamen Raum-/Kontextdaten
+- einfache Szenenvorschlaege aus gemeinsamem Kontextverhalten
+- Agent-Insights fuer Konflikte, Latenz und auffaelliges Feedback
+
--- a/docs/automations.md
+++ b/docs/automations.md
@@ -0,0 +1,6 @@
+# Keine manuell erzeugten Automationen
+
+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
@@ -0,0 +1,52 @@
+# Home-Assistant-Datenpipeline
+
+SillyHome Next trennt aktuelle Entity-Metadaten, Discovery und historische
+Messwerte. Dadurch gelangen nur klassifizierte, geeignete Daten in spätere
+Trainings- und Erklärungsprozesse.
+
+## Entity Discovery
+
+`GET /v1/discovery` klassifiziert Home-Assistant-Entities in:
+
+- `measurement`: numerische Messsensoren, für Training geeignet
+- `binary_context`: binäre Kontextsensoren wie Bewegung oder Anwesenheit
+- `context`: Personen-, Wetter- und Standortkontext
+- `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
+- `learnable=true|false` filtert nach Trainingsrelevanz
+
+## Historische Daten
+
+Historische Zustände werden über Home Assistants
+`/api/history/period/<start>`-Schnittstelle geladen. Abfragen verlangen:
+
+- mindestens eine Entity-ID, maximal 100
+- zeitzonenbehaftete Start- und Endzeit
+- ein Enddatum nach dem Startdatum
+- maximal 31 Tage pro Abfrage
+
+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. Binäre Kontext-Entities werden bewusst nicht in numerische
+Trainingsreihen konvertiert.
+
+## Datenschutz und Betrieb
+
+Die Daten bleiben lokal. Home-Assistant-Tokens gehören ausschließlich in die
+Umgebungskonfiguration und dürfen nicht protokolliert oder versioniert werden.
+Die API sollte nur lokal oder hinter einem authentifizierenden Reverse Proxy
+erreichbar sein.
--- a/docs/ml_api.md
+++ b/docs/ml_api.md
@@ -0,0 +1,261 @@
+# ML-Serving-API
+
+Diese Dokumentation beschreibt die REST-Endpunkte der aktuellen
+Modell-Artefakt-, Vorhersage- und aktor-zentrierten Lifecycle-Schnittstelle.
+
+Das Serving verwendet ein lokal trainiertes statistisches Baseline-Modell.
+
+## Basis-URL
+
+- Standard: `http://127.0.0.1:8000/ml`
+- Health: `/health`
+- Modelle: `/models`
+- Retraining: `/retrain`
+- Evaluation: `/evaluate`
+- 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.
+
+## Endpoints
+
+### `GET /ml/health`
+
+Health-Check der ML-Services.
+
+**Beispielantwort**
+```json
+{
+  "status": "ok",
+  "updated_at": "2026-06-11T12:00:00Z"
+}
+```
+
+### `GET /ml/models`
+
+Listet alle registrierten Modell-Artefakte auf.
+
+**Beispielantwort**
+```json
+{
+  "models": ["default"]
+}
+```
+
+### `POST /ml/predict`
+
+Einzelne Vorhersage für einen Sensor.
+
+**Request**
+```json
+{
+  "modelId": "default",
+  "sensor_id": "sensor.kitchen",
+  "values": {"temperature": 21.0}
+}
+```
+
+**Antwort**
+```json
+{
+  "model_id": "default",
+  "sensor_id": "sensor.kitchen",
+  "predictions": {"temperature": 21.4},
+  "confidence": 0.78,
+  "model_type": "statistical_baseline",
+  "explanations": {
+    "temperature": {
+      "direction": "steigend",
+      "change": 0.4,
+      "sample_count": 24,
+      "historical_mean": 20.7,
+      "trend_per_step": 0.4,
+      "summary": "temperature: steigend; Prognose ..."
+    }
+  }
+}
+```
+
+Die Erklärung nennt pro Merkmal den aktuellen und prognostizierten Wert,
+Richtung, Veränderung, Datenbasis, historischen Bereich, Streuung, Trend und
+Confidence. Sie wird deterministisch aus den gespeicherten Modellparametern
+erzeugt.
+
+### `POST /ml/retrain`
+
+Trainiert die Artefakt-Metadaten aus neuen Sensordaten. Existiert `modelId`
+bereits, wird das Artefakt atomisch ersetzt und beim nächsten Prozessstart aus
+dem Modellverzeichnis geladen.
+
+**Request**
+```json
+{
+  "modelId": "home-model",
+  "samples": [
+    {
+      "sensor_id": "sensor.kitchen",
+      "values": {"temperature": 21.0},
+      "label": "occupied"
+    }
+  ]
+}
+```
+
+**Antwort**
+```json
+{
+  "model_id": "home-model",
+  "supported_sensors": ["sensor.kitchen"],
+  "trained_features": 1,
+  "model_type": "statistical_baseline",
+  "replaced": false
+}
+```
+
+### `POST /ml/evaluate`
+
+Vergleicht Modellvorhersagen mit Validierungsdaten und liefert MAE, RMSE und
+Coverage. Der Request verwendet dasselbe Sample-Format wie `/ml/retrain`.
+
+### `POST /ml/batch`
+
+Batch-Vorhersage für mehrere Sensorwerte.
+
+**Request**
+```json
+{
+  "requests": [
+    {
+      "modelId": "default",
+      "sensor_id": "sensor.kitchen",
+      "values": {"temperature": 21.0}
+    },
+    {
+      "modelId": "default",
+      "sensor_id": "sensor.bedroom",
+      "values": {"temperature": 18.5}
+    }
+  ]
+}
+```
+
+**Antwort**
+```json
+{
+  "predictions": [
+    {
+      "model_id": "default",
+      "sensor_id": "sensor.kitchen",
+      "predictions": {"temperature": 21.4},
+      "confidence": 0.78,
+      "model_type": "statistical_baseline"
+    },
+    {
+      "model_id": "default",
+      "sensor_id": "sensor.bedroom",
+      "predictions": {"temperature": 18.3},
+      "confidence": 0.74,
+      "model_type": "statistical_baseline"
+    }
+  ]
+}
+```
+
+## Fehlerfälle
+
+- `404 Not Found`: Modell nicht registriert.
+- `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`. 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
+
+- `app/ml/predictor.py`
+- `app/ml/retraining.py`
+- `app/ml/registry/model_registry.py`
+- `backend/routes/ml.py`
--- a/docs/ml_training.md
+++ b/docs/ml_training.md
@@ -0,0 +1,51 @@
+# Verhaltenslernen und Vorhersage
+
+Seit `v0.5.0` ist der produktive Lernpfad aktor-zentriert. Nutzer wählen nur
+einen Aktor; Sensoren, Kontext und Modelle werden automatisch verwaltet.
+
+## Datengrundlage
+
+Für jeden Aktor lädt SillyHome Next:
+
+- 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
+
+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.
+
+## Modell
+
+Das lokale Modell speichert pro beobachteter Handlung:
+
+- Zielzustand
+- lokale Tageszeit
+- Wochentag
+- Kontextzustände
+- Herkunft und Gewicht
+
+Eine Vorhersage bewertet zeitliche Nähe, Wochentagsmuster und aktuellen
+Kontext. Mehrere passende historische Handlungen erhöhen die Confidence.
+
+## Betriebsstufen
+
+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.
+
+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`.
+
+## Schutzmechanismen
+
+- 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
@@ -1,16 +1,23 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "sillyhome-next"
-version = "0.1.0"
+version = "1.7.3"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
  "fastapi>=0.110.0",
  "uvicorn[standard]>=0.29.0",
  "pydantic>=2.6.0",
+  "requests>=2.31.0",
+  "websockets>=12.0",
 ]

 [project.optional-dependencies]
 dev = [
+  "httpx2>=2.3.0",
  "pytest>=8.0.0",
  "ruff>=0.4.0",
  "mypy>=1.9.0",
@@ -22,7 +29,11 @@ addopts = "-q"

 [tool.mypy]
 strict = true
+files = ["app", "backend", "tests"]
+
+[tool.setuptools.packages.find]
+include = ["app*", "backend*"]

 [tool.ruff]
 line-length = 100
-target-version = "py311"
+target-version = "py311"
--- a/repository.yaml
+++ b/repository.yaml
@@ -0,0 +1,3 @@
+name: SillyHome Next Add-ons
+url: http://192.168.6.31:3000/pino/sillyhome-next
+maintainer: Pino
--- a/scripts/gitea_setup.py
+++ b/scripts/gitea_setup.py
@@ -1,5 +1,4 @@
 import requests
-import json
 from pathlib import Path

 p = Path('/root/.openclaw/secrets/gitea.env')
--- 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,702 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from time import perf_counter
+from zoneinfo import ZoneInfo
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.api.v1.actuators import _deduplicate_actuator_ids
+from app.actuators.cache_db import DashboardCache
+from app.actuators.lifecycle import ActuatorReconciliationService
+from app.actuators.models import BehaviorPattern, JobStatus, ModelSnapshot
+from app.actuators.store import ActuatorStore
+from app.behavior.engine import BehaviorEngine
+from app.config import Settings
+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
+        self.service_calls: list[tuple[str, str, dict[str, object]]] = []
+
+    def read_entities(self) -> list[HaEntitySummary]:
+        self.read_entities_calls += 1
+        return list(self._entities)
+
+    def discover(
+        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]:
+        self.service_calls.append((domain, service, service_data))
+        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",
+            state="12",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellkammer_motion",
+            domain="binary_sensor",
+            device_class="motion",
+            friendly_name="Abstellkammer Bewegung",
+            area_name="Abstellkammer",
+            state="off",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.pfsense_interface_vpn_inbytes",
+            domain="sensor",
+            device_class="data_size",
+            state_class="measurement",
+            unit_of_measurement="KiB",
+            friendly_name="pfSense Interface VPN inbytes",
+        ),
+    ]
+    settings = Settings(
+        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.dashboard_cache = DashboardCache(tmp_path / "actuators" / "dashboard_cache.sqlite3")
+    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_actuator_simulation_ranks_sensor_states_without_switching(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"],
+            },
+        )
+        store = app.state.actuator_store
+        record = store.get("light.abstellkammer")
+        now = datetime.now(timezone.utc)
+        local = now.astimezone(ZoneInfo("Europe/Berlin"))
+        local_minute = local.hour * 60 + local.minute
+        patterns = [
+            BehaviorPattern(
+                target_state="on",
+                minute_of_day=local_minute,
+                weekday=now.weekday(),
+                context_states={
+                    "sensor.abstellkammer_illuminance": "12",
+                    "binary_sensor.abstellkammer_motion": "on",
+                },
+                source="user",
+                weight=1.0,
+                observed_at=now,
+            )
+            for _ in range(3)
+        ]
+        patterns.extend(
+            [
+                BehaviorPattern(
+                    target_state="off",
+                    minute_of_day=local_minute,
+                    weekday=now.weekday(),
+                    context_states={
+                        "sensor.abstellkammer_illuminance": "12",
+                        "binary_sensor.abstellkammer_motion": "off",
+                    },
+                    source="user",
+                    weight=0.5,
+                    observed_at=now,
+                )
+                for _ in range(3)
+            ]
+        )
+        store.upsert(
+            record.model_copy(
+                update={
+                    "behavior": record.behavior.model_copy(
+                        update={
+                            "patterns": patterns,
+                            "sample_count": len(patterns),
+                            "high_confidence_sample_count": len(patterns),
+                            "activation_ready": True,
+                            "activation_reason": "Testfreigabe.",
+                        }
+                    )
+                }
+            )
+        )
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/simulate",
+            json={
+                "state_options": {"binary_sensor.abstellkammer_motion": ["off", "on"]},
+                "sensor_weights": {
+                    "binary_sensor.abstellkammer_motion": 1.0,
+                    "sensor.abstellkammer_illuminance": 0.25,
+                },
+                "max_results": 2,
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert len(payload) == 2
+    assert payload[0]["prediction"]["target_state"] == "on"
+    assert payload[0]["sensor_states"]["binary_sensor.abstellkammer_motion"] == "on"
+    assert payload[0]["sensor_weights"]["sensor.abstellkammer_illuminance"] == 0.25
+    assert app.state.ha_reader.service_calls == []
+
+
+def test_safety_profile_can_block_actuator_manually(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/safety",
+            json={
+                "safety": {
+                    "stage": "shadow",
+                    "manual_block": True,
+                    "min_confidence": 0.9,
+                    "cooldown_seconds": 120,
+                    "rules": [
+                        {
+                            "rule_id": "manual_block",
+                            "label": "Manuelle Sperre respektieren",
+                            "enabled": True,
+                            "blocking": True,
+                            "reason": "Test",
+                        }
+                    ],
+                    "note": "Test",
+                }
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["behavior"]["safety"]["manual_block"] is True
+    assert payload["behavior"]["safety"]["min_confidence"] == 0.9
+    assert payload["behavior"]["safety"]["cooldown_seconds"] == 120
+
+
+def test_feedback_adapts_sensor_weights_and_model_can_rollback(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post(
+            "/v1/actuators",
+            json={"actuator_entity_id": "light.abstellkammer"},
+        )
+        record = app.state.actuator_store.get("light.abstellkammer")
+        version_id = "model-test"
+        snapshot = ModelSnapshot(
+            version_id=version_id,
+            sample_count=1,
+            high_confidence_sample_count=1,
+            average_confidence=0.9,
+            patterns=[],
+            reason="Test-Snapshot",
+        )
+        app.state.actuator_store.upsert(
+            record.model_copy(
+                update={
+                    "behavior": record.behavior.model_copy(
+                        update={
+                            "model_snapshots": [snapshot],
+                            "active_model_version": "model-current",
+                            "sample_count": 2,
+                        }
+                    )
+                }
+            )
+        )
+
+        feedback = client.post(
+            "/v1/actuators/light.abstellkammer/feedback",
+            json={"correct": False, "expected_state": "off"},
+        )
+        rollback = client.post(
+            "/v1/actuators/light.abstellkammer/model/rollback",
+            json={"version_id": version_id},
+        )
+
+    assert feedback.status_code == 200
+    feedback_payload = feedback.json()
+    assert feedback_payload["behavior"]["adaptive_weight_updates"]
+    assert feedback_payload["manual_override"]["sensor_weights"]
+    assert rollback.status_code == 200
+    assert rollback.json()["behavior"]["active_model_version"] == version_id
+
+
+def test_feedback_never_automate_sets_manual_block(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post(
+            "/v1/actuators",
+            json={"actuator_entity_id": "light.abstellkammer"},
+        )
+
+        feedback = client.post(
+            "/v1/actuators/light.abstellkammer/feedback",
+            json={"correct": False, "kind": "never_automate"},
+        )
+
+    assert feedback.status_code == 200
+    payload = feedback.json()
+    assert payload["behavior"]["safety"]["manual_block"] is True
+    assert payload["behavior"]["feedback_log"][-1] == "never_automate"
+
+
+def test_backup_export_restore_and_planning_refresh(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        backup = client.get("/v1/actuators/backup/export")
+        dry_run = client.post(
+            "/v1/actuators/light.abstellkammer/dry-run",
+            json={"enabled": True},
+        )
+        planning = client.post("/v1/actuators/planning/refresh")
+        restore = client.post(
+            "/v1/actuators/backup/restore",
+            json={"backup": backup.json(), "replace_existing": True},
+        )
+
+    assert backup.status_code == 200
+    assert backup.json()["records"][0]["actuator_entity_id"] == "light.abstellkammer"
+    assert dry_run.status_code == 200
+    assert dry_run.json()["behavior"]["dry_run_enabled"] is True
+    assert planning.status_code == 200
+    assert "agent_insights" in planning.json()[0]["behavior"]
+    assert restore.status_code == 200
+    assert restore.json()["restored_records"] == 1
+
+
+def test_summary_is_lightweight_and_uses_cached_entity_metadata(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.get("/v1/actuators/summary")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload[0]["actuator_entity_id"] == "light.abstellkammer"
+    assert payload[0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload[0]["area_name"] == "Abstellkammer"
+    assert "behavior" not in payload[0]
+    assert "numeric_candidates" not in payload[0]
+
+
+def test_dashboard_overview_uses_cache_without_ha_roundtrip(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        reader = app.state.ha_reader
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        calls_before = reader.read_entities_calls
+
+        response = client.get("/v1/actuators/dashboard")
+
+    assert response.status_code == 200
+    assert reader.read_entities_calls == calls_before
+    payload = response.json()
+    assert payload["cache"]["available"] is True
+    assert payload["cache"]["entity_count"] == 4
+    assert payload["actuators"][0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload["discovery_groups"]
+    assert payload["jobs"]["jobs"][-1]["kind"] == "discovery"
+
+
+def test_reconciliation_run_records_visible_job_queue(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post("/v1/actuators/reconciliation/run")
+        jobs = client.get("/v1/actuators/job-queue/state")
+
+    assert response.status_code == 200
+    assert jobs.status_code == 200
+    payload = jobs.json()
+    assert [job["kind"] for job in payload["jobs"][-3:]] == [
+        "reconciliation",
+        "training",
+        "evaluation",
+    ]
+    assert payload["jobs"][-1]["status"] == "completed"
+
+
+def test_dashboard_start_path_stays_within_three_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/start")
+        dashboard_elapsed = perf_counter() - dashboard_started_at
+
+    assert root_response.status_code == 200
+    assert dashboard_response.status_code == 200
+    assert root_elapsed < 3.0
+    assert dashboard_elapsed < 3.0
+
+
+def test_dashboard_reports_performance_budget_and_anomalies(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"})
+        store = app.state.actuator_store
+        job = store.start_job(kind="training", trigger="test", summary="Langsamer Testjob")
+        queue = store.load_job_queue()
+        queue.jobs = [
+            item.model_copy(update={"started_at": datetime.now(timezone.utc) - timedelta(seconds=4)})
+            if item.job_id == job.job_id
+            else item
+            for item in queue.jobs
+        ]
+        store._persist_job_queue(queue)
+        store.finish_job(job.job_id, status=JobStatus.COMPLETED, summary="Fertig")
+
+        dashboard_response = client.get("/v1/actuators/dashboard")
+        start_response = client.get("/v1/actuators/dashboard/start")
+        system_response = client.get("/v1/actuators/dashboard/system")
+        anomalies_response = client.get("/v1/actuators/anomalies")
+
+    assert dashboard_response.status_code == 200
+    assert start_response.status_code == 200
+    assert system_response.status_code == 200
+    system = dashboard_response.json()["system"]
+    start_payload = start_response.json()
+    assert start_payload["jobs"]["jobs"] == []
+    assert start_payload["discovery_groups"] == []
+    assert system_response.json()["actuators"] == []
+    assert system["performance_budget_ms"] == 3000
+    assert system["slow_job_count"] == 1
+    assert system["performance_status"] == "slow"
+    assert system["anomaly_count"] >= 1
+    assert anomalies_response.status_code == 200
+    assert anomalies_response.json()
+
+
+def test_dashboard_system_and_start_do_not_materialize_entity_cache(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> 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"})
+
+        def fail_full_payload(self: DashboardCache) -> dict[str, object]:
+            raise AssertionError("full entity payload must not be loaded")
+
+        monkeypatch.setattr(DashboardCache, "load_entities_payload", fail_full_payload)
+
+        system_response = client.get("/v1/actuators/dashboard/system")
+        start_response = client.get("/v1/actuators/dashboard/start")
+
+    assert system_response.status_code == 200
+    assert system_response.json()["actuators"] == []
+    assert system_response.json()["cache"]["entity_count"] == 4
+    assert start_response.status_code == 200
+    assert start_response.json()["actuators"][0]["friendly_name"] == "Abstellkammer Licht"
+
+
+def test_actuator_detail_uses_compact_payload(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/light.abstellkammer/detail")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["behavior"]["patterns"] == []
+    assert all(
+        snapshot["patterns"] == []
+        for snapshot in payload["behavior"]["model_snapshots"]
+    )
+
+
+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
@@ -0,0 +1,17 @@
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+def test_automation_api_is_not_exposed() -> None:
+    with TestClient(app) as client:
+        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"},
+            },
+        )
+
+    assert response.status_code == 404
--- a/tests/api/test_entities.py
+++ b/tests/api/test_entities.py
@@ -1,10 +1,146 @@
+from collections.abc import Sequence
+from datetime import datetime
+
 from fastapi.testclient import TestClient
+
+from app.ha.exceptions import HaTimeoutError
+from app.ha.discovery import DiscoveredEntity, EntityRole
+from app.ha.history import EntityHistorySeries, NumericHistoryPoint
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
 from app.main import app

-client = TestClient(app)
+
+class FakeHaReader(HaReader):
+    def __init__(self) -> None:
+        pass
+
+    def read_entities(self) -> Sequence[HaEntitySummary]:
+        return [HaEntitySummary(entity_id="sensor.temperature", domain="sensor")]
+
+    def discover(
+        self,
+        domains: set[str] | None = None,
+        learnable: bool | None = None,
+    ) -> Sequence[DiscoveredEntity]:
+        result = DiscoveredEntity(
+            entity_id="sensor.temperature",
+            domain="sensor",
+            device_class="temperature",
+            category="temperature",
+            role=EntityRole.MEASUREMENT,
+            learnable=True,
+            reason="Numerischer Messsensor für Zeitreihen und Training.",
+        )
+        if domains and result.domain not in domains:
+            return []
+        if learnable is not None and result.learnable is not learnable:
+            return []
+        return [result]
+
+    def read_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[EntityHistorySeries]:
+        return [
+            EntityHistorySeries(
+                entity_id=entity_ids[0],
+                points=[NumericHistoryPoint(timestamp=start_time, value=21.5)],
+            )
+        ]
+
+
+class TimeoutHaReader(HaReader):
+    def __init__(self) -> None:
+        pass
+
+    def read_entities(self) -> Sequence[HaEntitySummary]:
+        raise HaTimeoutError("contains internal details that must not leak")


 def test_openapi_docs_are_available() -> None:
-    response = client.get("/docs")
+    with TestClient(app) as client:
+        response = client.get("/docs")
    assert response.status_code == 200
    assert "SillyHome Next API" in response.text
+
+
+def test_entities_returns_reader_data() -> None:
+    with TestClient(app) as client:
+        app.state.ha_reader = FakeHaReader()
+        response = client.get("/v1/entities")
+    assert response.status_code == 200
+    assert response.json() == [
+        {
+                "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,
+        }
+    ]
+
+
+def test_entities_returns_503_without_home_assistant_config() -> None:
+    with TestClient(app) as client:
+        response = client.get("/v1/entities")
+    assert response.status_code == 503
+
+
+def test_entities_maps_ha_errors_without_leaking_details() -> None:
+    with TestClient(app) as client:
+        app.state.ha_reader = TimeoutHaReader()
+        response = client.get("/v1/entities")
+    assert response.status_code == 504
+    assert response.json() == {"detail": "Home Assistant request timed out."}
+
+
+def test_discovery_filters_entities() -> None:
+    with TestClient(app) as client:
+        app.state.ha_reader = FakeHaReader()
+        response = client.get("/v1/discovery?domain=sensor&learnable=true")
+
+    assert response.status_code == 200
+    assert response.json() == [
+        {
+            "entity_id": "sensor.temperature",
+            "domain": "sensor",
+            "device_class": "temperature",
+            "state_class": None,
+            "unit_of_measurement": None,
+            "category": "temperature",
+            "role": "measurement",
+            "learnable": True,
+            "reason": "Numerischer Messsensor für Zeitreihen und Training.",
+        }
+    ]
+
+
+def test_history_returns_normalized_series() -> None:
+    with TestClient(app) as client:
+        app.state.ha_reader = FakeHaReader()
+        response = client.get(
+            "/v1/history",
+            params=[
+                ("entity_id", "sensor.temperature"),
+                ("start_time", "2026-06-01T00:00:00Z"),
+                ("end_time", "2026-06-02T00:00:00Z"),
+            ],
+        )
+
+    assert response.status_code == 200
+    assert response.json() == [
+        {
+            "entity_id": "sensor.temperature",
+            "points": [{"timestamp": "2026-06-01T00:00:00Z", "value": 21.5}],
+        }
+    ]
--- a/tests/api/test_ml_routes.py
+++ b/tests/api/test_ml_routes.py
@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+
+def test_ml_routes_are_exposed_by_production_app() -> None:
+    with TestClient(app) as client:
+        health = client.get("/ml/health")
+        models = client.get("/ml/models")
+
+    assert health.status_code == 200
+    assert models.status_code == 200
+    assert isinstance(models.json()["models"], list)
+
+
+def test_unknown_model_returns_404() -> None:
+    with TestClient(app) as client:
+        response = client.post(
+            "/ml/predict",
+            json={
+                "modelId": "missing",
+                "sensor_id": "sensor.kitchen",
+                "values": {"temperature": 21.0},
+            },
+        )
+
+    assert response.status_code == 404
+
+
+def test_unsupported_sensor_returns_422(tmp_path: Path) -> None:
+    from app.ml.registry.model_registry import ModelRegistry
+    from app.ml.training import TrainedArtifact
+
+    registry = ModelRegistry(tmp_path)
+    registry.register(TrainedArtifact("default", ("sensor.kitchen",)))
+
+    with TestClient(app) as client:
+        app.state.registry = registry
+        response = client.post(
+            "/ml/predict",
+            json={
+                "modelId": "default",
+                "sensor_id": "sensor.unknown",
+                "values": {"temperature": 21.0},
+            },
+        )
+
+    assert response.status_code == 422
+
+
+def test_retrain_creates_and_replaces_persisted_model(tmp_path: Path) -> None:
+    from app.ml.registry.model_registry import ModelRegistry
+
+    registry = ModelRegistry(tmp_path)
+    with TestClient(app) as client:
+        app.state.registry = registry
+        created = client.post(
+            "/ml/retrain",
+            json={
+                "modelId": "home-model",
+                "samples": [
+                    {
+                        "sensor_id": "sensor.kitchen",
+                        "values": {"temperature": 21.0},
+                    }
+                ],
+            },
+        )
+        replaced = client.post(
+            "/ml/retrain",
+            json={
+                "modelId": "home-model",
+                "samples": [
+                    {
+                        "sensor_id": "sensor.bedroom",
+                        "values": {"temperature": 18.0},
+                    }
+                ],
+            },
+        )
+
+    assert created.status_code == 200
+    assert created.json() == {
+        "model_id": "home-model",
+        "supported_sensors": ["sensor.kitchen"],
+        "trained_features": 1,
+        "model_type": "statistical_baseline",
+        "replaced": False,
+    }
+    assert replaced.status_code == 200
+    assert replaced.json() == {
+        "model_id": "home-model",
+        "supported_sensors": ["sensor.bedroom"],
+        "trained_features": 1,
+        "model_type": "statistical_baseline",
+        "replaced": True,
+    }
+    restarted = ModelRegistry(tmp_path)
+    assert restarted.load_artifact("home-model").supported_sensors == ("sensor.bedroom",)
+
+
+def test_retrain_rejects_empty_samples() -> None:
+    with TestClient(app) as client:
+        response = client.post(
+            "/ml/retrain",
+            json={"modelId": "home-model", "samples": []},
+        )
+
+    assert response.status_code == 422
+
+
+def test_predict_returns_numeric_forecast_and_confidence(tmp_path: Path) -> None:
+    from app.ml.feature_store import FeatureStore, FeatureVector
+    from app.ml.registry.model_registry import ModelRegistry
+    from app.ml.training import TrainingPipeline
+
+    store = FeatureStore()
+    store.add_batch(
+        [
+            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
+            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
+        ]
+    )
+    registry = ModelRegistry(tmp_path)
+    registry.register(TrainingPipeline(store).run("home-model"))
+
+    with TestClient(app) as client:
+        app.state.registry = registry
+        response = client.post(
+            "/ml/predict",
+            json={
+                "modelId": "home-model",
+                "sensor_id": "sensor.kitchen",
+                "values": {"temperature": 21.0},
+            },
+        )
+
+    assert response.status_code == 200
+    assert response.json()["predictions"] == {"temperature": 22.0}
+    assert 0.0 < response.json()["confidence"] <= 1.0
+    assert response.json()["model_type"] == "statistical_baseline"
+    explanation = response.json()["explanations"]["temperature"]
+    assert explanation["direction"] == "steigend"
+    assert explanation["change"] == 1.0
+    assert explanation["sample_count"] == 2
+
+
+def test_evaluate_returns_real_error_metrics(tmp_path: Path) -> None:
+    from app.ml.feature_store import FeatureStore, FeatureVector
+    from app.ml.registry.model_registry import ModelRegistry
+    from app.ml.training import TrainingPipeline
+
+    store = FeatureStore()
+    store.add_batch(
+        [
+            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
+            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
+        ]
+    )
+    registry = ModelRegistry(tmp_path)
+    registry.register(TrainingPipeline(store).run("home-model"))
+
+    with TestClient(app) as client:
+        app.state.registry = registry
+        response = client.post(
+            "/ml/evaluate",
+            json={
+                "modelId": "home-model",
+                "samples": [
+                    {
+                        "sensor_id": "sensor.kitchen",
+                        "values": {"temperature": 21.0},
+                    }
+                ],
+            },
+        )
+
+    assert response.status_code == 200
+    metrics = {metric["name"]: metric["value"] for metric in response.json()["metrics"]}
+    assert metrics == {"mae": 1.0, "rmse": 1.0, "coverage": 1.0}
--- a/tests/automations/test_store.py
+++ b/tests/automations/test_store.py
@@ -0,0 +1,53 @@
+from pathlib import Path
+
+import pytest
+
+from app.automations.models import (
+    AutomationProposal,
+    NumericStateTrigger,
+    ProposalStatus,
+    ServiceAction,
+)
+from app.automations.store import AutomationStore
+
+
+def proposal() -> AutomationProposal:
+    return AutomationProposal(
+        alias="Wohnzimmer bei Kälte heizen",
+        description="Aktiviert den Heizmodus unter 18 Grad.",
+        trigger=NumericStateTrigger(entity_id="sensor.living_room_temperature", below=18.0),
+        action=ServiceAction(
+            service="climate.set_temperature",
+            entity_id="climate.living_room",
+            data={"temperature": 21.0},
+        ),
+    )
+
+
+def test_store_persists_approval_and_exports_yaml(tmp_path: Path) -> None:
+    store = AutomationStore(tmp_path)
+    created = store.create(proposal())
+    approved = store.decide(created.proposal_id, ProposalStatus.APPROVED, 1)
+    yaml = AutomationStore(tmp_path).export_yaml(created.proposal_id)
+    assert approved.status is ProposalStatus.APPROVED
+    assert approved.revision == 2
+    assert "platform: numeric_state" in yaml
+    assert "service: climate.set_temperature" in yaml
+    assert "temperature: 21.0" in yaml
+
+
+def test_store_requires_approval_and_current_revision(tmp_path: Path) -> None:
+    store = AutomationStore(tmp_path)
+    created = store.create(proposal())
+    with pytest.raises(ValueError, match="freigegebene"):
+        store.export_yaml(created.proposal_id)
+    with pytest.raises(ValueError, match="Revision"):
+        store.decide(created.proposal_id, ProposalStatus.APPROVED, 2)
+
+
+def test_store_allows_only_one_decision(tmp_path: Path) -> None:
+    store = AutomationStore(tmp_path)
+    created = store.create(proposal())
+    store.decide(created.proposal_id, ProposalStatus.REJECTED, 1)
+    with pytest.raises(ValueError, match="bereits entschieden"):
+        store.decide(created.proposal_id, ProposalStatus.APPROVED, 2)
--- a/tests/behavior/test_engine.py
+++ b/tests/behavior/test_engine.py
@@ -0,0 +1,906 @@
+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"})
+    ]
+
+
+def test_event_evaluation_records_decision_timeline_and_latency(
+    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="on",
+                last_changed=now,
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.evaluate(
+        "light.storage",
+        trigger_entity_id="binary_sensor.storage_door",
+        trigger_state="on",
+        event_received_at=now,
+    )
+
+    trace = result.behavior.decision_timeline[-1]
+    latency = result.behavior.latency_measurements[-1]
+    assert trace.trigger_entity_id == "binary_sensor.storage_door"
+    assert trace.target_state == "on"
+    assert trace.executed is True
+    assert latency.trigger_entity_id == "binary_sensor.storage_door"
+    assert latency.executed is True
+
+
+def test_dry_run_records_without_calling_service(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,
+                    "dry_run_enabled": 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="on",
+                last_changed=now,
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.evaluate("light.storage")
+
+    assert reader.service_calls == []
+    assert result.behavior.dry_run_sample_count == 1
+    assert result.behavior.decision_timeline[-1].executed is False
--- a/tests/ha/test_discovery.py
+++ b/tests/ha/test_discovery.py
@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ha.discovery import EntityRole, classify_entity, discover_entities
+from app.ha.models import HaEntitySummary
+
+
+@pytest.mark.parametrize(
+    ("entity", "role", "learnable"),
+    [
+        (
+            HaEntitySummary(
+                entity_id="sensor.temperature",
+                domain="sensor",
+                device_class="temperature",
+                state_class="measurement",
+                unit_of_measurement="°C",
+            ),
+            EntityRole.MEASUREMENT,
+            True,
+        ),
+        (
+            HaEntitySummary(
+                entity_id="binary_sensor.motion",
+                domain="binary_sensor",
+                device_class="motion",
+            ),
+            EntityRole.BINARY_CONTEXT,
+            True,
+        ),
+        (
+            HaEntitySummary(entity_id="person.simon", domain="person"),
+            EntityRole.CONTEXT,
+            True,
+        ),
+        (
+            HaEntitySummary(entity_id="light.living_room", domain="light"),
+            EntityRole.ACTUATOR,
+            False,
+        ),
+        (
+            HaEntitySummary(entity_id="camera.driveway", domain="camera"),
+            EntityRole.UNSUPPORTED,
+            False,
+        ),
+    ],
+)
+def test_classify_entity(
+    entity: HaEntitySummary,
+    role: EntityRole,
+    learnable: bool,
+) -> None:
+    result = classify_entity(entity)
+    assert result.role is role
+    assert result.learnable is learnable
+
+
+def test_discovery_filters_domain_and_learnable() -> None:
+    entities = [
+        HaEntitySummary(
+            entity_id="sensor.temperature",
+            domain="sensor",
+            device_class="temperature",
+        ),
+        HaEntitySummary(entity_id="sensor.status", domain="sensor"),
+        HaEntitySummary(
+            entity_id="binary_sensor.motion",
+            domain="binary_sensor",
+            device_class="motion",
+        ),
+    ]
+
+    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
@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import Mock
+
+import pytest
+import requests
+
+from app.ha.client import HaClient, HaClientSettings
+from app.ha.exceptions import (
+    HaAuthError,
+    HaHttpError,
+    HaTimeoutError,
+    HaUnexpectedPayloadError,
+)
+
+
+def _client_with_response(response: Mock) -> HaClient:
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.get = Mock(return_value=response)  # type: ignore[method-assign]
+    return client
+
+
+def _response(status_code: int = 200, payload: object | None = None) -> Mock:
+    response = Mock()
+    response.status_code = status_code
+    response.json.return_value = [] if payload is None else payload
+    if status_code >= 400:
+        response.raise_for_status.side_effect = requests.HTTPError("upstream failed")
+    return response
+
+
+def test_list_entities_returns_home_assistant_payload() -> None:
+    payload = [{"entity_id": "sensor.temperature", "state": "21"}]
+    client = _client_with_response(_response(payload=payload))
+    assert client.list_entities() == payload
+
+
+def test_list_entities_maps_timeout() -> None:
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.get = Mock(side_effect=requests.Timeout("timed out"))  # type: ignore[method-assign]
+    with pytest.raises(HaTimeoutError):
+        client.list_entities()
+
+
+@pytest.mark.parametrize("status_code", [401, 403])
+def test_list_entities_maps_auth_errors(status_code: int) -> None:
+    client = _client_with_response(_response(status_code=status_code))
+    with pytest.raises(HaAuthError) as exc_info:
+        client.list_entities()
+    assert exc_info.value.status_code == status_code
+
+
+def test_list_entities_maps_http_errors() -> None:
+    client = _client_with_response(_response(status_code=500))
+    with pytest.raises(HaHttpError) as exc_info:
+        client.list_entities()
+    assert exc_info.value.status_code == 500
+
+
+def test_list_entities_rejects_invalid_json() -> None:
+    response = _response()
+    response.json.side_effect = ValueError("not json")
+    client = _client_with_response(response)
+    with pytest.raises(HaUnexpectedPayloadError):
+        client.list_entities()
+
+
+def test_list_entities_rejects_non_list_payload() -> None:
+    client = _client_with_response(_response(payload={"entity_id": "sensor.temperature"}))
+    with pytest.raises(HaUnexpectedPayloadError):
+        client.list_entities()
+
+
+def test_get_history_calls_home_assistant_history_api() -> None:
+    response = _response(payload=[[{"entity_id": "sensor.temperature", "state": "21.0"}]])
+    client = _client_with_response(response)
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
+
+    payload = client.get_history(["sensor.temperature"], start, end)
+
+    assert payload == [[{"entity_id": "sensor.temperature", "state": "21.0"}]]
+    client._session.get.assert_called_once()  # type: ignore[attr-defined]
+    call = client._session.get.call_args  # type: ignore[attr-defined]
+    assert "/api/history/period/2026-06-01T00:00:00+00:00" in call.args[0]
+    assert call.kwargs["params"]["filter_entity_id"] == "sensor.temperature"
+    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"),
+    [
+        (
+            [],
+            datetime(2026, 6, 1, tzinfo=timezone.utc),
+            datetime(2026, 6, 2, tzinfo=timezone.utc),
+        ),
+        (
+            ["sensor.temperature"],
+            datetime(2026, 6, 1),
+            datetime(2026, 6, 2, tzinfo=timezone.utc),
+        ),
+        (
+            ["sensor.temperature"],
+            datetime(2026, 6, 2, tzinfo=timezone.utc),
+            datetime(2026, 6, 1, tzinfo=timezone.utc),
+        ),
+        (
+            ["invalid entity"],
+            datetime(2026, 6, 1, tzinfo=timezone.utc),
+            datetime(2026, 6, 2, tzinfo=timezone.utc),
+        ),
+        (
+            ["sensor.temperature"],
+            datetime(2026, 5, 1, tzinfo=timezone.utc),
+            datetime(2026, 6, 2, tzinfo=timezone.utc),
+        ),
+    ],
+)
+def test_get_history_validates_request(
+    entity_ids: list[str],
+    start: datetime,
+    end: datetime,
+) -> None:
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    with pytest.raises(ValueError):
+        client.get_history(entity_ids, start, end)
--- a/tests/ha/test_ha_reader.py
+++ b/tests/ha/test_ha_reader.py
@@ -1,7 +1,9 @@
 from __future__ import annotations

+from datetime import datetime, timezone
+
 from app.ha.client import HaClient, HaClientSettings
-from app.ha.models import HaEntitySummary, HaState
+from app.ha.exceptions import HaHttpError
 from app.ha.reader import HaReader


@@ -14,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",
@@ -27,6 +30,55 @@ class FakeHaClient(HaClient):
            },
        ]

+    def get_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[object]:
+        return [
+            [
+                {
+                    "entity_id": entity_ids[0],
+                    "state": "21.5",
+                    "last_changed": start_time.isoformat(),
+                }
+            ]
+        ]
+
+    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())
@@ -36,3 +88,86 @@ 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:
+    reader = HaReader(FakeHaClient())
+
+    discovered = reader.discover(learnable=True)
+
+    assert [entity.entity_id for entity in discovered] == ["sensor.temperature"]
+
+
+def test_ha_reader_normalizes_history() -> None:
+    reader = HaReader(FakeHaClient())
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+
+    history = reader.read_history(
+        ["sensor.temperature"],
+        start,
+        datetime(2026, 6, 2, tzinfo=timezone.utc),
+    )
+
+    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
@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pytest
+
+from app.ha.exceptions import HaUnexpectedPayloadError
+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:
+    payload = [
+        [
+            {
+                "entity_id": "sensor.temperature",
+                "state": "22.5",
+                "last_changed": "2026-06-01T12:15:00+00:00",
+            },
+            {
+                "state": "21.0",
+                "last_changed": "2026-06-01T12:00:00Z",
+            },
+        ],
+        [
+            {
+                "entity_id": "sensor.humidity",
+                "state": 45,
+                "last_updated": "2026-06-01T12:00:00+00:00",
+            }
+        ],
+    ]
+
+    result = normalize_history_payload(payload)
+
+    assert [series.entity_id for series in result] == [
+        "sensor.humidity",
+        "sensor.temperature",
+    ]
+    temperature = result[1]
+    assert [point.value for point in temperature.points] == [21.0, 22.5]
+    assert temperature.points[0].timestamp == datetime(
+        2026, 6, 1, 12, 0, tzinfo=timezone.utc
+    )
+
+
+def test_normalize_history_payload_skips_non_numeric_and_non_finite_states() -> None:
+    payload = [
+        [
+            {
+                "entity_id": "sensor.temperature",
+                "state": state,
+                "last_changed": "2026-06-01T12:00:00+00:00",
+            }
+            for state in ("unknown", "unavailable", "nan", "inf", "-inf", True, None)
+        ]
+    ]
+
+    assert normalize_history_payload(payload) == []
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {},
+        [{}],
+        [["invalid"]],
+        [[{"entity_id": "invalid", "state": "21", "last_changed": "2026-06-01"}]],
+        [[{"entity_id": "sensor.a", "state": "21", "last_changed": "invalid"}]],
+        [[{"state": "21", "last_changed": "2026-06-01T12:00:00+00:00"}]],
+        [
+            [
+                {
+                    "entity_id": "sensor.a",
+                    "state": "21",
+                    "last_changed": "2026-06-01T12:00:00+00:00",
+                },
+                {
+                    "entity_id": "sensor.b",
+                    "state": "22",
+                    "last_changed": "2026-06-01T12:01:00+00:00",
+                },
+            ]
+        ],
+    ],
+)
+def test_normalize_history_payload_rejects_malformed_structure(payload: object) -> None:
+    with pytest.raises(HaUnexpectedPayloadError):
+        normalize_history_payload(payload)
+
+
+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/ml/test_evaluation.py
+++ b/tests/ml/test_evaluation.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.evaluation import Evaluator
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.training import TrainingPipeline
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def evaluator_factory() -> Evaluator:
+    store = FeatureStore()
+    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
+    pipeline = TrainingPipeline(store)
+    pipeline.run("artifact_v1")
+    return Evaluator(pipeline)
+
+
+def test_evaluate_returns_report_with_metrics() -> None:
+    evaluator = evaluator_factory()
+    report = evaluator.evaluate(
+        "artifact_v1",
+        [
+            _vector("sensor.kitchen", 21.0),
+            _vector("sensor.bedroom", 18.5),
+        ],
+    )
+    assert report.artifact_id == "artifact_v1"
+    assert report.sample_size == 2
+    assert {metric.name for metric in report.metrics} == {"mae", "rmse", "coverage"}
+    assert next(metric.value for metric in report.metrics if metric.name == "coverage") == 1.0
+    assert next(metric.value for metric in report.metrics if metric.name == "mae") == 0.0
+
+
+def test_evaluate_without_training_raises_value_error() -> None:
+    evaluator = Evaluator(TrainingPipeline(FeatureStore()))
+    with pytest.raises(ValueError):
+        evaluator.evaluate("artifact_v1", [])
+
+
+def test_coverage_counts_only_supported_sensor_features() -> None:
+    evaluator = evaluator_factory()
+    report = evaluator.evaluate(
+        "artifact_v1",
+        [
+            _vector("sensor.kitchen", 21.0),
+            FeatureVector(sensor_id="sensor.kitchen", values={"humidity": 50.0}),
+            _vector("sensor.kitchen_extra", 20.0),
+        ],
+    )
+
+    metrics = {metric.name: metric.value for metric in report.metrics}
+    assert metrics["coverage"] == pytest.approx(1 / 3)
--- a/tests/ml/test_explanation.py
+++ b/tests/ml/test_explanation.py
@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from app.ml.explanation import explain_feature
+from app.ml.training import FeatureModel
+
+
+def _model(slope: float) -> FeatureModel:
+    return FeatureModel(
+        sample_count=4,
+        mean=20.0,
+        standard_deviation=1.0,
+        minimum=18.0,
+        maximum=22.0,
+        slope=slope,
+        intercept=18.5,
+    )
+
+
+def test_explain_feature_describes_rising_forecast() -> None:
+    explanation = explain_feature("temperature", 21.0, 21.5, _model(0.5))
+
+    assert explanation.direction == "steigend"
+    assert explanation.change == 0.5
+    assert explanation.historical_range == (18.0, 22.0)
+    assert "4 Messwerte" in explanation.summary
+    assert "Trend +0.500" in explanation.summary
+
+
+def test_explain_feature_describes_stable_and_falling_forecasts() -> None:
+    stable = explain_feature("humidity", 50.0, 50.0, _model(0.0))
+    falling = explain_feature("temperature", 21.0, 20.5, _model(-0.5))
+
+    assert stable.direction == "stabil"
+    assert falling.direction == "fallend"
--- a/tests/ml/test_feature_store.py
+++ b/tests/ml/test_feature_store.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def test_append_and_latest_returns_last_vector() -> None:
+    store = FeatureStore()
+    vectors = [_vector("sensor.living_room", 20.0), _vector("sensor.living_room", 21.5)]
+    for item in vectors:
+        store.add(item)
+    assert store.latest("sensor.living_room") == vectors[-1]
+
+
+def test_latest_returns_none_when_empty() -> None:
+    store = FeatureStore()
+    assert store.latest("sensor.living_room") is None
+
+
+def test_add_batch_appends_all_vectors() -> None:
+    store = FeatureStore()
+    vectors = [
+        _vector("sensor.kitchen", 19.0),
+        _vector("sensor.kitchen", 20.0),
+        _vector("sensor.bathroom", 23.5),
+    ]
+    store.add_batch(vectors)
+    assert len(store.all()) == 3
+    latest = store.latest("sensor.kitchen")
+    assert latest is not None
+    assert latest.values["temperature"] == 20.0
+
+
+def test_different_sensors_are_stored_independently() -> None:
+    store = FeatureStore()
+    store.add(_vector("sensor.living_room", 21.0))
+    store.add(_vector("sensor.bedroom", 18.5))
+    living_room = store.latest("sensor.living_room")
+    bedroom = store.latest("sensor.bedroom")
+    assert living_room is not None
+    assert bedroom is not None
+    assert living_room.values["temperature"] == 21.0
+    assert bedroom.values["temperature"] == 18.5
--- a/tests/ml/test_model_registry.py
+++ b/tests/ml/test_model_registry.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.training import TrainedArtifact
+
+
+def test_registry_loads_persisted_artifacts_after_restart(tmp_path: Path) -> None:
+    registry = ModelRegistry(tmp_path)
+    artifact = TrainedArtifact("model-v1", ("sensor.kitchen", "sensor.bedroom"))
+    registry.register(artifact)
+
+    restarted = ModelRegistry(tmp_path)
+
+    assert restarted.load_artifact("model-v1") == artifact
+
+
+def test_registry_persists_statistical_parameters(tmp_path: Path) -> None:
+    from app.ml.feature_store import FeatureStore, FeatureVector
+    from app.ml.training import TrainingPipeline
+
+    store = FeatureStore()
+    store.add_batch(
+        [
+            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
+            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
+        ]
+    )
+    artifact = TrainingPipeline(store).run("model-v1")
+
+    ModelRegistry(tmp_path).register(artifact)
+
+    assert ModelRegistry(tmp_path).load_artifact("model-v1") == artifact
+
+
+def test_registry_replaces_persisted_artifact_after_restart(tmp_path: Path) -> None:
+    registry = ModelRegistry(tmp_path)
+    registry.register(TrainedArtifact("model-v1", ("sensor.kitchen",)))
+    replacement = TrainedArtifact("model-v1", ("sensor.bedroom",))
+
+    registry.register(replacement)
+
+    assert registry.load_artifact("model-v1") == replacement
+    assert ModelRegistry(tmp_path).load_artifact("model-v1") == replacement
+
+
+@pytest.mark.parametrize("artifact_id", ["../escape", "nested/model", "..", ""])
+def test_registry_rejects_unsafe_artifact_ids(tmp_path: Path, artifact_id: str) -> None:
+    registry = ModelRegistry(tmp_path)
+
+    with pytest.raises(ValueError):
+        registry.register(TrainedArtifact(artifact_id, ("sensor.kitchen",)))
+
+    assert list(tmp_path.parent.glob("escape.json")) == []
+
+
+def test_registry_rejects_corrupt_persisted_artifact(tmp_path: Path) -> None:
+    (tmp_path / "broken.json").write_text(
+        json.dumps({"artifact_id": "../broken", "supported_sensors": []}),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ValueError, match="broken.json"):
+        ModelRegistry(tmp_path)
--- a/tests/ml/test_predictor.py
+++ b/tests/ml/test_predictor.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.predictor import Predictor
+from app.ml.training import TrainingPipeline
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def predictor() -> Predictor:
+    store = FeatureStore()
+    store.add_batch(
+        [
+            _vector("sensor.kitchen", 19.0),
+            _vector("sensor.kitchen", 20.0),
+            _vector("sensor.bedroom", 18.5),
+        ]
+    )
+    pipeline = TrainingPipeline(store)
+    pipeline.run("artifact_v1")
+    return Predictor(pipeline)
+
+
+def test_predict_returns_statistical_forecast() -> None:
+    p = predictor()
+    result = p.predict("artifact_v1", _vector("sensor.kitchen", 21.0))
+    assert result.artifact_id == "artifact_v1"
+    assert result.sensor_id == "sensor.kitchen"
+    assert result.predictions == {"temperature": 22.0}
+    assert 0.0 < result.confidence <= 1.0
+    assert result.model_type == "statistical_baseline"
+    explanation = result.explanations["temperature"]
+    assert explanation.direction == "steigend"
+    assert explanation.current_value == 21.0
+    assert explanation.predicted_value == 22.0
+    assert explanation.sample_count == 2
+
+
+def test_predict_rejects_unknown_sensor() -> None:
+    p = predictor()
+    with pytest.raises(ValueError):
+        p.predict("artifact_v1", _vector("sensor.unknown", 10.0))
+
+
+def test_predict_batch_matches_single_calls() -> None:
+    p = predictor()
+    entities = [_vector("sensor.kitchen", 21.0), _vector("sensor.bedroom", 19.0)]
+    assert p.predict_batch("artifact_v1", entities) == [
+        p.predict("artifact_v1", item) for item in entities
+    ]
+
+
+def test_default_artifact_returns_last_registered() -> None:
+    store = FeatureStore()
+    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
+    pipeline = TrainingPipeline(store)
+    pipeline.run("first")
+    pipeline.run("second")
+    assert Predictor.default_artifact(pipeline).artifact_id == "second"
--- a/tests/ml/test_retraining.py
+++ b/tests/ml/test_retraining.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from app.ml.feature_store import FeatureVector
+from app.ml.registry.model_registry import ModelRegistry
+from app.ml.retraining import RetrainingService, retrain_model
+
+
+def _vector(sensor_id: str) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": 21.0})
+
+
+def test_retraining_registers_new_artifact(tmp_path: Path) -> None:
+    registry = ModelRegistry(tmp_path)
+
+    result = retrain_model(registry, "home-model", [_vector("sensor.kitchen")])
+
+    assert result.replaced is False
+    assert registry.load_artifact("home-model") == result.artifact
+
+
+def test_retraining_replaces_existing_artifact(tmp_path: Path) -> None:
+    registry = ModelRegistry(tmp_path)
+    service = RetrainingService(registry)
+    service.retrain("home-model", [_vector("sensor.kitchen")])
+
+    result = service.retrain("home-model", [_vector("sensor.bedroom")])
+
+    assert result.replaced is True
+    assert result.artifact.supported_sensors == ("sensor.bedroom",)
+    assert ModelRegistry(tmp_path).load_artifact("home-model") == result.artifact
+
+
+def test_retraining_rejects_empty_training_data(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="keine Trainingsdaten"):
+        retrain_model(ModelRegistry(tmp_path), "home-model", [])
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`"""Learning and prediction for actuator behavior."""`
				`@@ -0,0 +1 @@`
				`"""Secondary application entry points for SillyHome Next."""`