feat: add manual context assignment and fix actuator discovery

fix: batch ha metadata and improve mobile dashboard
fix: complete websocket delivery for v0.7.1
2026-06-14 23:15:00 +02:00 · 2026-06-14 22:52:42 +02:00 · 2026-06-14 22:30:29 +02:00 · 2026-06-14 17:55:44 +02:00 · 2026-06-14 17:23:29 +02:00
17 changed files with 840 additions and 78 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,33 @@
 # Changelog

+## 0.7.3 - 2026-06-14
+- Automatische Kontextzuordnung ignoriert generische Bereiche wie `Monitoring`,
+  damit System-/Disk-/Überhitzungssensoren nicht fälschlich Lichtaktoren erklären
+- Aktor-Auswahl auf tatsächlich sicher steuerbare Domains begrenzt:
+  `light`, `switch`, `cover`, `fan`, `humidifier`
+- Neue manuelle Kontext-Zuordnung pro Aktor: Haupt-Messsensor optional setzen und
+  mehrere relevante Kontext-Entities wie PIR, Außenhelligkeit, Luftfeuchtigkeit
+  oder andere Lichtzustände auswählen
+- Dashboard-Dropdown durch echtes Select plus Suche ersetzt; mobile Bedienung und
+  Aktor-Details enthalten Speichern/Neu-laden-Aktionen für manuelle Kontextwahl
+
+## 0.7.2 - 2026-06-14
+- Home-Assistant-Entity-Metadaten werden in Batches gelesen, damit große HA-
+  Installationen nicht mehr am Template-Ausgabe-Limit scheitern
+- Nicht über die HA-Config-API exponierte Automationen werden leise übersprungen,
+  statt wiederholt Warnungen in die Logs zu schreiben
+- Dashboard für mobile Nutzung optimiert: Sticky-Schnellnavigation, Karten statt
+  breiter Tabelle, größere Touch-Ziele und bessere Detail-/Menüführung
+- WebSocket-Status ist direkt im Dashboard-Systemstatus sichtbar
+
+## 0.7.1 - 2026-06-14
+- Event-basierter Home-Assistant-WebSocket-Listener authentifiziert sich jetzt
+  mit dem echten HA-WebSocket-Protokoll (`auth_required` -> `auth` -> `auth_ok`)
+- Kompatibilität mit aktuellen `websockets`-Versionen wiederhergestellt
+- WebSocket-Healthcheck und Event-Listener-Tests laufen ohne zusätzliches
+  Async-Pytest-Plugin
+- Add-on-Version angehoben, damit Home Assistant das aktualisierte Image baut
+
 ## 0.7.0 - 2026-06-14
 - Freie Eingabe von Home-Assistant-Entitätsnamen mit Vorschlagsliste
 - Freigabestatus und Blockadegrund sind in Übersicht und Details immer sichtbar
--- a/addon/config.yaml
+++ b/addon/config.yaml
@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "0.7.0"
+version: "0.7.3"
 slug: sillyhome_next
 description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
 url: http://192.168.6.31:3000/pino/sillyhome-next
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
@@ -13,6 +13,7 @@ from app.actuators.models import (
    AssignmentSource,
    LifecycleAuditEntry,
    LifecycleStatus,
+    ManualOverride,
    ModelLifecycleState,
    ReconciliationState,
    model_id_for_actuator,
@@ -47,6 +48,7 @@ _STOPWORDS = frozenset(
        "light",
        "licht",
        "lichtschalter",
+        "monitoring",
        "power",
        "sensor",
        "state",
@@ -55,6 +57,7 @@ _STOPWORDS = frozenset(
        "value",
    }
 )
+_GENERIC_AREA_NAMES = frozenset({"monitoring", "system", "technik"})
 _NUMERIC_AUTO_ACCEPT_SCORE = 0.82
 _NUMERIC_AUTO_ACCEPT_MIN_SCORE = 0.5
 _NUMERIC_MIN_MARGIN = 0.18
@@ -93,6 +96,67 @@ class ActuatorReconciliationService:
        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,
+            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": _merge_manual_candidates(
+                    record.numeric_candidates,
+                    entities,
+                    [numeric_entity_id] if numeric_entity_id else [],
+                    role=EntityRole.MEASUREMENT,
+                ),
+                "context_candidates": _merge_manual_candidates(
+                    record.context_candidates,
+                    entities,
+                    selected_context_ids,
+                    role=EntityRole.CONTEXT,
+                ),
+                "lifecycle": lifecycle,
+                "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 +262,14 @@ class ActuatorReconciliationService:
            ),
            context=True,
        )
-        assignment = self._select_assignment(
-            actuator=actuator,
-            numeric_candidates=numeric_candidates,
-            context_candidates=context_candidates,
+        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 +280,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 +296,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,
        *,
@@ -522,7 +607,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:
@@ -550,6 +640,49 @@ def _score_candidate(
    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:
+            by_id[entity_id] = existing.model_copy(
+                update={
+                    "auto_accepted": True,
+                    "confidence": 1.0,
+                    "evidence": [
+                        *existing.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 _preferred_device_classes(domain: str, *, context: bool) -> frozenset[str]:
    if context:
        return frozenset({"door", "garage_door", "motion", "occupancy", "opening", "presence"})
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -14,6 +14,19 @@ from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader

 router = APIRouter(prefix="/v1/actuators", tags=["actuators"])
+_MANUAL_CONTEXT_DOMAINS = frozenset({
+    "binary_sensor",
+    "climate",
+    "cover",
+    "device_tracker",
+    "fan",
+    "humidifier",
+    "light",
+    "person",
+    "sensor",
+    "switch",
+    "weather",
+})


 class ConfigureActuatorRequest(BaseModel):
@@ -32,6 +45,12 @@ 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)
+
+
@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()}
@@ -42,6 +61,22 @@ 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("/context-options", response_model=list[HaEntitySummary])
+def context_options(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaEntitySummary]:
+    return sorted(
+        [
+            entity
+            for entity in ha_reader.read_entities()
+            if entity.domain in _MANUAL_CONTEXT_DOMAINS
+        ],
+        key=lambda entity: (
+            entity.area_name or "",
+            entity.friendly_name or entity.entity_id,
+            entity.entity_id,
+        ),
+    )
+
+
@router.get("", response_model=list[ActuatorRecord])
 def list_configured(request: Request) -> list[ActuatorRecord]:
    return _service(request).list_configured()
@@ -116,6 +151,27 @@ 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}/related-automations/refresh",
    response_model=ActuatorRecord,
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
@@ -608,6 +608,35 @@ class BehaviorEngine:
        )
        return self._store.upsert(updated)

+    def handle_state_change(self, entity_id: str, new_state: dict[str, object] | 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.
+        """
+        # Aktor direkt evaluieren
+        for record in self._store.list():
+            if record.actuator_entity_id == entity_id:
+                try:
+                    self.evaluate(record.actuator_entity_id)
+                except Exception:
+                    logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", record.actuator_entity_id)
+                return
+        # Kontext-Entity: alle Aktoren finden, die diesen Kontext nutzen
+        affected_actuators = [
+            record.actuator_entity_id
+            for record in self._store.list()
+            if (
+                record.assignment.selected_numeric_entity_id == entity_id
+                or entity_id in record.assignment.selected_context_entity_ids
+            )
+        ]
+        for actuator_entity_id in affected_actuators:
+            try:
+                self.evaluate(actuator_entity_id)
+            except Exception:
+                logger.exception("Event-basierte Vorhersage fehlgeschlagen für %s", actuator_entity_id)
+

 def predict_behavior(
    patterns: list[BehaviorPattern],
--- a/app/ha/client.py
+++ b/app/ha/client.py
@@ -22,6 +22,7 @@ logger = logging.getLogger(__name__)
 _ENTITY_ID_PATTERN = re.compile(r"^[a-z0-9_]+\.[a-z0-9_]+$")
 _SERVICE_PART_PATTERN = re.compile(r"^[a-z0-9_]+$")
 _MAX_HISTORY_SECONDS = 31 * 24 * 60 * 60
+_METADATA_BATCH_SIZE = 200


@dataclass(frozen=True)
@@ -141,6 +142,17 @@ class HaClient:
            return {}
        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
            raise ValueError("entity_id enthält ein ungültiges Format.")
+        result: dict[str, dict[str, str | None]] = {}
+        for start in range(0, len(entity_ids), _METADATA_BATCH_SIZE):
+            result.update(
+                self._list_entity_metadata_batch(entity_ids[start:start + _METADATA_BATCH_SIZE])
+            )
+        return result
+
+    def _list_entity_metadata_batch(
+        self,
+        entity_ids: list[str],
+    ) -> dict[str, dict[str, str | None]]:
        template = _metadata_template(entity_ids)
        rendered = self._post_text("/api/template", {"template": template})
        try:
--- a/app/ha/discovery.py
+++ b/app/ha/discovery.py
@@ -82,18 +82,11 @@ _BINARY_CONTEXT_CLASSES = frozenset({
    "window",
 })
 _ACTUATOR_DOMAINS = frozenset({
-    "button",
-    "climate",
    "cover",
    "fan",
    "humidifier",
    "light",
-    "lock",
-    "scene",
-    "select",
-    "siren",
    "switch",
-    "valve",
 })
 _CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "sun", "weather", "zone"})
 _LEARNABLE_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "weather"})
--- a/app/ha/reader.py
+++ b/app/ha/reader.py
@@ -6,7 +6,7 @@ from threading import RLock
 from typing import Any
 import logging

-from app.ha.exceptions import HaClientError
+from app.ha.exceptions import HaClientError, HaHttpError

 from app.ha.client import HaClient
 from app.ha.discovery import DiscoveredEntity, discover_entities
@@ -167,6 +167,19 @@ class HaReader:
                    continue
                try:
                    config = self._client.get_automation_config(config_id)
+                except HaHttpError as exc:
+                    if exc.status_code == 404:
+                        logger.info(
+                            "Automation config not exposed by Home Assistant for %s.",
+                            raw_entity_id,
+                        )
+                        continue
+                    logger.warning(
+                        "Automation config unavailable for %s: %s",
+                        raw_entity_id,
+                        exc,
+                    )
+                    continue
                except (HaClientError, ValueError) as exc:
                    logger.warning(
                        "Automation config unavailable for %s: %s",
--- a/app/main.py
+++ b/app/main.py
@@ -1,9 +1,12 @@
 import asyncio
+import json
+import logging
 from contextlib import asynccontextmanager, suppress
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import cast

+import websockets
 from fastapi import FastAPI
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
@@ -20,13 +23,27 @@ from app.ha.reader import HaReader
 from app.ml.registry.model_registry import ModelRegistry
 from backend.routes.ml import init_ml_routes

+logger = logging.getLogger(__name__)
+
+class _WsStatus:
+    """Einfacher Status-Tracker für den WebSocket-Listener.
+
+    Wird als Attribut an app.state gehängt und enthält:
+    - status: "disconnected" | "connecting" | "connected" | "reconnecting" | "error"
+    - error: str | None (Fehlermeldung bei status=error)
+    """
+    def __init__(self) -> None:
+        self.status: str = "disconnected"
+        self.error: str | None = None
+

@asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    settings = app.state.settings
    client: HaClient | None = None
    reconcile_task: asyncio.Task[None] | None = None
-    prediction_task: asyncio.Task[None] | None = None
+    event_listener_task: asyncio.Task[None] | None = None
+    fallback_task: asyncio.Task[None] | None = None
    app.state.registry = ModelRegistry(settings.model_store)
    app.state.actuator_store = ActuatorStore(settings.actuator_store)
    if hasattr(app.state, "ha_reader"):
@@ -54,11 +71,13 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            store=app.state.actuator_store,
            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)
        reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
-        prediction_task = asyncio.create_task(_periodic_prediction(app))
+        event_listener_task = asyncio.create_task(_ha_event_listener(app, client))
+        fallback_task = asyncio.create_task(_fallback_prediction(app))
    try:
        yield
    finally:
@@ -66,10 +85,14 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            reconcile_task.cancel()
            with suppress(asyncio.CancelledError):
                await reconcile_task
-        if prediction_task is not None:
-            prediction_task.cancel()
+        if event_listener_task is not None:
+            event_listener_task.cancel()
            with suppress(asyncio.CancelledError):
-                await prediction_task
+                await event_listener_task
+        if fallback_task is not None:
+            fallback_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await fallback_task
        if client is not None:
            client.close()

@@ -77,7 +100,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.0",
+    version="0.7.3",
    lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -94,6 +117,19 @@ app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 def health() -> dict[str, str]:
    return {"status": "ok"}

+@app.get("/health/websocket")
+def websocket_health() -> dict[str, object]:
+    """Gibt den aktuellen Status des WebSocket-Listeners zurück.
+
+    Antwort:
+    - status: "disconnected" | "connecting" | "connected" | "reconnecting" | "error"
+    - error: str | None (nur bei status=error)
+    """
+    ws_status = getattr(app.state, "ws_status", None)
+    if ws_status is None:
+        return {"status": "unavailable", "error": "WebSocket-Listener nicht initialisiert"}
+    return {"status": ws_status.status, "error": ws_status.error}
+

@app.get("/")
 def root() -> FileResponse:
@@ -115,10 +151,107 @@ async def _periodic_reconciliation(app: FastAPI) -> None:
            await asyncio.to_thread(engine.train_all)


-async def _periodic_prediction(app: FastAPI) -> None:
+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
+    store = app.state.actuator_store
+    if not isinstance(engine, BehaviorEngine) or not isinstance(store, ActuatorStore):
+        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
+    ha_url = str(settings.ha_url).rstrip("/")
+    ws_url = ha_url.replace("http://", "ws://").replace("https://", "wss://") + "/api/websocket"
+    auth_token = cast(str, settings.ha_token)
+    ws_status = getattr(app.state, "ws_status", None)
+    while True:
+        if ws_status is not None:
+            ws_status.status = "connecting"
+        try:
+            async with websockets.connect(ws_url) as websocket:
+                auth_required_msg = await websocket.recv()
+                auth_required_data = json.loads(auth_required_msg)
+                if auth_required_data.get("type") != "auth_required":
+                    logger.error("Unerwartete WebSocket-Authentifizierungsaufforderung")
+                    if ws_status is not None:
+                        ws_status.status = "error"
+                        ws_status.error = "Unerwartete Authentifizierungsaufforderung"
+                    await asyncio.sleep(5)
+                    continue
+
+                await websocket.send(json.dumps({"type": "auth", "access_token": auth_token}))
+                auth_result_msg = await websocket.recv()
+                auth_result_data = json.loads(auth_result_msg)
+                if auth_result_data.get("type") != "auth_ok":
+                    logger.error("WebSocket-Authentifizierung fehlgeschlagen")
+                    if ws_status is not None:
+                        ws_status.status = "error"
+                        ws_status.error = "Authentifizierung fehlgeschlagen"
+                    await asyncio.sleep(5)
+                    continue
+
+                logger.info("WebSocket-Verbindung zu Home Assistant hergestellt")
+                if ws_status is not None:
+                    ws_status.status = "connected"
+                    ws_status.error = None
+                # Auf alle State Changes subscriben
+                subscribe_msg = {
+                    "id": 1,
+                    "type": "subscribe_events",
+                    "event_type": "state_changed"
+                }
+                await websocket.send(json.dumps(subscribe_msg))
+                while True:
+                    message = await websocket.recv()
+                    try:
+                        data = json.loads(message)
+                        if data.get("type") != "event":
+                            continue
+                        event = data.get("event", {})
+                        if event.get("event_type") != "state_changed":
+                            continue
+                        entity_id = event.get("entity_id")
+                        if not 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"))
+                    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)
+            if ws_status is not None:
+                ws_status.status = "reconnecting"
+                ws_status.error = str(exc)
+            await asyncio.sleep(5)
+        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)
+
+
+# Fallback: periodische Vorhersage falls Event-Stream ausfällt
+async def _fallback_prediction(app: FastAPI) -> None:
+    """Periodische Vorhersage als Fallback, wenn WebSocket-Listener nicht verbunden ist.
+
+    Dies verhindert kompletten Ausfall der Vorhersagen bei Netzwerkproblemen.
+    """
    while True:
        await asyncio.sleep(app.state.settings.prediction_interval_seconds)
-        engine = getattr(app.state, "behavior_engine", None)
-        if not isinstance(engine, BehaviorEngine):
-            continue
-        await asyncio.to_thread(engine.evaluate_all)
+        # Nur ausführen, wenn WebSocket nicht verbunden ist
+        ws_status = getattr(app.state, "ws_status", None)
+        if ws_status is None or ws_status.status != "connected":
+            engine = getattr(app.state, "behavior_engine", None)
+            if isinstance(engine, BehaviorEngine):
+                logger.debug(
+                    "Fallback-Vorhersage aktiv (WebSocket-Status: %s)",
+                    ws_status.status if ws_status else "unavailable",
+                )
+                await asyncio.to_thread(engine.evaluate_all)
--- a/app/static/index.html
+++ b/app/static/index.html
@@ -5,14 +5,18 @@
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <title>SillyHome Next</title>
  <style>
-    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #10151c; color: #eaf1f8; }
-    body { margin: 0; }
+    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #10151c; color: #eaf1f8; scroll-behavior:smooth; }
+    body { margin: 0; font-size:16px; }
    header { padding: 22px; background: linear-gradient(135deg,#142b3a,#193f36); }
    h1,h2,h3 { margin: 0 0 12px; }
    header p { margin: 5px 0; color: #c3d1dc; }
    main { display: grid; grid-template-columns: repeat(auto-fit,minmax(320px,1fr)); gap: 14px; padding: 14px; }
    section { background: #18212b; border: 1px solid #2d3a47; border-radius: 12px; padding: 16px; }
+    section:target { outline:2px solid #66dfa9; outline-offset:2px; }
    .wide { grid-column: 1 / -1; }
+    .quick-nav { position:sticky; top:0; z-index:10; display:flex; gap:8px; overflow-x:auto; padding:10px 14px; background:rgba(16,21,28,.94); border-bottom:1px solid #2d3a47; backdrop-filter:blur(8px); }
+    .quick-nav a { flex:0 0 auto; padding:10px 12px; border-radius:999px; background:#22303c; border:1px solid #31404d; color:#eaf1f8; text-decoration:none; font-weight:700; font-size:.92rem; }
+    .quick-nav a.primary { background:#23715b; }
    .steps { display:grid; grid-template-columns:repeat(auto-fit,minmax(220px,1fr)); gap:12px; }
    .step { background:#111a23; border:1px solid #31404d; border-radius:10px; padding:14px; }
    .step-number { display:inline-grid; place-items:center; width:28px; height:28px; border-radius:50%; background:#23715b; font-weight:700; margin-bottom:8px; }
@@ -21,10 +25,12 @@
    .warn { color: #f3c969; }
    .bad { color: #ff8f8f; }
    label { display: block; margin: 9px 0 4px; color: #b9c9d6; }
-    select,input,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; }
-    button { margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
+    select,input,button { box-sizing: border-box; width: 100%; border-radius: 10px; border: 1px solid #3b4b5b; padding: 12px; background: #101820; color: #fff; font:inherit; }
+    select[multiple] { min-height:190px; }
+    button { min-height:44px; margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
    button.secondary { background: #37495c; }
    button.danger { background: #7b3434; }
+    button.compact { width:auto; min-width:120px; margin-right:8px; }
    table { width: 100%; border-collapse: collapse; font-size: .92rem; }
    td,th { padding: 8px; border-bottom: 1px solid #2d3a47; text-align: left; vertical-align: top; }
    ul { margin: 8px 0; padding-left: 18px; }
@@ -33,6 +39,36 @@
    .chips { display:flex; flex-wrap:wrap; gap:6px; margin-top:8px; }
    .chip { padding:4px 8px; border-radius:999px; background:#22303c; border:1px solid #31404d; font-size:.85rem; }
    .muted { color:#9fb0be; }
+    .card-list { display:grid; gap:12px; }
+    .actuator-card { background:#111a23; border:1px solid #31404d; border-radius:14px; padding:14px; }
+    .actuator-card.selected { border-color:#66dfa9; box-shadow:0 0 0 1px rgba(102,223,169,.3); }
+    .card-title { display:flex; justify-content:space-between; gap:10px; align-items:flex-start; margin-bottom:8px; }
+    .entity-id { overflow-wrap:anywhere; font-weight:800; }
+    .metric-grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(150px,1fr)); gap:8px; margin:10px 0; }
+    .metric { background:#18212b; border:1px solid #2d3a47; border-radius:10px; padding:10px; }
+    .metric strong { display:block; margin-bottom:4px; color:#cfe0ec; font-size:.84rem; }
+    .actions { display:flex; flex-wrap:wrap; gap:8px; margin-top:10px; }
+    .actions button { flex:1 1 180px; margin-top:0; }
+    .detail-header { display:flex; justify-content:space-between; gap:12px; align-items:flex-start; flex-wrap:wrap; }
+    .manual-context { margin-top:14px; background:#111a23; border:1px solid #31404d; border-radius:14px; padding:14px; }
+    code { color:#cfe0ec; overflow-wrap:anywhere; }
+    @media (max-width: 760px) {
+      header { padding:18px 14px; }
+      header h1 { font-size:1.55rem; }
+      main { display:block; padding:10px; }
+      section { margin-bottom:12px; padding:14px; border-radius:14px; }
+      .steps { grid-template-columns:1fr; }
+      .grid-two { grid-template-columns:1fr; }
+      .metric-grid { grid-template-columns:1fr 1fr; }
+      .actions { display:grid; grid-template-columns:1fr; }
+      .actions button, button.compact { width:100%; min-width:0; margin-right:0; }
+      .quick-nav { padding:8px 10px; }
+      .quick-nav a { padding:10px 11px; }
+    }
+    @media (max-width: 430px) {
+      .metric-grid { grid-template-columns:1fr; }
+      body { font-size:15px; }
+    }
  </style>
 </head>
 <body>
@@ -41,8 +77,15 @@
  <p>Hier wählst du nur Geräte aus, deren Bedienung SillyHome lernen soll. Sensoren, Zusammenhänge und Modelle werden automatisch verwaltet.</p>
  <p class="notice">Sicherer Start: Zuerst wird nur beobachtet und vorhergesagt. Ohne deine spätere Freigabe wird nichts geschaltet.</p>
 </header>
+<nav class="quick-nav" aria-label="Schnellnavigation">
+  <a class="primary" href="#choose">Gerät wählen</a>
+  <a href="#observed">Beobachtet</a>
+  <a href="#detail">Details</a>
+  <a href="#status-section">Status</a>
+  <a href="#guide">Ablauf</a>
+</nav>
 <main>
-  <section class="wide">
+  <section class="wide" id="guide">
    <h2>So gehst du vor</h2>
    <div class="steps">
      <div class="step">
@@ -66,7 +109,7 @@
    </div>
  </section>

-  <section>
+  <section id="status-section">
    <h2>Systemstatus</h2>
    <p class="muted">Zeigt, ob Verbindung, Lernsystem und automatische Prüfungen funktionieren. Hier musst du normalerweise nichts einstellen.</p>
    <div id="status">Prüfung läuft ...</div>
@@ -74,23 +117,27 @@
    <button class="secondary" onclick="loadOverview()">Status aktualisieren</button>
  </section>

-  <section>
+  <section id="choose">
    <h2>1. Gerät zum Lernen auswählen</h2>
    <p class="muted">Wähle eine Lampe, einen Rollladen oder einen anderen unterstützten Aktor. Du wählst keine Sensoren und erstellst keine Regeln.</p>
    <label for="actuator-input">Entitätsname oder Gerät aus Home Assistant</label>
    <input id="actuator-input" list="actuator-options" placeholder="z. B. light.licht_abstellraum" autocomplete="off">
    <datalist id="actuator-options"></datalist>
+    <label for="actuator-select">Oder aus Liste wählen</label>
+    <select id="actuator-select" onchange="selectActuatorFromList()">
+      <option value="">Geräteliste wird geladen ...</option>
+    </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>
  </section>

-  <section class="wide">
+  <section class="wide" id="observed">
    <h2>2. Beobachtete Geräte</h2>
    <p class="muted">Öffne „Details“, um Lernfortschritt, aktuelle Vorhersage und den automatisch gefundenen Kontext zu sehen.</p>
    <div id="configured-actuators">Noch nicht geladen.</div>
  </section>

-  <section class="wide">
+  <section class="wide" id="detail">
    <h2>3. Lernfortschritt und Freigabe</h2>
    <p class="muted">Die Freigabe erscheint erst, wenn genug eindeutig zugeordnete Handlungen gelernt wurden. Vorher bleibt das Gerät sicher im Beobachtungsmodus.</p>
    <div id="actuator-detail" class="muted">Öffne bei einem beobachteten Gerät die Details.</div>
@@ -104,6 +151,8 @@ const escapeHtml = value => String(value ?? "")
  .replaceAll('"', "&quot;")
  .replaceAll("'", "&#039;");
 let currentActuatorId = null;
+let actuatorChoices = [];
+let contextOptions = [];

 async function api(path, options = {}) {
  const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
@@ -139,12 +188,19 @@ function behaviorLabel(record) {
  return "sammelt Handlungen";
 }

+function predictionLabel(record) {
+  return record.behavior.prediction
+    ? `${record.behavior.prediction.target_state} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
+    : "Keine fällige Aktion";
+}
+
 async function loadOverview() {
  const status = document.getElementById("status");
  const chips = document.getElementById("status-chips");
  try {
-    const [health, ml, reconciliation, actuators] = await Promise.all([
+    const [health, websocket, ml, reconciliation, actuators] = await Promise.all([
      api("health"),
+      api("health/websocket"),
      api("ml/health"),
      api("v1/actuators/reconciliation/state"),
      api("v1/actuators"),
@@ -152,6 +208,7 @@ async function loadOverview() {
    status.innerHTML = `<p class="ok">System bereit</p><p>Letzte automatische Prüfung: ${escapeHtml(reconciliation.last_completed_at || "noch nie")}</p>`;
    chips.innerHTML = [
      `<span class="chip">API: ${escapeHtml(health.status)}</span>`,
+      `<span class="chip">WebSocket: ${escapeHtml(websocket.status)}</span>`,
      `<span class="chip">Lernsystem: ${escapeHtml(ml.status)}</span>`,
      `<span class="chip">Aktoren: ${actuators.length}</span>`,
      `<span class="chip">Lernbereite Geräte: ${reconciliation.trained_models}</span>`,
@@ -160,28 +217,52 @@ async function loadOverview() {
    status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
    chips.innerHTML = "";
  }
-  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
+  await Promise.all([loadActuatorDiscovery(), loadContextOptions(), loadConfiguredActuators()]);
 }

 async function loadActuatorDiscovery() {
  const options = document.getElementById("actuator-options");
+  const select = document.getElementById("actuator-select");
  try {
    const [available, configured] = await Promise.all([
      api("v1/actuators/discovery"),
      api("v1/actuators"),
    ]);
    const configuredIds = new Set(configured.map(record => record.actuator_entity_id));
-    const choices = available.filter(entity => !configuredIds.has(entity.entity_id));
-    options.innerHTML = choices.map(entity =>
+    actuatorChoices = available.filter(entity => !configuredIds.has(entity.entity_id));
+    options.innerHTML = actuatorChoices.map(entity =>
      `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.friendly_name || entity.entity_id)}${entity.area_name ? ` (${escapeHtml(entity.area_name)})` : ""}</option>`
    ).join("");
+    select.innerHTML = [
+      `<option value="">Gerät auswählen ...</option>`,
+      ...actuatorChoices.map(entity =>
+        `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})</option>`
+      ),
+    ].join("");
  } catch (error) {
    options.innerHTML = "";
+    select.innerHTML = `<option value="">Geräteliste konnte nicht geladen werden</option>`;
  }
 }

+async function loadContextOptions() {
+  try {
+    contextOptions = await api("v1/actuators/context-options");
+  } catch (error) {
+    contextOptions = [];
+  }
+}
+
+function selectActuatorFromList() {
+  const value = document.getElementById("actuator-select").value;
+  if (value) document.getElementById("actuator-input").value = value;
+}
+
 async function configureActuator() {
-  const actuatorId = document.getElementById("actuator-input").value.trim();
+  const actuatorId = (
+    document.getElementById("actuator-input").value.trim()
+    || document.getElementById("actuator-select").value.trim()
+  );
  const result = document.getElementById("actuator-config-result");
  if (!actuatorId) return;
  result.textContent = "Kontext wird automatisch analysiert ...";
@@ -194,6 +275,7 @@ async function configureActuator() {
    result.textContent = `${record.actuator_entity_id}: ${lifecycleLabel(record)}.`;
    await loadOverview();
    await showActuator(record.actuator_entity_id);
+    document.getElementById("detail").scrollIntoView({behavior: "smooth", block: "start"});
  } catch (error) {
    result.textContent = error.message;
  }
@@ -204,29 +286,33 @@ async function loadConfiguredActuators() {
  try {
    const rows = await api("v1/actuators");
    box.innerHTML = rows.length ? `
-      <table>
-        <tr><th>Gerät</th><th>Lernstatus</th><th>Freigabe</th><th>Gelernte Handlungen</th><th>Letzte Vorhersage</th><th>Aktionen</th></tr>
+      <div class="card-list">
        ${rows.map(record => `
-          <tr>
-            <td>${escapeHtml(record.actuator_entity_id)}</td>
-            <td class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</td>
-            <td class="${record.behavior.activation_ready ? "ok" : "warn"}">${escapeHtml(record.behavior.activation_ready ? "bereit" : record.behavior.activation_reason)}</td>
-            <td>${record.behavior.sample_count}</td>
-            <td>${record.behavior.prediction
-              ? `${escapeHtml(record.behavior.prediction.target_state)} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
-              : "-"}</td>
-            <td>
-              <button onclick="showActuator('${escapeHtml(record.actuator_entity_id)}')">Details</button>
+          <article class="actuator-card ${currentActuatorId === record.actuator_entity_id ? "selected" : ""}">
+            <div class="card-title">
+              <div>
+                <div class="entity-id">${escapeHtml(record.actuator_entity_id)}</div>
+                <div class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</div>
+              </div>
+              <span class="chip">${escapeHtml(lifecycleLabel(record))}</span>
+            </div>
+            <div class="metric-grid">
+              <div class="metric"><strong>Freigabe</strong><span class="${record.behavior.activation_ready ? "ok" : "warn"}">${escapeHtml(record.behavior.activation_ready ? "bereit" : record.behavior.activation_reason)}</span></div>
+              <div class="metric"><strong>Handlungen</strong>${record.behavior.sample_count}</div>
+              <div class="metric"><strong>Vorhersage</strong>${escapeHtml(predictionLabel(record))}</div>
+            </div>
+            <div class="actions">
+              <button onclick="showActuator('${escapeHtml(record.actuator_entity_id)}')">Details öffnen</button>
              ${record.behavior.mode === "active"
                ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, true)">Stoppen + HA-Automationen fortsetzen</button>`
                : record.behavior.activation_ready
                  ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true, true, false)">SillyHome übernehmen lassen</button>`
                  : ""}
              <button class="danger" onclick="removeActuator('${escapeHtml(record.actuator_entity_id)}')">Entfernen</button>
-            </td>
-          </tr>
+            </div>
+          </article>
        `).join("")}
-      </table>` : "<p>Noch keine Aktoren ausgewählt.</p>";
+      </div>` : "<p>Noch keine Aktoren ausgewählt.</p>";
  } catch (error) {
    box.textContent = error.message;
  }
@@ -255,6 +341,37 @@ async function showActuator(actuatorId, evaluationMessage = "") {
      pattern => pattern.source === "automation",
    ).length;
    const relatedAutomations = record.behavior.related_automations || [];
+    const manualContextIds = new Set(record.assignment.selected_context_entity_ids || []);
+    const numericOptions = contextOptions.filter(entity => entity.domain === "sensor");
+    const manualAssignment = `
+      <div class="manual-context">
+        <h3>Kontext selbst festlegen</h3>
+        <p class="muted">Hier kannst du Sensoren und Zustände ergänzen, die deiner Meinung nach wichtig für den Schaltvorgang sind. Beispiele: PIR, Helligkeit außen, Luftfeuchtigkeit innen/außen oder ein Lichtzustand.</p>
+        <label for="manual-numeric-select">Optionaler Haupt-Messsensor</label>
+        <select id="manual-numeric-select">
+          <option value="">Keinen numerischen Hauptsensor verwenden</option>
+          ${numericOptions.map(entity => `
+            <option value="${escapeHtml(entity.entity_id)}" ${record.assignment.selected_numeric_entity_id === entity.entity_id ? "selected" : ""}>
+              ${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})
+            </option>
+          `).join("")}
+        </select>
+        <label for="manual-context-select">Zusätzliche Kontext-Entities</label>
+        <select id="manual-context-select" multiple>
+          ${contextOptions
+            .filter(entity => entity.entity_id !== record.actuator_entity_id)
+            .map(entity => `
+              <option value="${escapeHtml(entity.entity_id)}" ${manualContextIds.has(entity.entity_id) ? "selected" : ""}>
+                ${escapeHtml(entity.area_name || "Ohne Bereich")} - ${escapeHtml(entity.friendly_name || entity.entity_id)} (${escapeHtml(entity.entity_id)})
+              </option>
+            `).join("")}
+        </select>
+        <div class="actions">
+          <button onclick="saveManualAssignment('${escapeHtml(record.actuator_entity_id)}')">Diese Kontext-Auswahl speichern</button>
+          <button class="secondary" onclick="loadContextOptions().then(() => showActuator('${escapeHtml(record.actuator_entity_id)}'))">Listen neu laden</button>
+        </div>
+      </div>
+    `;
    const activationButton = record.behavior.mode === "active"
      ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, true)">SillyHome stoppen und pausierte HA-Automationen fortsetzen</button>
         <button class="secondary" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, false)">SillyHome stoppen; HA-Automationen pausiert lassen</button>`
@@ -268,13 +385,20 @@ async function showActuator(actuatorId, evaluationMessage = "") {
            <strong>${escapeHtml(automation.friendly_name)}</strong>
            <code>${escapeHtml(automation.entity_id)}</code>:
            <span class="${automation.enabled ? "ok" : "warn"}">${automation.enabled ? "aktiv" : "pausiert"}</span>
-            <button class="secondary" onclick="setRelatedAutomation('${escapeHtml(record.actuator_entity_id)}', '${escapeHtml(automation.entity_id)}', ${automation.enabled ? "false" : "true"})">${automation.enabled ? "Pausieren" : "Fortsetzen"}</button>
+            <button class="secondary compact" onclick="setRelatedAutomation('${escapeHtml(record.actuator_entity_id)}', '${escapeHtml(automation.entity_id)}', ${automation.enabled ? "false" : "true"})">${automation.enabled ? "Pausieren" : "Fortsetzen"}</button>
          </li>`).join("")}</ul>`
      : "<p class='muted'>Keine eindeutig passende HA-Automation gefunden.</p>";
    box.innerHTML = `
-      <div class="grid-two">
+      <div class="detail-header">
        <div>
          <h3>${escapeHtml(record.actuator_entity_id)}</h3>
+          <p class="muted">Alle wichtigen Aktionen für dieses Gerät.</p>
+        </div>
+        <button class="secondary compact" onclick="loadOverview()">Alles aktualisieren</button>
+      </div>
+      <div class="grid-two">
+        <div>
+          <h3>Zuordnung</h3>
          <p><strong>Status:</strong> <span class="${statusClass(record)}">${escapeHtml(lifecycleLabel(record))}</span></p>
          <p><strong>Kontextzuordnung:</strong> automatisch erledigt</p>
          <p><strong>Zuordnungssicherheit:</strong> ${Math.round(record.assignment.confidence * 100)} %</p>
@@ -290,7 +414,7 @@ async function showActuator(actuatorId, evaluationMessage = "") {
          <p><strong>Letztes Training:</strong> ${escapeHtml(record.behavior.last_trained_at || "noch nicht")}</p>
          <p><strong>Was noch passiert:</strong> ${escapeHtml(record.behavior.reason)}</p>
          <p><strong>Freigabestatus:</strong> <span class="${record.behavior.activation_ready ? "ok" : "warn"}">${escapeHtml(record.behavior.activation_reason)}</span></p>
-          ${activationButton}
+          <div class="actions">${activationButton}</div>
          <button class="secondary" onclick="evaluateActuator('${escapeHtml(record.actuator_entity_id)}')">Aktuelle Situation auswerten</button>
          <p class="muted">Die Prüfung simuliert keinen Sensorwechsel und schaltet keinen Aktor.</p>
          ${evaluationMessage ? `<p class="ok">${escapeHtml(evaluationMessage)}</p>` : ""}
@@ -305,12 +429,35 @@ 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>"}
+      ${manualAssignment}
    `;
+    document.getElementById("detail").scrollIntoView({behavior: "smooth", block: "start"});
  } catch (error) {
    box.textContent = error.message;
  }
 }

+async function saveManualAssignment(actuatorId) {
+  const numericEntityId = document.getElementById("manual-numeric-select").value || null;
+  const contextEntityIds = Array.from(
+    document.getElementById("manual-context-select").selectedOptions,
+  ).map(option => option.value);
+  try {
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/assignment`, {
+      method: "POST",
+      body: JSON.stringify({
+        numeric_entity_id: numericEntityId,
+        context_entity_ids: contextEntityIds,
+        note: "Manuell im Dashboard gesetzt",
+      }),
+    });
+    await loadConfiguredActuators();
+    await showActuator(actuatorId, "Manuelle Kontext-Auswahl gespeichert.");
+  } catch (error) {
+    alert(error.message);
+  }
+}
+
 async function evaluateActuator(actuatorId) {
  try {
    const record = await api(
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "sillyhome-next"
-version = "0.7.0"
+version = "0.7.3"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
@@ -12,6 +12,7 @@ dependencies = [
  "uvicorn[standard]>=0.29.0",
  "pydantic>=2.6.0",
  "requests>=2.31.0",
+  "websockets>=12.0",
 ]

 [project.optional-dependencies]
--- a/tests/actuators/test_lifecycle.py
+++ b/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
@@ -240,7 +239,45 @@ 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_manual_assignment_persists_and_wins_over_automatic_mapping(tmp_path: Path) -> None:
    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
    entities = [
        HaEntitySummary(
@@ -273,21 +310,18 @@ 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
--- a/tests/api/test_actuators.py
+++ b/tests/api/test_actuators.py
@@ -179,14 +179,39 @@ 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_context_options_returns_learnable_entities(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+
+        response = client.get("/v1/actuators/context-options")
+
+    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 "light.abstellkammer" in entity_ids
--- a/tests/ha/test_ha_client.py
+++ b/tests/ha/test_ha_client.py
@@ -108,6 +108,27 @@ def test_list_entity_metadata_calls_template_api() -> None:
    }


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

 from app.ha.client import HaClient, HaClientSettings
+from app.ha.exceptions import HaHttpError
 from app.ha.reader import HaReader


@@ -150,3 +151,23 @@ def test_ha_reader_finds_automation_that_targets_entity() -> None:
    assert len(matches) == 1
    assert matches[0].entity_id == "automation.storage_light"
    assert matches[0].enabled is True
+
+
+def test_ha_reader_ignores_automation_configs_not_exposed_by_ha() -> None:
+    client = FakeHaClient()
+    client.list_entities = lambda: [  # type: ignore[method-assign]
+        {
+            "entity_id": "automation.storage_light",
+            "state": "on",
+            "attributes": {
+                "id": "123",
+                "friendly_name": "Storage light",
+            },
+        }
+    ]
+    client.get_automation_config = lambda automation_id: (_ for _ in ()).throw(  # type: ignore[method-assign]
+        HaHttpError(404, "Resource not found")
+    )
+    reader = HaReader(client)
+
+    assert reader.find_automations_for_entity("light.storage") == []
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -12,6 +12,7 @@ def test_dashboard_is_served_at_root() -> None:
    assert "So gehst du vor" in response.text
    assert "Gerät zum Lernen auswählen" 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 "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,6 +22,9 @@ 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 "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
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -0,0 +1,112 @@
+import asyncio
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import anyio
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.actuators.store import ActuatorStore
+from app.behavior.engine import BehaviorEngine
+from app.main import _ha_event_listener, app as fastapi_app, lifespan
+
+
+class _FakeWebSocket:
+    def __init__(self, messages: list[str | BaseException]) -> None:
+        self._messages = messages
+        self.sent: list[dict[str, object]] = []
+
+    async def __aenter__(self) -> "_FakeWebSocket":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        return None
+
+    async def recv(self) -> str:
+        message = self._messages.pop(0)
+        if isinstance(message, BaseException):
+            raise message
+        return message
+
+    async def send(self, message: str) -> None:
+        import json
+
+        self.sent.append(json.loads(message))
+
+
+class _RecordingBehaviorEngine(BehaviorEngine):
+    def __init__(self, tmp_path: Path) -> None:
+        super().__init__(
+            ha_reader=MagicMock(),
+            store=ActuatorStore(tmp_path / "actuators"),
+            settings=MagicMock(),
+        )
+        self.state_changes: list[tuple[str, dict[str, object] | None]] = []
+
+    def handle_state_change(self, entity_id: str, new_state: dict[str, object] | None) -> None:
+        self.state_changes.append((entity_id, new_state))
+
+
+def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
+    async def run_test() -> None:
+        fake_ws = _FakeWebSocket(
+            [
+                '{"type":"auth_required"}',
+                '{"type":"auth_ok"}',
+                (
+                    '{"type":"event","event":{"event_type":"state_changed",'
+                    '"entity_id":"light.test","new_state":{"state":"on"}}}'
+                ),
+                asyncio.CancelledError(),
+            ]
+        )
+
+        with patch("websockets.connect", return_value=fake_ws):
+            try:
+                await _ha_event_listener(mock_app, mock_client)
+            except asyncio.CancelledError:
+                pass
+
+        assert fake_ws.sent == [
+            {"type": "auth", "access_token": "test-token"},
+            {"id": 1, "type": "subscribe_events", "event_type": "state_changed"},
+        ]
+
+    mock_app = MagicMock()
+    mock_app.state.settings = MagicMock()
+    mock_app.state.settings.ha_url = "http://homeassistant:8123"
+    mock_app.state.settings.ha_token = "test-token"
+    mock_app.state.ws_status = MagicMock()
+    mock_engine = _RecordingBehaviorEngine(tmp_path)
+    mock_app.state.behavior_engine = mock_engine
+    mock_store = ActuatorStore(tmp_path / "store")
+    mock_app.state.actuator_store = mock_store
+    mock_client = MagicMock()
+
+    anyio.run(run_test)
+    assert mock_engine.state_changes == [("light.test", {"state": "on"})]
+    assert mock_app.state.ws_status.status == "connected"
+    assert mock_app.state.ws_status.error is None
+
+
+def test_lifespan_skips_event_listener_without_ha_config() -> None:
+    app = FastAPI()
+    app.state.settings = MagicMock()
+    app.state.settings.ha_configured = False
+
+    async def run_test() -> None:
+        async with lifespan(app):
+            pass
+
+    anyio.run(run_test)
+
+
+def test_websocket_health_returns_unavailable_without_listener() -> None:
+    with TestClient(fastapi_app) as client:
+        response = client.get("/health/websocket")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "unavailable",
+        "error": "WebSocket-Listener nicht initialisiert",
+    }
Author	SHA1	Message	Date
Otto	09e14689a3	feat: add manual context assignment and fix actuator discovery Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 23:15:00 +02:00
Otto	d87d3abc00	fix: batch ha metadata and improve mobile dashboard Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 22:52:42 +02:00
Otto	2ae5576b8f	fix: complete websocket delivery for v0.7.1 Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 22:30:29 +02:00
Otto	51d23e0a9a	feat: WebSocket-Healthcheck und Status-Tracking\n\n- Fügt _WsStatus-Klasse hinzu, die den aktuellen Verbindungsstatus verfolgt\n- Neuer Endpoint /health/websocket gibt Status zurück (connected/connecting/error)\n- Event-Listener aktualisiert den Status bei allen Zustandsänderungen\n- Fallback-Task wird korrekt im lifespan verwaltet\n- Bessere Fehlerbehandlung und Statusmeldungen\n\nImproves observability of the event-based architecture. Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 17:55:44 +02:00
Otto	c8f491ba1a	feat: event-basierte Vorhersage via HA-WebSocket\n\n- Entfernt periodisches Prediction-Intervall (60s)\n- Fügt WebSocket-Listener hinzu, der bei jedem State Change sofort evaluiert\n- BehaviorEngine.handle_state_change() identifiziert betroffene Aktoren und löst evaluate() aus\n- Fallback periodische Vorhersage bleibt als Backup\n- pyproject: websockets dependency\n- tests: test_main.py für Event-Listener\n\nCloses #39 Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-14 17:23:29 +02:00