Add actuator simulation tuning

Add production diagnostics and planning features
Fix HA websocket keepalive regression
2026-06-18 19:06:47 +02:00 · 2026-06-18 11:53:53 +02:00 · 2026-06-18 07:48:46 +02:00 · 2026-06-18 01:02:29 +02:00 · 2026-06-18 00:30:12 +02:00 · 2026-06-18 00:07:47 +02:00
28 changed files with 2757 additions and 181 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,5 @@ __pycache__/
 .env
 .env.local
 .env.*
+/.actuator_store/
+/MagicMock/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,44 @@
 # Changelog

+## 1.7.0 - 2026-06-18
+- Produktiv-Ausbau fuer Schaltvertrauen: persistente Entscheidungs-Timeline,
+  Event-Latenzmessungen und Dry-run pro Aktor.
+- Backup-/Restore-API fuer Aktor-Konfigurationen, Reconciliation-Status und
+  sichtbare Job-Historie.
+- Feedback kann jetzt konkrete Korrekturtypen wie `too_early`, `too_late` und
+  `never_automate` speichern; `never_automate` setzt eine manuelle Sperre.
+- Planungs-Refresh erzeugt Raum-/Aktorgruppen, einfache Szenenvorschlaege und
+  lokale Agent-Insights aus vorhandenen Daten.
+- Event-Verarbeitung laedt Aktor-Konfigurationen nur noch einmal pro
+  Home-Assistant-State-Change.
+
+## 1.6.1 - 2026-06-18
+- Home-Assistant-WebSocket nutzt wieder keinen clientseitigen Keepalive-Ping.
+  Damit bleibt das Event-Verhalten aus 0.7.8 stabil und Sensorwechsel fuehren
+  nicht erst ueber Fallback oder manuelle Statusabfrage zu Schaltungen.
+
+## 1.6.0 - 2026-06-18
+- `/v1/actuators/dashboard/system` und `/dashboard/start` lesen fuer
+  Cache-Status nur noch SQLite-Metadaten statt den kompletten Entity-Cache zu
+  materialisieren.
+- Aktor-Summaries lesen benoetigte Entity-Metadaten gezielt aus SQLite anhand
+  der Aktor-IDs.
+- Ingress-Dashboard bereinigt: weniger Erklaertexte, kein Ablauf-Menue, kein
+  Versions-Chip im Einrichtungsbereich.
+- Detailansicht ergaenzt Zurueck-Navigation, Aktualisieren und Auswahl eines
+  anderen beobachteten Geraets.
+- Frontend bleibt Anzeige- und Bedienebene; Backend liefert schlanke
+  View-Daten, Worker aktualisieren HA-/Discovery-Cache im Hintergrund.
+
+## 1.5.4 - 2026-06-18
+- Add-on-Start vertraut Ingress-Proxy-Headern nicht mehr blind. Uvicorn loggt
+  damit den direkten Docker-/Ingress-Peer statt LAN-IPs aus `X-Forwarded-For`.
+- Dashboard behält bereits geladene System-, Lern- und Discovery-Daten beim
+  Wechseln der Ansichten und aktualisiert sie nur im Hintergrund.
+- Details sind kein eigener Menüpunkt mehr, sondern gehören zum ausgewählten
+  Aktor aus der Lernübersicht. Bereits geöffnete Details bleiben sichtbar und
+  laden nur bei expliziter Aktualisierung neu.
+
 ## 1.2.0 - 2026-06-17
 - Automatische Sensor-Gewichtungsanpassung aus Nutzerfeedback:
  korrektes Feedback staerkt aktuelle Kontextsignale leicht, falsches Feedback
--- a/README.md
+++ b/README.md
@@ -19,6 +19,20 @@ nach einer ausdrücklichen Freigabe ausführen.
  [`docs/V1_1_0_OPERATING_GUIDE.md`](docs/V1_1_0_OPERATING_GUIDE.md)
 - Version 1.2.0 adaptive Gewichtung, Rollback und Profile:
  [`docs/V1_2_0_OPERATING_GUIDE.md`](docs/V1_2_0_OPERATING_GUIDE.md)
+- Version 1.3.0 Anomalie- und Performance-Überwachung:
+  [`docs/V1_3_0_OPERATING_GUIDE.md`](docs/V1_3_0_OPERATING_GUIDE.md)
+- Version 1.4.0 deutsches Dashboard und gestufter Datenabruf:
+  [`docs/V1_4_0_OPERATING_GUIDE.md`](docs/V1_4_0_OPERATING_GUIDE.md)
+- Version 1.5.0 Menü-Dashboard und kompakte Detaildaten:
+  [`docs/V1_5_0_OPERATING_GUIDE.md`](docs/V1_5_0_OPERATING_GUIDE.md)
+- Version 1.5.1 Stabilisierung der Dashboard-Ladepfade:
+  [`docs/V1_5_1_OPERATING_GUIDE.md`](docs/V1_5_1_OPERATING_GUIDE.md)
+- Version 1.5.2 Rollback-Speicher und HA-Timeouts:
+  [`docs/V1_5_2_OPERATING_GUIDE.md`](docs/V1_5_2_OPERATING_GUIDE.md)
+- Version 1.5.3 SQLite-Cache fuer Ingress-Dashboard:
+  [`docs/V1_5_3_OPERATING_GUIDE.md`](docs/V1_5_3_OPERATING_GUIDE.md)
+- Version 1.7.0 Diagnose, Backup, Dry-run und Planung:
+  [`docs/V1_7_0_OPERATING_GUIDE.md`](docs/V1_7_0_OPERATING_GUIDE.md)
 - Arbeitsregeln für Coding-Agenten: [`AGENTS.md`](AGENTS.md)

 ## Reifegrad
--- a/addon/config.yaml
+++ b/addon/config.yaml
@@ -1,5 +1,5 @@
 name: SillyHome Next
-version: "1.2.0"
+version: "1.7.1"
 slug: sillyhome_next
 description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
 url: http://192.168.6.31:3000/pino/sillyhome-next
--- a/addon/run.sh
+++ b/addon/run.sh
@@ -21,5 +21,4 @@ if [ -f /data/options.json ]; then
 fi

 mkdir -p "$SILLYHOME_MODEL_STORE" "$SILLYHOME_AUTOMATION_STORE" "$SILLYHOME_ACTUATOR_STORE"
-exec uvicorn app.main:app --app-dir /app --host 0.0.0.0 --port 8000 \
-  --proxy-headers --forwarded-allow-ips='*'
+exec uvicorn app.main:app --app-dir /app --host 0.0.0.0 --port 8000
--- a/app/actuators/cache_db.py
+++ b/app/actuators/cache_db.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from threading import RLock
+
+from app.ha.models import HaEntitySummary
+
+
+class DashboardCache:
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path).resolve()
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = RLock()
+        self._init()
+
+    def load_entities_payload(self) -> dict[str, object]:
+        with self._lock, self._connect() as connection:
+            rows = connection.execute(
+                "select entity_id, payload from ha_entities order by entity_id"
+            ).fetchall()
+            updated_at = self._get_meta(connection, "ha_entities_updated_at")
+            groups_json = self._get_meta(connection, "discovery_groups") or "[]"
+        try:
+            groups = json.loads(groups_json)
+        except ValueError:
+            groups = []
+        return {
+            "updated_at": updated_at,
+            "discovery_groups": groups if isinstance(groups, list) else [],
+            "entities": [json.loads(row[1]) for row in rows],
+        }
+
+    def load_status(self) -> dict[str, object]:
+        with self._lock, self._connect() as connection:
+            updated_at = self._get_meta(connection, "ha_entities_updated_at")
+            groups_json = self._get_meta(connection, "discovery_groups") or "[]"
+            entity_count = connection.execute("select count(*) from ha_entities").fetchone()[0]
+        try:
+            groups = json.loads(groups_json)
+        except ValueError:
+            groups = []
+        return {
+            "updated_at": updated_at,
+            "discovery_groups": groups if isinstance(groups, list) else [],
+            "entity_count": int(entity_count or 0),
+        }
+
+    def load_entity_map(self, entity_ids: set[str]) -> dict[str, HaEntitySummary]:
+        if not entity_ids:
+            return {}
+        placeholders = ",".join("?" for _ in entity_ids)
+        with self._lock, self._connect() as connection:
+            rows = connection.execute(
+                f"select entity_id, payload from ha_entities where entity_id in ({placeholders})",
+                tuple(sorted(entity_ids)),
+            ).fetchall()
+        result: dict[str, HaEntitySummary] = {}
+        for entity_id, payload in rows:
+            try:
+                result[str(entity_id)] = HaEntitySummary.model_validate(json.loads(payload))
+            except (TypeError, ValueError):
+                continue
+        return result
+
+    def save_entities_payload(
+        self,
+        *,
+        entities: list[HaEntitySummary],
+        discovery_groups: list[dict[str, object]],
+    ) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+        rows = [
+            (entity.entity_id, entity.model_dump_json())
+            for entity in entities
+        ]
+        with self._lock, self._connect() as connection:
+            connection.execute("delete from ha_entities")
+            connection.executemany(
+                "insert into ha_entities(entity_id, payload) values (?, ?)",
+                rows,
+            )
+            self._set_meta(connection, "ha_entities_updated_at", now)
+            self._set_meta(
+                connection,
+                "discovery_groups",
+                json.dumps(discovery_groups, ensure_ascii=True, sort_keys=True),
+            )
+
+    def _init(self) -> None:
+        with self._connect() as connection:
+            connection.execute(
+                """
+                create table if not exists ha_entities (
+                    entity_id text primary key,
+                    payload text not null
+                )
+                """
+            )
+            connection.execute(
+                """
+                create table if not exists cache_meta (
+                    key text primary key,
+                    value text
+                )
+                """
+            )
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(self._path, timeout=30)
+
+    @staticmethod
+    def _get_meta(connection: sqlite3.Connection, key: str) -> str | None:
+        row = connection.execute(
+            "select value from cache_meta where key = ?",
+            (key,),
+        ).fetchone()
+        return str(row[0]) if row is not None and row[0] is not None else None
+
+    @staticmethod
+    def _set_meta(connection: sqlite3.Connection, key: str, value: str) -> None:
+        connection.execute(
+            """
+            insert into cache_meta(key, value) values (?, ?)
+            on conflict(key) do update set value = excluded.value
+            """,
+            (key, value),
+        )
--- a/app/actuators/models.py
+++ b/app/actuators/models.py
@@ -52,6 +52,14 @@ class JobStatus(StrEnum):
    FAILED = "failed"


+class FeedbackKind(StrEnum):
+    CORRECT = "correct"
+    WRONG = "wrong"
+    TOO_EARLY = "too_early"
+    TOO_LATE = "too_late"
+    NEVER_AUTOMATE = "never_automate"
+
+
 class AssignmentCandidate(BaseModel):
    entity_id: str
    domain: str
@@ -146,6 +154,43 @@ class DecisionFactor(BaseModel):
    evidence: list[str] = Field(default_factory=list)


+class SimulationOutcome(BaseModel):
+    scenario_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    actuator_entity_id: str
+    sensor_states: dict[str, str] = Field(default_factory=dict)
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    prediction: BehaviorPrediction | None = None
+    decision_factors: list[DecisionFactor] = Field(default_factory=list)
+    would_execute: bool = False
+    blockers: list[str] = Field(default_factory=list)
+    score: float = Field(default=0.0, ge=0.0, le=1.0)
+    recommendation: str = Field(default="", max_length=700)
+
+
+class DecisionTrace(BaseModel):
+    trace_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    trigger_entity_id: str | None = None
+    trigger_state: str | None = None
+    target_state: str | None = None
+    confidence: float | None = Field(default=None, ge=0.0, le=1.0)
+    executed: bool = False
+    blocked: bool = False
+    reason: str = Field(default="", max_length=700)
+    blockers: list[str] = Field(default_factory=list)
+    duration_ms: int | None = Field(default=None, ge=0)
+
+
+class LatencyMeasurement(BaseModel):
+    measured_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    trigger_entity_id: str | None = None
+    event_to_decision_ms: int | None = Field(default=None, ge=0)
+    decision_to_service_ms: int | None = Field(default=None, ge=0)
+    event_to_done_ms: int | None = Field(default=None, ge=0)
+    executed: bool = False
+    source: str = Field(default="manual", max_length=40)
+
+
 class AdaptiveWeightUpdate(BaseModel):
    entity_id: str
    previous_weight: float = Field(ge=0.0, le=1.0)
@@ -223,6 +268,16 @@ class AutomationConflict(BaseModel):
    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))


+class AnomalyEvent(BaseModel):
+    anomaly_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    severity: str = Field(default="info", max_length=20)
+    category: str = Field(max_length=40)
+    title: str = Field(min_length=1, max_length=160)
+    detail: str = Field(min_length=1, max_length=500)
+    detected_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    resolved: bool = False
+
+
 class TimeProfile(BaseModel):
    profile_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
    label: str = Field(min_length=1, max_length=80)
@@ -238,6 +293,32 @@ class RelatedAutomation(BaseModel):
    enabled: bool


+class ActuatorGroup(BaseModel):
+    group_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    name: str = Field(min_length=1, max_length=120)
+    area_name: str | None = Field(default=None, max_length=120)
+    member_entity_ids: list[str] = Field(default_factory=list)
+    reason: str = Field(default="", max_length=300)
+
+
+class SceneSuggestion(BaseModel):
+    scene_id: str = Field(pattern=r"^[a-z0-9_-]{1,64}$")
+    label: str = Field(min_length=1, max_length=120)
+    member_entity_ids: list[str] = Field(default_factory=list)
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
+    reason: str = Field(default="", max_length=500)
+    last_seen_at: datetime | None = None
+
+
+class AgentInsight(BaseModel):
+    insight_id: str = Field(pattern=r"^[a-z0-9_.-]{1,120}$")
+    severity: str = Field(default="info", max_length=20)
+    title: str = Field(min_length=1, max_length=160)
+    detail: str = Field(min_length=1, max_length=700)
+    action: str | None = Field(default=None, max_length=300)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
 class BehaviorState(BaseModel):
    mode: BehaviorMode = BehaviorMode.SHADOW
    status: BehaviorStatus = BehaviorStatus.COLLECTING
@@ -270,6 +351,17 @@ class BehaviorState(BaseModel):
    adaptive_weight_updates: list[AdaptiveWeightUpdate] = Field(default_factory=list)
    automation_conflicts: list[AutomationConflict] = Field(default_factory=list)
    time_profiles: list[TimeProfile] = Field(default_factory=list)
+    anomalies: list[AnomalyEvent] = Field(default_factory=list)
+    decision_timeline: list[DecisionTrace] = Field(default_factory=list)
+    latency_measurements: list[LatencyMeasurement] = Field(default_factory=list)
+    feedback_log: list[FeedbackKind] = Field(default_factory=list)
+    dry_run_enabled: bool = False
+    dry_run_started_at: datetime | None = None
+    dry_run_sample_count: int = Field(default=0, ge=0)
+    dry_run_hit_count: int = Field(default=0, ge=0)
+    actuator_groups: list[ActuatorGroup] = Field(default_factory=list)
+    scene_suggestions: list[SceneSuggestion] = Field(default_factory=list)
+    agent_insights: list[AgentInsight] = Field(default_factory=list)


 class ActuatorRecord(BaseModel):
--- a/app/actuators/store.py
+++ b/app/actuators/store.py
@@ -100,6 +100,11 @@ class ActuatorStore:
            except ValueError as exc:
                raise ValueError("Ungültiger Job-Queue-Status.") from exc

+    def save_job_queue(self, queue: JobQueueState) -> JobQueueState:
+        with self._lock:
+            self._persist_job_queue(queue)
+            return queue
+
    def start_job(
        self,
        *,
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -8,8 +8,16 @@ from pathlib import Path
 from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
 from pydantic import BaseModel, Field

+from app.actuators.cache_db import DashboardCache
 from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import ActuatorRecord, ReconciliationState, SensorWeightGroup
+from app.actuators.models import (
+    ActuatorRecord,
+    AnomalyEvent,
+    FeedbackKind,
+    ReconciliationState,
+    SensorWeightGroup,
+    SimulationOutcome,
+)
 from app.actuators.models import JobQueueItem, JobQueueState, JobStatus, SafetyProfile
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
@@ -51,9 +59,40 @@ class WeightOverrideRequest(BaseModel):
    note: str | None = Field(default=None, max_length=500)


+class SimulationRequest(BaseModel):
+    sensor_states: dict[str, str] = Field(default_factory=dict)
+    sensor_weights: dict[str, float] = Field(default_factory=dict)
+    state_options: dict[str, list[str]] = Field(default_factory=dict)
+    include_current: bool = True
+    max_results: int = Field(default=8, ge=1, le=20)
+
+
 class FeedbackRequest(BaseModel):
    correct: bool
    expected_state: str | None = Field(default=None, max_length=100)
+    kind: FeedbackKind | None = None
+
+
+class DryRunRequest(BaseModel):
+    enabled: bool
+
+
+class BackupPayload(BaseModel):
+    exported_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    records: list[ActuatorRecord] = Field(default_factory=list)
+    reconciliation: ReconciliationState = Field(default_factory=ReconciliationState)
+    jobs: JobQueueState = Field(default_factory=JobQueueState)
+
+
+class RestoreRequest(BaseModel):
+    backup: BackupPayload
+    replace_existing: bool = False
+
+
+class RestoreResult(BaseModel):
+    restored_records: int = 0
+    skipped_existing: int = 0
+    restored_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))


 class SafetyProfileRequest(BaseModel):
@@ -89,6 +128,8 @@ class ActuatorSummary(BaseModel):
    activation_ready: bool
    activation_reason: str
    sample_count: int
+    anomaly_count: int = 0
+    critical_anomaly_count: int = 0
    prediction_target_state: str | None = None
    prediction_confidence: float | None = None
    updated_at: str
@@ -108,6 +149,12 @@ class DashboardSystemStatus(BaseModel):
    configured_actuators: int = 0
    trained_models: int = 0
    review_required: int = 0
+    performance_budget_ms: int = 3000
+    job_p95_duration_ms: int | None = None
+    slow_job_count: int = 0
+    performance_status: str = "unknown"
+    anomaly_count: int = 0
+    critical_anomaly_count: int = 0


 class DashboardDiscoveryGroup(BaseModel):
@@ -124,6 +171,12 @@ class DashboardOverview(BaseModel):
    jobs: JobQueueState = Field(default_factory=JobQueueState)


+class AnomalyOverview(BaseModel):
+    actuator_entity_id: str
+    friendly_name: str | None = None
+    anomalies: list[AnomalyEvent] = Field(default_factory=list)
+
+
@router.get("/discovery", response_model=list[HaEntitySummary])
 def discover_actuators(
    request: Request,
@@ -266,6 +319,14 @@ def list_configured_summary(request: Request) -> list[ActuatorSummary]:
            activation_ready=record.behavior.activation_ready,
            activation_reason=record.behavior.activation_reason,
            sample_count=record.behavior.sample_count,
+            anomaly_count=len([item for item in record.behavior.anomalies if not item.resolved]),
+            critical_anomaly_count=len(
+                [
+                    item
+                    for item in record.behavior.anomalies
+                    if not item.resolved and item.severity == "critical"
+                ]
+            ),
            prediction_target_state=(
                record.behavior.prediction.target_state
                if record.behavior.prediction is not None
@@ -284,27 +345,49 @@ def list_configured_summary(request: Request) -> list[ActuatorSummary]:

@router.get("/dashboard", response_model=DashboardOverview)
 def dashboard_overview(request: Request) -> DashboardOverview:
-    cache_payload = _load_entity_cache_payload(request)
-    raw_entities = cache_payload.get("entities", [])
-    if not isinstance(raw_entities, list):
-        raw_entities = []
-    raw_updated_at = cache_payload.get("updated_at")
+    return _dashboard_overview(request, include_background=True, include_actuators=True)
+
+
+@router.get("/dashboard/start", response_model=DashboardOverview)
+def dashboard_start(request: Request) -> DashboardOverview:
+    return _dashboard_overview(request, include_background=False, include_actuators=True)
+
+
+@router.get("/dashboard/system", response_model=DashboardOverview)
+def dashboard_system(request: Request) -> DashboardOverview:
+    return _dashboard_overview(request, include_background=False, include_actuators=False)
+
+
+def _dashboard_overview(
+    request: Request,
+    *,
+    include_background: bool,
+    include_actuators: bool,
+) -> DashboardOverview:
+    cache_status = _load_entity_cache_status(request)
+    raw_updated_at = cache_status.get("updated_at")
    updated_at = raw_updated_at if isinstance(raw_updated_at, str) else None
-    raw_groups = cache_payload.get("discovery_groups", [])
+    raw_groups = cache_status.get("discovery_groups", [])
    cached_groups = [
        DashboardDiscoveryGroup.model_validate(group)
        for group in raw_groups
        if isinstance(group, dict)
-    ] if isinstance(raw_groups, list) else []
+    ] if include_background and isinstance(raw_groups, list) else []
    reconciliation = _reconciliation_state_or_default(request)
    ws_status = getattr(request.app.state, "ws_status", None)
-    actuators = list_configured_summary(request)
+    actuators = list_configured_summary(request) if include_actuators else []
    store = getattr(request.app.state, "actuator_store", None)
    jobs = (
        store.load_job_queue()
-        if isinstance(store, ActuatorStore)
+        if include_background and isinstance(store, ActuatorStore)
        else JobQueueState()
    )
+    job_p95_duration_ms, slow_job_count, performance_status = _performance_status(jobs)
+    anomaly_count = sum(record.anomaly_count for record in actuators)
+    critical_anomaly_count = sum(record.critical_anomaly_count for record in actuators)
+    entity_count = cache_status.get("entity_count")
+    if not isinstance(entity_count, int):
+        entity_count = 0
    return DashboardOverview(
        system=DashboardSystemStatus(
            websocket_status=getattr(ws_status, "status", "unavailable"),
@@ -314,14 +397,23 @@ def dashboard_overview(request: Request) -> DashboardOverview:
                if reconciliation.last_completed_at is not None
                else None
            ),
-            configured_actuators=len(actuators),
+            configured_actuators=(
+                len(actuators)
+                if include_actuators
+                else reconciliation.configured_actuators
+            ),
            trained_models=reconciliation.trained_models,
            review_required=reconciliation.review_required,
+            job_p95_duration_ms=job_p95_duration_ms,
+            slow_job_count=slow_job_count,
+            performance_status=performance_status,
+            anomaly_count=anomaly_count,
+            critical_anomaly_count=critical_anomaly_count,
        ),
        cache=EntityCacheStatus(
-            available=bool(raw_entities),
+            available=bool(entity_count),
            updated_at=updated_at,
-            entity_count=len(raw_entities),
+            entity_count=entity_count,
        ),
        actuators=actuators,
        discovery_groups=cached_groups,
@@ -329,6 +421,71 @@ def dashboard_overview(request: Request) -> DashboardOverview:
    )


+@router.get("/anomalies", response_model=list[AnomalyOverview])
+def list_anomalies(request: Request) -> list[AnomalyOverview]:
+    records = _service(request).list_configured()
+    entity_map = _load_cached_entity_map(
+        request,
+        {record.actuator_entity_id for record in records},
+    )
+    overview: list[AnomalyOverview] = []
+    for record in records:
+        active = [item for item in record.behavior.anomalies if not item.resolved]
+        if not active:
+            continue
+        entity = entity_map.get(record.actuator_entity_id)
+        overview.append(
+            AnomalyOverview(
+                actuator_entity_id=record.actuator_entity_id,
+                friendly_name=entity.friendly_name if entity is not None else None,
+                anomalies=active,
+            )
+        )
+    return overview
+
+
+@router.get("/backup/export", response_model=BackupPayload)
+def export_backup(request: Request) -> BackupPayload:
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Actuator Store nicht initialisiert.",
+        )
+    return BackupPayload(
+        records=store.list(),
+        reconciliation=store.load_reconciliation_state(),
+        jobs=store.load_job_queue(),
+    )
+
+
+@router.post("/backup/restore", response_model=RestoreResult)
+def restore_backup(payload: RestoreRequest, request: Request) -> RestoreResult:
+    store = getattr(request.app.state, "actuator_store", None)
+    if not isinstance(store, ActuatorStore):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Actuator Store nicht initialisiert.",
+        )
+    existing_ids = {record.actuator_entity_id for record in store.list()}
+    restored = 0
+    skipped = 0
+    for record in payload.backup.records:
+        if record.actuator_entity_id in existing_ids and not payload.replace_existing:
+            skipped += 1
+            continue
+        store.upsert(record)
+        restored += 1
+    store.save_reconciliation_state(payload.backup.reconciliation)
+    store.save_job_queue(payload.backup.jobs)
+    return RestoreResult(restored_records=restored, skipped_existing=skipped)
+
+
+@router.post("/planning/refresh", response_model=list[ActuatorRecord])
+def refresh_planning_insights(request: Request) -> list[ActuatorRecord]:
+    return _behavior(request).refresh_planning_insights()
+
+
@router.get("", response_model=list[ActuatorRecord])
 def list_configured(request: Request) -> list[ActuatorRecord]:
    return _service(request).list_configured()
@@ -355,6 +512,47 @@ def get_actuator(actuator_entity_id: str, request: Request) -> ActuatorRecord:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


+@router.get("/{actuator_entity_id}/detail", response_model=ActuatorRecord)
+def get_actuator_detail(actuator_entity_id: str, request: Request) -> ActuatorRecord:
+    try:
+        record = _service(request).get_actuator(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    selected_ids = {
+        entity_id
+        for entity_id in [
+            record.assignment.selected_numeric_entity_id,
+            *record.assignment.selected_context_entity_ids,
+        ]
+        if entity_id
+    }
+    compact_snapshots = [
+        snapshot.model_copy(update={"patterns": []})
+        for snapshot in record.behavior.model_snapshots[-3:]
+    ]
+    compact_behavior = record.behavior.model_copy(
+        update={
+            "patterns": [],
+            "model_snapshots": compact_snapshots,
+        }
+    )
+    return record.model_copy(
+        update={
+            "behavior": compact_behavior,
+            "numeric_candidates": [
+                candidate
+                for candidate in record.numeric_candidates
+                if candidate.entity_id in selected_ids
+            ],
+            "context_candidates": [
+                candidate
+                for candidate in record.context_candidates
+                if candidate.entity_id in selected_ids
+            ],
+        }
+    )
+
+
@router.delete("/{actuator_entity_id}", status_code=204)
 def delete_actuator(actuator_entity_id: str, request: Request) -> None:
    _service(request).delete_actuator(actuator_entity_id)
@@ -384,6 +582,28 @@ def evaluate_actuator(
        raise HTTPException(status_code=404, detail=str(exc)) from exc


+@router.post("/{actuator_entity_id}/simulate", response_model=list[SimulationOutcome])
+def simulate_actuator(
+    actuator_entity_id: str,
+    payload: SimulationRequest,
+    request: Request,
+) -> list[SimulationOutcome]:
+    try:
+        _validate_simulation_payload(payload)
+        return _behavior(request).simulate(
+            actuator_entity_id,
+            sensor_states=payload.sensor_states,
+            sensor_weights=payload.sensor_weights,
+            state_options=payload.state_options,
+            include_current=payload.include_current,
+            max_results=payload.max_results,
+        )
+    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}/feedback", response_model=ActuatorRecord)
 def record_feedback(
    actuator_entity_id: str,
@@ -395,11 +615,24 @@ def record_feedback(
            actuator_entity_id,
            correct=payload.correct,
            expected_state=payload.expected_state,
+            kind=payload.kind,
        )
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


+@router.post("/{actuator_entity_id}/dry-run", response_model=ActuatorRecord)
+def set_dry_run(
+    actuator_entity_id: str,
+    payload: DryRunRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).set_dry_run(actuator_entity_id, enabled=payload.enabled)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
@router.post("/{actuator_entity_id}/safety", response_model=ActuatorRecord)
 def set_safety_profile(
    actuator_entity_id: str,
@@ -635,6 +868,26 @@ def _finish_job(
    store.finish_job(job.job_id, status=status, summary=summary, error=error)


+def _performance_status(jobs: JobQueueState) -> tuple[int | None, int, str]:
+    budget_ms = 3000
+    durations = sorted(
+        job.duration_ms
+        for job in jobs.jobs
+        if job.status is JobStatus.COMPLETED and job.duration_ms is not None
+    )
+    slow_count = sum(1 for duration in durations if duration >= budget_ms)
+    if durations:
+        index = min(len(durations) - 1, int(round((len(durations) - 1) * 0.95)))
+        p95: int | None = durations[index]
+        status_value = "slow" if slow_count else "ok"
+    else:
+        p95 = None
+        status_value = "unknown"
+    if any(job.status is JobStatus.RUNNING for job in jobs.jobs):
+        status_value = "running" if status_value == "unknown" else status_value
+    return p95, slow_count, status_value
+
+
 def _service(request: Request) -> ActuatorReconciliationService:
    service = getattr(request.app.state, "actuator_service", None)
    if not isinstance(service, ActuatorReconciliationService):
@@ -669,6 +922,22 @@ def _validate_weight_payload(payload: WeightOverrideRequest) -> None:
                raise ValueError(f"Ungültige Entity-ID in Gruppe {group.name}: {entity_id}")


+def _validate_simulation_payload(payload: SimulationRequest) -> None:
+    for entity_id in [
+        *payload.sensor_states.keys(),
+        *payload.sensor_weights.keys(),
+        *payload.state_options.keys(),
+    ]:
+        if "." not in entity_id:
+            raise ValueError(f"Ungültige Entity-ID: {entity_id}")
+    for entity_id, weight in payload.sensor_weights.items():
+        if not 0.0 <= weight <= 1.0:
+            raise ValueError(f"Ungültige Gewichtung für {entity_id}: {weight}")
+    for entity_id, states in payload.state_options.items():
+        if not states:
+            raise ValueError(f"Keine Zustände für {entity_id} angegeben.")
+
+
 def _reconciliation_state_or_default(request: Request) -> ReconciliationState:
    store = getattr(request.app.state, "actuator_store", None)
    if not isinstance(store, ActuatorStore):
@@ -708,6 +977,11 @@ def _load_cached_entity_map(
 ) -> dict[str, HaEntitySummary]:
    if not entity_ids:
        return {}
+    cache = getattr(request.app.state, "dashboard_cache", None)
+    if isinstance(cache, DashboardCache):
+        cached_result = cache.load_entity_map(entity_ids)
+        if cached_result:
+            return cached_result
    payload = _load_entity_cache_payload(request)
    raw_entities = payload.get("entities", [])
    if not isinstance(raw_entities, list):
@@ -726,7 +1000,35 @@ def _load_cached_entity_map(
    return result


+def _load_entity_cache_status(request: Request) -> dict[str, object]:
+    cache = getattr(request.app.state, "dashboard_cache", None)
+    if isinstance(cache, DashboardCache):
+        status_payload = cache.load_status()
+        if status_payload.get("entity_count"):
+            return status_payload
+    path = _entity_cache_path(request)
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, TypeError, ValueError):
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    raw_entities = payload.get("entities", [])
+    return {
+        "updated_at": payload.get("updated_at"),
+        "discovery_groups": payload.get("discovery_groups", []),
+        "entity_count": len(raw_entities) if isinstance(raw_entities, list) else 0,
+    }
+
+
 def _load_entity_cache_payload(request: Request) -> dict[str, object]:
+    cache = getattr(request.app.state, "dashboard_cache", None)
+    if isinstance(cache, DashboardCache):
+        payload = cache.load_entities_payload()
+        if payload.get("entities"):
+            return payload
    path = _entity_cache_path(request)
    if not path.exists():
        return {}
@@ -738,18 +1040,18 @@ def _load_entity_cache_payload(request: Request) -> dict[str, object]:


 def _save_cached_entities(request: Request, entities: list[HaEntitySummary]) -> None:
+    group_payload = _discovery_group_payload(entities)
+    cache = getattr(request.app.state, "dashboard_cache", None)
+    if isinstance(cache, DashboardCache):
+        cache.save_entities_payload(
+            entities=entities,
+            discovery_groups=group_payload,
+        )
    path = _entity_cache_path(request)
    path.parent.mkdir(parents=True, exist_ok=True)
-    group_counts: dict[tuple[str, str], int] = {}
-    for entity in discover_entities(entities):
-        key = (entity.category, entity.role.value)
-        group_counts[key] = group_counts.get(key, 0) + 1
    payload = {
        "updated_at": datetime.now(timezone.utc).isoformat(),
-        "discovery_groups": [
-            {"category": category, "role": role, "count": count}
-            for (category, role), count in sorted(group_counts.items())
-        ],
+        "discovery_groups": group_payload,
        "entities": [entity.model_dump(mode="json") for entity in entities],
    }
    temporary = path.with_suffix(".json.tmp")
@@ -760,6 +1062,17 @@ def _save_cached_entities(request: Request, entities: list[HaEntitySummary]) ->
    os.replace(temporary, path)


+def _discovery_group_payload(entities: list[HaEntitySummary]) -> list[dict[str, object]]:
+    group_counts: dict[tuple[str, str], int] = {}
+    for entity in discover_entities(entities):
+        key = (entity.category, entity.role.value)
+        group_counts[key] = group_counts.get(key, 0) + 1
+    return [
+        {"category": category, "role": role, "count": count}
+        for (category, role), count in sorted(group_counts.items())
+    ]
+
+
 def _deduplicate_actuator_ids(
    discovered: list[tuple[str, str]],
    entities: dict[str, HaEntitySummary],
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
--- a/app/config.py
+++ b/app/config.py
@@ -21,6 +21,8 @@ class Settings:
    prediction_interval_seconds: int = 60
    execution_cooldown_seconds: int = 900
    timezone: str = "Europe/Berlin"
+    ha_timeout_seconds: int = 25
+    dashboard_cache_refresh_seconds: int = 3600

    @property
    def ha_configured(self) -> bool:
@@ -55,4 +57,8 @@ def load_settings() -> Settings:
            60, int(os.getenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "900"))
        ),
        timezone=os.getenv("SILLYHOME_TIMEZONE", "Europe/Berlin"),
+        ha_timeout_seconds=max(5, int(os.getenv("SILLYHOME_HA_TIMEOUT_SECONDS", "25"))),
+        dashboard_cache_refresh_seconds=max(
+            300, int(os.getenv("SILLYHOME_DASHBOARD_CACHE_REFRESH_SECONDS", "3600"))
+        ),
    )
--- a/app/main.py
+++ b/app/main.py
@@ -12,6 +12,7 @@ from fastapi import FastAPI
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles

+from app.actuators.cache_db import DashboardCache
 from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.store import ActuatorStore
 from app.api.v1.actuators import router as actuators_router
@@ -20,6 +21,7 @@ from app.behavior.engine import BehaviorEngine
 from app.config import load_settings
 from app.core.exception_handlers import register_exception_handlers
 from app.ha.client import HaClient, HaClientSettings
+from app.ha.discovery import discover_entities
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 from app.ml.registry.model_registry import ModelRegistry
@@ -47,8 +49,12 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    reconcile_task: asyncio.Task[None] | None = None
    event_listener_task: asyncio.Task[None] | None = None
    fallback_task: asyncio.Task[None] | None = None
+    cache_refresh_task: asyncio.Task[None] | None = None
    app.state.registry = ModelRegistry(settings.model_store)
    app.state.actuator_store = ActuatorStore(settings.actuator_store)
+    app.state.dashboard_cache = DashboardCache(
+        Path(settings.actuator_store).resolve() / "dashboard_cache.sqlite3"
+    )
    if hasattr(app.state, "ha_reader"):
        del app.state.ha_reader
    if hasattr(app.state, "actuator_service"):
@@ -60,6 +66,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            settings=HaClientSettings(
                url=cast(str, settings.ha_url),
                token=cast(str, settings.ha_token),
+                timeout_seconds=settings.ha_timeout_seconds,
            )
        )
        app.state.ha_reader = HaReader(client=client)
@@ -79,6 +86,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
        reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
        event_listener_task = asyncio.create_task(_ha_event_listener(app, client))
        fallback_task = asyncio.create_task(_fallback_prediction(app))
+        cache_refresh_task = asyncio.create_task(_periodic_dashboard_cache_refresh(app))
    try:
        yield
    finally:
@@ -98,6 +106,10 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            fallback_task.cancel()
            with suppress(asyncio.CancelledError):
                await fallback_task
+        if cache_refresh_task is not None:
+            cache_refresh_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await cache_refresh_task
        if client is not None:
            client.close()

@@ -105,7 +117,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
    title="SillyHome Next API",
    description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="1.2.0",
+    version="1.7.1",
    lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -159,6 +171,42 @@ async def _periodic_reconciliation(app: FastAPI) -> None:
            logger.exception("Geplante Reconciliation fehlgeschlagen; nächster Lauf versucht es erneut.")


+async def _periodic_dashboard_cache_refresh(app: FastAPI) -> None:
+    await asyncio.sleep(2)
+    while True:
+        await _refresh_dashboard_cache(app, trigger="scheduled")
+        await asyncio.sleep(app.state.settings.dashboard_cache_refresh_seconds)
+
+
+async def _refresh_dashboard_cache(app: FastAPI, *, trigger: str) -> None:
+    ha_reader = getattr(app.state, "ha_reader", None)
+    cache = getattr(app.state, "dashboard_cache", None)
+    if not isinstance(ha_reader, HaReader) or not isinstance(cache, DashboardCache):
+        return
+    try:
+        entities = await asyncio.to_thread(ha_reader.read_entities)
+        groups = _discovery_group_payload(list(entities))
+        await asyncio.to_thread(
+            cache.save_entities_payload,
+            entities=list(entities),
+            discovery_groups=groups,
+        )
+        logger.info("Dashboard-Cache aktualisiert (%s): %d Entities", trigger, len(entities))
+    except Exception as exc:
+        logger.warning("Dashboard-Cache konnte nicht aktualisiert werden (%s): %s", trigger, exc)
+
+
+def _discovery_group_payload(entities: list[HaEntitySummary]) -> list[dict[str, object]]:
+    group_counts: dict[tuple[str, str], int] = {}
+    for entity in discover_entities(entities):
+        key = (entity.category, entity.role.value)
+        group_counts[key] = group_counts.get(key, 0) + 1
+    return [
+        {"category": category, "role": role, "count": count}
+        for (category, role), count in sorted(group_counts.items())
+    ]
+
+
 async def _startup_reconciliation(app: FastAPI) -> None:
    delay_seconds = 5
    while True:
@@ -211,11 +259,7 @@ 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=20,
-                ping_timeout=10,
-            ) as websocket:
+            async with websockets.connect(ws_url, ping_interval=None) as websocket:
                auth_required_msg = await websocket.recv()
                auth_required_data = json.loads(auth_required_msg)
                if auth_required_data.get("type") != "auth_required":
@@ -267,8 +311,6 @@ 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(
--- a/app/static/index.html
+++ b/app/static/index.html
--- a/docs/V1_3_0_OPERATING_GUIDE.md
+++ b/docs/V1_3_0_OPERATING_GUIDE.md
@@ -0,0 +1,68 @@
+# SillyHome Next v1.3.0 Operating Guide
+
+v1.3.0 ergänzt die v1.2-Lernfunktionen um Anomalie-Erkennung und
+Performance-Überwachung. Das Dashboard bleibt Visualisierung und Einrichtung;
+der direkte Schaltpfad bleibt kurz und führt vor dem Home-Assistant-Service-Call
+keine Discovery, kein Training und keine Modellanalyse aus.
+
+## Performance-Budget
+
+- Dashboard-Start und `/v1/actuators/dashboard` haben ein Budget von 3000 ms.
+- Das Dashboard zeigt die eigene Ladezeit, das aktive Budget, Job-p95 und die
+  Anzahl langsamer Jobs.
+- Jobs ab 3000 ms werden in der Job-Queue als langsam markiert.
+- Der automatisierte API-Test prüft den Root- und Dashboard-Startpfad gegen das
+  3-Sekunden-Budget.
+
+## Anomalie-Erkennung
+
+Anomalien werden pro Aktor gespeichert und im Aktor-Detail angezeigt. Erkannt
+werden aktuell:
+
+- fehlender Sensor-/Kontextbezug
+- zu wenige Lernbeispiele
+- unklare Quellen historischer Schaltungen
+- veraltetes Training
+- Vorhersagen unter der Sicherheitsgrenze
+- aktive manuelle Sicherheitssperren
+- Safety-Blocker
+- parallele HA-Automationen bei aktivem SillyHome
+- hohe negative Feedbackquote
+
+Die Anomalien sind Hinweise für Setup und manuelles Gegensteuern. Sie lösen
+keine automatische Eskalation und keine langsamere Schaltung aus.
+
+## API
+
+- `GET /v1/actuators/dashboard` liefert jetzt zusätzlich:
+  - `performance_budget_ms`
+  - `job_p95_duration_ms`
+  - `slow_job_count`
+  - `performance_status`
+  - `anomaly_count`
+  - `critical_anomaly_count`
+- `GET /v1/actuators/anomalies` liefert offene Anomalien gruppiert nach Aktor.
+
+## Betrieb
+
+Bei Ladezeiten ab 3 Sekunden gilt die Seite als nicht performant. Dann zuerst
+prüfen:
+
+1. Dashboard-Statistik: Ladezeit, Job-p95, langsame Jobs.
+2. Job-Queue: welche Aktion langsam war.
+3. Aktor-Detail: Anomalien, Safety-Blocker und Automation-Konflikte.
+4. Falls Discovery oder Training langsam war: nicht in den Startpfad ziehen,
+   sondern geplant, manuell oder über Queue laufen lassen.
+
+## Qualität
+
+Vor Release/Installation ausführen:
+
+```bash
+pytest -q
+ruff check .
+mypy app backend tests
+git diff --check
+```
+
+Zusätzlich das eingebettete Dashboard-JavaScript mit `node --check` prüfen.
--- a/docs/V1_4_0_OPERATING_GUIDE.md
+++ b/docs/V1_4_0_OPERATING_GUIDE.md
@@ -0,0 +1,42 @@
+# SillyHome Next v1.4.0 Operating Guide
+
+v1.4.0 überarbeitet das Dashboard für mobile Nutzung, deutsche Verständlichkeit
+und stabileren Datenabruf.
+
+## Schneller Startpfad
+
+- Die Startseite lädt zuerst nur die Bedienoberfläche und den kompakten
+  Dashboard-Startdatensatz.
+- Neuer Start-Endpunkt: `GET /v1/actuators/dashboard/start`.
+- Der Start-Endpunkt liefert keine Discovery-Gruppen und keine Aufgabenliste.
+- Status, Aufgabenliste, Reconciliation-Zeitpunkt und Detail-Kontext werden
+  danach im Hintergrund geladen.
+- Auf der Startansicht werden zunächst nur die ersten 24 Aktoren gerendert.
+  Weitere Geräte werden auf Knopfdruck nachgerendert.
+
+## Deutsche Oberfläche
+
+Interne Protokollwerte bleiben stabil, werden in der Oberfläche aber übersetzt:
+
+- `observe` -> `Nur beobachten`
+- `suggest` -> `Vorschläge anzeigen`
+- `shadow` -> `Prüfmodus ohne Schalten`
+- `partial` -> `Teilfreigabe`
+- `active` -> `Aktiv freigegeben`
+- Job-Status wie `running`, `completed`, `failed` erscheinen als `läuft`,
+  `abgeschlossen`, `fehlgeschlagen`.
+- Anomalie-Schweregrade erscheinen als `Hinweis`, `Warnung`, `Kritisch`.
+
+## Stabilität
+
+- Startdaten und Statusdaten sind getrennt. Ein langsamer Statuscheck blockiert
+  nicht mehr die Geräteübersicht.
+- Die Aufgabenliste wird separat geladen und kann ausfallen, ohne die
+  Bedienoberfläche zu blockieren.
+- Detaildaten bleiben gestuft: zuerst Shell und gespeicherte Werte, danach
+  Kontextvorschläge.
+
+## Performance-Regel
+
+3 Sekunden bleiben die harte Grenze für den Startpfad. Alles, was schwerer ist
+als Startdaten, muss nachgelagert oder auf Nutzeraktion geladen werden.
--- a/docs/V1_5_0_OPERATING_GUIDE.md
+++ b/docs/V1_5_0_OPERATING_GUIDE.md
@@ -0,0 +1,47 @@
+# SillyHome Next v1.5.0 Operating Guide
+
+v1.5.0 trennt Dashboard-Ansichten, Datenabruf und Detaildaten weiter auf. Ziel
+ist, dass die Seite auf mobiler Datenverbindung schneller nutzbar wird und keine
+schweren Lern-, Discovery- oder Detaildaten beim Start lädt.
+
+## Menüstruktur
+
+- Startseite / System: Systemübersicht, Cache, Performance, Status.
+- Lernen: konfigurierte Aktoren und Lernstand.
+- Details: genau ein ausgewählter Aktor.
+- Discovery & Einrichtung: Geräteliste, Vorschläge und neue Aktoren.
+- Einstellungen: Sprache und Standardverhalten.
+- Ablauf: Bedienhinweise.
+
+Beim Öffnen der Seite wird immer nur die Startseite geladen. Andere Ansichten
+laden erst beim Öffnen.
+
+## Kompakte Detaildaten
+
+Neuer Endpunkt:
+
+```text
+GET /v1/actuators/{actuator_entity_id}/detail
+```
+
+Dieser Endpunkt entfernt große Musterlisten und Snapshot-Muster aus dem ersten
+Detailabruf. Geladen werden nur die Werte, die für die erste Detailansicht
+benötigt werden. Kontextvorschläge bleiben ein separater Abruf und laufen erst
+auf Nutzeraktion.
+
+## Sprache
+
+Die Sprache kann unter `Einstellungen` gewählt werden. Deutsch ist Standard.
+Technische API-Werte bleiben stabil, werden aber im Dashboard über die
+Sprachschicht angezeigt.
+
+## Performance-Regeln
+
+- Kein Discovery beim Start.
+- Keine Aufgabenliste beim Start.
+- Keine Kontextvorschläge beim Öffnen eines Aktors.
+- Keine Musterlisten im ersten Detailabruf.
+- Geräteübersicht rendert begrenzt und lädt weitere Karten per Button nach.
+
+Die Angabe „bereit in X ms“ beschreibt nur den jeweiligen API-/Ansichtsabruf.
+Sie ist nicht gleichzusetzen mit der kompletten HA/Ingress-Navigationszeit.
--- a/docs/V1_5_1_OPERATING_GUIDE.md
+++ b/docs/V1_5_1_OPERATING_GUIDE.md
@@ -0,0 +1,32 @@
+# SillyHome Next v1.5.1 Operating Guide
+
+v1.5.1 ist ein Stabilisierungshotfix für die nach v1.2.0 entstandenen
+Dashboard-Änderungen. Fachlich gehört diese Arbeit zur v1.2.x-Patchlinie; die
+höhere technische Versionsnummer ist nur nötig, weil Home Assistant bereits
+v1.5.0 installiert hat und Add-on-Updates monoton nach oben laufen.
+
+## Korrekturen
+
+- Die System-Startseite nutzt `GET /v1/actuators/dashboard/system` und lädt
+  keine Aktorenliste.
+- Sichtbare 3-Sekunden-Abbrüche mit Browsertexten wie `signal is aborted
+  without reason` wurden entfernt.
+- Startdaten und Detaildaten werden ohne künstlichen Frontend-Abbruch geladen.
+- Timeout-Meldungen werden deutsch und verständlich angezeigt, wenn sie bei
+  Nebenprüfungen auftreten.
+- `summary`-Zeilen wie `anzeigenaufklappen` haben jetzt Abstand und Layout.
+
+## Ladeverhalten
+
+- Statische Seite wird sofort gerendert.
+- Systemdaten laden im Hintergrund.
+- Lernen/Geräte laden nur im Menü `Lernen`.
+- Discovery lädt nur im Menü `Discovery & Einrichtung`.
+- Aktorwerte laden erst beim Öffnen der Detailansicht.
+- Kontextvorschläge laden erst auf Nutzeraktion.
+
+## Hinweis zur Performance-Anzeige
+
+Die App zeigt keine echte HA/Ingress-Navigationszeit an. Gemessen werden nur
+einzelne interne Abrufe nach Start der Seite. Aussagen zur gesamten Ladezeit
+müssen über Browser/Ingress oder HA-Messung geprüft werden.
--- a/docs/V1_5_2_OPERATING_GUIDE.md
+++ b/docs/V1_5_2_OPERATING_GUIDE.md
@@ -0,0 +1,32 @@
+# SillyHome Next v1.5.2 Operating Guide
+
+v1.5.2 begrenzt den Rollback-Speicher und entschärft Home-Assistant-Timeouts,
+die in den Add-on-Logs sichtbar wurden.
+
+## Rollback-Speicher
+
+- Pro Aktor bleiben maximal 3 Modell-Snapshots erhalten.
+- Pro Snapshot bleiben maximal 120 Muster erhalten.
+- Beim Speichern eines Aktors werden ältere oder zu große Snapshots automatisch
+  gekappt.
+- Der kompakte Detail-Endpunkt liefert ebenfalls maximal 3 Rollback-Snapshots
+  und keine Musterlisten.
+
+Damit bleibt Rollback nutzbar, ohne dass die JSON-Dateien mit alten Modellen
+stark wachsen.
+
+## Home-Assistant-Zugriffe
+
+- REST-Zugriffe auf Home Assistant haben jetzt standardmäßig 25 Sekunden
+  Timeout statt 10 Sekunden.
+- Der Wert ist über `SILLYHOME_HA_TIMEOUT_SECONDS` konfigurierbar.
+- WebSocket-Keepalive wurde auf 30 Sekunden Ping-Intervall und 30 Sekunden
+  Ping-Timeout entschärft.
+
+## Log-Einordnung
+
+- `GET ... HTTP/1.1` ist bei Uvicorn/HA-Ingress normal und kein Fehler.
+- `Zeitüberschreitung beim Zugriff auf Home Assistant` bedeutet, dass HA selbst
+  zu langsam geantwortet hat oder der Ingress/Netzpfad verzögert war.
+- `keepalive ping timeout` bedeutet, dass die HA-WebSocket-Verbindung nicht
+  rechtzeitig geantwortet hat. SillyHome reconnectet automatisch.
--- a/docs/V1_5_3_OPERATING_GUIDE.md
+++ b/docs/V1_5_3_OPERATING_GUIDE.md
@@ -0,0 +1,37 @@
+# SillyHome Next v1.5.3 Operating Guide
+
+v1.5.3 führt eine SQLite-Cache-Schicht für Ingress-Dashboarddaten ein.
+
+## Ziel
+
+Die Ingress-Seite soll nicht bei jedem Aufruf live Home Assistant abfragen.
+Home-Assistant-Daten werden geplant aktualisiert und lokal gelesen.
+
+## SQLite-Cache
+
+- Cache-Datei: `<actuator_store>/dashboard_cache.sqlite3`
+- Tabelle `ha_entities`: aktuelle HA-Entity-Summaries als JSON
+- Tabelle `cache_meta`: Aktualisierungszeitpunkt und Discovery-Gruppen
+
+Dashboard-APIs lesen bevorzugt aus SQLite. Der alte JSON-Cache bleibt als
+Fallback erhalten.
+
+## Aktualisierung
+
+- Beim App-Start läuft ein Hintergrund-Refresh nach kurzer Verzögerung.
+- Danach läuft der Refresh stündlich.
+- Konfiguration: `SILLYHOME_DASHBOARD_CACHE_REFRESH_SECONDS`
+- Mindestwert: 300 Sekunden.
+- Explizite Discovery aktualisiert SQLite und JSON-Fallback.
+
+## Schaltpfad
+
+Das direkte Schalten bleibt unverändert: Safety prüft lokale Daten, danach geht
+der Home-Assistant-Service-Call direkt raus. Der Dashboard-Cache liegt nicht im
+Schaltpfad.
+
+## Noch offen
+
+Diese Version verschiebt Entity-/Discovery-Daten in SQLite. Die vollständige
+Migration aller Aktor-Konfigurationen und Workflows aus JSON in relationale
+Tabellen ist ein größerer Folgeschritt und muss mit Migrationsplan erfolgen.
--- a/docs/V1_5_4_OPERATING_GUIDE.md
+++ b/docs/V1_5_4_OPERATING_GUIDE.md
@@ -0,0 +1,35 @@
+# SillyHome Next v1.5.4 Operating Guide
+
+Diese Version korrigiert Ingress-Logging und Dashboard-Navigation.
+
+## Ingress-/Access-Logs
+
+- Das Add-on startet Uvicorn ohne `--proxy-headers` und ohne
+  `--forwarded-allow-ips='*'`.
+- Vorher konnte Uvicorn LAN-Adressen aus `X-Forwarded-For` anzeigen. Diese
+  Adresse war dann der urspruengliche Client oder Home-Assistant-Proxy, nicht
+  der direkte Container-Peer.
+- Nach dem Update sollten Access-Logs den direkten Docker-/Ingress-Peer zeigen.
+  `GET ... HTTP/1.1` bleibt normal und ist kein Hinweis auf fehlendes Streaming.
+
+## Dashboard-Verhalten
+
+- Die Startseite nutzt weiter `/v1/actuators/dashboard/system`.
+- Die Lernuebersicht nutzt weiter `/v1/actuators/dashboard/start`.
+- Bereits geladene System-, Lern- und Discovery-Daten bleiben beim Wechseln der
+  Ansichten im Browser erhalten und werden nur im Hintergrund aufgefrischt.
+- Details sind kein eigener Menuepunkt mehr. Sie werden nur ueber ein
+  ausgewaehltes beobachtetes Geraet geoeffnet.
+- Ein bereits geoeffneter Aktor zeigt seine Detaildaten sofort aus dem
+  Browser-Cache. Neue Detaildaten werden erst ueber `Details aktualisieren`
+  oder nach einer Speichern-/Schaltaktion geladen.
+
+## Pruefung
+
+1. Add-on aktualisieren und neu starten.
+2. Ingress hart neu laden.
+3. Zwischen Startseite, Lernen und Discovery wechseln.
+4. Erwartung: Bereits geladene Inhalte bleiben sichtbar; keine volle
+   Neuladung bei jedem Ansichtswechsel.
+5. Details eines Aktors oeffnen, wegwechseln und wieder Details oeffnen.
+   Erwartung: Die zuletzt geladene Detailansicht steht sofort wieder da.
--- a/docs/V1_6_0_OPERATING_GUIDE.md
+++ b/docs/V1_6_0_OPERATING_GUIDE.md
@@ -0,0 +1,36 @@
+# SillyHome Next v1.6.0 Operating Guide
+
+v1.6.0 trennt Startansicht, Aktoruebersicht, Discovery und Detaildaten staerker.
+
+## API-Pfade
+
+- `GET /v1/actuators/dashboard/system`
+  - nur System- und Cache-Metadaten
+  - keine Aktorenliste
+  - kein vollstaendiges Entity-Payload aus SQLite
+- `GET /v1/actuators/dashboard/start`
+  - Aktor-Summaries
+  - Entity-Metadaten nur fuer konfigurierte Aktoren
+  - keine Discovery-Gruppen und keine Jobliste
+- `GET /v1/actuators/discovery`
+  - steuerbare HA-Entities
+  - nutzt SQLite-Cache, liest HA nur bei Cache-Miss oder `refresh=true`
+- `GET /v1/actuators/{id}/detail`
+  - genau ein ausgewaehlter Aktor
+  - kompakte Modell-/Kontextdaten
+
+## Dashboard
+
+- Frontend zeigt Daten an und loest gezielte Aktionen aus.
+- Backend liefert schlanke View-Daten.
+- Worker aktualisieren HA-Entity-/Discovery-Cache beim Start und danach
+  stündlich.
+- Die Detailansicht gehoert zu einem Aktor und hat eigene Navigation:
+  Zurueck, anderes Geraet, Aktualisieren.
+
+## Erwartete Wirkung
+
+- Systemstart muss ohne Entity-Materialisierung reagieren.
+- Lernen und Details laden nur ihren eigenen Datenkern.
+- Discovery bleibt ein eigener Bedarfspfad.
+- Texte im Dashboard sind kurz und handlungsnah.
--- a/docs/V1_7_0_OPERATING_GUIDE.md
+++ b/docs/V1_7_0_OPERATING_GUIDE.md
@@ -0,0 +1,45 @@
+# SillyHome Next v1.7.0 Operating Guide
+
+v1.7.0 erweitert den Produktivbetrieb um Diagnose, Backup, Dry-run und
+Planungshilfen.
+
+## Diagnose
+
+- Jede Auswertung speichert eine kompakte `decision_timeline` am Aktor.
+- Event-basierte Auswertungen speichern zusaetzlich `latency_measurements`.
+- Die Timeline beantwortet: was war der Ausloeser, welches Ziel wurde
+  vorhergesagt, wurde geschaltet oder blockiert, und warum.
+
+## Backup und Restore
+
+- `GET /v1/actuators/backup/export` exportiert Aktoren, Reconciliation-Status
+  und Job-Historie als JSON.
+- `POST /v1/actuators/backup/restore` spielt diesen Stand wieder ein.
+- Ohne `replace_existing=true` werden vorhandene Aktoren nicht ueberschrieben.
+
+## Dry-run
+
+- `POST /v1/actuators/{entity_id}/dry-run` aktiviert oder beendet den Testmodus.
+- Im Dry-run werden freigegebene Aktionen bewertet und protokolliert, aber nicht
+  an Home Assistant gesendet.
+
+## Feedback
+
+Feedback akzeptiert neben `correct`/`expected_state` nun optionale Typen:
+
+- `correct`
+- `wrong`
+- `too_early`
+- `too_late`
+- `never_automate`
+
+`never_automate` setzt eine manuelle Sicherheitssperre am Aktor.
+
+## Planung
+
+`POST /v1/actuators/planning/refresh` berechnet lokale Hinweise:
+
+- Aktorgruppen aus gemeinsamen Raum-/Kontextdaten
+- einfache Szenenvorschlaege aus gemeinsamem Kontextverhalten
+- Agent-Insights fuer Konflikte, Latenz und auffaelliges Feedback
+
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "sillyhome-next"
-version = "1.2.0"
+version = "1.7.1"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
--- a/tests/api/test_actuators.py
+++ b/tests/api/test_actuators.py
@@ -1,17 +1,20 @@
 from __future__ import annotations

-from time import perf_counter
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
+from time import perf_counter
+from zoneinfo import ZoneInfo

+import pytest
 from fastapi.testclient import TestClient

+from app.api.v1.actuators import _deduplicate_actuator_ids
+from app.actuators.cache_db import DashboardCache
 from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import ModelSnapshot
+from app.actuators.models import BehaviorPattern, JobStatus, ModelSnapshot
 from app.actuators.store import ActuatorStore
 from app.behavior.engine import BehaviorEngine
 from app.config import Settings
-from app.api.v1.actuators import _deduplicate_actuator_ids
 from app.ha.discovery import DiscoveredEntity
 from app.ha.discovery import discover_entities
 from app.ha.history import (
@@ -146,6 +149,7 @@ def _install_service(tmp_path: Path) -> None:
    )
    app.state.registry = ModelRegistry(tmp_path / "models")
    app.state.actuator_store = ActuatorStore(tmp_path / "actuators")
+    app.state.dashboard_cache = DashboardCache(tmp_path / "actuators" / "dashboard_cache.sqlite3")
    app.state.ha_reader = FakeHaReader(
        entities,
        {"sensor.abstellkammer_illuminance": [10, 11, 12, 13, 14, 15]},
@@ -269,6 +273,91 @@ def test_weight_override_endpoint_updates_sensor_relevance(tmp_path: Path) -> No
    assert numeric["sensor.abstellkammer_illuminance"]["effective_weight"] == 0.75


+def test_actuator_simulation_ranks_sensor_states_without_switching(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        client.post(
+            "/v1/actuators/light.abstellkammer/assignment",
+            json={
+                "numeric_entity_id": "sensor.abstellkammer_illuminance",
+                "context_entity_ids": ["binary_sensor.abstellkammer_motion"],
+            },
+        )
+        store = app.state.actuator_store
+        record = store.get("light.abstellkammer")
+        now = datetime.now(timezone.utc)
+        local = now.astimezone(ZoneInfo("Europe/Berlin"))
+        local_minute = local.hour * 60 + local.minute
+        patterns = [
+            BehaviorPattern(
+                target_state="on",
+                minute_of_day=local_minute,
+                weekday=now.weekday(),
+                context_states={
+                    "sensor.abstellkammer_illuminance": "12",
+                    "binary_sensor.abstellkammer_motion": "on",
+                },
+                source="user",
+                weight=1.0,
+                observed_at=now,
+            )
+            for _ in range(3)
+        ]
+        patterns.extend(
+            [
+                BehaviorPattern(
+                    target_state="off",
+                    minute_of_day=local_minute,
+                    weekday=now.weekday(),
+                    context_states={
+                        "sensor.abstellkammer_illuminance": "12",
+                        "binary_sensor.abstellkammer_motion": "off",
+                    },
+                    source="user",
+                    weight=0.5,
+                    observed_at=now,
+                )
+                for _ in range(3)
+            ]
+        )
+        store.upsert(
+            record.model_copy(
+                update={
+                    "behavior": record.behavior.model_copy(
+                        update={
+                            "patterns": patterns,
+                            "sample_count": len(patterns),
+                            "high_confidence_sample_count": len(patterns),
+                            "activation_ready": True,
+                            "activation_reason": "Testfreigabe.",
+                        }
+                    )
+                }
+            )
+        )
+
+        response = client.post(
+            "/v1/actuators/light.abstellkammer/simulate",
+            json={
+                "state_options": {"binary_sensor.abstellkammer_motion": ["off", "on"]},
+                "sensor_weights": {
+                    "binary_sensor.abstellkammer_motion": 1.0,
+                    "sensor.abstellkammer_illuminance": 0.25,
+                },
+                "max_results": 2,
+            },
+        )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert len(payload) == 2
+    assert payload[0]["prediction"]["target_state"] == "on"
+    assert payload[0]["sensor_states"]["binary_sensor.abstellkammer_motion"] == "on"
+    assert payload[0]["sensor_weights"]["sensor.abstellkammer_illuminance"] == 0.25
+    assert app.state.ha_reader.service_calls == []
+
+
 def test_safety_profile_can_block_actuator_manually(tmp_path: Path) -> None:
    with TestClient(app) as client:
        _install_service(tmp_path)
@@ -351,6 +440,51 @@ def test_feedback_adapts_sensor_weights_and_model_can_rollback(tmp_path: Path) -
    assert rollback.json()["behavior"]["active_model_version"] == version_id


+def test_feedback_never_automate_sets_manual_block(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post(
+            "/v1/actuators",
+            json={"actuator_entity_id": "light.abstellkammer"},
+        )
+
+        feedback = client.post(
+            "/v1/actuators/light.abstellkammer/feedback",
+            json={"correct": False, "kind": "never_automate"},
+        )
+
+    assert feedback.status_code == 200
+    payload = feedback.json()
+    assert payload["behavior"]["safety"]["manual_block"] is True
+    assert payload["behavior"]["feedback_log"][-1] == "never_automate"
+
+
+def test_backup_export_restore_and_planning_refresh(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        backup = client.get("/v1/actuators/backup/export")
+        dry_run = client.post(
+            "/v1/actuators/light.abstellkammer/dry-run",
+            json={"enabled": True},
+        )
+        planning = client.post("/v1/actuators/planning/refresh")
+        restore = client.post(
+            "/v1/actuators/backup/restore",
+            json={"backup": backup.json(), "replace_existing": True},
+        )
+
+    assert backup.status_code == 200
+    assert backup.json()["records"][0]["actuator_entity_id"] == "light.abstellkammer"
+    assert dry_run.status_code == 200
+    assert dry_run.json()["behavior"]["dry_run_enabled"] is True
+    assert planning.status_code == 200
+    assert "agent_insights" in planning.json()[0]["behavior"]
+    assert restore.status_code == 200
+    assert restore.json()["restored_records"] == 1
+
+
 def test_summary_is_lightweight_and_uses_cached_entity_metadata(tmp_path: Path) -> None:
    with TestClient(app) as client:
        _install_service(tmp_path)
@@ -407,7 +541,7 @@ def test_reconciliation_run_records_visible_job_queue(tmp_path: Path) -> None:
    assert payload["jobs"][-1]["status"] == "completed"


-def test_dashboard_start_path_stays_within_five_second_budget(tmp_path: Path) -> None:
+def test_dashboard_start_path_stays_within_three_second_budget(tmp_path: Path) -> None:
    with TestClient(app) as client:
        _install_service(tmp_path)
        client.get("/v1/actuators/discovery")
@@ -418,13 +552,92 @@ def test_dashboard_start_path_stays_within_five_second_budget(tmp_path: Path) ->
        root_elapsed = perf_counter() - root_started_at

        dashboard_started_at = perf_counter()
-        dashboard_response = client.get("/v1/actuators/dashboard")
+        dashboard_response = client.get("/v1/actuators/dashboard/start")
        dashboard_elapsed = perf_counter() - dashboard_started_at

    assert root_response.status_code == 200
    assert dashboard_response.status_code == 200
-    assert root_elapsed < 5.0
-    assert dashboard_elapsed < 5.0
+    assert root_elapsed < 3.0
+    assert dashboard_elapsed < 3.0
+
+
+def test_dashboard_reports_performance_budget_and_anomalies(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+        store = app.state.actuator_store
+        job = store.start_job(kind="training", trigger="test", summary="Langsamer Testjob")
+        queue = store.load_job_queue()
+        queue.jobs = [
+            item.model_copy(update={"started_at": datetime.now(timezone.utc) - timedelta(seconds=4)})
+            if item.job_id == job.job_id
+            else item
+            for item in queue.jobs
+        ]
+        store._persist_job_queue(queue)
+        store.finish_job(job.job_id, status=JobStatus.COMPLETED, summary="Fertig")
+
+        dashboard_response = client.get("/v1/actuators/dashboard")
+        start_response = client.get("/v1/actuators/dashboard/start")
+        system_response = client.get("/v1/actuators/dashboard/system")
+        anomalies_response = client.get("/v1/actuators/anomalies")
+
+    assert dashboard_response.status_code == 200
+    assert start_response.status_code == 200
+    assert system_response.status_code == 200
+    system = dashboard_response.json()["system"]
+    start_payload = start_response.json()
+    assert start_payload["jobs"]["jobs"] == []
+    assert start_payload["discovery_groups"] == []
+    assert system_response.json()["actuators"] == []
+    assert system["performance_budget_ms"] == 3000
+    assert system["slow_job_count"] == 1
+    assert system["performance_status"] == "slow"
+    assert system["anomaly_count"] >= 1
+    assert anomalies_response.status_code == 200
+    assert anomalies_response.json()
+
+
+def test_dashboard_system_and_start_do_not_materialize_entity_cache(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        def fail_full_payload(self: DashboardCache) -> dict[str, object]:
+            raise AssertionError("full entity payload must not be loaded")
+
+        monkeypatch.setattr(DashboardCache, "load_entities_payload", fail_full_payload)
+
+        system_response = client.get("/v1/actuators/dashboard/system")
+        start_response = client.get("/v1/actuators/dashboard/start")
+
+    assert system_response.status_code == 200
+    assert system_response.json()["actuators"] == []
+    assert system_response.json()["cache"]["entity_count"] == 4
+    assert start_response.status_code == 200
+    assert start_response.json()["actuators"][0]["friendly_name"] == "Abstellkammer Licht"
+
+
+def test_actuator_detail_uses_compact_payload(tmp_path: Path) -> None:
+    with TestClient(app) as client:
+        _install_service(tmp_path)
+        client.get("/v1/actuators/discovery")
+        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
+
+        response = client.get("/v1/actuators/light.abstellkammer/detail")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["behavior"]["patterns"] == []
+    assert all(
+        snapshot["patterns"] == []
+        for snapshot in payload["behavior"]["model_snapshots"]
+    )


 def test_discovery_reads_entities_once_and_reuses_them(tmp_path: Path) -> None:
--- a/tests/behavior/test_engine.py
+++ b/tests/behavior/test_engine.py
@@ -778,3 +778,129 @@ def test_state_change_uses_event_cache_without_rest_state_query(
    assert reader.service_calls == [
        ("light", "turn_on", {"entity_id": "light.storage"})
    ]
+
+
+def test_event_evaluation_records_decision_timeline_and_latency(
+    tmp_path: Path,
+) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={"selected_context_entity_ids": ["binary_sensor.storage_door"]}
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="on",
+                last_changed=now,
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.evaluate(
+        "light.storage",
+        trigger_entity_id="binary_sensor.storage_door",
+        trigger_state="on",
+        event_received_at=now,
+    )
+
+    trace = result.behavior.decision_timeline[-1]
+    latency = result.behavior.latency_measurements[-1]
+    assert trace.trigger_entity_id == "binary_sensor.storage_door"
+    assert trace.target_state == "on"
+    assert trace.executed is True
+    assert latency.trigger_entity_id == "binary_sensor.storage_door"
+    assert latency.executed is True
+
+
+def test_dry_run_records_without_calling_service(tmp_path: Path) -> None:
+    now = datetime.now(timezone.utc).replace(microsecond=0)
+    settings = _settings(tmp_path)
+    store = ActuatorStore(settings.actuator_store)
+    record = store.configure("light.storage")
+    record = record.model_copy(
+        update={
+            "assignment": record.assignment.model_copy(
+                update={"selected_context_entity_ids": ["binary_sensor.storage_door"]}
+            ),
+            "behavior": record.behavior.model_copy(
+                update={
+                    "mode": BehaviorMode.ACTIVE,
+                    "status": BehaviorStatus.TRAINED,
+                    "activation_ready": True,
+                    "dry_run_enabled": True,
+                    "patterns": [
+                        BehaviorPattern(
+                            target_state="on",
+                            minute_of_day=60,
+                            weekday=0,
+                            context_states={"binary_sensor.storage_door": "on"},
+                            trigger_entity_id="binary_sensor.storage_door",
+                            trigger_from_state="off",
+                            trigger_to_state="on",
+                            source="automation",
+                            weight=1.0,
+                            observed_at=now - timedelta(days=days_ago),
+                        )
+                        for days_ago in (3, 2, 1)
+                    ],
+                }
+            ),
+        }
+    )
+    store.upsert(record)
+    reader = FakeBehaviorReader(
+        entities=[
+            HaEntitySummary(entity_id="light.storage", domain="light", state="off"),
+            HaEntitySummary(
+                entity_id="binary_sensor.storage_door",
+                domain="binary_sensor",
+                state="on",
+                last_changed=now,
+            ),
+        ],
+        history=[],
+        logbook=[],
+    )
+    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
+
+    result = engine.evaluate("light.storage")
+
+    assert reader.service_calls == []
+    assert result.behavior.dry_run_sample_count == 1
+    assert result.behavior.decision_timeline[-1].executed is False
--- a/tests/test_addon_config.py
+++ b/tests/test_addon_config.py
@@ -16,3 +16,10 @@ def test_addon_version_invalidates_application_build_layer() -> None:
    config_copy = dockerfile.index("COPY config.yaml /tmp/addon-config.yaml")
    repository_clone = dockerfile.index("git clone --depth 1 --branch main")
    assert config_copy < repository_clone
+
+
+def test_addon_does_not_trust_forwarded_lan_ips() -> None:
+    run_script = Path("addon/run.sh").read_text(encoding="utf-8")
+
+    assert "--proxy-headers" not in run_script
+    assert "--forwarded-allow-ips" not in run_script
--- a/tests/test_dashboard.py
+++ b/tests/test_dashboard.py
@@ -9,29 +9,32 @@ def test_dashboard_is_served_at_root() -> None:

    assert response.status_code == 200
    assert "SillyHome Next" in response.text
-    assert "Arbeitsdashboard für gelernte Home-Assistant-Bedienung" in response.text
-    assert "So gehst du vor" in response.text
-    assert "Steuerung" in response.text
-    assert "Entitätsname oder Gerät aus Home Assistant" in response.text
-    assert "Oder aus Liste wählen" in response.text
+    assert "Geräte, Lernen, Freigaben und Systemzustand" in response.text
+    assert "So gehst du vor" not in response.text
+    assert "Discovery & Einrichtung" in response.text
+    assert "Entity-ID" in response.text
+    assert "Geräteliste" in response.text
    assert "Liste durchsuchen" in response.text
    assert "Geräteliste bei Bedarf laden" in response.text
-    assert "Vorschläge können Home Assistant stark abfragen" in response.text
-    assert "Wie gewohnt bedienen" in response.text
-    assert "Ohne deine spätere Freigabe wird nichts geschaltet" in response.text
-    assert "Du wählst keine Sensoren und erstellst keine Regeln" in response.text
+    assert "Vorschläge können Home Assistant stark abfragen" not in response.text
+    assert '<option value="detail">Details</option>' not in response.text
+    assert "Wie gewohnt bedienen" not in response.text
+    assert "Ohne deine spätere Freigabe wird nichts geschaltet" not in response.text
+    assert "Du wählst keine Sensoren und erstellst keine Regeln" not in response.text
    assert "Freigabestatus" in response.text
    assert "SillyHome übernehmen lassen" in response.text
    assert "Passende Home-Assistant-Automationen" in response.text
    assert "Pausieren" in response.text
-    assert "Davon erkannte HA-Automationen" in response.text
+    assert "Erkannte HA-Automationen" in response.text
    assert "Aktuelle Situation auswerten" in response.text
    assert "Kontext selbst festlegen" in response.text
    assert "Entity-IDs manuell ergänzen" in response.text
+    assert "Zurück zur Übersicht" in response.text
+    assert "Anderes Gerät" in response.text
    assert "manual-context-freeform" in response.text
    assert "Diese Kontext-Auswahl speichern" in response.text
    assert "manual-context-select" in response.text
-    assert "Die Prüfung simuliert keinen Sensorwechsel" in response.text
+    assert "Die Prüfung simuliert keinen Sensorwechsel" not in response.text
    assert "Kein frischer passender Sensorwechsel erkannt" in response.text
    assert "Vorhersage jetzt prüfen" not in response.text
    assert "record.behavior.activation_ready" in response.text
@@ -40,7 +43,9 @@ def test_dashboard_is_served_at_root() -> None:
    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 'details class="collapsible"' not in response.text
    assert 'class="group-panel"' in response.text
+    assert "cachedDetailHtml" in response.text
+    assert "refreshOverviewInBackground" 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
@@ -92,11 +92,10 @@ def test_ha_event_listener_processes_state_change(tmp_path: Path) -> None:
            except asyncio.CancelledError:
                pass

-        connect.assert_called_once_with(
-            "ws://homeassistant:8123/api/websocket",
-            ping_interval=20,
-            ping_timeout=10,
-        )
+            connect.assert_called_once_with(
+                "ws://homeassistant:8123/api/websocket",
+                ping_interval=None,
+            )
        assert fake_ws.sent == [
            {"type": "auth", "access_token": "test-token"},
            {"id": 1, "type": "subscribe_events", "event_type": "state_changed"},
Author	SHA1	Message	Date
Otto	8070a85b52	Add actuator simulation tuning Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 19:06:47 +02:00
Otto	575211f0db	Add production diagnostics and planning features Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 11:53:53 +02:00
Otto	d9dc186f9b	Fix HA websocket keepalive regression Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 07:48:46 +02:00
Otto	214b384b70	Release v1.6.0 dashboard architecture cleanup Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 01:02:29 +02:00
Otto	6323b93f23	Fix ingress logging and dashboard cache navigation Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 00:30:12 +02:00
Otto	1d176cce45	Add SQLite dashboard cache Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-18 00:07:47 +02:00
Otto	bd087728e1	Limit rollback snapshots and relax HA timeouts Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 23:44:21 +02:00
Otto	10f9113547	Stabilize dashboard loading hotfix Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 23:19:22 +02:00
Otto	47fa8eb0ce	Split dashboard views and compact detail 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 22:34:38 +02:00
Otto	bc4e33ddd8	Localize and streamline dashboard 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 21:56:24 +02:00
Otto	9419a9cd8c	Add anomaly and performance monitoring Some checks failed quality / test (3.11) (push) Has been cancelled Details quality / test (3.13) (push) Has been cancelled Details	2026-06-17 18:58:32 +02:00