Speed up HA event processing

CHANGELOG.md

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

addon/config.yaml

@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "0.7.11"
+version: "0.7.17"
 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

@@ -57,7 +57,7 @@ _STOPWORDS = frozenset(
         "value",
     }
 )
-_GENERIC_AREA_NAMES = frozenset({"monitoring", "system", "technik"})
+_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
@@ -88,6 +88,7 @@ _DIAGNOSTIC_TOKENS = frozenset({
     "diagnostic",
     "firmware",
     "gesehen",
+    "heat",
     "last",
     "linkquality",
     "knoten",
@@ -100,10 +101,28 @@ _DIAGNOSTIC_TOKENS = frozenset({
     "signal",
     "ssid",
     "status",
+    "overheat",
+    "overheating",
+    "overload",
     "uptime",
+    "uberhitzung",
+    "ueberhitzung",
+    "ueberlast",
+    "überhitzung",
+    "überlast",
     "wifi",
     "zuletzt",
 })
+_AUTO_CONTEXT_CLASSES = frozenset({
+    "door",
+    "garage_door",
+    "illuminance",
+    "motion",
+    "occupancy",
+    "opening",
+    "presence",
+    "window",
+})
 
 
 class ActuatorReconciliationService:
@@ -628,8 +647,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)
             )
@@ -743,6 +766,23 @@ def _has_context_relationship(actuator: HaEntitySummary, entity: HaEntitySummary
     )
 
 
+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,

app/api/v1/actuators.py

@@ -8,7 +8,7 @@ from app.actuators.models import ActuatorRecord, ReconciliationState
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
 from app.dependencies import get_ha_reader
-from app.ha.discovery import EntityRole
+from app.ha.discovery import DiscoveredEntity, EntityRole
 from app.ha.exceptions import HaClientError
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
@@ -43,6 +43,18 @@ class FeedbackRequest(BaseModel):
     expected_state: str | None = Field(default=None, max_length=100)
 
 
+class ActuatorSuggestion(BaseModel):
+    entity_id: str
+    domain: str
+    friendly_name: str | None = None
+    area_name: str | None = None
+    device_name: str | None = None
+    confidence: float
+    reason: str
+    related_automation_count: int = 0
+    likely_context_count: int = 0
+
+
 @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()}
@@ -58,6 +70,66 @@ def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaE
     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 ha_reader.discover()}
+    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,
@@ -294,3 +366,67 @@ def _actuator_duplicate_key(entity: HaEntitySummary, category: str) -> str:
     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

@@ -898,7 +898,7 @@ 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 == "cover":
         return {"open": "open_cover", "closed": "close_cover"}.get(target_state)

app/ha/discovery.py

@@ -92,7 +92,9 @@ _ACTUATOR_DOMAINS = frozenset({
     "input_button",
     "lock",
     "light",
+    "media_player",
     "number",
+    "remote",
     "siren",
     "switch",
     "valve",
@@ -225,6 +227,8 @@ def _actuator_category(entity: HaEntitySummary) -> str:
         return "lock"
     if entity.domain == "fan":
         return "fan"
+    if entity.domain in {"media_player", "remote"}:
+        return "media_tv"
     if entity.domain in {"input_boolean", "number"}:
         return "helper"
     return entity.domain

app/main.py

@@ -43,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
@@ -74,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):
@@ -102,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.11",
+    version="0.7.17",
     lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -147,10 +150,39 @@ 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:
@@ -179,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, ping_interval=None) 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":
@@ -231,6 +267,8 @@ async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
                             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(
@@ -243,18 +281,22 @@ async def _ha_event_listener(app: FastAPI, client: HaClient) -> None:
                         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
@@ -280,7 +322,10 @@ 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]:
@@ -302,6 +347,17 @@ def _update_ha_state_cache(
     )
 
 
+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],

app/static/index.html

@@ -142,6 +142,8 @@
           <option value="lock">Schlösser</option>
           <option value="fan">Lüftung / Ventilatoren</option>
           <option value="humidifier">Befeuchter / Entfeuchter</option>
+          <option value="media_player">TV / Medien</option>
+          <option value="remote">Fernbedienungen</option>
           <option value="number">Numerische Helper</option>
           <option value="valve">Ventile</option>
         </select>
@@ -157,6 +159,7 @@
     </select>
     <button onclick="configureActuator()">Gerät hinzufügen und Beobachtung starten</button>
     <p id="actuator-config-result" class="muted">Noch kein Aktor ausgewählt.</p>
+    <div id="actuator-suggestions" class="card-list"></div>
   </section>
 
   <section class="wide" id="observed">
@@ -182,6 +185,7 @@ let currentActuatorId = null;
 let actuatorChoices = [];
 let contextOptions = [];
 let manualContextState = {options: [], selected: new Set()};
+const ACTUATOR_RESULT_LIMIT = 50;
 
 async function api(path, options = {}) {
   const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
@@ -302,6 +306,7 @@ async function loadOverview() {
     chips.innerHTML = "";
   }
   await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
+  void loadActuatorSuggestions();
 }
 
 async function loadActuatorDiscovery() {
@@ -324,6 +329,32 @@ async function loadActuatorDiscovery() {
   }
 }
 
+async function loadActuatorSuggestions() {
+  const box = document.getElementById("actuator-suggestions");
+  if (!box) return;
+  try {
+    const suggestions = await api("v1/actuators/suggestions");
+    box.innerHTML = suggestions.length ? `
+      <h3>Vorschläge aus bestehenden Zusammenhängen</h3>
+      ${suggestions.slice(0, 8).map(item => `
+        <article class="actuator-card">
+          <div class="card-title">
+            <div>
+              <div class="entity-id">${escapeHtml(item.entity_id)}</div>
+              <div class="muted">${escapeHtml(item.area_name || item.device_name || item.domain)}</div>
+            </div>
+            <span class="chip">${Math.round(item.confidence * 100)} %</span>
+          </div>
+          <p class="muted">${escapeHtml(item.reason)}</p>
+          <button class="secondary" onclick="configureSuggestedActuator('${escapeHtml(item.entity_id)}')">Vorschlag übernehmen</button>
+        </article>
+      `).join("")}
+    ` : "";
+  } catch (_) {
+    box.innerHTML = "";
+  }
+}
+
 function actuatorGroupLabel(domain) {
   const labels = {
     button: "Buttons",
@@ -332,7 +363,9 @@ function actuatorGroupLabel(domain) {
     input_boolean: "Helper-Schalter",
     input_button: "Helper-Buttons",
     lock: "Schlösser",
+    media_player: "TV / Medien",
     number: "Numerische Helper",
+    remote: "Fernbedienungen",
     switch: "Schalter / Steckdosen",
     cover: "Rollläden / Cover",
     fan: "Lüftung / Ventilatoren",
@@ -349,14 +382,17 @@ function renderActuatorSelect() {
   const query = normalizedSearch(document.getElementById("actuator-search")?.value || "");
   const filtered = actuatorChoices
     .filter(entity => !domain || entity.domain === domain)
-    .filter(entity => matchesSearch(entity, query))
-    .slice(0, 120);
-  const domains = [...new Set(filtered.map(entity => entity.domain))].sort();
+    .filter(entity => matchesSearch(entity, query));
+  const visible = filtered.slice(0, ACTUATOR_RESULT_LIMIT);
+  const domains = [...new Set(visible.map(entity => entity.domain))].sort();
+  const limitLabel = filtered.length > visible.length
+    ? ` - ${visible.length} von ${filtered.length}; Suche oder Typ weiter eingrenzen`
+    : "";
   select.innerHTML = [
-    `<option value="">${filtered.length ? "Gerät auswählen ..." : "Keine passenden Geräte gefunden"}</option>`,
+    `<option value="">${filtered.length ? `Gerät auswählen${limitLabel}` : "Keine passenden Geräte gefunden"}</option>`,
     ...domains.map(group => `
       <optgroup label="${escapeHtml(actuatorGroupLabel(group))}">
-        ${filtered
+        ${visible
           .filter(entity => entity.domain === group)
           .map(entity => `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entityLabel(entity))}</option>`)
           .join("")}
@@ -429,13 +465,28 @@ async function configureActuator() {
 async function loadConfiguredActuators() {
   const box = document.getElementById("configured-actuators");
   try {
-    const rows = await api("v1/actuators");
+    const [rows, entities] = await Promise.all([
+      api("v1/actuators"),
+      api("v1/entities"),
+    ]);
+    const entityMap = new Map(entities.map(entity => [entity.entity_id, entity]));
+    const groups = new Map();
+    for (const record of rows) {
+      const entity = entityMap.get(record.actuator_entity_id) || {};
+      const group = entity.area_name || actuatorGroupLabel(record.actuator_entity_id.split(".", 1)[0]);
+      if (!groups.has(group)) groups.set(group, []);
+      groups.get(group).push({record, entity});
+    }
+    const groupedRows = [...groups.entries()].sort(([left], [right]) => left.localeCompare(right));
     box.innerHTML = rows.length ? `
-      <div class="card-list">
-        ${rows.map(record => `
+      ${groupedRows.map(([group, items]) => `
+        <h3>${escapeHtml(group)}</h3>
+        <div class="card-list">
+        ${items.map(({record, entity}) => `
           <article class="actuator-card ${currentActuatorId === record.actuator_entity_id ? "selected" : ""}">
             <div class="card-title">
               <div>
+                <div><strong>${escapeHtml(entity.friendly_name || record.actuator_entity_id)}</strong></div>
                 <div class="entity-id">${escapeHtml(record.actuator_entity_id)}</div>
                 <div class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</div>
               </div>
@@ -457,7 +508,8 @@ async function loadConfiguredActuators() {
             </div>
           </article>
         `).join("")}
-      </div>` : "<p>Noch keine Aktoren ausgewählt.</p>";
+        </div>
+      `).join("")}` : "<p>Noch keine Aktoren ausgewählt.</p>";
   } catch (error) {
     box.textContent = error.message;
   }
@@ -482,6 +534,14 @@ async function showActuator(actuatorId, evaluationMessage = "") {
       .filter(candidate => contexts.includes(candidate.entity_id))
       .map(candidate => `<li><strong>${escapeHtml(candidate.friendly_name || candidate.entity_id)}</strong>: ${candidate.evidence.map(escapeHtml).join(", ") || "statistisch relevanter Kandidat"}</li>`)
       .join("");
+    const currentContextControls = contexts.length
+      ? `<ul>${contexts.map(entityId => `
+          <li>
+            <code>${escapeHtml(entityId)}</code>
+            <button class="secondary compact" onclick="removeContextEntity('${escapeHtml(record.actuator_entity_id)}', '${escapeHtml(entityId)}')">Entfernen</button>
+          </li>
+        `).join("")}</ul>`
+      : "<p class='muted'>Noch keine Kontext-Entity ausgewählt.</p>";
     const prediction = record.behavior.prediction;
     const learnedAutomationActions = record.behavior.patterns.filter(
       pattern => pattern.source === "automation",
@@ -597,6 +657,8 @@ async function showActuator(actuatorId, evaluationMessage = "") {
       ${automationControls}
       <h3>Welche Zusammenhänge automatisch verwendet werden</h3>
       ${evidence ? `<ul>${evidence}</ul>` : "<p class='warn'>Noch kein geeigneter Kontext erkannt. SillyHome prüft bei neuen HA-Daten erneut.</p>"}
+      <h3>Verwendete Sensoren/Zustände ändern</h3>
+      ${currentContextControls}
       ${manualAssignment}
     `;
     document.getElementById("detail").scrollIntoView({behavior: "smooth", block: "start"});
@@ -631,6 +693,34 @@ async function saveManualAssignment(actuatorId) {
   }
 }
 
+async function removeContextEntity(actuatorId, entityId) {
+  try {
+    const record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
+    const numericEntityId = record.assignment.selected_numeric_entity_id === entityId
+      ? null
+      : record.assignment.selected_numeric_entity_id;
+    const contextEntityIds = (record.assignment.selected_context_entity_ids || [])
+      .filter(id => id !== entityId);
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/assignment`, {
+      method: "POST",
+      body: JSON.stringify({
+        numeric_entity_id: numericEntityId,
+        context_entity_ids: contextEntityIds,
+        note: `Entity ${entityId} entfernt`,
+      }),
+    });
+    await loadConfiguredActuators();
+    await showActuator(actuatorId, "Kontext-Entity entfernt.");
+  } catch (error) {
+    alert(error.message);
+  }
+}
+
+async function configureSuggestedActuator(actuatorId) {
+  document.getElementById("actuator-input").value = actuatorId;
+  await configureActuator();
+}
+
 async function evaluateActuator(actuatorId) {
   try {
     const record = await api(

pyproject.toml

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

tests/actuators/test_lifecycle.py

@@ -277,6 +277,39 @@ def test_reconciliation_ignores_generic_monitoring_area_for_automatic_context(
     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_manual_assignment_persists_and_wins_over_automatic_mapping(tmp_path: Path) -> None:
     start = datetime(2026, 6, 1, tzinfo=timezone.utc)
     entities = [

tests/behavior/test_engine.py

@@ -558,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"),

tests/ha/test_discovery.py

@@ -91,6 +91,10 @@ def test_discovery_filters_domain_and_learnable() -> None:
             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",

tests/test_main.py

@@ -94,7 +94,8 @@ def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
 
         connect.assert_called_once_with(
             "ws://homeassistant:8123/api/websocket",
-            ping_interval=None,
+            ping_interval=20,
+            ping_timeout=10,
         )
         assert fake_ws.sent == [
             {"type": "auth", "access_token": "test-token"},
@@ -110,6 +111,7 @@ def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
     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()