Rework dashboard loading and cache entity metadata

Fix dashboard summary status rendering
Use lightweight actuator dashboard summaries
2026-06-17 00:41:50 +02:00 · 2026-06-17 00:21:14 +02:00 · 2026-06-17 00:09:35 +02:00 · 2026-06-17 00:02:19 +02:00 · 2026-06-16 13:58:58 +02:00 · 2026-06-16 13:51:02 +02:00
13 changed files with 605 additions and 91 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,59 @@
 # Changelog

+## 0.7.21 - 2026-06-17
+- Dashboard-Ladepfad getrennt: beobachtete Geräte laden sofort über
+  `/v1/actuators/summary`; Status, Discovery und Vorschläge laufen unabhängig
+  nachgelagert und blockieren die Übersicht nicht mehr.
+- Systemstatus nutzt Timeouts und bleibt auch bei langsamem ML-/HA-Status
+  bedienbar.
+- HA-Entity-Metadaten werden als JSON-Cache gespeichert und für Friendly Name,
+  Raum und Gerät in schlanken Summaries wiederverwendet.
+- Anleitung, Gerätegruppen und manuelle Kontextauswahl sind aufklappbar und
+  kompakter für Smartphone- und Desktopansichten.
+
+## 0.7.20 - 2026-06-17
+- Dashboard-Übersicht ist kompatibel mit dem leichten Summary-Format und greift
+  nicht mehr auf `record.behavior.status` aus dem Vollformat zu.
+
+## 0.7.19 - 2026-06-17
+- Dashboard-Übersicht nutzt einen leichten `/v1/actuators/summary`-Endpunkt
+  statt voller Lernmuster und kompletter HA-Entityliste.
+- Nach Aktionen werden Dashboard-Caches gezielt invalidiert, damit keine
+  stale oder doppelt geladenen Einträge entstehen.
+
+## 0.7.18 - 2026-06-16
+- Dashboard lädt Aktoren, Entities und Discovery nur noch einmal pro Refresh und
+  rendert daraus Auswahl und Übersicht ohne doppelte API-Ladewege.
+- Manuelle Kontext-Evidenz wird dedupliziert, damit Hinweise wie
+  "Manuell vom Nutzer als relevant festgelegt" nicht mehrfach erscheinen.
+- Kontextauswahl ist vollständiger: Feuchte, Wetter, Licht-/Schalterzustände,
+  Bewegungs-/Tür-/Präsenzmelder, PV/Akku/Einspeisung und Helper werden sauberer
+  kategorisiert und per Suche/Kategorie erreichbar.
+- Domainspezifische Zuordnung geschärft: Lüftungen bevorzugen Feuchte/Temperatur,
+  Lichter Helligkeit/Bewegung/Tür/Präsenz, Heizungen Temperatur/Anwesenheit/Wetter.
+
+## 0.7.17 - 2026-06-16
+- WebSocket-Eventpfad ist schneller: irrelevante HA-State-Changes werden vor
+  dem teuren State-Cache-Listenbau verworfen.
+- WebSocket nutzt Keepalive und reconnectet nach Abbrüchen nach 1s statt 5s.
+
+## 0.7.16 - 2026-06-16
+- Beobachtete Aktoren werden in der Übersicht nach Raum oder Typ gruppiert und
+  mit Friendly Name angezeigt.
+
+## 0.7.15 - 2026-06-16
+- Add-on-Start ist robust gegen Home-Assistant-Core-502 beim Systemboot:
+  API und WebSocket-Listener starten trotzdem, Reconciliation/Training werden
+  im Hintergrund mit Retry nachgeholt.
+- Periodische Reconciliation und Fallback-Auswertung beenden den Dienst nicht
+  mehr bei temporären HA-Fehlern.
+- Add-on-Watchdog prüft `/health`, damit Supervisor den Dienst nach Absturz
+  wieder starten kann.
+
+## 0.7.14 - 2026-06-16
+- Onboarding-Vorschläge laden im Dashboard nachgelagert, damit Status,
+  Aktor-Auswahl und bestehende Geräte nicht auf Automation-Discovery warten.
+
 ## 0.7.13 - 2026-06-16
 - Diagnose-/Schutzsensoren wie Überhitzung und Überlast werden nicht mehr nur
  wegen gleicher Strom-/Monitoring-Bereiche automatisch als Lichtkontext
--- a/addon/config.yaml
+++ b/addon/config.yaml
@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "0.7.13"
+version: "0.7.21"
 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
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
@@ -72,29 +72,42 @@ _MANUAL_CONTEXT_DOMAINS = frozenset({
    "device_tracker",
    "fan",
    "humidifier",
+    "input_boolean",
+    "input_number",
+    "input_select",
    "light",
+    "media_player",
    "person",
+    "remote",
+    "scene",
    "sensor",
+    "sun",
    "switch",
    "weather",
 })
-_CONTEXT_SUGGESTION_LIMIT = 120
+_CONTEXT_SUGGESTION_LIMIT = 500
 _OUTDOOR_TOKENS = frozenset({"aussen", "außen", "outdoor", "garten", "terrasse", "balkon"})
 _DIAGNOSTIC_TOKENS = frozenset({
    "basic",
    "battery",
+    "bytes",
    "connect",
    "count",
+    "data",
    "diagnostic",
    "firmware",
    "gesehen",
    "heat",
+    "inbytes",
+    "interface",
    "last",
    "linkquality",
    "knoten",
    "knotens",
    "mqtt",
    "node",
+    "outbytes",
+    "pfsense",
    "reason",
    "restart",
    "rssi",
@@ -105,6 +118,7 @@ _DIAGNOSTIC_TOKENS = frozenset({
    "overheating",
    "overload",
    "uptime",
+    "vpn",
    "uberhitzung",
    "ueberhitzung",
    "ueberlast",
@@ -175,13 +189,10 @@ class ActuatorReconciliationService:
            selected = entity.entity_id in selected_ids
            if selected:
                score = max(score, 1.0)
-            if not selected and (
-                _is_diagnostic_context(entity)
-                or not _has_context_relationship(actuator, entity)
-            ):
-                continue
-            if not selected and score < 0.1:
+            if not selected and _is_diagnostic_context(entity):
                continue
+            if not selected and not _has_context_relationship(actuator, entity):
+                score = max(score, 0.01)
            ranked.append((score, _context_sort_group(entity), entity))
        ranked.sort(
            key=lambda item: (
@@ -849,12 +860,17 @@ def _merge_manual_candidates(
    for entity_id in selected_entity_ids:
        existing = by_id.get(entity_id)
        if existing is not None:
+            evidence = [
+                item
+                for item in existing.evidence
+                if item != "Manuell vom Nutzer als relevant festgelegt."
+            ]
            by_id[entity_id] = existing.model_copy(
                update={
                    "auto_accepted": True,
                    "confidence": 1.0,
                    "evidence": [
-                        *existing.evidence,
+                        *evidence,
                        "Manuell vom Nutzer als relevant festgelegt.",
                    ],
                }
@@ -883,13 +899,28 @@ def _merge_manual_candidates(

 def _preferred_device_classes(domain: str, *, context: bool) -> frozenset[str]:
    if context:
-        return frozenset({"door", "garage_door", "motion", "occupancy", "opening", "presence"})
+        mapping = {
+            "climate": {"occupancy", "presence", "window"},
+            "cover": {"illuminance", "wind_speed"},
+            "fan": {"humidity", "moisture", "occupancy", "presence", "temperature"},
+            "humidifier": {"humidity", "moisture", "temperature"},
+            "light": {"door", "garage_door", "motion", "occupancy", "opening", "presence", "window"},
+            "switch": {"door", "garage_door", "motion", "occupancy", "opening", "presence", "window"},
+        }
+        return frozenset(
+            mapping.get(
+                domain,
+                {"door", "garage_door", "motion", "occupancy", "opening", "presence"},
+            )
+        )
    mapping = {
-        "climate": {"temperature", "humidity", "power"},
+        "climate": {"temperature", "humidity"},
        "cover": {"illuminance", "temperature", "wind_speed"},
-        "fan": {"temperature", "humidity", "power"},
-        "humidifier": {"humidity", "temperature", "power"},
-        "light": {"illuminance", "power", "energy"},
+        "fan": {"temperature", "humidity", "moisture"},
+        "humidifier": {"humidity", "moisture", "temperature"},
+        "light": {"illuminance"},
+        "media_player": {"power", "energy"},
+        "remote": {"battery"},
        "switch": {"power", "energy", "current"},
        "valve": {"temperature", "pressure", "humidity"},
    }
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -1,5 +1,10 @@
 from __future__ import annotations

+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
 from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
 from pydantic import BaseModel, Field

@@ -7,6 +12,7 @@ from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.models import ActuatorRecord, ReconciliationState
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
+from app.config import Settings
 from app.dependencies import get_ha_reader
 from app.ha.discovery import DiscoveredEntity, EntityRole
 from app.ha.exceptions import HaClientError
@@ -55,9 +61,37 @@ class ActuatorSuggestion(BaseModel):
    likely_context_count: int = 0


+class ActuatorSummary(BaseModel):
+    actuator_entity_id: str
+    domain: str
+    friendly_name: str | None = None
+    area_name: str | None = None
+    device_name: str | None = None
+    enabled: bool
+    behavior_mode: str
+    behavior_status: str
+    lifecycle_status: str
+    activation_ready: bool
+    activation_reason: str
+    sample_count: int
+    prediction_target_state: str | None = None
+    prediction_confidence: float | None = None
+    updated_at: str
+
+
@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()}
+def discover_actuators(
+    request: Request,
+    refresh: bool = Query(default=False),
+    ha_reader: HaReader = Depends(get_ha_reader),
+) -> list[HaEntitySummary]:
+    cached_entities = [] if refresh else _load_cached_entities(request)
+    if cached_entities:
+        entities = {entity.entity_id: entity for entity in cached_entities}
+    else:
+        fresh_entities = list(ha_reader.read_entities())
+        _save_cached_entities(request, fresh_entities)
+        entities = {entity.entity_id: entity for entity in fresh_entities}
    discovered = ha_reader.discover()
    actuator_ids = _deduplicate_actuator_ids(
        [
@@ -143,6 +177,51 @@ def context_options(
        raise HTTPException(status_code=404, detail=str(exc)) from exc


+@router.get("/summary", response_model=list[ActuatorSummary])
+def list_configured_summary(request: Request) -> list[ActuatorSummary]:
+    entity_map = {entity.entity_id: entity for entity in _load_cached_entities(request)}
+    return [
+        ActuatorSummary(
+            actuator_entity_id=record.actuator_entity_id,
+            domain=record.actuator_entity_id.split(".", 1)[0],
+            friendly_name=(
+                entity_map[record.actuator_entity_id].friendly_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            area_name=(
+                entity_map[record.actuator_entity_id].area_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            device_name=(
+                entity_map[record.actuator_entity_id].device_name
+                if record.actuator_entity_id in entity_map
+                else None
+            ),
+            enabled=record.enabled,
+            behavior_mode=record.behavior.mode.value,
+            behavior_status=record.behavior.status.value,
+            lifecycle_status=record.lifecycle.status.value,
+            activation_ready=record.behavior.activation_ready,
+            activation_reason=record.behavior.activation_reason,
+            sample_count=record.behavior.sample_count,
+            prediction_target_state=(
+                record.behavior.prediction.target_state
+                if record.behavior.prediction is not None
+                else None
+            ),
+            prediction_confidence=(
+                record.behavior.prediction.confidence
+                if record.behavior.prediction is not None
+                else None
+            ),
+            updated_at=record.updated_at.isoformat(),
+        )
+        for record in _service(request).list_configured()
+    ]
+
+
@router.get("", response_model=list[ActuatorRecord])
 def list_configured(request: Request) -> list[ActuatorRecord]:
    return _service(request).list_configured()
@@ -333,6 +412,45 @@ def _behavior(request: Request) -> BehaviorEngine:
    return engine


+def _entity_cache_path(request: Request) -> Path:
+    store = getattr(request.app.state, "actuator_store", None)
+    settings = getattr(request.app.state, "settings", None)
+    if isinstance(store, ActuatorStore):
+        base_dir = store._root
+    elif isinstance(settings, Settings):
+        base_dir = Path(settings.actuator_store).resolve().parent
+    else:
+        base_dir = Path(".").resolve()
+    return Path(os.getenv("SILLYHOME_ENTITY_CACHE", base_dir / "ha_entity_cache.json"))
+
+
+def _load_cached_entities(request: Request) -> list[HaEntitySummary]:
+    path = _entity_cache_path(request)
+    if not path.exists():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        raw_entities = payload.get("entities", [])
+        return [HaEntitySummary.model_validate(entity) for entity in raw_entities]
+    except (OSError, TypeError, ValueError):
+        return []
+
+
+def _save_cached_entities(request: Request, entities: list[HaEntitySummary]) -> None:
+    path = _entity_cache_path(request)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "entities": [entity.model_dump(mode="json") for entity in entities],
+    }
+    temporary = path.with_suffix(".json.tmp")
+    temporary.write_text(
+        json.dumps(payload, ensure_ascii=True, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
 def _deduplicate_actuator_ids(
    discovered: list[tuple[str, str]],
    entities: dict[str, HaEntitySummary],
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
@@ -900,6 +900,8 @@ def predict_behavior(
 def service_for_state(domain: str, target_state: str) -> str | None:
    if domain in {"fan", "humidifier", "light", "media_player", "remote", "switch"}:
        return {"on": "turn_on", "off": "turn_off"}.get(target_state)
+    if domain == "scene":
+        return "turn_on" if target_state == "on" else None
    if domain == "cover":
        return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
    return None
--- a/app/ha/discovery.py
+++ b/app/ha/discovery.py
@@ -95,6 +95,7 @@ _ACTUATOR_DOMAINS = frozenset({
    "media_player",
    "number",
    "remote",
+    "scene",
    "siren",
    "switch",
    "valve",
@@ -229,6 +230,8 @@ def _actuator_category(entity: HaEntitySummary) -> str:
        return "fan"
    if entity.domain in {"media_player", "remote"}:
        return "media_tv"
+    if entity.domain == "scene":
+        return "scene"
    if entity.domain in {"input_boolean", "number"}:
        return "helper"
    return entity.domain
--- a/app/main.py
+++ b/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.13",
+    version="0.7.21",
    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],
--- a/app/static/index.html
+++ b/app/static/index.html
@@ -6,27 +6,40 @@
  <title>SillyHome Next</title>
  <style>
    :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); }
+    body { margin: 0; font-size:15px; }
+    header { padding: 18px 20px; 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; }
+    main { display: grid; grid-template-columns: minmax(280px,.85fr) minmax(0,1.35fr); gap: 12px; padding: 12px; max-width:1380px; margin:0 auto; }
+    section { background: #18212b; border: 1px solid #2d3a47; border-radius: 8px; padding: 12px; min-width:0; }
    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; }
+    details.collapsible > summary,
+    .manual-context > summary,
+    .group-panel > summary { cursor:pointer; font-weight:800; color:#eaf1f8; }
+    details.collapsible > summary { list-style:none; display:flex; justify-content:space-between; gap:10px; }
+    details.collapsible > summary::-webkit-details-marker,
+    .manual-context > summary::-webkit-details-marker,
+    .group-panel > summary::-webkit-details-marker { display:none; }
+    details.collapsible > summary::after,
+    .manual-context > summary::after,
+    .group-panel > summary::after { content:"aufklappen"; color:#9fb0be; font-weight:600; font-size:.86rem; }
+    details[open].collapsible > summary::after,
+    .manual-context[open] > summary::after,
+    .group-panel[open] > summary::after { content:"zuklappen"; }
+    .steps { display:grid; grid-template-columns:repeat(auto-fit,minmax(190px,1fr)); gap:10px; margin-top:12px; }
+    .step { background:#111a23; border:1px solid #31404d; border-radius:8px; padding:10px; }
    .step-number { display:inline-grid; place-items:center; width:28px; height:28px; border-radius:50%; background:#23715b; font-weight:700; margin-bottom:8px; }
    .step p { margin:5px 0; }
    .ok { color: #66dfa9; }
    .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: 10px; border: 1px solid #3b4b5b; padding: 12px; background: #101820; color: #fff; font:inherit; }
-    select[multiple] { min-height:190px; }
+    select,input,button { box-sizing: border-box; width: 100%; border-radius: 8px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; font:inherit; min-width:0; }
+    select[multiple] { min-height:150px; }
    button { min-height:44px; margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
    button.secondary { background: #37495c; }
    button.danger { background: #7b3434; }
@@ -39,18 +52,18 @@
    .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; }
+    .card-list { display:grid; grid-template-columns:repeat(auto-fit,minmax(260px,1fr)); gap:10px; }
+    .actuator-card { background:#111a23; border:1px solid #31404d; border-radius:8px; padding:10px; min-width:0; }
    .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-grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(120px,1fr)); gap:6px; margin:8px 0; }
+    .metric { background:#18212b; border:1px solid #2d3a47; border-radius:8px; padding:8px; min-width:0; }
    .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; }
+    .manual-context { margin-top:12px; background:#111a23; border:1px solid #31404d; border-radius:8px; padding:10px; }
    .inline-controls { display:grid; grid-template-columns:repeat(auto-fit,minmax(160px,1fr)); gap:8px; margin:8px 0; }
    .manual-entry { min-height:80px; resize:vertical; }
    textarea { box-sizing:border-box; width:100%; border-radius:10px; border:1px solid #3b4b5b; padding:12px; background:#101820; color:#fff; font:inherit; }
@@ -59,11 +72,12 @@
    @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; }
+      main { display:block; padding:8px; }
+      section { margin-bottom:10px; padding:10px; border-radius:8px; }
      .steps { grid-template-columns:1fr; }
      .grid-two { grid-template-columns:1fr; }
      .metric-grid { grid-template-columns:1fr 1fr; }
+      .card-list { grid-template-columns: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; }
@@ -90,7 +104,8 @@
 </nav>
 <main>
  <section class="wide" id="guide">
-    <h2>So gehst du vor</h2>
+    <details class="collapsible">
+    <summary><span>So gehst du vor</span></summary>
    <div class="steps">
      <div class="step">
        <span class="step-number">1</span>
@@ -111,6 +126,7 @@
        <p><strong>Was passiert?</strong> Erst dann darf SillyHome passende Vorhersagen automatisch ausführen. Die Freigabe kann jederzeit gestoppt werden.</p>
      </div>
    </div>
+    </details>
  </section>

  <section id="status-section">
@@ -144,6 +160,7 @@
          <option value="humidifier">Befeuchter / Entfeuchter</option>
          <option value="media_player">TV / Medien</option>
          <option value="remote">Fernbedienungen</option>
+          <option value="scene">Szenen</option>
          <option value="number">Numerische Helper</option>
          <option value="valve">Ventile</option>
        </select>
@@ -185,7 +202,21 @@ let currentActuatorId = null;
 let actuatorChoices = [];
 let contextOptions = [];
 let manualContextState = {options: [], selected: new Set()};
+let cachedActuators = null;
+let cachedEntities = null;
+let cachedDiscovery = null;
 const ACTUATOR_RESULT_LIMIT = 50;
+const STATUS_TIMEOUT_MS = 2500;
+
+function uniqueValues(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function invalidateDashboardCache() {
+  cachedActuators = null;
+  cachedEntities = null;
+  cachedDiscovery = null;
+}

 async function api(path, options = {}) {
  const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
@@ -194,8 +225,20 @@ async function api(path, options = {}) {
  return body;
 }

+async function apiWithTimeout(path, timeoutMs = STATUS_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await api(path, {signal: controller.signal});
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 function lifecycleLabel(record) {
-  if (record.behavior.status === "trained") return "Kontext erkannt";
+  const behaviorStatus = record.behavior_status || record.behavior?.status;
+  const lifecycleStatus = record.lifecycle_status || record.lifecycle?.status;
+  if (behaviorStatus === "trained") return "Kontext erkannt";
  const labels = {
    trained: "lernt",
    pending_history: "sammelt Historie",
@@ -204,26 +247,32 @@ function lifecycleLabel(record) {
    archived: "wartet auf Kontext",
    orphaned: "Aktor nicht gefunden",
  };
-  return labels[record.lifecycle.status] || record.lifecycle.status;
+  return labels[lifecycleStatus] || lifecycleStatus;
 }

 function statusClass(record) {
-  if (record.behavior.status === "trained") return "ok";
-  if (record.lifecycle.status === "trained") return "ok";
-  if (["pending_history", "pending_assignment", "archived"].includes(record.lifecycle.status)) return "warn";
+  const behaviorStatus = record.behavior_status || record.behavior?.status;
+  const lifecycleStatus = record.lifecycle_status || record.lifecycle?.status;
+  if (behaviorStatus === "trained") return "ok";
+  if (lifecycleStatus === "trained") return "ok";
+  if (["pending_history", "pending_assignment", "archived"].includes(lifecycleStatus)) return "warn";
  return "bad";
 }

 function behaviorLabel(record) {
-  if (record.behavior.mode === "active") return "aktiv freigegeben";
-  if (record.behavior.status === "trained") return "Shadow-Vorhersage";
-  if (record.behavior.status === "blocked") return "Lernen blockiert";
+  const mode = record.behavior_mode || record.behavior?.mode;
+  const status = record.behavior_status || record.behavior?.status;
+  if (mode === "active") return "aktiv freigegeben";
+  if (status === "trained") return "Shadow-Vorhersage";
+  if (status === "blocked") return "Lernen blockiert";
  return "sammelt Handlungen";
 }

 function predictionLabel(record) {
-  return record.behavior.prediction
-    ? `${record.behavior.prediction.target_state} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
+  const target = record.prediction_target_state || record.behavior?.prediction?.target_state;
+  const confidence = record.prediction_confidence ?? record.behavior?.prediction?.confidence;
+  return target
+    ? `${target} (${Math.round(confidence * 100)} %)`
    : "Keine fällige Aktion";
 }

@@ -251,14 +300,33 @@ function matchesSearch(entity, query) {

 function categoryForEntity(entity) {
  const cls = entity.device_class || "";
+  const text = normalizedSearch([
+    entity.entity_id,
+    entity.friendly_name,
+    entity.area_name,
+    entity.device_name,
+  ].filter(Boolean).join(" "));
+  if (["pv", "solar", "akku", "batterie", "battery", "einspeisung", "wechselrichter"].some(token => text.includes(token))) {
+    return "PV / Akku / Einspeisung";
+  }
+  if (entity.domain === "fan") return "Lüftung / Ventilatoren";
+  if (entity.domain === "climate") return "Heizung / Klima";
+  if (entity.domain === "weather") return "Wetter";
+  if (entity.domain === "person" || entity.domain === "device_tracker") return "Anwesenheit / Personen";
+  if (entity.domain === "cover") return "Rollläden / Cover";
  if (entity.domain === "light") return "Lichtzustände";
-  if (entity.domain === "switch") return "Schalter / Helper";
+  if (entity.domain === "switch") return "Schalter / Steckdosen";
+  if (entity.domain.startsWith("input_")) return "Helper";
+  if (entity.domain === "scene") return "Szenen";
+  if (entity.domain === "media_player" || entity.domain === "remote") return "TV / Medien";
  if (["motion", "occupancy", "presence"].includes(cls)) return "PIR / Präsenz";
  if (["illuminance"].includes(cls)) return "Helligkeit";
  if (["door", "garage_door", "opening", "window"].includes(cls)) return "Tür / Fenster";
+  if (["smoke", "safety", "problem"].includes(cls)) return "Sicherheit / Diagnose";
  if (["humidity", "moisture"].includes(cls)) return "Luftfeuchtigkeit";
  if (["temperature"].includes(cls)) return "Temperatur";
  if (["power", "energy", "current", "voltage"].includes(cls)) return "Strom / Energie";
+  if (["battery", "signal_strength"].includes(cls)) return "Batterie / Signal";
  if (entity.domain === "binary_sensor") return "Binäre Sensoren";
  if (entity.domain === "sensor") return "Weitere Messsensoren";
  return "Weitere Zustände";
@@ -283,43 +351,93 @@ function optionGroups(entities, selectedIds = new Set()) {
 }

 async function loadOverview() {
+  document.getElementById("configured-actuators").innerHTML = "<p class='muted'>Beobachtete Geräte werden geladen ...</p>";
+  await loadSummaryData();
+  renderConfiguredActuators();
+  void loadStatus();
+  void loadActuatorDiscovery();
+  void loadActuatorSuggestions();
+}
+
+async function loadStatus() {
  const status = document.getElementById("status");
  const chips = document.getElementById("status-chips");
+  status.innerHTML = "<p class='muted'>Status wird geprüft ...</p>";
  try {
-    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"),
+    const [health, websocket, ml, reconciliation, actuators] = await Promise.allSettled([
+      apiWithTimeout("health"),
+      apiWithTimeout("health/websocket"),
+      apiWithTimeout("ml/health"),
+      apiWithTimeout("v1/actuators/reconciliation/state"),
+      apiWithTimeout("v1/actuators/summary"),
    ]);
-    status.innerHTML = `<p class="ok">System bereit</p><p>Letzte automatische Prüfung: ${escapeHtml(reconciliation.last_completed_at || "noch nie")}</p>`;
+    const values = [health, websocket, ml, reconciliation, actuators].map(result =>
+      result.status === "fulfilled" ? result.value : null
+    );
+    const [healthValue, websocketValue, mlValue, reconciliationValue, actuatorValue] = values;
+    const hasError = values.some(value => value === null);
+    status.innerHTML = hasError
+      ? "<p class='warn'>Status teilweise verfügbar. Das Dashboard bleibt bedienbar.</p>"
+      : `<p class="ok">System bereit</p><p>Letzte automatische Prüfung: ${escapeHtml(reconciliationValue.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>`,
+      `<span class="chip">API: ${escapeHtml(healthValue?.status || "offen")}</span>`,
+      `<span class="chip">WebSocket: ${escapeHtml(websocketValue?.status || "offen")}</span>`,
+      `<span class="chip">Lernsystem: ${escapeHtml(mlValue?.status || "offen")}</span>`,
+      `<span class="chip">Aktoren: ${Array.isArray(actuatorValue) ? actuatorValue.length : "offen"}</span>`,
+      `<span class="chip">Lernbereite Geräte: ${escapeHtml(reconciliationValue?.trained_models ?? "offen")}</span>`,
    ].join("");
  } catch (error) {
    status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
    chips.innerHTML = "";
  }
-  await Promise.all([
-    loadActuatorDiscovery(),
-    loadActuatorSuggestions(),
-    loadConfiguredActuators(),
+}
+
+async function loadSummaryData() {
+  const actuators = await api("v1/actuators/summary");
+  cachedActuators = actuators;
+  cachedEntities = [];
+}
+
+async function loadDashboardData() {
+  await loadSummaryData();
+  await loadDiscoveryData();
+}
+
+async function loadDiscoveryData() {
+  const discovery = await api("v1/actuators/discovery");
+  cachedDiscovery = discovery;
+}
+
+async function loadFullDashboardData() {
+  const [actuators, discovery] = await Promise.all([
+    api("v1/actuators/summary"),
+    api("v1/actuators/discovery"),
  ]);
+  cachedActuators = actuators;
+  cachedEntities = [];
+  cachedDiscovery = discovery;
 }

 async function loadActuatorDiscovery() {
+  const select = document.getElementById("actuator-select");
+  if (select && !cachedDiscovery) {
+    select.innerHTML = `<option value="">Geräteliste lädt im Hintergrund ...</option>`;
+  }
+  if (!cachedActuators) {
+    await loadSummaryData();
+  }
+  if (!cachedDiscovery) {
+    await loadDiscoveryData();
+  }
+  renderActuatorDiscovery();
+}
+
+function renderActuatorDiscovery() {
  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 available = cachedDiscovery || [];
+    const configured = cachedActuators || [];
    const configuredIds = new Set(configured.map(record => record.actuator_entity_id));
    actuatorChoices = available.filter(entity => !configuredIds.has(entity.entity_id));
    options.innerHTML = actuatorChoices.slice(0, 120).map(entity =>
@@ -328,7 +446,7 @@ async function loadActuatorDiscovery() {
    renderActuatorSelect();
  } catch (error) {
    options.innerHTML = "";
-    select.innerHTML = `<option value="">Geräteliste konnte nicht geladen werden</option>`;
+    select.innerHTML = `<option value="">Geräteliste konnte nicht geladen werden: ${escapeHtml(error.message)}</option>`;
  }
 }

@@ -369,6 +487,7 @@ function actuatorGroupLabel(domain) {
    media_player: "TV / Medien",
    number: "Numerische Helper",
    remote: "Fernbedienungen",
+    scene: "Szenen",
    switch: "Schalter / Steckdosen",
    cover: "Rollläden / Cover",
    fan: "Lüftung / Ventilatoren",
@@ -466,37 +585,57 @@ async function configureActuator() {
 }

 async function loadConfiguredActuators() {
+  if (!cachedActuators) {
+    await loadSummaryData();
+  }
+  renderConfiguredActuators();
+}
+
+function renderConfiguredActuators() {
  const box = document.getElementById("configured-actuators");
  try {
-    const rows = await api("v1/actuators");
+    const rows = cachedActuators || [];
+    const groups = new Map();
+    for (const record of rows) {
+      const group = record.area_name || actuatorGroupLabel(record.domain || record.actuator_entity_id.split(".", 1)[0]);
+      if (!groups.has(group)) groups.set(group, []);
+      groups.get(group).push({record});
+    }
+    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]) => `
+        <details class="group-panel" open>
+        <summary>${escapeHtml(group)} (${items.length})</summary>
+        <div class="card-list">
+        ${items.map(({record}) => `
          <article class="actuator-card ${currentActuatorId === record.actuator_entity_id ? "selected" : ""}">
            <div class="card-title">
              <div>
+                <div><strong>${escapeHtml(record.friendly_name || record.device_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 class="${(record.behavior_status || 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>Freigabe</strong><span class="${record.activation_ready ? "ok" : "warn"}">${escapeHtml(record.activation_ready ? "bereit" : record.activation_reason)}</span></div>
+              <div class="metric"><strong>Handlungen</strong>${record.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"
+              ${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
+                : record.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>
            </div>
          </article>
        `).join("")}
-      </div>` : "<p>Noch keine Aktoren ausgewählt.</p>";
+        </div>
+        </details>
+      `).join("")}` : "<p>Noch keine Aktoren ausgewählt.</p>";
  } catch (error) {
    box.textContent = error.message;
  }
@@ -519,7 +658,7 @@ async function showActuator(actuatorId, evaluationMessage = "") {
    ].filter(Boolean);
    const evidence = [...record.numeric_candidates, ...record.context_candidates]
      .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>`)
+      .map(candidate => `<li><strong>${escapeHtml(candidate.friendly_name || candidate.entity_id)}</strong>: ${uniqueValues(candidate.evidence).map(escapeHtml).join(", ") || "statistisch relevanter Kandidat"}</li>`)
      .join("");
    const currentContextControls = contexts.length
      ? `<ul>${contexts.map(entityId => `
@@ -550,8 +689,8 @@ async function showActuator(actuatorId, evaluationMessage = "") {
      selected: manualContextIds,
    };
    const manualAssignment = `
-      <div class="manual-context">
-        <h3>Kontext selbst festlegen</h3>
+      <details class="manual-context" open>
+        <summary>Kontext selbst festlegen</summary>
        <p class="muted">Die Vorschläge sind aktorbezogen vorsortiert. Wenn etwas fehlt, trage die Entity-ID unten manuell ein, z. B. PIR, Helligkeit außen, Luftfeuchtigkeit oder Lichtzustände.</p>
        <label for="manual-numeric-select">Optionaler Haupt-Messsensor</label>
        <select id="manual-numeric-select">
@@ -581,7 +720,7 @@ async function showActuator(actuatorId, evaluationMessage = "") {
          <button onclick="saveManualAssignment('${escapeHtml(record.actuator_entity_id)}')">Diese Kontext-Auswahl speichern</button>
          <button class="secondary" onclick="loadContextOptions('${escapeHtml(record.actuator_entity_id)}').then(() => showActuator('${escapeHtml(record.actuator_entity_id)}'))">Vorschläge neu laden</button>
        </div>
-      </div>
+      </details>
    `;
    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>
@@ -673,6 +812,7 @@ async function saveManualAssignment(actuatorId) {
        note: "Manuell im Dashboard gesetzt",
      }),
    });
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId, "Manuelle Kontext-Auswahl gespeichert.");
  } catch (error) {
@@ -696,6 +836,7 @@ async function removeContextEntity(actuatorId, entityId) {
        note: `Entity ${entityId} entfernt`,
      }),
    });
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId, "Kontext-Entity entfernt.");
  } catch (error) {
@@ -720,6 +861,7 @@ async function evaluateActuator(actuatorId) {
    const message = record.behavior.prediction
      ? `Prüfung ${checkedAt}: ${record.behavior.prediction.target_state} mit ${Math.round(record.behavior.prediction.confidence * 100)} % vorhergesagt.`
      : `Prüfung ${checkedAt}: Kein frischer passender Sensorwechsel erkannt; aktuell ist keine Aktion fällig.`;
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId, message);
  } catch (error) {
@@ -737,6 +879,7 @@ async function sendFeedback(actuatorId, correct) {
        expected_state: expectedState || null,
      }),
    });
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId, correct ? "Vorhersage als korrekt gelernt." : "Vorhersage als falsch markiert.");
  } catch (error) {
@@ -762,6 +905,7 @@ async function setActivation(actuatorId, active, pauseMatchingAutomations, resto
        restore_paused_automations: restorePausedAutomations,
      }),
    });
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId);
  } catch (error) {
@@ -780,6 +924,7 @@ async function setRelatedAutomation(actuatorId, automationEntityId, enabled) {
        enabled,
      }),
    });
+    invalidateDashboardCache();
    await loadConfiguredActuators();
    await showActuator(actuatorId);
  } catch (error) {
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "sillyhome-next"
-version = "0.7.13"
+version = "0.7.21"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
--- a/tests/actuators/test_lifecycle.py
+++ b/tests/actuators/test_lifecycle.py
@@ -310,6 +310,48 @@ def test_reconciliation_does_not_auto_select_overload_sensors_by_power_area(
    assert all(candidate.auto_accepted is False for candidate in record.context_candidates)


+def test_fan_prefers_humidity_over_power_sensor(tmp_path: Path) -> None:
+    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
+    entities = [
+        HaEntitySummary(
+            entity_id="fan.bad_lueftung",
+            domain="fan",
+            friendly_name="Bad Lüftung",
+            area_name="Bad",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.bad_luftfeuchtigkeit",
+            domain="sensor",
+            device_class="humidity",
+            state_class="measurement",
+            unit_of_measurement="%",
+            friendly_name="Bad Luftfeuchtigkeit",
+            area_name="Bad",
+        ),
+        HaEntitySummary(
+            entity_id="sensor.bad_power",
+            domain="sensor",
+            device_class="power",
+            state_class="measurement",
+            unit_of_measurement="W",
+            friendly_name="Bad Leistung",
+            area_name="Bad",
+        ),
+    ]
+    service = _service(
+        tmp_path,
+        entities,
+        {
+            "sensor.bad_luftfeuchtigkeit": _points(8, start, 55.0),
+            "sensor.bad_power": _points(8, start, 5.0),
+        },
+    )
+
+    record = service.configure_actuator("fan.bad_lueftung")
+
+    assert record.assignment.selected_numeric_entity_id == "sensor.bad_luftfeuchtigkeit"
+
+
 def test_manual_assignment_persists_and_wins_over_automatic_mapping(tmp_path: Path) -> None:
    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
    entities = [
@@ -358,3 +400,39 @@ def test_manual_assignment_persists_and_wins_over_automatic_mapping(tmp_path: Pa
    assert record.assignment.selected_context_entity_ids == ["sensor.abstellkammer_illuminance"]
    assert record.assignment.source is AssignmentSource.MANUAL
    assert record.manual_override is not None
+
+
+def test_manual_assignment_evidence_is_not_duplicated(tmp_path: Path) -> None:
+    entities = [
+        HaEntitySummary(
+            entity_id="light.abstellkammer",
+            domain="light",
+            friendly_name="Abstellkammer Licht",
+            area_name="Abstellkammer",
+        ),
+        HaEntitySummary(
+            entity_id="binary_sensor.abstellkammer_motion",
+            domain="binary_sensor",
+            device_class="motion",
+            friendly_name="Abstellkammer Bewegung",
+            area_name="Abstellkammer",
+        ),
+    ]
+    service = _service(tmp_path, entities, {})
+    service.configure_actuator("light.abstellkammer")
+    for _ in range(3):
+        service.set_manual_assignment(
+            "light.abstellkammer",
+            numeric_entity_id=None,
+            context_entity_ids=["binary_sensor.abstellkammer_motion"],
+            note="Manuell gesetzt",
+        )
+
+    record = service.get_actuator("light.abstellkammer")
+    candidate = next(
+        item
+        for item in record.context_candidates
+        if item.entity_id == "binary_sensor.abstellkammer_motion"
+    )
+
+    assert candidate.evidence.count("Manuell vom Nutzer als relevant festgelegt.") == 1
--- a/tests/api/test_actuators.py
+++ b/tests/api/test_actuators.py
@@ -213,6 +213,23 @@ def test_manual_assignment_endpoint_updates_context(tmp_path: Path) -> None:
    ]


+def test_summary_is_lightweight_and_uses_cached_entity_metadata(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.get("/v1/actuators/summary")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload[0]["actuator_entity_id"] == "light.abstellkammer"
+    assert payload[0]["friendly_name"] == "Abstellkammer Licht"
+    assert payload[0]["area_name"] == "Abstellkammer"
+    assert "behavior" not in payload[0]
+    assert "numeric_candidates" not in payload[0]
+
+
 def test_context_options_returns_learnable_entities(tmp_path: Path) -> None:
    with TestClient(app) as client:
        _install_service(tmp_path)
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -32,5 +32,12 @@ def test_dashboard_is_served_at_root() -> None:
    assert "Kein frischer passender Sensorwechsel erkannt" in response.text
    assert "Vorhersage jetzt prüfen" not in response.text
    assert "record.behavior.activation_ready" in response.text
+    assert "record.behavior.status ===" not in response.text
+    assert "record.behavior_status || record.behavior?.status" in response.text
+    assert 'api("v1/actuators")' not in response.text
+    assert 'api("v1/actuators/summary")' in response.text
+    assert 'api("v1/entities")' not in response.text
+    assert 'details class="collapsible"' in response.text
+    assert 'class="group-panel"' in response.text
    assert "Automation-Entwurf" not in response.text
    assert "Manuelle Overrides" not in response.text
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -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()
Author	SHA1	Message	Date
Otto	4db4276b95	Rework dashboard loading and cache entity metadata Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:41:50 +02:00
Otto	98a2b2cc38	Fix dashboard summary status rendering Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:21:14 +02:00
Otto	387e027fe2	Use lightweight actuator dashboard summaries Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:09:35 +02:00
Otto	f8bee92e64	Optimize dashboard categories and context loading Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 00:02:19 +02:00
Otto	9ddb065f62	Speed up HA event processing Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:58:58 +02:00
Otto	8222f24ebe	Group configured actuator overview Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:51:02 +02:00
Otto	a7a2f8c78a	Make SillyHome startup resilient Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 13:43:41 +02:00
Otto	faf4099756	Load actuator suggestions asynchronously Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-16 12:14:51 +02:00