Add safety dashboard and decision transparency

CHANGELOG.md

@@ -1,5 +1,213 @@
 # Changelog
 
+## 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

README.md

@@ -11,6 +11,12 @@ nach einer ausdrücklichen Freigabe ausführen.
   [`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)
 - Arbeitsregeln für Coding-Agenten: [`AGENTS.md`](AGENTS.md)
 
 ## Reifegrad
@@ -58,6 +64,8 @@ uvicorn app.main:app --reload
 - `http://127.0.0.1:8000/v1/discovery` - klassifizierte, filterbare Entities
 - `http://127.0.0.1:8000/v1/history` - normalisierte numerische Zeitreihen
 - `http://127.0.0.1:8000/v1/actuators/discovery` - unterstützte Aktuatoren für den aktor-zentrierten Workflow
+- `http://127.0.0.1:8000/v1/actuators/dashboard` - schnelle Dashboard-Startdaten aus Store und JSON-Cache
+- `http://127.0.0.1:8000/v1/actuators/summary` - schlanke Liste beobachteter Aktoren
 - `POST http://127.0.0.1:8000/v1/actuators` - Aktor freigeben; Kontextzuordnung und Modell-Lebenszyklus starten automatisch
 - `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/evaluate` - Shadow-Vorhersage aktualisieren
 - `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/activation` - autonomes Schalten pro Aktor freigeben oder stoppen

addon/config.yaml

@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "0.7.2"
+version: "1.1.0"
 slug: sillyhome_next
 description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
 url: http://192.168.6.31:3000/pino/sillyhome-next
@@ -7,6 +7,7 @@ arch:
   - amd64
 startup: application
 boot: auto
+watchdog: http://[HOST]:[PORT:8000]/health
 init: false
 ingress: true
 ingress_port: 8000

app/actuators/lifecycle.py

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

app/actuators/models.py

@@ -37,6 +37,21 @@ class BehaviorStatus(StrEnum):
     BLOCKED = "blocked"
 
 
+class SafetyStage(StrEnum):
+    OBSERVE = "observe"
+    SUGGEST = "suggest"
+    SHADOW = "shadow"
+    PARTIAL = "partial"
+    ACTIVE = "active"
+
+
+class JobStatus(StrEnum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
 class AssignmentCandidate(BaseModel):
     entity_id: str
     domain: str
@@ -49,6 +64,8 @@ class AssignmentCandidate(BaseModel):
     device_name: str | None = None
     score: float = Field(ge=0.0)
     confidence: float = Field(ge=0.0, le=1.0)
+    manual_weight: float | None = Field(default=None, ge=0.0, le=1.0)
+    effective_weight: float = Field(default=1.0, ge=0.0, le=1.0)
     auto_accepted: bool = False
     evidence: list[str] = Field(default_factory=list)
 
@@ -62,9 +79,18 @@ class AssignmentSelection(BaseModel):
     reason: str = "Noch keine Zuordnung vorhanden."
 
 
+class SensorWeightGroup(BaseModel):
+    group_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    name: str = Field(min_length=1, max_length=120)
+    entity_ids: list[str] = Field(default_factory=list)
+    weight: float = Field(default=1.0, ge=0.0, le=1.0)
+
+
 class ManualOverride(BaseModel):
     numeric_entity_id: str | None = None
     context_entity_ids: list[str] = Field(default_factory=list)
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    sensor_weight_groups: list[SensorWeightGroup] = Field(default_factory=list)
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     note: str | None = None
 
@@ -110,6 +136,61 @@ class BehaviorPrediction(BaseModel):
     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 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
@@ -139,6 +220,16 @@ class BehaviorState(BaseModel):
     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)
 
 
 class ActuatorRecord(BaseModel):
@@ -165,5 +256,22 @@ class ReconciliationState(BaseModel):
     last_summary: str = "Noch keine Reconciliation ausgeführt."
 
 
+class JobQueueItem(BaseModel):
+    job_id: str = Field(min_length=1, max_length=120)
+    kind: str = Field(min_length=1, max_length=40)
+    target: str | None = Field(default=None, max_length=160)
+    trigger: str = Field(default="manual", max_length=40)
+    status: JobStatus = JobStatus.PENDING
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    duration_ms: int | None = Field(default=None, ge=0)
+    error: str | None = Field(default=None, max_length=500)
+    summary: str = Field(default="", max_length=500)
+
+
+class JobQueueState(BaseModel):
+    jobs: list[JobQueueItem] = Field(default_factory=list)
+
+
 def model_id_for_actuator(actuator_entity_id: str) -> str:
     return f"actuator.{actuator_entity_id}"

app/actuators/store.py

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

app/api/v1/actuators.py

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

app/behavior/engine.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Sequence
 from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
 
@@ -11,13 +12,17 @@ from app.actuators.models import (
     BehaviorPrediction,
     BehaviorState,
     BehaviorStatus,
+    DecisionFactor,
     ExecutionEvent,
     RelatedAutomation,
+    SafetyProfile,
+    SafetyStage,
 )
 from app.actuators.store import ActuatorStore
 from app.config import Settings
 from app.ha.exceptions import HaClientError
 from app.ha.history import LogbookEntry, StateHistoryPoint, StateHistorySeries
+from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 
 _MAX_PATTERNS = 500
@@ -173,6 +178,10 @@ class BehaviorEngine:
                 "patterns": patterns[-_MAX_PATTERNS:],
                 "last_trained_at": now,
                 "reason": reason,
+                "sample_trend": [*record.behavior.sample_trend, len(patterns)][-30:],
+                "knowledge": _knowledge_lines(record, len(patterns), trusted_actions),
+                "assumptions": _assumption_lines(record),
+                "uncertainties": _uncertainty_lines(record, len(patterns), trusted_actions),
             }
         )
         return self._save_behavior(record, behavior)
@@ -187,23 +196,32 @@ class BehaviorEngine:
                 results.append(record)
         return results
 
-    def evaluate(self, actuator_entity_id: str) -> ActuatorRecord:
+    def evaluate(
+        self,
+        actuator_entity_id: str,
+        *,
+        context_state_overrides: dict[str, str | None] | None = None,
+        context_changed_at_overrides: dict[str, datetime | None] | None = None,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> ActuatorRecord:
         record = self._store.get(actuator_entity_id)
         now = datetime.now(timezone.utc)
-        try:
-            entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
-        except HaClientError as exc:
-            logger.warning("Current HA state unavailable for %s: %s", actuator_entity_id, exc)
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "last_evaluated_at": now,
-                        "prediction": None,
-                        "reason": f"Aktueller Home-Assistant-Zustand ist nicht verfügbar: {exc}",
-                    }
-                ),
-            )
+        if current_entities is None:
+            try:
+                current_entities = self._ha_reader.read_entities()
+            except HaClientError as exc:
+                logger.warning("Current HA state unavailable for %s: %s", actuator_entity_id, exc)
+                return self._save_behavior(
+                    record,
+                    record.behavior.model_copy(
+                        update={
+                            "last_evaluated_at": now,
+                            "prediction": None,
+                            "reason": f"Aktueller Home-Assistant-Zustand ist nicht verfügbar: {exc}",
+                        }
+                    ),
+                )
+        entities = {entity.entity_id: entity for entity in current_entities}
         actuator = entities.get(actuator_entity_id)
         if actuator is None:
             return self._save_behavior(
@@ -230,6 +248,22 @@ class BehaviorEngine:
             entity_id: entities[entity_id].last_changed
             for entity_id in current_context
         }
+        selected_context_ids = {
+            entity_id
+            for entity_id in (
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+            if entity_id
+        }
+        for entity_id, state in (context_state_overrides or {}).items():
+            if entity_id in selected_context_ids and state is not None:
+                current_context[entity_id] = state
+        for entity_id, changed_at in (context_changed_at_overrides or {}).items():
+            if entity_id in current_context:
+                current_context_changed_at[entity_id] = changed_at or now
         prediction = predict_behavior(
             record.behavior.patterns,
             current_context=current_context,
@@ -241,16 +275,25 @@ class BehaviorEngine:
             timezone_name=self._settings.timezone,
         )
         if prediction is not None:
+            safety_allowed, safety_blockers = self._assess_safety(
+                record,
+                actuator.state,
+                prediction,
+                now,
+            )
             prediction = prediction.model_copy(
                 update={
-                    "execution_reason": self._prediction_execution_reason(
-                        record,
-                        actuator.state,
-                        prediction,
-                        now,
+                    "execution_reason": (
+                        "Ausführung ist freigegeben."
+                        if safety_allowed
+                        else "Nicht ausgeführt: " + " ".join(safety_blockers)
                     )
                 }
             )
+        else:
+            safety_allowed = False
+            safety_blockers = ["Keine fällige Vorhersage."]
+        decision_factors = _decision_factors_for(record, current_context, prediction)
         behavior = record.behavior.model_copy(
             update={
                 "last_evaluated_at": now,
@@ -260,18 +303,21 @@ class BehaviorEngine:
                     if prediction is not None
                     else "Aktuell ist kein gelerntes Handlungsmuster fällig."
                 ),
+                "decision_factors": decision_factors,
+                "knowledge": _knowledge_lines(record, record.behavior.sample_count, record.behavior.high_confidence_sample_count),
+                "assumptions": _assumption_lines(record),
+                "uncertainties": _uncertainty_lines(record, record.behavior.sample_count, record.behavior.high_confidence_sample_count),
+                "safety_blockers": safety_blockers if prediction is not None else [],
+                "confidence_trend": (
+                    [*record.behavior.confidence_trend, round(prediction.confidence, 4)][-30:]
+                    if prediction is not None
+                    else record.behavior.confidence_trend
+                ),
             }
         )
         if (
             prediction is not None
-            and behavior.mode is BehaviorMode.ACTIVE
-            and prediction.confidence >= self._settings.prediction_confidence
-            and actuator.state != prediction.target_state
-            and self._cooldown_elapsed(
-                behavior,
-                now,
-                prediction.target_state,
-            )
+            and safety_allowed
         ):
             domain = actuator_entity_id.split(".", 1)[0]
             service = service_for_state(domain, prediction.target_state)
@@ -329,6 +375,116 @@ class BehaviorEngine:
                 )
         return self._save_behavior(record, behavior)
 
+    def record_feedback(
+        self,
+        actuator_entity_id: str,
+        *,
+        correct: bool,
+        expected_state: str | None = None,
+    ) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            raise KeyError("Aktor ist aktuell nicht in Home Assistant verfügbar.")
+        context_ids = [
+            entity_id
+            for entity_id in [
+                record.assignment.selected_numeric_entity_id,
+                *record.assignment.selected_context_entity_ids,
+            ]
+            if entity_id
+        ]
+        current_context = {
+            entity_id: entities[entity_id].state
+            for entity_id in context_ids
+            if entity_id in entities and entities[entity_id].state is not None
+        }
+        prediction = record.behavior.prediction
+        patterns = list(record.behavior.patterns)
+        reason = "Nutzerfeedback gespeichert."
+        if correct and prediction is not None:
+            local = now.astimezone(ZoneInfo(self._settings.timezone))
+            patterns.append(
+                BehaviorPattern(
+                    target_state=prediction.target_state,
+                    minute_of_day=local.hour * 60 + local.minute,
+                    weekday=local.weekday(),
+                    context_states={
+                        entity_id: state
+                        for entity_id, state in current_context.items()
+                        if state is not None
+                    },
+                    source="user_feedback",
+                    weight=1.0,
+                    observed_at=now,
+                )
+            )
+            reason = "Vorhersage wurde vom Nutzer als korrekt bestätigt."
+            correct_count = record.behavior.correct_feedback_count + 1
+            incorrect_count = record.behavior.incorrect_feedback_count
+        else:
+            target = prediction.target_state if prediction is not None else None
+            if target:
+                patterns = [
+                    pattern.model_copy(update={"weight": 0.1})
+                    if pattern.target_state == target
+                    and _pattern_context_matches(pattern, current_context)
+                    else pattern
+                    for pattern in patterns
+                ]
+            if expected_state:
+                local = now.astimezone(ZoneInfo(self._settings.timezone))
+                patterns.append(
+                    BehaviorPattern(
+                        target_state=expected_state,
+                        minute_of_day=local.hour * 60 + local.minute,
+                        weekday=local.weekday(),
+                        context_states={
+                            entity_id: state
+                            for entity_id, state in current_context.items()
+                            if state is not None
+                        },
+                        source="user_correction",
+                        weight=1.0,
+                        observed_at=now,
+                    )
+                )
+            reason = "Vorhersage wurde vom Nutzer als falsch markiert."
+            correct_count = record.behavior.correct_feedback_count
+            incorrect_count = record.behavior.incorrect_feedback_count + 1
+        behavior = record.behavior.model_copy(
+            update={
+                "patterns": patterns[-_MAX_PATTERNS:],
+                "prediction": (
+                    prediction.model_copy(update={"execution_reason": reason})
+                    if prediction is not None
+                    else None
+                ),
+                "reason": reason,
+                "last_trained_at": now,
+                "correct_feedback_count": correct_count,
+                "incorrect_feedback_count": incorrect_count,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def set_safety_profile(
+        self,
+        actuator_entity_id: str,
+        *,
+        profile: SafetyProfile,
+    ) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        behavior = record.behavior.model_copy(
+            update={
+                "safety": profile.model_copy(update={"updated_at": datetime.now(timezone.utc)}),
+                "reason": "Sicherheitsprofil wurde manuell aktualisiert.",
+            }
+        )
+        return self._save_behavior(record, behavior)
+
     def refresh_related_automations(self, actuator_entity_id: str) -> ActuatorRecord:
         record = self._store.get(actuator_entity_id)
         related = [
@@ -411,6 +567,9 @@ class BehaviorEngine:
                 update={
                     "mode": mode,
                     "approved_at": approved_at,
+                    "safety": record.behavior.safety.model_copy(
+                        update={"stage": SafetyStage.ACTIVE, "updated_at": now}
+                    ),
                     "reason": (
                         "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
                     ),
@@ -491,6 +650,9 @@ class BehaviorEngine:
             update={
                 "mode": mode,
                 "approved_at": approved_at,
+                "safety": record.behavior.safety.model_copy(
+                    update={"stage": SafetyStage.SHADOW, "updated_at": now}
+                ),
                 "related_automations": [
                     automation.model_copy(update={"enabled": True})
                     if (
@@ -535,6 +697,51 @@ class BehaviorEngine:
             return "Nicht ausgeführt: Sicherheits-Cooldown ist noch aktiv."
         return "Ausführung ist freigegeben."
 
+    def _assess_safety(
+        self,
+        record: ActuatorRecord,
+        current_state: str | None,
+        prediction: BehaviorPrediction,
+        now: datetime,
+    ) -> tuple[bool, list[str]]:
+        profile = record.behavior.safety
+        blockers: list[str] = []
+        domain = record.actuator_entity_id.split(".", 1)[0]
+        if not record.enabled:
+            blockers.append("Aktor ist in SillyHome deaktiviert.")
+        if domain not in _SAFE_ACTIVE_DOMAINS:
+            blockers.append(f"Domain {domain} ist nicht für autonomes Schalten freigegeben.")
+        if profile.manual_block:
+            blockers.append("Manuelle Sicherheitssperre ist aktiv.")
+        stage = profile.stage
+        if (
+            record.behavior.mode is BehaviorMode.ACTIVE
+            and profile.updated_at is None
+            and stage is SafetyStage.SHADOW
+        ):
+            stage = SafetyStage.ACTIVE
+        if stage not in {SafetyStage.ACTIVE, SafetyStage.PARTIAL}:
+            blockers.append(f"Safety-Stufe {stage.value} erlaubt noch kein Schalten.")
+        if record.behavior.mode is not BehaviorMode.ACTIVE:
+            blockers.append("SillyHome ist im Shadow-Modus.")
+        if not record.behavior.activation_ready:
+            blockers.append(record.behavior.activation_reason)
+        threshold = _confidence_threshold_for(profile, prediction.target_state)
+        if prediction.confidence < threshold:
+            blockers.append(
+                f"Sicherheit {prediction.confidence:.0%} liegt unter der Schwelle {threshold:.0%}."
+            )
+        if current_state == prediction.target_state:
+            blockers.append("Zielzustand ist bereits erreicht.")
+        if not self._cooldown_elapsed(
+            record.behavior,
+            now,
+            prediction.target_state,
+            cooldown_seconds=profile.cooldown_seconds,
+        ):
+            blockers.append("Sicherheits-Cooldown ist noch aktiv.")
+        return not blockers, blockers
+
     def _build_patterns(
         self,
         *,
@@ -585,6 +792,8 @@ class BehaviorEngine:
         behavior: BehaviorState,
         now: datetime,
         target_state: str,
+        *,
+        cooldown_seconds: int | None = None,
     ) -> bool:
         if behavior.last_executed_at is None:
             return True
@@ -592,7 +801,9 @@ class BehaviorEngine:
         if last_event is not None and last_event.target_state != target_state:
             return True
         return (now - behavior.last_executed_at) >= timedelta(
-            seconds=self._settings.execution_cooldown_seconds
+            seconds=cooldown_seconds
+            if cooldown_seconds is not None
+            else self._settings.execution_cooldown_seconds
         )
 
     def _save_behavior(
@@ -608,20 +819,30 @@ class BehaviorEngine:
         )
         return self._store.upsert(updated)
 
-    def handle_state_change(self, entity_id: str, new_state: dict[str, object] | None) -> None:
+    def handle_state_change(
+        self,
+        entity_id: str,
+        new_state: dict[str, object] | None,
+        *,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> None:
         """Wird bei jedem HA-State-Change aufgerufen und löst sofortige Vorhersage aus.
 
         - Wenn entity_id ein Aktor ist: evaluate() direkt.
         - Wenn entity_id ein Kontext-Entity ist: alle betroffenen Aktoren evaluieren.
+        - Wenn current_entities gesetzt ist, kommt die Auswertung direkt aus dem
+          WebSocket-State-Cache statt aus einer frischen REST-Abfrage.
         """
         # Aktor direkt evaluieren
         for record in self._store.list():
             if record.actuator_entity_id == entity_id:
                 try:
-                    self.evaluate(record.actuator_entity_id)
+                    self.evaluate(record.actuator_entity_id, current_entities=current_entities)
                 except Exception:
                     logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", record.actuator_entity_id)
                 return
+        event_state = _event_state(new_state)
+        event_changed_at = _event_changed_at(new_state) or datetime.now(timezone.utc)
         # Kontext-Entity: alle Aktoren finden, die diesen Kontext nutzen
         affected_actuators = [
             record.actuator_entity_id
@@ -633,11 +854,142 @@ class BehaviorEngine:
         ]
         for actuator_entity_id in affected_actuators:
             try:
-                self.evaluate(actuator_entity_id)
+                self.evaluate(
+                    actuator_entity_id,
+                    context_state_overrides={entity_id: event_state},
+                    context_changed_at_overrides={entity_id: event_changed_at},
+                    current_entities=current_entities,
+                )
             except Exception:
                 logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", actuator_entity_id)
 
 
+def _event_state(new_state: dict[str, object] | None) -> str | None:
+    if not isinstance(new_state, dict):
+        return None
+    state = new_state.get("state")
+    return state if isinstance(state, str) else None
+
+
+def _event_changed_at(new_state: dict[str, object] | None) -> datetime | None:
+    if not isinstance(new_state, dict):
+        return None
+    value = new_state.get("last_changed") or new_state.get("last_updated")
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
+def _confidence_threshold_for(profile: SafetyProfile, target_state: str) -> float:
+    if target_state == "on" and profile.min_confidence_on is not None:
+        return profile.min_confidence_on
+    if target_state in {"off", "closed"} and profile.min_confidence_off is not None:
+        return profile.min_confidence_off
+    return profile.min_confidence
+
+
+def _decision_factors_for(
+    record: ActuatorRecord,
+    current_context: dict[str, str | None],
+    prediction: BehaviorPrediction | None,
+) -> list[DecisionFactor]:
+    factors: list[DecisionFactor] = []
+    candidates = {
+        candidate.entity_id: candidate
+        for candidate in [*record.numeric_candidates, *record.context_candidates]
+    }
+    for entity_id, state in current_context.items():
+        candidate = candidates.get(entity_id)
+        weight = candidate.effective_weight if candidate is not None else 1.0
+        relevance = candidate.confidence if candidate is not None else 0.5
+        contribution = round(min(1.0, weight * relevance), 4)
+        factors.append(
+            DecisionFactor(
+                entity_id=entity_id,
+                label=(
+                    candidate.friendly_name
+                    if candidate is not None and candidate.friendly_name
+                    else entity_id
+                ),
+                factor_type="context",
+                state=state,
+                weight=round(weight, 4),
+                contribution=contribution,
+                evidence=(
+                    candidate.evidence[:4]
+                    if candidate is not None
+                    else ["Aktuell ausgewähltes Kontextsignal."]
+                ),
+            )
+        )
+    if prediction is not None:
+        factors.append(
+            DecisionFactor(
+                label=f"Vorhersage {prediction.target_state}",
+                factor_type="prediction",
+                state=prediction.target_state,
+                weight=1.0,
+                contribution=prediction.confidence,
+                evidence=[prediction.reason],
+            )
+        )
+    return sorted(factors, key=lambda item: (-item.contribution, item.label))[:12]
+
+
+def _knowledge_lines(
+    record: ActuatorRecord,
+    sample_count: int,
+    trusted_actions: int,
+) -> list[str]:
+    lines = [
+        f"{sample_count} historische Aktorhandlungen sind ausgewertet.",
+        f"{trusted_actions} Handlungen stammen eindeutig von Nutzer oder HA-Automationen.",
+    ]
+    if record.assignment.selected_numeric_entity_id:
+        lines.append(f"Hauptsensor: {record.assignment.selected_numeric_entity_id}.")
+    if record.assignment.selected_context_entity_ids:
+        lines.append(
+            f"{len(record.assignment.selected_context_entity_ids)} Kontextsignale sind verbunden."
+        )
+    return lines
+
+
+def _assumption_lines(record: ActuatorRecord) -> list[str]:
+    lines = [
+        "Ähnliche Zeitfenster und ähnliche Kontextzustände deuten auf ähnliche Nutzerabsicht hin."
+    ]
+    if record.manual_override is not None:
+        lines.append("Manuelle Sensor-/Kontextkorrekturen werden höher gewichtet.")
+    if record.behavior.related_automations:
+        lines.append("Passende HA-Automationen gelten als starker Hinweis auf vorhandene Logik.")
+    return lines
+
+
+def _uncertainty_lines(
+    record: ActuatorRecord,
+    sample_count: int,
+    trusted_actions: int,
+) -> list[str]:
+    lines: list[str] = []
+    if sample_count < trusted_actions + 3:
+        lines.append("Noch wenig Varianz in den gelernten Handlungen.")
+    if trusted_actions < sample_count:
+        lines.append("Ein Teil der Handlungen ist nicht eindeutig Nutzer oder Automation zugeordnet.")
+    if record.assignment.review_required:
+        lines.append("Die automatische Kontextzuordnung verlangt noch Prüfung.")
+    if record.behavior.incorrect_feedback_count:
+        lines.append(
+            f"{record.behavior.incorrect_feedback_count} negative Feedbacks senken Vertrauen."
+        )
+    return lines or ["Keine kritische Unsicherheit aus den lokalen Daten erkannt."]
+
+
 def predict_behavior(
     patterns: list[BehaviorPattern],
     *,
@@ -745,8 +1097,10 @@ def predict_behavior(
 
 
 def service_for_state(domain: str, target_state: str) -> str | None:
-    if domain in {"fan", "humidifier", "light", "switch"}:
+    if domain in {"fan", "humidifier", "light", "media_player", "remote", "switch"}:
         return {"on": "turn_on", "off": "turn_off"}.get(target_state)
+    if domain == "scene":
+        return "turn_on" if target_state == "on" else None
     if domain == "cover":
         return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
     return None
@@ -792,6 +1146,20 @@ def _matches_own_execution(
     )
 
 
+def _pattern_context_matches(
+    pattern: BehaviorPattern,
+    current_context: dict[str, str | None],
+) -> bool:
+    comparable = [
+        (entity_id, expected)
+        for entity_id, expected in pattern.context_states.items()
+        if entity_id in current_context
+    ]
+    if not comparable:
+        return False
+    return all(current_context[entity_id] == expected for entity_id, expected in comparable)
+
+
 def _recent_context_transition(
     history: dict[str, StateHistorySeries],
     context_ids: list[str],

app/ha/discovery.py

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

app/main.py

@@ -3,6 +3,7 @@ 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
 
@@ -19,6 +20,7 @@ from app.behavior.engine import BehaviorEngine
 from app.config import load_settings
 from app.core.exception_handlers import register_exception_handlers
 from app.ha.client import HaClient, HaClientSettings
+from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 from app.ml.registry.model_registry import ModelRegistry
 from backend.routes.ml import init_ml_routes
@@ -41,6 +43,7 @@ class _WsStatus:
 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
@@ -72,15 +75,17 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
             settings=settings,
         )
         app.state.ws_status = _WsStatus()
-        await asyncio.to_thread(app.state.actuator_service.reconcile_all, "startup")
-        await asyncio.to_thread(app.state.behavior_engine.train_all)
-        await asyncio.to_thread(app.state.behavior_engine.evaluate_all)
+        startup_task = asyncio.create_task(_startup_reconciliation(app))
         reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
         event_listener_task = asyncio.create_task(_ha_event_listener(app, client))
         fallback_task = asyncio.create_task(_fallback_prediction(app))
     try:
         yield
     finally:
+        if startup_task is not None:
+            startup_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await startup_task
         if reconcile_task is not None:
             reconcile_task.cancel()
             with suppress(asyncio.CancelledError):
@@ -100,7 +105,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
     title="SillyHome Next API",
     description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.7.2",
+    version="1.1.0",
     lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -145,24 +150,59 @@ async def _periodic_reconciliation(app: FastAPI) -> None:
         service = getattr(app.state, "actuator_service", None)
         if not isinstance(service, ActuatorReconciliationService):
             continue
-        await asyncio.to_thread(service.reconcile_all, "scheduled")
+        try:
+            await asyncio.to_thread(service.reconcile_all, "scheduled")
+            engine = getattr(app.state, "behavior_engine", None)
+            if isinstance(engine, BehaviorEngine):
+                await asyncio.to_thread(engine.train_all)
+        except Exception:
+            logger.exception("Geplante Reconciliation fehlgeschlagen; nächster Lauf versucht es erneut.")
+
+
+async def _startup_reconciliation(app: FastAPI) -> None:
+    delay_seconds = 5
+    while True:
+        service = getattr(app.state, "actuator_service", None)
         engine = getattr(app.state, "behavior_engine", None)
-        if isinstance(engine, BehaviorEngine):
+        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):
+    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)
@@ -171,7 +211,11 @@ async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
         if ws_status is not None:
             ws_status.status = "connecting"
         try:
-            async with websockets.connect(ws_url) as websocket:
+            async with websockets.connect(
+                ws_url,
+                ping_interval=20,
+                ping_timeout=10,
+            ) as websocket:
                 auth_required_msg = await websocket.recv()
                 auth_required_data = json.loads(auth_required_msg)
                 if auth_required_data.get("type") != "auth_required":
@@ -194,6 +238,7 @@ async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
                     continue
 
                 logger.info("WebSocket-Verbindung zu Home Assistant hergestellt")
+                state_cache = await asyncio.to_thread(_load_ha_state_cache, ha_reader)
                 if ws_status is not None:
                     ws_status.status = "connected"
                     ws_status.error = None
@@ -213,28 +258,45 @@ async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
                         event = data.get("event", {})
                         if event.get("event_type") != "state_changed":
                             continue
-                        entity_id = event.get("entity_id")
+                        event_data = event.get("data", {})
+                        if not isinstance(event_data, dict):
+                            logger.warning("State-Changed-Event ohne gültige Daten empfangen")
+                            continue
+                        entity_id = event_data.get("entity_id")
                         if not entity_id:
                             continue
+                        new_state = event_data.get("new_state")
+                        _update_ha_state_cache(state_cache, entity_id, new_state)
+                        if not _is_relevant_state_change(store, str(entity_id)):
+                            continue
                         # Prüfe, ob Entity ein Aktor oder relevanter Kontext ist
                         # Sofortige Vorhersage für betroffene Aktoren auslösen
-                        await asyncio.to_thread(engine.handle_state_change, entity_id, event.get("new_state"))
+                        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, OSError) as exc:
-            logger.warning("WebSocket-Verbindung unterbrochen: %s. Wiederholung in 5s...", exc)
+        except (
+            websockets.exceptions.ConnectionClosed,
+            websockets.exceptions.InvalidStatus,
+            OSError,
+        ) as exc:
+            logger.warning("WebSocket-Verbindung unterbrochen: %s. Wiederholung in 1s...", exc)
             if ws_status is not None:
                 ws_status.status = "reconnecting"
                 ws_status.error = str(exc)
-            await asyncio.sleep(5)
+            await asyncio.sleep(1)
         except Exception as exc:
             logger.exception("Unerwarteter Fehler im Event-Listener: %s", exc)
             if ws_status is not None:
                 ws_status.status = "error"
                 ws_status.error = str(exc)
-            await asyncio.sleep(5)
+            await asyncio.sleep(1)
 
 
 # Fallback: periodische Vorhersage falls Event-Stream ausfällt
@@ -244,7 +306,13 @@ async def _fallback_prediction(app: FastAPI) -> None:
     Dies verhindert kompletten Ausfall der Vorhersagen bei Netzwerkproblemen.
     """
     while True:
-        await asyncio.sleep(app.state.settings.prediction_interval_seconds)
+        ws_status = getattr(app.state, "ws_status", None)
+        websocket_connected = ws_status is not None and ws_status.status == "connected"
+        await asyncio.sleep(
+            app.state.settings.prediction_interval_seconds
+            if websocket_connected
+            else min(5, app.state.settings.prediction_interval_seconds)
+        )
         # Nur ausführen, wenn WebSocket nicht verbunden ist
         ws_status = getattr(app.state, "ws_status", None)
         if ws_status is None or ws_status.status != "connected":
@@ -254,4 +322,82 @@ async def _fallback_prediction(app: FastAPI) -> None:
                     "Fallback-Vorhersage aktiv (WebSocket-Status: %s)",
                     ws_status.status if ws_status else "unavailable",
                 )
-                await asyncio.to_thread(engine.evaluate_all)
+                try:
+                    await asyncio.to_thread(engine.evaluate_all)
+                except Exception:
+                    logger.exception("Fallback-Vorhersage fehlgeschlagen.")
+
+
+def _load_ha_state_cache(reader: HaReader) -> dict[str, HaEntitySummary]:
+    return {entity.entity_id: entity for entity in reader.read_entities()}
+
+
+def _update_ha_state_cache(
+    state_cache: dict[str, HaEntitySummary],
+    entity_id: str,
+    new_state: object,
+) -> None:
+    if not isinstance(new_state, dict):
+        state_cache.pop(entity_id, None)
+        return
+    state_cache[entity_id] = _ha_entity_from_event(
+        entity_id,
+        new_state,
+        state_cache.get(entity_id),
+    )
+
+
+def _is_relevant_state_change(store: ActuatorStore, entity_id: str) -> bool:
+    for record in store.list():
+        if record.actuator_entity_id == entity_id:
+            return True
+        if record.assignment.selected_numeric_entity_id == entity_id:
+            return True
+        if entity_id in record.assignment.selected_context_entity_ids:
+            return True
+    return False
+
+
+def _ha_entity_from_event(
+    entity_id: str,
+    new_state: dict[str, object],
+    previous: HaEntitySummary | None,
+) -> HaEntitySummary:
+    attributes = new_state.get("attributes")
+    attr = attributes if isinstance(attributes, dict) else {}
+    state_class = _optional_event_string(attr.get("state_class"))
+    device_class = _optional_event_string(attr.get("device_class"))
+    unit_of_measurement = _optional_event_string(attr.get("unit_of_measurement"))
+    friendly_name = _optional_event_string(attr.get("friendly_name"))
+    return HaEntitySummary(
+        entity_id=entity_id,
+        domain=entity_id.split(".", 1)[0],
+        state=_optional_event_string(new_state.get("state")),
+        last_changed=_event_datetime(new_state.get("last_changed"))
+        or _event_datetime(new_state.get("last_updated")),
+        state_class=state_class or (previous.state_class if previous else None),
+        device_class=device_class or (previous.device_class if previous else None),
+        unit_of_measurement=unit_of_measurement
+        or (previous.unit_of_measurement if previous else None),
+        friendly_name=friendly_name or (previous.friendly_name if previous else None),
+        area_id=previous.area_id if previous else None,
+        area_name=previous.area_name if previous else None,
+        device_id=previous.device_id if previous else None,
+        device_name=previous.device_name if previous else None,
+    )
+
+
+def _optional_event_string(value: object) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _event_datetime(value: object) -> datetime | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed

docs/V1_0_0_OPERATING_GUIDE.md

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

docs/V1_0_ACCEPTANCE.md

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

docs/V1_1_0_OPERATING_GUIDE.md

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

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sillyhome-next"
-version = "0.7.2"
+version = "1.1.0"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [

tests/actuators/test_lifecycle.py

@@ -7,7 +7,6 @@ from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.models import (
     AssignmentSource,
     LifecycleStatus,
-    ManualOverride,
     model_id_for_actuator,
 )
 from app.actuators.store import ActuatorStore
@@ -79,7 +78,7 @@ def _service(
             model_store=str(tmp_path / "models"),
             automation_store=str(tmp_path / "automations"),
             actuator_store=str(tmp_path / "actuators"),
-            history_days=14,
+            history_days=31,
             min_training_points=5,
             retrain_stale_hours=24,
             reconcile_interval_seconds=900,
@@ -240,7 +239,120 @@ def test_reconciliation_does_not_cross_assign_other_room_light_energy(
     assert record.lifecycle.status is LifecycleStatus.ARCHIVED
 
 
-def test_legacy_manual_override_is_cleared_and_automatic_mapping_wins(tmp_path: Path) -> None:
+def test_reconciliation_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(
@@ -273,21 +385,54 @@ def test_legacy_manual_override_is_cleared_and_automatic_mapping_wins(tmp_path:
         "sensor.abstellkammer_power": _points(8, start, 30.0),
     }
     service = _service(tmp_path, entities, history)
-    configured = service.configure_actuator("light.abstellkammer")
-    legacy = configured.model_copy(
-        update={
-            "manual_override": ManualOverride(
-                numeric_entity_id="sensor.abstellkammer_power",
-                context_entity_ids=[],
-                note="Alte manuelle Zuordnung",
-            )
-        }
+    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",
     )
-    service._store.upsert(legacy)
 
     restarted = _service(tmp_path, entities, history)
     record = restarted.reconcile_actuator("light.abstellkammer")
 
-    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_illuminance"
-    assert record.assignment.source.value == "automatic"
-    assert record.manual_override is None
+    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

tests/api/test_actuators.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from time import perf_counter
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -9,6 +10,7 @@ from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
 from app.config import Settings
+from app.api.v1.actuators import _deduplicate_actuator_ids
 from app.ha.discovery import DiscoveredEntity
 from app.ha.discovery import discover_entities
 from app.ha.history import (
@@ -27,8 +29,11 @@ class FakeHaReader(HaReader):
     def __init__(self, entities: list[HaEntitySummary], history: dict[str, list[float]]) -> None:
         self._entities = entities
         self._history = history
+        self.read_entities_calls = 0
+        self.service_calls: list[tuple[str, str, dict[str, object]]] = []
 
     def read_entities(self) -> list[HaEntitySummary]:
+        self.read_entities_calls += 1
         return list(self._entities)
 
     def discover(
@@ -82,6 +87,7 @@ class FakeHaReader(HaReader):
         service: str,
         service_data: dict[str, object],
     ) -> list[object]:
+        self.service_calls.append((domain, service, service_data))
         return []
 
     def find_automations_for_entity(
@@ -115,6 +121,14 @@ def _install_service(tmp_path: Path) -> None:
             friendly_name="Abstellkammer Bewegung",
             area_name="Abstellkammer",
         ),
+        HaEntitySummary(
+            entity_id="sensor.pfsense_interface_vpn_inbytes",
+            domain="sensor",
+            device_class="data_size",
+            state_class="measurement",
+            unit_of_measurement="KiB",
+            friendly_name="pfSense Interface VPN inbytes",
+        ),
     ]
     settings = Settings(
         ha_url="http://ha.local",
@@ -179,14 +193,246 @@ def test_actuator_api_configures_reconciles_and_removes(tmp_path: Path) -> None:
         assert client.get("/v1/actuators").json() == []
 
 
-def test_manual_override_endpoint_is_not_exposed(tmp_path: Path) -> None:
+def test_manual_assignment_endpoint_updates_context(tmp_path: Path) -> None:
     with TestClient(app) as client:
         _install_service(tmp_path)
         client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
 
         response = client.post(
-            "/v1/actuators/light.abstellkammer/override",
-            json={"numeric_entity_id": "sensor.abstellkammer_illuminance"},
+            "/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 == 404
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["assignment"]["source"] == "manual"
+    assert payload["assignment"]["selected_numeric_entity_id"] == (
+        "sensor.abstellkammer_illuminance"
+    )
+    assert payload["assignment"]["selected_context_entity_ids"] == [
+        "binary_sensor.abstellkammer_motion"
+    ]
+
+
+def test_weight_override_endpoint_updates_sensor_relevance(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        client.post(
+            "/v1/actuators/light.abstellkammer/assignment",
+            json={
+                "numeric_entity_id": "sensor.abstellkammer_illuminance",
+                "context_entity_ids": ["binary_sensor.abstellkammer_motion"],
+            },
+        )
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/weights",
+            json={
+                "sensor_weights": {
+                    "sensor.abstellkammer_illuminance": 0.75,
+                    "binary_sensor.abstellkammer_motion": 0.5,
+                },
+                "sensor_weight_groups": [
+                    {
+                        "group_id": "abstellkammer_context",
+                        "name": "Abstellkammer Kontext",
+                        "entity_ids": [
+                            "sensor.abstellkammer_illuminance",
+                            "binary_sensor.abstellkammer_motion",
+                        ],
+                        "weight": 0.8,
+                    }
+                ],
+                "note": "Gewichtung korrigiert",
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["manual_override"]["sensor_weights"]["sensor.abstellkammer_illuminance"] == 0.75
+    assert payload["manual_override"]["sensor_weight_groups"][0]["group_id"] == (
+        "abstellkammer_context"
+    )
+    numeric = {
+        candidate["entity_id"]: candidate
+        for candidate in payload["numeric_candidates"]
+    }
+    assert numeric["sensor.abstellkammer_illuminance"]["manual_weight"] == 0.75
+    assert numeric["sensor.abstellkammer_illuminance"]["effective_weight"] == 0.75
+
+
+def test_safety_profile_can_block_actuator_manually(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/safety",
+            json={
+                "safety": {
+                    "stage": "shadow",
+                    "manual_block": True,
+                    "min_confidence": 0.9,
+                    "cooldown_seconds": 120,
+                    "rules": [
+                        {
+                            "rule_id": "manual_block",
+                            "label": "Manuelle Sperre respektieren",
+                            "enabled": True,
+                            "blocking": True,
+                            "reason": "Test",
+                        }
+                    ],
+                    "note": "Test",
+                }
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["behavior"]["safety"]["manual_block"] is True
+    assert payload["behavior"]["safety"]["min_confidence"] == 0.9
+    assert payload["behavior"]["safety"]["cooldown_seconds"] == 120
+
+
+def test_summary_is_lightweight_and_uses_cached_entity_metadata(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.get("/v1/actuators/summary")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload[0]["actuator_entity_id"] == "light.abstellkammer"
+    assert payload[0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload[0]["area_name"] == "Abstellkammer"
+    assert "behavior" not in payload[0]
+    assert "numeric_candidates" not in payload[0]
+
+
+def test_dashboard_overview_uses_cache_without_ha_roundtrip(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        reader = app.state.ha_reader
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        calls_before = reader.read_entities_calls
+
+        response = client.get("/v1/actuators/dashboard")
+
+    assert response.status_code == 200
+    assert reader.read_entities_calls == calls_before
+    payload = response.json()
+    assert payload["cache"]["available"] is True
+    assert payload["cache"]["entity_count"] == 4
+    assert payload["actuators"][0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload["discovery_groups"]
+    assert payload["jobs"]["jobs"][-1]["kind"] == "discovery"
+
+
+def test_reconciliation_run_records_visible_job_queue(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.post("/v1/actuators/reconciliation/run")
+        jobs = client.get("/v1/actuators/job-queue/state")
+
+    assert response.status_code == 200
+    assert jobs.status_code == 200
+    payload = jobs.json()
+    assert [job["kind"] for job in payload["jobs"][-3:]] == [
+        "reconciliation",
+        "training",
+        "evaluation",
+    ]
+    assert payload["jobs"][-1]["status"] == "completed"
+
+
+def test_dashboard_start_path_stays_within_five_second_budget(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        root_started_at = perf_counter()
+        root_response = client.get("/")
+        root_elapsed = perf_counter() - root_started_at
+
+        dashboard_started_at = perf_counter()
+        dashboard_response = client.get("/v1/actuators/dashboard")
+        dashboard_elapsed = perf_counter() - dashboard_started_at
+
+    assert root_response.status_code == 200
+    assert dashboard_response.status_code == 200
+    assert root_elapsed < 5.0
+    assert dashboard_elapsed < 5.0
+
+
+def test_discovery_reads_entities_once_and_reuses_them(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        reader = app.state.ha_reader
+
+        response = client.get("/v1/actuators/discovery", params={"refresh": True})
+
+    assert response.status_code == 200
+    assert reader.read_entities_calls == 1
+
+
+def test_context_options_returns_learnable_entities(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        response = client.get(
+            "/v1/actuators/context-options",
+            params={"actuator_entity_id": "light.abstellkammer"},
+        )
+
+    assert response.status_code == 200
+    entity_ids = {item["entity_id"] for item in response.json()}
+    assert "sensor.abstellkammer_illuminance" in entity_ids
+    assert "binary_sensor.abstellkammer_motion" in entity_ids
+    assert "sensor.pfsense_interface_vpn_inbytes" not in entity_ids
+
+
+def test_actuator_discovery_prefers_light_over_duplicate_switch() -> None:
+    entities = {
+        "light.schreibtisch": HaEntitySummary(
+            entity_id="light.schreibtisch",
+            domain="light",
+            friendly_name="Schreibtisch Licht",
+            device_id="device-1",
+        ),
+        "switch.schreibtisch": HaEntitySummary(
+            entity_id="switch.schreibtisch",
+            domain="switch",
+            friendly_name="Schreibtisch Schalter",
+            device_id="device-1",
+        ),
+        "cover.rollladen": HaEntitySummary(
+            entity_id="cover.rollladen",
+            domain="cover",
+            friendly_name="Rollladen",
+            device_id="device-2",
+        ),
+    }
+
+    result = _deduplicate_actuator_ids(
+        [
+            ("switch.schreibtisch", "switch_socket"),
+            ("light.schreibtisch", "light"),
+            ("cover.rollladen", "cover_shutter"),
+        ],
+        entities,
+    )
+
+    assert result == ["cover.rollladen", "light.schreibtisch"]

tests/api/test_entities.py

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

tests/behavior/test_engine.py

@@ -8,6 +8,7 @@ import pytest
 from app.actuators.models import (
     BehaviorMode,
     BehaviorPattern,
+    BehaviorPrediction,
     BehaviorState,
     BehaviorStatus,
     ExecutionEvent,
@@ -212,6 +213,125 @@ def test_engine_counts_known_automation_actions_like_manual_actions(
     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:
@@ -438,6 +558,7 @@ def test_cooldown_allows_opposite_follow_up_action(tmp_path: Path) -> None:
     ("domain", "state", "service"),
     [
         ("light", "on", "turn_on"),
+        ("media_player", "off", "turn_off"),
         ("switch", "off", "turn_off"),
         ("cover", "open", "open_cover"),
         ("cover", "closed", "close_cover"),
@@ -523,3 +644,137 @@ def test_prediction_ignores_stale_causal_context_state() -> None:
         min_support=1,
         window_minutes=30,
     ) is None
+
+
+def test_state_change_uses_websocket_context_state_for_immediate_action(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": ["binary_sensor.storage_door"],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="off",
+                last_changed=now - timedelta(minutes=5),
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    engine.handle_state_change(
+        "binary_sensor.storage_door",
+        {"state": "on", "last_changed": now.isoformat()},
+    )
+
+    assert reader.service_calls == [
+        ("light", "turn_on", {"entity_id": "light.storage"})
+    ]
+
+
+def test_state_change_uses_event_cache_without_rest_state_query(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={
+                    "selected_context_entity_ids": ["binary_sensor.storage_door"],
+                }
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[],
+        history=[],
+        logbook=[],
+    )
+
+    def fail_read_entities() -> list[HaEntitySummary]:
+        raise AssertionError("Event-Auswertung darf keinen REST-State lesen.")
+
+    reader.read_entities = fail_read_entities  # type: ignore[method-assign]
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    engine.handle_state_change(
+        "binary_sensor.storage_door",
+        {"state": "on", "last_changed": now.isoformat()},
+        current_entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="on",
+                last_changed=now,
+            ),
+        ],
+    )
+
+    assert reader.service_calls == [
+        ("light", "turn_on", {"entity_id": "light.storage"})
+    ]

tests/ha/test_discovery.py

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

tests/test_dashboard.py

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

tests/test_main.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Sequence
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -8,6 +9,8 @@ from fastapi.testclient import TestClient
 
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
+from app.ha.models import HaEntitySummary
+from app.ha.reader import HaReader
 from app.main import _ha_event_listener, app as fastapi_app, lifespan
 
 
@@ -41,10 +44,32 @@ class _RecordingBehaviorEngine(BehaviorEngine):
             store=ActuatorStore(tmp_path / "actuators"),
             settings=MagicMock(),
         )
-        self.state_changes: list[tuple[str, dict[str, object] | None]] = []
+        self.state_changes: list[
+            tuple[str, dict[str, object] | None, Sequence[HaEntitySummary] | None]
+        ] = []
 
-    def handle_state_change(self, entity_id: str, new_state: dict[str, object] | None) -> None:
-        self.state_changes.append((entity_id, new_state))
+    def handle_state_change(
+        self,
+        entity_id: str,
+        new_state: dict[str, object] | None,
+        *,
+        current_entities: Sequence[HaEntitySummary] | None = None,
+    ) -> None:
+        self.state_changes.append((entity_id, new_state, current_entities))
+
+
+class _FakeHaReader(HaReader):
+    def __init__(self) -> None:
+        pass
+
+    def read_entities(self) -> list[HaEntitySummary]:
+        return [
+            HaEntitySummary(
+                entity_id="light.test",
+                domain="light",
+                state="off",
+            )
+        ]
 
 
 def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
@@ -55,18 +80,23 @@ def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
                 '{"type":"auth_ok"}',
                 (
                     '{"type":"event","event":{"event_type":"state_changed",'
-                    '"entity_id":"light.test","new_state":{"state":"on"}}}'
+                    '"data":{"entity_id":"light.test","new_state":{"state":"on"}}}}'
                 ),
                 asyncio.CancelledError(),
             ]
         )
 
-        with patch("websockets.connect", return_value=fake_ws):
+        with patch("websockets.connect", return_value=fake_ws) as connect:
             try:
                 await _ha_event_listener(mock_app, mock_client)
             except asyncio.CancelledError:
                 pass
 
+        connect.assert_called_once_with(
+            "ws://homeassistant:8123/api/websocket",
+            ping_interval=20,
+            ping_timeout=10,
+        )
         assert fake_ws.sent == [
             {"type": "auth", "access_token": "test-token"},
             {"id": 1, "type": "subscribe_events", "event_type": "state_changed"},
@@ -79,12 +109,20 @@ def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
     mock_app.state.ws_status = MagicMock()
     mock_engine = _RecordingBehaviorEngine(tmp_path)
     mock_app.state.behavior_engine = mock_engine
+    mock_app.state.ha_reader = _FakeHaReader()
     mock_store = ActuatorStore(tmp_path / "store")
+    mock_store.configure("light.test")
     mock_app.state.actuator_store = mock_store
     mock_client = MagicMock()
 
     anyio.run(run_test)
-    assert mock_engine.state_changes == [("light.test", {"state": "on"})]
+    assert len(mock_engine.state_changes) == 1
+    entity_id, new_state, current_entities = mock_engine.state_changes[0]
+    assert entity_id == "light.test"
+    assert new_state == {"state": "on"}
+    assert current_entities == [
+        HaEntitySummary(entity_id="light.test", domain="light", state="on")
+    ]
     assert mock_app.state.ws_status.status == "connected"
     assert mock_app.state.ws_status.error is None