BEHAVIOR-001: learn and predict actuator actions

2026-06-14 10:37:59 +02:00
parent 6305f52cd2
commit fa250216be
34 changed files with 1614 additions and 489 deletions
--- a/app/actuators/lifecycle.py
+++ b/app/actuators/lifecycle.py
@@ -13,7 +13,6 @@ from app.actuators.models import (
    AssignmentSource,
    LifecycleAuditEntry,
    LifecycleStatus,
-    ManualOverride,
    ModelLifecycleState,
    ReconciliationState,
    model_id_for_actuator,
@@ -57,7 +56,7 @@ _STOPWORDS = frozenset(
 _NUMERIC_AUTO_ACCEPT_SCORE = 0.82
 _NUMERIC_MIN_MARGIN = 0.18
 _CONTEXT_AUTO_ACCEPT_SCORE = 0.78
-_MAX_CONTEXT_SELECTIONS = 3
+_MAX_CONTEXT_SELECTIONS = 5
 _AUDIT_LIMIT = 20


@@ -85,21 +84,6 @@ class ActuatorReconciliationService:
    def get_actuator(self, actuator_entity_id: str) -> ActuatorRecord:
        return self._store.get(actuator_entity_id)

-    def set_override(
-        self,
-        actuator_entity_id: str,
-        override: ManualOverride | None,
-    ) -> ActuatorRecord:
-        record = self._store.get(actuator_entity_id)
-        updated = record.model_copy(
-            update={
-                "manual_override": override,
-                "updated_at": datetime.now(timezone.utc),
-            }
-        )
-        self._store.upsert(updated)
-        return self.reconcile_actuator(actuator_entity_id, trigger="override")
-
    def delete_actuator(self, actuator_entity_id: str) -> None:
        model_id = model_id_for_actuator(actuator_entity_id)
        self._registry.archive(model_id)
@@ -132,7 +116,7 @@ class ActuatorReconciliationService:
            last_summary=(
                f"{len(refreshed)} Aktuatoren geprüft, "
                f"{sum(1 for record in refreshed if record.assignment.review_required)} "
-                "mit Prüfbedarf."
+                "mit niedriger Zuordnungssicherheit."
            ),
        )
        self._store.save_reconciliation_state(summary)
@@ -214,7 +198,6 @@ class ActuatorReconciliationService:
            actuator=actuator,
            numeric_candidates=numeric_candidates,
            context_candidates=context_candidates,
-            override=record.manual_override,
        )
        lifecycle = self._reconcile_lifecycle(
            actuator=actuator,
@@ -225,6 +208,7 @@ class ActuatorReconciliationService:
        updated = record.model_copy(
            update={
                "assignment": assignment,
+                "manual_override": None,
                "numeric_candidates": numeric_candidates,
                "context_candidates": context_candidates,
                "lifecycle": lifecycle,
@@ -246,27 +230,11 @@ class ActuatorReconciliationService:
        actuator: HaEntitySummary,
        numeric_candidates: list[AssignmentCandidate],
        context_candidates: list[AssignmentCandidate],
-        override: ManualOverride | None,
    ) -> AssignmentSelection:
-        if override is not None:
-            selected_numeric = override.numeric_entity_id
-            selected_contexts = list(dict.fromkeys(override.context_entity_ids))
-            return AssignmentSelection(
-                selected_numeric_entity_id=selected_numeric,
-                selected_context_entity_ids=selected_contexts,
-                source=AssignmentSource.MANUAL,
-                confidence=1.0 if selected_numeric else 0.6,
-                review_required=False,
-                reason=(
-                    "Manuelle Zuordnung überschreibt die automatische Heuristik dauerhaft."
-                ),
-            )
-
        top_numeric = numeric_candidates[0] if numeric_candidates else None
        top_contexts = [
            candidate.entity_id
            for candidate in context_candidates
-            if candidate.auto_accepted
        ][: _MAX_CONTEXT_SELECTIONS]
        if top_numeric is None:
            return AssignmentSelection(
@@ -275,7 +243,10 @@ class ActuatorReconciliationService:
                source=AssignmentSource.NONE,
                confidence=0.0,
                review_required=True,
-                reason=f"Kein numerischer Sensor konnte für {display_name(actuator)} bestimmt werden.",
+                reason=(
+                    f"Für {display_name(actuator)} ist noch kein nutzbarer numerischer "
+                    "Kontext verfügbar. Die Zuordnung wird automatisch erneut geprüft."
+                ),
            )

        return AssignmentSelection(
@@ -285,9 +256,9 @@ class ActuatorReconciliationService:
            confidence=top_numeric.confidence,
            review_required=not top_numeric.auto_accepted,
            reason=(
-                "Automatisch akzeptiert."
+                "Kontext automatisch und eindeutig zugeordnet."
                if top_numeric.auto_accepted
-                else "Top-Kandidat gefunden, aber Zuordnung ist noch nicht eindeutig genug."
+                else "Besten verfügbaren Kontext automatisch mit niedriger Sicherheit zugeordnet."
            ),
        )

@@ -306,14 +277,6 @@ class ActuatorReconciliationService:
                "Ohne numerische Sensorzuordnung wird kein Modell aktiv gehalten.",
                now=now,
            )
-        if assignment.review_required and assignment.source is not AssignmentSource.MANUAL:
-            return self._archive_state(
-                lifecycle,
-                "Zuordnung ist nicht eindeutig; Modell wartet auf Review.",
-                now=now,
-                status=LifecycleStatus.REVIEW_REQUIRED,
-            )
-
        sensor_id = assignment.selected_numeric_entity_id
        series = self._read_history(sensor_id, now)
        points = series.points if series is not None else []
@@ -327,7 +290,7 @@ class ActuatorReconciliationService:
                            f"{len(points)} von mindestens {self._settings.min_training_points} "
                            f"Messpunkten für {sensor_id} vorhanden."
                        ),
-                        "next_action": "Mehr Historie sammeln und Reconciliation erneut ausführen.",
+                        "next_action": "Historie wird automatisch weiter gesammelt.",
                        "last_history_point_count": len(points),
                    }
                ),
@@ -369,7 +332,7 @@ class ActuatorReconciliationService:
                        "last_history_signature": signature,
                        "last_history_point_count": len(points),
                        "reason": retrain_reason,
-                        "next_action": "Automatisch überwachen und bei neuen Daten neu trainieren.",
+                        "next_action": "Neue Daten automatisch überwachen und nachtrainieren.",
                    }
                ),
                action="retrained" if result.replaced else "trained",
@@ -384,8 +347,8 @@ class ActuatorReconciliationService:
                    "last_reconciled_at": now,
                    "last_history_signature": signature,
                    "last_history_point_count": len(points),
-                    "reason": "Modell ist aktuell und passt zur bestätigten Sensorzuordnung.",
-                    "next_action": "Auf neue Historie oder Staleness warten.",
+                    "reason": "Modell ist aktuell und passt zur automatischen Kontextzuordnung.",
+                    "next_action": "Neue Historie automatisch auswerten.",
                }
            ),
            action="kept",
@@ -423,7 +386,7 @@ class ActuatorReconciliationService:
                    "status": status,
                    "last_reconciled_at": now,
                    "reason": reason,
-                    "next_action": "Review oder neue Zuordnung erforderlich.",
+                    "next_action": "Bei neuen Home-Assistant-Daten automatisch erneut zuordnen.",
                }
            ),
            action="archived",
--- a/app/actuators/models.py
+++ b/app/actuators/models.py
@@ -25,6 +25,18 @@ class LifecycleStatus(StrEnum):
    ARCHIVED = "archived"


+class BehaviorMode(StrEnum):
+    SHADOW = "shadow"
+    ACTIVE = "active"
+    PAUSED = "paused"
+
+
+class BehaviorStatus(StrEnum):
+    COLLECTING = "collecting"
+    TRAINED = "trained"
+    BLOCKED = "blocked"
+
+
 class AssignmentCandidate(BaseModel):
    entity_id: str
    domain: str
@@ -71,10 +83,49 @@ class ModelLifecycleState(BaseModel):
    last_history_signature: str | None = None
    last_history_point_count: int = Field(default=0, ge=0)
    reason: str = "Noch keine Trainingsdaten ausgewertet."
-    next_action: str = "Aktuator auswählen und Zuordnung prüfen."
+    next_action: str = "Aktor auswählen; Kontext und Historie werden automatisch geprüft."
    audit: list[LifecycleAuditEntry] = Field(default_factory=list)


+class BehaviorPattern(BaseModel):
+    target_state: str = Field(min_length=1, max_length=100)
+    minute_of_day: int = Field(ge=0, le=1439)
+    weekday: int = Field(ge=0, le=6)
+    context_states: dict[str, str] = Field(default_factory=dict)
+    source: str = Field(default="observed", max_length=40)
+    weight: float = Field(default=1.0, ge=0.1, le=1.0)
+    observed_at: datetime
+
+
+class BehaviorPrediction(BaseModel):
+    target_state: str
+    confidence: float = Field(ge=0.0, le=1.0)
+    generated_at: datetime
+    reason: str
+    matching_patterns: int = Field(default=0, ge=0)
+    executed: bool = False
+
+
+class ExecutionEvent(BaseModel):
+    target_state: str
+    executed_at: datetime
+
+
+class BehaviorState(BaseModel):
+    mode: BehaviorMode = BehaviorMode.SHADOW
+    status: BehaviorStatus = BehaviorStatus.COLLECTING
+    approved_at: datetime | None = None
+    sample_count: int = Field(default=0, ge=0)
+    high_confidence_sample_count: int = Field(default=0, ge=0)
+    patterns: list[BehaviorPattern] = Field(default_factory=list)
+    prediction: BehaviorPrediction | None = None
+    last_trained_at: datetime | None = None
+    last_evaluated_at: datetime | None = None
+    last_executed_at: datetime | None = None
+    execution_events: list[ExecutionEvent] = Field(default_factory=list)
+    reason: str = "Historische Aktorhandlungen werden analysiert."
+
+
 class ActuatorRecord(BaseModel):
    actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
    enabled: bool = True
@@ -85,6 +136,7 @@ class ActuatorRecord(BaseModel):
    numeric_candidates: list[AssignmentCandidate] = Field(default_factory=list)
    context_candidates: list[AssignmentCandidate] = Field(default_factory=list)
    lifecycle: ModelLifecycleState
+    behavior: BehaviorState = Field(default_factory=BehaviorState)


 class ReconciliationState(BaseModel):
--- a/app/api/v1/actuators.py
+++ b/app/api/v1/actuators.py
@@ -4,8 +4,9 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
 from pydantic import BaseModel, Field

 from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import ActuatorRecord, ManualOverride, ReconciliationState
+from app.actuators.models import ActuatorRecord, ReconciliationState
 from app.actuators.store import ActuatorStore
+from app.behavior.engine import BehaviorEngine
 from app.dependencies import get_ha_reader
 from app.ha.discovery import EntityRole
 from app.ha.models import HaEntitySummary
@@ -19,11 +20,8 @@ class ConfigureActuatorRequest(BaseModel):
    enabled: bool = True


-class OverrideRequest(BaseModel):
-    numeric_entity_id: str | None = Field(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
-    context_entity_ids: list[str] = Field(default_factory=list)
-    note: str | None = Field(default=None, max_length=300)
-    clear: bool = False
+class ActivationRequest(BaseModel):
+    active: bool


@router.get("/discovery", response_model=list[HaEntitySummary])
@@ -44,10 +42,12 @@ def list_configured(request: Request) -> list[ActuatorRecord]:
@router.post("", response_model=ActuatorRecord, status_code=201)
 def configure(payload: ConfigureActuatorRequest, request: Request) -> ActuatorRecord:
    try:
-        return _service(request).configure_actuator(
+        record = _service(request).configure_actuator(
            payload.actuator_entity_id,
            enabled=payload.enabled,
        )
+        _behavior(request).train(record.actuator_entity_id)
+        return _behavior(request).evaluate(record.actuator_entity_id)
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc

@@ -65,34 +65,44 @@ def delete_actuator(actuator_entity_id: str, request: Request) -> None:
    _service(request).delete_actuator(actuator_entity_id)


-@router.post("/{actuator_entity_id}/override", response_model=ActuatorRecord)
-def set_override(
-    actuator_entity_id: str,
-    payload: OverrideRequest,
-    request: Request,
-) -> ActuatorRecord:
-    override = None if payload.clear else ManualOverride(
-        numeric_entity_id=payload.numeric_entity_id,
-        context_entity_ids=payload.context_entity_ids,
-        note=payload.note,
-    )
-    try:
-        return _service(request).set_override(actuator_entity_id, override)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-
@router.post("/{actuator_entity_id}/reconcile", response_model=ActuatorRecord)
 def reconcile_actuator(
    actuator_entity_id: str,
    request: Request,
 ) -> ActuatorRecord:
    try:
-        return _service(request).reconcile_actuator(actuator_entity_id, trigger="manual")
+        _service(request).reconcile_actuator(actuator_entity_id, trigger="manual")
+        _behavior(request).train(actuator_entity_id)
+        return _behavior(request).evaluate(actuator_entity_id)
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


+@router.post("/{actuator_entity_id}/evaluate", response_model=ActuatorRecord)
+def evaluate_actuator(
+    actuator_entity_id: str,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).evaluate(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/{actuator_entity_id}/activation", response_model=ActuatorRecord)
+def set_activation(
+    actuator_entity_id: str,
+    payload: ActivationRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).set_active(actuator_entity_id, active=payload.active)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
@router.get("/reconciliation/state", response_model=ReconciliationState)
 def get_reconciliation_state(request: Request) -> ReconciliationState:
    store = getattr(request.app.state, "actuator_store", None)
@@ -109,7 +119,10 @@ def run_reconciliation(
    request: Request,
    trigger: str = Query(default="manual", pattern=r"^[a-z0-9_-]{1,32}$"),
 ) -> ReconciliationState:
-    return _service(request).reconcile_all(trigger=trigger)
+    state = _service(request).reconcile_all(trigger=trigger)
+    _behavior(request).train_all()
+    _behavior(request).evaluate_all()
+    return state


 def _service(request: Request) -> ActuatorReconciliationService:
@@ -120,3 +133,13 @@ def _service(request: Request) -> ActuatorReconciliationService:
            detail="Actuator-Reconciliation nicht initialisiert.",
        )
    return service
+
+
+def _behavior(request: Request) -> BehaviorEngine:
+    engine = getattr(request.app.state, "behavior_engine", None)
+    if not isinstance(engine, BehaviorEngine):
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Verhaltenslernen ist nicht initialisiert.",
+        )
+    return engine
--- a/app/behavior/init.py
+++ b/app/behavior/init.py
@@ -0,0 +1 @@
+"""Learning and prediction for actuator behavior."""
--- a/app/behavior/engine.py
+++ b/app/behavior/engine.py
@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+
+from app.actuators.models import (
+    ActuatorRecord,
+    BehaviorMode,
+    BehaviorPattern,
+    BehaviorPrediction,
+    BehaviorState,
+    BehaviorStatus,
+    ExecutionEvent,
+)
+from app.actuators.store import ActuatorStore
+from app.config import Settings
+from app.ha.exceptions import HaClientError
+from app.ha.history import LogbookEntry, StateHistoryPoint, StateHistorySeries
+from app.ha.reader import HaReader
+
+_MAX_PATTERNS = 500
+_MAX_EXECUTION_EVENTS = 100
+_ACTION_LOGBOOK_TOLERANCE = timedelta(seconds=10)
+_OWN_ACTION_TOLERANCE = timedelta(seconds=20)
+_SAFE_ACTIVE_DOMAINS = frozenset({"cover", "fan", "humidifier", "light", "switch"})
+_AUTOMATION_CONTEXT_DOMAINS = frozenset({"automation", "script"})
+logger = logging.getLogger(__name__)
+
+
+class BehaviorEngine:
+    def __init__(
+        self,
+        *,
+        ha_reader: HaReader,
+        store: ActuatorStore,
+        settings: Settings,
+    ) -> None:
+        self._ha_reader = ha_reader
+        self._store = store
+        self._settings = settings
+
+    def train_all(self) -> list[ActuatorRecord]:
+        return [self.train(record.actuator_entity_id) for record in self._store.list()]
+
+    def train(self, actuator_entity_id: str) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        raw_context_ids = list(
+            dict.fromkeys(
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+        )
+        context_ids = [
+            entity_id for entity_id in raw_context_ids if isinstance(entity_id, str)
+        ]
+        if not context_ids:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.COLLECTING,
+                        "last_trained_at": now,
+                        "reason": "Noch kein geeigneter Kontext für Verhaltenslernen vorhanden.",
+                    }
+                ),
+            )
+
+        start = now - timedelta(days=self._settings.history_days)
+        history_ids = [actuator_entity_id, *context_ids]
+        try:
+            history = {
+                series.entity_id: series
+                for series in self._ha_reader.read_state_history(history_ids, start, now)
+            }
+        except (HaClientError, ValueError) as exc:
+            logger.warning("Behavior history unavailable for %s: %s", actuator_entity_id, exc)
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.BLOCKED,
+                        "last_trained_at": now,
+                        "reason": f"Home-Assistant-Historie konnte nicht gelesen werden: {exc}",
+                    }
+                ),
+            )
+        actuator_history = history.get(actuator_entity_id)
+        if actuator_history is None or len(actuator_history.points) < 2:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "status": BehaviorStatus.COLLECTING,
+                        "sample_count": 0,
+                        "high_confidence_sample_count": 0,
+                        "patterns": [],
+                        "last_trained_at": now,
+                        "reason": "Noch keine historischen Aktorhandlungen gefunden.",
+                    }
+                ),
+            )
+
+        try:
+            logbook = list(self._ha_reader.read_logbook(actuator_entity_id, start, now))
+        except (HaClientError, ValueError) as exc:
+            logger.warning("Logbook unavailable for %s: %s", actuator_entity_id, exc)
+            logbook = []
+        patterns = self._build_patterns(
+            actuator_history=actuator_history,
+            context_history=history,
+            context_ids=context_ids,
+            logbook=logbook,
+            own_executions=record.behavior.execution_events,
+        )
+        high_confidence = sum(1 for pattern in patterns if pattern.source == "user")
+        status = (
+            BehaviorStatus.TRAINED
+            if len(patterns) >= self._settings.min_behavior_actions
+            else BehaviorStatus.COLLECTING
+        )
+        reason = (
+            f"{len(patterns)} Handlungen mit automatisch erfasstem Kontext gelernt."
+            if status is BehaviorStatus.TRAINED
+            else (
+                f"{len(patterns)} von mindestens {self._settings.min_behavior_actions} "
+                "benötigten Handlungen gelernt."
+            )
+        )
+        behavior = record.behavior.model_copy(
+            update={
+                "status": status,
+                "sample_count": len(patterns),
+                "high_confidence_sample_count": high_confidence,
+                "patterns": patterns[-_MAX_PATTERNS:],
+                "last_trained_at": now,
+                "reason": reason,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def evaluate_all(self) -> list[ActuatorRecord]:
+        return [self.evaluate(record.actuator_entity_id) for record in self._store.list()]
+
+    def evaluate(self, actuator_entity_id: str) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        try:
+            entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
+        except HaClientError as exc:
+            logger.warning("Current HA state unavailable for %s: %s", actuator_entity_id, exc)
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "last_evaluated_at": now,
+                        "prediction": None,
+                        "reason": f"Aktueller Home-Assistant-Zustand ist nicht verfügbar: {exc}",
+                    }
+                ),
+            )
+        actuator = entities.get(actuator_entity_id)
+        if actuator is None:
+            return self._save_behavior(
+                record,
+                record.behavior.model_copy(
+                    update={
+                        "last_evaluated_at": now,
+                        "prediction": None,
+                        "reason": "Aktor ist aktuell nicht in Home Assistant verfügbar.",
+                    }
+                ),
+            )
+        current_context = {
+            entity_id: entities[entity_id].state
+            for entity_id in (
+                [
+                    record.assignment.selected_numeric_entity_id,
+                    *record.assignment.selected_context_entity_ids,
+                ]
+            )
+            if entity_id and entity_id in entities and entities[entity_id].state is not None
+        }
+        prediction = predict_behavior(
+            record.behavior.patterns,
+            current_context=current_context,
+            now=now,
+            min_support=self._settings.min_behavior_actions,
+            window_minutes=self._settings.prediction_window_minutes,
+            timezone_name=self._settings.timezone,
+        )
+        behavior = record.behavior.model_copy(
+            update={
+                "last_evaluated_at": now,
+                "prediction": prediction,
+                "reason": (
+                    prediction.reason
+                    if prediction is not None
+                    else "Aktuell ist kein gelerntes Handlungsmuster fällig."
+                ),
+            }
+        )
+        if (
+            prediction is not None
+            and behavior.mode is BehaviorMode.ACTIVE
+            and prediction.confidence >= self._settings.prediction_confidence
+            and actuator.state != prediction.target_state
+            and self._cooldown_elapsed(behavior, now)
+        ):
+            domain = actuator_entity_id.split(".", 1)[0]
+            service = service_for_state(domain, prediction.target_state)
+            if service is not None:
+                try:
+                    self._ha_reader.call_service(
+                        domain,
+                        service,
+                        {"entity_id": actuator_entity_id},
+                    )
+                except (HaClientError, ValueError) as exc:
+                    logger.error(
+                        "Predicted action failed for %s: %s",
+                        actuator_entity_id,
+                        exc,
+                    )
+                    behavior = behavior.model_copy(
+                        update={
+                            "reason": f"Vorhersage wurde aus Sicherheitsgründen nicht ausgeführt: {exc}"
+                        }
+                    )
+                    return self._save_behavior(record, behavior)
+                event = ExecutionEvent(
+                    target_state=prediction.target_state,
+                    executed_at=now,
+                )
+                behavior = behavior.model_copy(
+                    update={
+                        "prediction": prediction.model_copy(update={"executed": True}),
+                        "last_executed_at": now,
+                        "execution_events": [
+                            *behavior.execution_events,
+                            event,
+                        ][-_MAX_EXECUTION_EVENTS:],
+                        "reason": (
+                            f"Vorhersage mit {prediction.confidence:.0%} Sicherheit ausgeführt."
+                        ),
+                    }
+                )
+            else:
+                behavior = behavior.model_copy(
+                    update={
+                        "reason": (
+                            f"Der vorhergesagte Zustand {prediction.target_state!r} "
+                            "ist für autonomes Schalten nicht freigegeben."
+                        )
+                    }
+                )
+        return self._save_behavior(record, behavior)
+
+    def set_active(self, actuator_entity_id: str, *, active: bool) -> ActuatorRecord:
+        record = self._store.get(actuator_entity_id)
+        now = datetime.now(timezone.utc)
+        if active:
+            domain = actuator_entity_id.split(".", 1)[0]
+            if domain not in _SAFE_ACTIVE_DOMAINS:
+                raise ValueError(
+                    f"Automatisches Schalten ist für die Domain {domain} nicht freigegeben."
+                )
+            if record.behavior.status is not BehaviorStatus.TRAINED:
+                raise ValueError("Das Verhaltensmodell hat noch nicht genügend Handlungen gelernt.")
+            if (
+                record.behavior.high_confidence_sample_count
+                < self._settings.min_behavior_actions
+            ):
+                raise ValueError(
+                    "Für die Freigabe fehlen noch eindeutig dir zugeordnete Handlungen. "
+                    "Bediene den Aktor einige Male über Home Assistant."
+                )
+            mode = BehaviorMode.ACTIVE
+            approved_at = now
+            reason = "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
+        else:
+            mode = BehaviorMode.SHADOW
+            approved_at = None
+            reason = "Shadow-Modus aktiv; Vorhersagen werden nicht ausgeführt."
+        behavior = record.behavior.model_copy(
+            update={
+                "mode": mode,
+                "approved_at": approved_at,
+                "reason": reason,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def _build_patterns(
+        self,
+        *,
+        actuator_history: StateHistorySeries,
+        context_history: dict[str, StateHistorySeries],
+        context_ids: list[str],
+        logbook: list[LogbookEntry],
+        own_executions: list[ExecutionEvent],
+    ) -> list[BehaviorPattern]:
+        patterns: list[BehaviorPattern] = []
+        previous_state = actuator_history.points[0].state
+        for point in actuator_history.points[1:]:
+            if point.state == previous_state:
+                continue
+            previous_state = point.state
+            if _matches_own_execution(point, own_executions):
+                continue
+            source, weight = _action_source(point, logbook)
+            if source == "automation":
+                continue
+            contexts = {
+                entity_id: state
+                for entity_id in context_ids
+                if (state := _state_at(context_history.get(entity_id), point.timestamp)) is not None
+            }
+            local = point.timestamp.astimezone(ZoneInfo(self._settings.timezone))
+            patterns.append(
+                BehaviorPattern(
+                    target_state=point.state,
+                    minute_of_day=local.hour * 60 + local.minute,
+                    weekday=local.weekday(),
+                    context_states=contexts,
+                    source=source,
+                    weight=weight,
+                    observed_at=point.timestamp,
+                )
+            )
+        return patterns
+
+    def _cooldown_elapsed(self, behavior: BehaviorState, now: datetime) -> bool:
+        return behavior.last_executed_at is None or (
+            now - behavior.last_executed_at
+        ) >= timedelta(seconds=self._settings.execution_cooldown_seconds)
+
+    def _save_behavior(
+        self,
+        record: ActuatorRecord,
+        behavior: BehaviorState,
+    ) -> ActuatorRecord:
+        updated = record.model_copy(
+            update={
+                "behavior": behavior,
+                "updated_at": datetime.now(timezone.utc),
+            }
+        )
+        return self._store.upsert(updated)
+
+
+def predict_behavior(
+    patterns: list[BehaviorPattern],
+    *,
+    current_context: dict[str, str | None],
+    now: datetime,
+    min_support: int,
+    window_minutes: int,
+    timezone_name: str = "Europe/Berlin",
+) -> BehaviorPrediction | None:
+    if not patterns:
+        return None
+    local = now.astimezone(ZoneInfo(timezone_name))
+    minute_of_day = local.hour * 60 + local.minute
+    by_state: dict[str, list[float]] = {}
+    for pattern in patterns:
+        distance = _circular_minute_distance(minute_of_day, pattern.minute_of_day)
+        if distance > window_minutes:
+            continue
+        time_score = 1.0 - (distance / max(window_minutes, 1))
+        weekday_score = (
+            1.0
+            if local.weekday() == pattern.weekday
+            else 0.5
+            if (local.weekday() >= 5) == (pattern.weekday >= 5)
+            else 0.0
+        )
+        comparable = [
+            (entity_id, expected)
+            for entity_id, expected in pattern.context_states.items()
+            if entity_id in current_context
+        ]
+        context_score = (
+            sum(current_context[entity_id] == expected for entity_id, expected in comparable)
+            / len(comparable)
+            if comparable
+            else 0.5
+        )
+        score = pattern.weight * (
+            0.45 * time_score + 0.45 * context_score + 0.10 * weekday_score
+        )
+        by_state.setdefault(pattern.target_state, []).append(score)
+    if not by_state:
+        return None
+    target_state, scores = max(
+        by_state.items(),
+        key=lambda item: (sum(item[1]), len(item[1]), item[0]),
+    )
+    support = len(scores)
+    confidence = min(1.0, (sum(scores) / support) * min(1.0, support / min_support))
+    if confidence <= 0:
+        return None
+    return BehaviorPrediction(
+        target_state=target_state,
+        confidence=round(confidence, 4),
+        generated_at=now,
+        matching_patterns=support,
+        reason=(
+            f"{support} ähnliche Handlungsmuster passen zu Zeit und aktuellem Kontext."
+        ),
+    )
+
+
+def service_for_state(domain: str, target_state: str) -> str | None:
+    if domain in {"fan", "humidifier", "light", "switch"}:
+        return {"on": "turn_on", "off": "turn_off"}.get(target_state)
+    if domain == "cover":
+        return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
+    return None
+
+
+def _state_at(series: StateHistorySeries | None, timestamp: datetime) -> str | None:
+    if series is None:
+        return None
+    state: str | None = None
+    for point in series.points:
+        if point.timestamp > timestamp:
+            break
+        state = point.state
+    return state
+
+
+def _action_source(
+    point: StateHistoryPoint,
+    logbook: list[LogbookEntry],
+) -> tuple[str, float]:
+    nearest = min(
+        logbook,
+        key=lambda item: abs(item.timestamp - point.timestamp),
+        default=None,
+    )
+    if nearest is None or abs(nearest.timestamp - point.timestamp) > _ACTION_LOGBOOK_TOLERANCE:
+        return "physical_or_unknown", 0.7
+    if nearest.context_user_id:
+        return "user", 1.0
+    if nearest.context_domain in _AUTOMATION_CONTEXT_DOMAINS:
+        return "automation", 0.1
+    return "physical_or_unknown", 0.7
+
+
+def _matches_own_execution(
+    point: StateHistoryPoint,
+    own_executions: list[ExecutionEvent],
+) -> bool:
+    return any(
+        event.target_state == point.state
+        and abs(event.executed_at - point.timestamp) <= _OWN_ACTION_TOLERANCE
+        for event in own_executions
+    )
+
+
+def _circular_minute_distance(left: int, right: int) -> int:
+    direct = abs(left - right)
+    return min(direct, 1440 - direct)
--- a/app/config.py
+++ b/app/config.py
@@ -15,6 +15,12 @@ class Settings:
    min_training_points: int = 24
    retrain_stale_hours: int = 24
    reconcile_interval_seconds: int = 900
+    min_behavior_actions: int = 3
+    prediction_confidence: float = 0.82
+    prediction_window_minutes: int = 30
+    prediction_interval_seconds: int = 60
+    execution_cooldown_seconds: int = 900
+    timezone: str = "Europe/Berlin"

    @property
    def ha_configured(self) -> bool:
@@ -34,4 +40,19 @@ def load_settings() -> Settings:
        reconcile_interval_seconds=max(
            60, int(os.getenv("SILLYHOME_RECONCILE_INTERVAL_SECONDS", "900"))
        ),
+        min_behavior_actions=max(2, int(os.getenv("SILLYHOME_MIN_BEHAVIOR_ACTIONS", "3"))),
+        prediction_confidence=max(
+            0.5,
+            min(0.99, float(os.getenv("SILLYHOME_PREDICTION_CONFIDENCE", "0.82"))),
+        ),
+        prediction_window_minutes=max(
+            5, min(120, int(os.getenv("SILLYHOME_PREDICTION_WINDOW_MINUTES", "30")))
+        ),
+        prediction_interval_seconds=max(
+            30, int(os.getenv("SILLYHOME_PREDICTION_INTERVAL_SECONDS", "60"))
+        ),
+        execution_cooldown_seconds=max(
+            60, int(os.getenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "900"))
+        ),
+        timezone=os.getenv("SILLYHOME_TIMEZONE", "Europe/Berlin"),
    )
--- a/app/ha/client.py
+++ b/app/ha/client.py
@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from datetime import datetime
 import json
 import re
+from typing import Any
 from urllib.parse import quote

 import requests
@@ -19,6 +20,7 @@ from app.ha.exceptions import (
 logger = logging.getLogger(__name__)

 _ENTITY_ID_PATTERN = re.compile(r"^[a-z0-9_]+\.[a-z0-9_]+$")
+_SERVICE_PART_PATTERN = re.compile(r"^[a-z0-9_]+$")
 _MAX_HISTORY_SECONDS = 31 * 24 * 60 * 60


@@ -84,6 +86,44 @@ class HaClient:
            )
        return payload

+    def get_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> list[object]:
+        self._validate_period([entity_id], start_time, end_time)
+        start = quote(start_time.isoformat(), safe=":+")
+        payload = self._get_json(
+            f"/api/logbook/{start}",
+            params={
+                "entity": entity_id,
+                "end_time": end_time.isoformat(),
+            },
+        )
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "Logbook-Antwort von Home Assistant hat unerwartetes Format."
+            )
+        return payload
+
+    def call_service(
+        self,
+        domain: str,
+        service: str,
+        service_data: dict[str, object],
+    ) -> list[object]:
+        if not _SERVICE_PART_PATTERN.fullmatch(domain):
+            raise ValueError("Ungültige Service-Domain.")
+        if not _SERVICE_PART_PATTERN.fullmatch(service):
+            raise ValueError("Ungültiger Service-Name.")
+        payload = self._post_json(f"/api/services/{domain}/{service}", service_data)
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError(
+                "Service-Antwort von Home Assistant hat unerwartetes Format."
+            )
+        return payload
+
    def list_entity_metadata(self, entity_ids: list[str]) -> dict[str, dict[str, str | None]]:
        if not entity_ids:
            return {}
@@ -153,6 +193,36 @@ class HaClient:

        return payload

+    def _post_json(self, path: str, payload: Any) -> object:
+        try:
+            response = self._session.post(
+                f"{self._settings.url.rstrip('/')}{path}",
+                json=payload,
+                timeout=self._settings.timeout_seconds,
+            )
+        except requests.Timeout as exc:
+            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
+        except requests.RequestException as exc:
+            raise HaHttpError(
+                getattr(getattr(exc, "response", None), "status_code", 502),
+                "Netzwerkfehler beim Zugriff auf Home Assistant.",
+            ) from exc
+        if response.status_code in (401, 403):
+            raise HaAuthError(
+                response.status_code,
+                "Authentifizierung bei Home Assistant fehlgeschlagen.",
+            )
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant ist kein gültiges JSON."
+            ) from exc
+
    def _post_text(self, path: str, payload: dict[str, str]) -> str:
        try:
            response = self._session.post(
@@ -179,6 +249,25 @@ class HaClient:
            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
        return response.text

+    @staticmethod
+    def _validate_period(
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> None:
+        if not entity_ids:
+            raise ValueError("Mindestens eine entity_id ist erforderlich.")
+        if len(entity_ids) > 100:
+            raise ValueError("Es können höchstens 100 Entities abgefragt werden.")
+        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
+            raise ValueError("entity_id enthält ein ungültiges Format.")
+        if start_time.tzinfo is None or end_time.tzinfo is None:
+            raise ValueError("start_time und end_time müssen eine Zeitzone enthalten.")
+        if end_time <= start_time:
+            raise ValueError("end_time muss nach start_time liegen.")
+        if (end_time - start_time).total_seconds() > _MAX_HISTORY_SECONDS:
+            raise ValueError("History-Abfragen sind auf 31 Tage begrenzt.")
+

 def _metadata_template(entity_ids: list[str]) -> str:
    ids = json.dumps(entity_ids, ensure_ascii=True)
--- a/app/ha/history.py
+++ b/app/ha/history.py
@@ -18,6 +18,25 @@ class EntityHistorySeries(BaseModel):
    points: list[NumericHistoryPoint]


+class StateHistoryPoint(BaseModel):
+    timestamp: datetime
+    state: str
+
+
+class StateHistorySeries(BaseModel):
+    entity_id: str
+    points: list[StateHistoryPoint]
+
+
+class LogbookEntry(BaseModel):
+    entity_id: str
+    timestamp: datetime
+    message: str = ""
+    context_user_id: str | None = None
+    context_domain: str | None = None
+    context_service: str | None = None
+
+
 def normalize_history_payload(payload: object) -> list[EntityHistorySeries]:
    if not isinstance(payload, list):
        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
@@ -33,6 +52,68 @@ def normalize_history_payload(payload: object) -> list[EntityHistorySeries]:
    return sorted(normalized, key=lambda item: item.entity_id)


+def normalize_state_history_payload(payload: object) -> list[StateHistorySeries]:
+    if not isinstance(payload, list):
+        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
+    normalized: list[StateHistorySeries] = []
+    for raw_series in payload:
+        if not isinstance(raw_series, list):
+            raise HaUnexpectedPayloadError("History-Serie muss eine Liste sein.")
+        entity_id: str | None = None
+        points: list[StateHistoryPoint] = []
+        for raw_entry in raw_series:
+            if not isinstance(raw_entry, dict):
+                raise HaUnexpectedPayloadError("History-Eintrag muss ein Objekt sein.")
+            raw_entity_id = raw_entry.get("entity_id")
+            if raw_entity_id is not None:
+                if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
+                    raise HaUnexpectedPayloadError(
+                        "History-Eintrag enthält ungültige entity_id."
+                    )
+                if entity_id is not None and entity_id != raw_entity_id:
+                    raise HaUnexpectedPayloadError("History-Serie enthält mehrere Entities.")
+                entity_id = raw_entity_id
+            raw_state = raw_entry.get("state")
+            if not isinstance(raw_state, str) or raw_state in {"unknown", "unavailable"}:
+                continue
+            if entity_id is None:
+                raise HaUnexpectedPayloadError("History-Serie enthält keine entity_id.")
+            timestamp = _parse_timestamp(
+                raw_entry.get("last_changed") or raw_entry.get("last_updated")
+            )
+            if not points or points[-1].state != raw_state:
+                points.append(StateHistoryPoint(timestamp=timestamp, state=raw_state))
+        if entity_id is not None and points:
+            points.sort(key=lambda point: point.timestamp)
+            normalized.append(StateHistorySeries(entity_id=entity_id, points=points))
+    return sorted(normalized, key=lambda item: item.entity_id)
+
+
+def normalize_logbook_payload(payload: object, entity_id: str) -> list[LogbookEntry]:
+    if not isinstance(payload, list):
+        raise HaUnexpectedPayloadError("Logbook-Payload muss eine Liste sein.")
+    entries: list[LogbookEntry] = []
+    for raw_entry in payload:
+        if not isinstance(raw_entry, dict):
+            raise HaUnexpectedPayloadError("Logbook-Eintrag muss ein Objekt sein.")
+        raw_entity_id = raw_entry.get("entity_id")
+        if raw_entity_id != entity_id:
+            continue
+        entries.append(
+            LogbookEntry(
+                entity_id=entity_id,
+                timestamp=_parse_timestamp(raw_entry.get("when")),
+                message=str(raw_entry.get("message") or ""),
+                context_user_id=_optional_string(raw_entry.get("context_user_id")),
+                context_domain=_optional_string(
+                    raw_entry.get("context_domain") or raw_entry.get("domain")
+                ),
+                context_service=_optional_string(raw_entry.get("context_service")),
+            )
+        )
+    return sorted(entries, key=lambda item: item.timestamp)
+
+
 def _normalize_series(raw_series: list[object]) -> EntityHistorySeries | None:
    entity_id: str | None = None
    points: list[NumericHistoryPoint] = []
@@ -89,3 +170,9 @@ def _parse_timestamp(value: object) -> datetime:
    if parsed.tzinfo is None:
        raise HaUnexpectedPayloadError("History-Zeitstempel muss eine Zeitzone enthalten.")
    return parsed
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None or value == "":
+        return None
+    return str(value)
--- a/app/ha/models.py
+++ b/app/ha/models.py
@@ -14,6 +14,7 @@ class HaState(BaseModel):
 class HaEntitySummary(BaseModel):
    entity_id: str
    domain: str
+    state: str | None = None
    state_class: str | None = None
    device_class: str | None = None
    unit_of_measurement: str | None = None
--- a/app/ha/reader.py
+++ b/app/ha/reader.py
@@ -9,7 +9,14 @@ from app.ha.exceptions import HaClientError

 from app.ha.client import HaClient
 from app.ha.discovery import DiscoveredEntity, discover_entities
-from app.ha.history import EntityHistorySeries, normalize_history_payload
+from app.ha.history import (
+    EntityHistorySeries,
+    LogbookEntry,
+    StateHistorySeries,
+    normalize_history_payload,
+    normalize_logbook_payload,
+    normalize_state_history_payload,
+)
 from app.ha.models import HaEntitySummary

 logger = logging.getLogger(__name__)
@@ -45,6 +52,7 @@ class HaReader:
                HaEntitySummary(
                    entity_id=entity_id,
                    domain=domain,
+                    state=_optional_str(item.get("state")),
                    state_class=_optional_str(attributes.get("state_class")),
                    device_class=_optional_str(attributes.get("device_class")),
                    unit_of_measurement=_optional_str(attributes.get("unit_of_measurement")),
@@ -77,6 +85,32 @@ class HaReader:
        payload = self._client.get_history(entity_ids, start_time, end_time)
        return normalize_history_payload(payload)

+    def read_state_history(
+        self,
+        entity_ids: list[str],
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[StateHistorySeries]:
+        payload = self._client.get_history(entity_ids, start_time, end_time)
+        return normalize_state_history_payload(payload)
+
+    def read_logbook(
+        self,
+        entity_id: str,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> Sequence[LogbookEntry]:
+        payload = self._client.get_logbook(entity_id, start_time, end_time)
+        return normalize_logbook_payload(payload, entity_id)
+
+    def call_service(
+        self,
+        domain: str,
+        service: str,
+        service_data: dict[str, object],
+    ) -> Sequence[object]:
+        return self._client.call_service(domain, service, service_data)
+

 def _optional_str(value: object) -> str | None:
    if value is None or value == "":
--- a/app/main.py
+++ b/app/main.py
@@ -12,8 +12,7 @@ from app.actuators.lifecycle import ActuatorReconciliationService
 from app.actuators.store import ActuatorStore
 from app.api.v1.actuators import router as actuators_router
 from app.api.v1.entities import router as entities_router
-from app.api.v1.automations import router as automations_router
-from app.automations.store import AutomationStore
+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
@@ -27,13 +26,15 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    settings = app.state.settings
    client: HaClient | None = None
    reconcile_task: asyncio.Task[None] | None = None
+    prediction_task: asyncio.Task[None] | None = None
    app.state.registry = ModelRegistry(settings.model_store)
-    app.state.automation_store = AutomationStore(settings.automation_store)
    app.state.actuator_store = ActuatorStore(settings.actuator_store)
    if hasattr(app.state, "ha_reader"):
        del app.state.ha_reader
    if hasattr(app.state, "actuator_service"):
        del app.state.actuator_service
+    if hasattr(app.state, "behavior_engine"):
+        del app.state.behavior_engine
    if settings.ha_configured:
        client = HaClient(
            settings=HaClientSettings(
@@ -48,8 +49,16 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            registry=app.state.registry,
            settings=settings,
        )
+        app.state.behavior_engine = BehaviorEngine(
+            ha_reader=app.state.ha_reader,
+            store=app.state.actuator_store,
+            settings=settings,
+        )
        await asyncio.to_thread(app.state.actuator_service.reconcile_all, "startup")
+        await asyncio.to_thread(app.state.behavior_engine.train_all)
+        await asyncio.to_thread(app.state.behavior_engine.evaluate_all)
        reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
+        prediction_task = asyncio.create_task(_periodic_prediction(app))
    try:
        yield
    finally:
@@ -57,6 +66,10 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
            reconcile_task.cancel()
            with suppress(asyncio.CancelledError):
                await reconcile_task
+        if prediction_task is not None:
+            prediction_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await prediction_task
        if client is not None:
            client.close()

@@ -64,13 +77,12 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
    title="SillyHome Next API",
    description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.4.0",
+    version="0.5.0",
    lifespan=lifespan,
 )
 app.state.settings = load_settings()
 register_exception_handlers(app)
 app.include_router(entities_router)
-app.include_router(automations_router)
 app.include_router(actuators_router)
 init_ml_routes(app, model_store=app.state.settings.model_store)

@@ -95,3 +107,15 @@ async def _periodic_reconciliation(app: FastAPI) -> None:
        if not isinstance(service, ActuatorReconciliationService):
            continue
        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)
+
+
+async def _periodic_prediction(app: FastAPI) -> None:
+    while True:
+        await asyncio.sleep(app.state.settings.prediction_interval_seconds)
+        engine = getattr(app.state, "behavior_engine", None)
+        if not isinstance(engine, BehaviorEngine):
+            continue
+        await asyncio.to_thread(engine.evaluate_all)
--- a/app/static/index.html
+++ b/app/static/index.html
@@ -7,9 +7,9 @@
  <style>
    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #10151c; color: #eaf1f8; }
    body { margin: 0; }
-    header { padding: 20px; background: linear-gradient(135deg,#142b3a,#193f36); }
+    header { padding: 22px; background: linear-gradient(135deg,#142b3a,#193f36); }
    h1,h2,h3 { margin: 0 0 12px; }
-    header p { margin: 4px 0; color: #b9c9d6; }
+    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; }
    .wide { grid-column: 1 / -1; }
@@ -17,87 +17,92 @@
    .warn { color: #f3c969; }
    .bad { color: #ff8f8f; }
    label { display: block; margin: 9px 0 4px; color: #b9c9d6; }
-    input,select,textarea,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 9px; background: #101820; color: #fff; }
+    select,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; }
    button { margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
    button.secondary { background: #37495c; }
-    pre { white-space: pre-wrap; overflow: auto; background: #0d141b; padding: 10px; border-radius: 7px; }
-    table { width: 100%; border-collapse: collapse; font-size: .9rem; }
-    td,th { padding: 7px; border-bottom: 1px solid #2d3a47; text-align: left; vertical-align: top; }
+    button.danger { background: #7b3434; }
+    table { width: 100%; border-collapse: collapse; font-size: .92rem; }
+    td,th { padding: 8px; border-bottom: 1px solid #2d3a47; text-align: left; vertical-align: top; }
    ul { margin: 8px 0; padding-left: 18px; }
-    .notice { border-left: 4px solid #e8b34b; padding-left: 10px; }
-    .grid-two { display:grid; grid-template-columns:repeat(auto-fit,minmax(220px,1fr)); gap:8px; }
+    .notice { border-left: 4px solid #66dfa9; padding-left: 10px; }
+    .grid-two { display:grid; grid-template-columns:repeat(auto-fit,minmax(240px,1fr)); gap:12px; }
    .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; }
  </style>
 </head>
 <body>
 <header>
  <h1>SillyHome Next</h1>
-  <p>Aktuator-zentrierte Home-Assistant-Analyse mit nachvollziehbarer Sensorzuordnung und kontrolliertem Modell-Lebenszyklus.</p>
-  <p class="notice">Sicherheitsmodus: SillyHome führt niemals selbst Aktor-Services aus. Automationen bleiben manuell freizugebende YAML-Entwürfe.</p>
+  <p>Du wählst nur die Aktoren. SillyHome findet Kontext, lernt Gewohnheiten und trifft Vorhersagen im Shadow-Modus.</p>
+  <p class="notice">Geschaltet wird erst nach deiner ausdrücklichen Freigabe pro Aktor.</p>
 </header>
 <main>
  <section>
    <h2>Systemstatus</h2>
    <div id="status">Prüfung läuft ...</div>
    <div class="chips" id="status-chips"></div>
-    <button class="secondary" onclick="loadOverview()">Neu laden</button>
-    <button onclick="runReconciliation()">Reconciliation ausführen</button>
+    <button class="secondary" onclick="loadOverview()">Status aktualisieren</button>
  </section>

  <section>
-    <h2>Aktuator wählen</h2>
+    <h2>Aktor freigeben</h2>
+    <p class="muted">Nach der Auswahl analysiert SillyHome automatisch passende Sensoren, Zustände und Historie.</p>
    <label for="actuator-select">Home-Assistant-Aktor</label>
    <select id="actuator-select"></select>
-    <button onclick="configureActuator()">Aktuator übernehmen</button>
-    <pre id="actuator-config-result">Noch kein Aktuator konfiguriert.</pre>
+    <button onclick="configureActuator()">Auswählen und Lernen starten</button>
+    <p id="actuator-config-result" class="muted">Noch kein Aktor ausgewählt.</p>
  </section>

  <section class="wide">
-    <h2>Konfigurierte Aktuatoren</h2>
+    <h2>Ausgewählte Aktoren</h2>
    <div id="configured-actuators">Noch nicht geladen.</div>
  </section>

  <section class="wide">
-    <h2>Zuordnung und Modellstatus</h2>
-    <div id="actuator-detail">Einen konfigurierten Aktuator auswählen.</div>
-  </section>
-
-  <section class="wide">
-    <h2>Automation-Entwurf</h2>
-    <p>Der Entwurf muss explizit freigegeben werden. Auch danach wird nur YAML exportiert, nichts geschaltet.</p>
-    <div class="grid-two">
-      <div><label for="alias">Name</label><input id="alias" value="Licht bei Dunkelheit"></div>
-      <div><label for="trigger">Trigger-Entity</label><input id="trigger" placeholder="sensor.flur_illuminance"></div>
-      <div><label for="below">Unter Grenzwert</label><input id="below" type="number" value="10"></div>
-      <div><label for="service">Dienst</label><select id="service"><option>light.turn_on</option><option>light.turn_off</option><option>switch.turn_on</option><option>switch.turn_off</option></select></div>
-      <div><label for="target">Ziel-Entity</label><input id="target" placeholder="light.flur"></div>
-    </div>
-    <button onclick="createProposal()">Entwurf speichern</button>
-    <button class="secondary" onclick="loadProposals()">Entwürfe aktualisieren</button>
-    <div id="proposals"></div>
+    <h2>Automatisch erkannter Lernkontext</h2>
+    <div id="actuator-detail" class="muted">Wähle einen Aktor aus der Liste.</div>
  </section>
 </main>
 <script>
-const pretty = value => JSON.stringify(value, null, 2);
+const escapeHtml = value => String(value ?? "")
+  .replaceAll("&", "&amp;")
+  .replaceAll("<", "&lt;")
+  .replaceAll(">", "&gt;")
+  .replaceAll('"', "&quot;")
+  .replaceAll("'", "&#039;");
 let currentActuatorId = null;

 async function api(path, options = {}) {
  const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
-  const body = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(body.detail || `${response.status} ${response.statusText}`);
+  const body = response.status === 204 ? null : await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(body?.detail || `${response.status} ${response.statusText}`);
  return body;
 }

+function lifecycleLabel(record) {
+  const labels = {
+    trained: "lernt",
+    pending_history: "sammelt Historie",
+    pending_assignment: "sucht Kontext",
+    review_required: "geringe Zuordnungssicherheit",
+    archived: "wartet auf Kontext",
+    orphaned: "Aktor nicht gefunden",
+  };
+  return labels[record.lifecycle.status] || record.lifecycle.status;
+}
+
 function statusClass(record) {
-  if (record.assignment.review_required) return "warn";
  if (record.lifecycle.status === "trained") return "ok";
-  if (record.lifecycle.status === "review_required" || record.lifecycle.status === "invalid") return "warn";
+  if (["pending_history", "pending_assignment", "archived"].includes(record.lifecycle.status)) return "warn";
  return "bad";
 }

-function renderEvidence(evidence) {
-  return evidence.length ? `<ul>${evidence.map(item => `<li>${item}</li>`).join("")}</ul>` : "<span class='bad'>Keine Evidenz</span>";
+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";
+  return "sammelt Handlungen";
 }

 async function loadOverview() {
@@ -110,57 +115,53 @@ async function loadOverview() {
      api("v1/actuators/reconciliation/state"),
      api("v1/actuators"),
    ]);
-    status.innerHTML = `<p class="ok">API und ML bereit</p><p>Letzte Reconciliation: ${reconciliation.last_completed_at || "noch nie"}</p><p>${reconciliation.last_summary}</p>`;
+    status.innerHTML = `<p class="ok">System bereit</p><p>Letzte automatische Prüfung: ${escapeHtml(reconciliation.last_completed_at || "noch nie")}</p>`;
    chips.innerHTML = [
-      `<span class="chip">Health: ${health.status}</span>`,
-      `<span class="chip">ML: ${ml.status}</span>`,
-      `<span class="chip">Aktuatoren: ${actuators.length}</span>`,
-      `<span class="chip">Trainierte Modelle: ${reconciliation.trained_models}</span>`,
+      `<span class="chip">API: ${escapeHtml(health.status)}</span>`,
+      `<span class="chip">Lernsystem: ${escapeHtml(ml.status)}</span>`,
+      `<span class="chip">Aktoren: ${actuators.length}</span>`,
+      `<span class="chip">Aktive Modelle: ${reconciliation.trained_models}</span>`,
    ].join("");
  } catch (error) {
-    status.innerHTML = `<p class="bad">${error.message}</p>`;
+    status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
    chips.innerHTML = "";
  }
-  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators(), loadProposals()]);
+  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
 }

 async function loadActuatorDiscovery() {
  const select = document.getElementById("actuator-select");
  try {
-    const actuators = await api("v1/actuators/discovery");
-    select.innerHTML = actuators.length
-      ? actuators.map(entity => `<option value="${entity.entity_id}">${entity.friendly_name || entity.entity_id}${entity.area_name ? ` (${entity.area_name})` : ""}</option>`).join("")
-      : "<option value=''>Keine Aktuatoren gefunden</option>";
+    const [available, configured] = await Promise.all([
+      api("v1/actuators/discovery"),
+      api("v1/actuators"),
+    ]);
+    const configuredIds = new Set(configured.map(record => record.actuator_entity_id));
+    const choices = available.filter(entity => !configuredIds.has(entity.entity_id));
+    select.innerHTML = choices.length
+      ? choices.map(entity => `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.friendly_name || entity.entity_id)}${entity.area_name ? ` (${escapeHtml(entity.area_name)})` : ""}</option>`).join("")
+      : "<option value=''>Alle erkannten Aktoren sind ausgewählt</option>";
  } catch (error) {
-    select.innerHTML = `<option value="">${error.message}</option>`;
+    select.innerHTML = `<option value="">${escapeHtml(error.message)}</option>`;
  }
 }

 async function configureActuator() {
  const actuatorId = document.getElementById("actuator-select").value;
-  const box = document.getElementById("actuator-config-result");
+  const result = document.getElementById("actuator-config-result");
  if (!actuatorId) return;
+  result.textContent = "Kontext wird automatisch analysiert ...";
  try {
    const record = await api("v1/actuators", {
      method: "POST",
      body: JSON.stringify({actuator_entity_id: actuatorId}),
    });
    currentActuatorId = record.actuator_entity_id;
-    box.textContent = pretty(record);
+    result.textContent = `${record.actuator_entity_id}: ${lifecycleLabel(record)}.`;
    await loadOverview();
    await showActuator(record.actuator_entity_id);
  } catch (error) {
-    box.textContent = error.message;
-  }
-}
-
-async function runReconciliation() {
-  try {
-    await api("v1/actuators/reconciliation/run", {method: "POST"});
-    await loadOverview();
-    if (currentActuatorId) await showActuator(currentActuatorId);
-  } catch (error) {
-    alert(error.message);
+    result.textContent = error.message;
  }
 }

@@ -170,18 +171,22 @@ async function loadConfiguredActuators() {
    const rows = await api("v1/actuators");
    box.innerHTML = rows.length ? `
      <table>
-        <tr><th>Aktuator</th><th>Numerischer Sensor</th><th>Review</th><th>Modellstatus</th><th>Letztes Training</th><th>Aktion</th></tr>
+        <tr><th>Aktor</th><th>Verhaltensmodell</th><th>Handlungen</th><th>Vorhersage</th><th></th></tr>
        ${rows.map(record => `
          <tr>
-            <td>${record.actuator_entity_id}</td>
-            <td>${record.assignment.selected_numeric_entity_id || "-"}</td>
-            <td class="${record.assignment.review_required ? "warn" : "ok"}">${record.assignment.review_required ? "erforderlich" : "nein"}</td>
-            <td class="${statusClass(record)}">${record.lifecycle.status}</td>
-            <td>${record.lifecycle.last_trained_at || "-"}</td>
-            <td><button onclick="showActuator('${record.actuator_entity_id}')">Details</button></td>
+            <td>${escapeHtml(record.actuator_entity_id)}</td>
+            <td class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</td>
+            <td>${record.behavior.sample_count}</td>
+            <td>${record.behavior.prediction
+              ? `${escapeHtml(record.behavior.prediction.target_state)} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
+              : "-"}</td>
+            <td>
+              <button onclick="showActuator('${escapeHtml(record.actuator_entity_id)}')">Details</button>
+              <button class="danger" onclick="removeActuator('${escapeHtml(record.actuator_entity_id)}')">Entfernen</button>
+            </td>
          </tr>
        `).join("")}
-      </table>` : "<p>Keine konfigurierten Aktuatoren.</p>";
+      </table>` : "<p>Noch keine Aktoren ausgewählt.</p>";
  } catch (error) {
    box.textContent = error.message;
  }
@@ -192,163 +197,93 @@ async function showActuator(actuatorId) {
  const box = document.getElementById("actuator-detail");
  try {
    const record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
-    const numericRows = record.numeric_candidates.map(candidate => `
-      <tr>
-        <td>${candidate.entity_id}</td>
-        <td>${candidate.score.toFixed(3)} / ${candidate.confidence.toFixed(2)}</td>
-        <td>${candidate.auto_accepted ? "<span class='ok'>auto</span>" : "<span class='warn'>review</span>"}</td>
-        <td>${renderEvidence(candidate.evidence)}</td>
-      </tr>
-    `).join("");
-    const contextRows = record.context_candidates.map(candidate => `
-      <tr>
-        <td>${candidate.entity_id}</td>
-        <td>${candidate.score.toFixed(3)} / ${candidate.confidence.toFixed(2)}</td>
-        <td>${candidate.auto_accepted ? "<span class='ok'>auto</span>" : "<span class='warn'>optional</span>"}</td>
-        <td>${renderEvidence(candidate.evidence)}</td>
-      </tr>
-    `).join("");
+    const contexts = [
+      record.assignment.selected_numeric_entity_id,
+      ...record.assignment.selected_context_entity_ids,
+    ].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>`)
+      .join("");
+    const prediction = record.behavior.prediction;
+    const activationButton = record.behavior.mode === "active"
+      ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false)">Autonomes Schalten stoppen</button>`
+      : record.behavior.status === "trained"
+        ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true)">Lernen und Schalten freigeben</button>`
+        : "<p class='muted'>Freigabe wird möglich, sobald genügend Handlungen gelernt wurden.</p>";
    box.innerHTML = `
      <div class="grid-two">
        <div>
-          <h3>Auswahl</h3>
-          <p><strong>Aktuator:</strong> ${record.actuator_entity_id}</p>
-          <p><strong>Numerischer Sensor:</strong> ${record.assignment.selected_numeric_entity_id || "-"}</p>
-          <p><strong>Kontext:</strong> ${record.assignment.selected_context_entity_ids.join(", ") || "-"}</p>
-          <p><strong>Quelle:</strong> ${record.assignment.source}</p>
-          <p><strong>Review:</strong> <span class="${record.assignment.review_required ? "warn" : "ok"}">${record.assignment.review_required ? "erforderlich" : "nicht erforderlich"}</span></p>
-          <p><strong>Begruendung:</strong> ${record.assignment.reason}</p>
+          <h3>${escapeHtml(record.actuator_entity_id)}</h3>
+          <p><strong>Status:</strong> <span class="${statusClass(record)}">${escapeHtml(lifecycleLabel(record))}</span></p>
+          <p><strong>Zuordnung:</strong> automatisch</p>
+          <p><strong>Sicherheit:</strong> ${Math.round(record.assignment.confidence * 100)} %</p>
+          <p><strong>Bewertung:</strong> ${escapeHtml(record.assignment.reason)}</p>
        </div>
        <div>
-          <h3>Modell-Lebenszyklus</h3>
-          <p><strong>Status:</strong> <span class="${statusClass(record)}">${record.lifecycle.status}</span></p>
-          <p><strong>Letztes Training:</strong> ${record.lifecycle.last_trained_at || "-"}</p>
-          <p><strong>Messpunkte:</strong> ${record.lifecycle.last_history_point_count}</p>
-          <p><strong>Grund:</strong> ${record.lifecycle.reason}</p>
-          <p><strong>Nächste Aktion:</strong> ${record.lifecycle.next_action}</p>
-          <button onclick="reconcileActuator('${record.actuator_entity_id}')">Diesen Aktuator erneut prüfen</button>
+          <h3>Verhaltensmodell</h3>
+          <p><strong>Modus:</strong> ${escapeHtml(behaviorLabel(record))}</p>
+          <p><strong>Gelernte Handlungen:</strong> ${record.behavior.sample_count}</p>
+          <p><strong>Davon eindeutig Benutzer:</strong> ${record.behavior.high_confidence_sample_count}</p>
+          <p><strong>Letztes Training:</strong> ${escapeHtml(record.behavior.last_trained_at || "noch nicht")}</p>
+          <p><strong>Status:</strong> ${escapeHtml(record.behavior.reason)}</p>
+          ${activationButton}
+          <button class="secondary" onclick="evaluateActuator('${escapeHtml(record.actuator_entity_id)}')">Vorhersage jetzt prüfen</button>
        </div>
      </div>
-      <div class="grid-two">
-        <div>
-          <h3>Manuelle Overrides</h3>
-          <label for="override-numeric">Numerischer Sensor</label>
-          <input id="override-numeric" value="${record.manual_override?.numeric_entity_id || record.assignment.selected_numeric_entity_id || ""}">
-          <label for="override-context">Kontext-Entities (kommagetrennt)</label>
-          <textarea id="override-context">${(record.manual_override?.context_entity_ids || record.assignment.selected_context_entity_ids || []).join(", ")}</textarea>
-          <label for="override-note">Notiz</label>
-          <input id="override-note" value="${record.manual_override?.note || ""}">
-          <button onclick="saveOverride('${record.actuator_entity_id}')">Override speichern</button>
-          <button class="secondary" onclick="clearOverride('${record.actuator_entity_id}')">Override löschen</button>
-        </div>
-        <div>
-          <h3>Audit</h3>
-          <pre>${pretty(record.lifecycle.audit)}</pre>
-        </div>
-      </div>
-      <h3>Numerische Kandidaten</h3>
-      ${numericRows ? `<table><tr><th>Entity</th><th>Score / Confidence</th><th>Auto</th><th>Evidenz</th></tr>${numericRows}</table>` : "<p>Keine Kandidaten.</p>"}
-      <h3>Kontext-Kandidaten</h3>
-      ${contextRows ? `<table><tr><th>Entity</th><th>Score / Confidence</th><th>Auto</th><th>Evidenz</th></tr>${contextRows}</table>` : "<p>Keine Kandidaten.</p>"}
+      <h3>Aktuelle Vorhersage</h3>
+      ${prediction
+        ? `<p><strong>${escapeHtml(prediction.target_state)}</strong> mit ${Math.round(prediction.confidence * 100)} % Sicherheit. ${escapeHtml(prediction.reason)} ${prediction.executed ? "<span class='ok'>Ausgeführt.</span>" : "<span class='muted'>Nicht ausgeführt.</span>"}</p>`
+        : "<p class='muted'>Aktuell ist kein gelerntes Handlungsmuster fällig.</p>"}
+      <h3>Automatisch verwendeter Kontext</h3>
+      ${evidence ? `<ul>${evidence}</ul>` : "<p class='warn'>Noch kein geeigneter Kontext erkannt. SillyHome prüft bei neuen HA-Daten erneut.</p>"}
    `;
  } catch (error) {
    box.textContent = error.message;
  }
 }

-async function reconcileActuator(actuatorId) {
+async function evaluateActuator(actuatorId) {
  try {
-    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/reconcile`, {method: "POST"});
-    await loadOverview();
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/evaluate`, {method: "POST"});
+    await loadConfiguredActuators();
    await showActuator(actuatorId);
  } catch (error) {
    alert(error.message);
  }
 }

-async function saveOverride(actuatorId) {
-  const numeric = document.getElementById("override-numeric").value.trim() || null;
-  const contexts = document.getElementById("override-context").value
-    .split(",")
-    .map(item => item.trim())
-    .filter(Boolean);
-  const note = document.getElementById("override-note").value.trim() || null;
+async function setActivation(actuatorId, active) {
+  const question = active
+    ? `${actuatorId} wirklich für autonomes Lernen und Schalten freigeben?`
+    : `${actuatorId} wieder in den Shadow-Modus setzen?`;
+  if (!confirm(question)) return;
  try {
-    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/override`, {
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/activation`, {
      method: "POST",
-      body: JSON.stringify({
-        numeric_entity_id: numeric,
-        context_entity_ids: contexts,
-        note,
-      }),
+      body: JSON.stringify({active}),
    });
-    await loadOverview();
+    await loadConfiguredActuators();
    await showActuator(actuatorId);
  } catch (error) {
    alert(error.message);
  }
 }

-async function clearOverride(actuatorId) {
+async function removeActuator(actuatorId) {
+  if (!confirm(`${actuatorId} aus SillyHome entfernen?`)) return;
  try {
-    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/override`, {
-      method: "POST",
-      body: JSON.stringify({clear: true}),
-    });
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}`, {method: "DELETE"});
+    if (currentActuatorId === actuatorId) {
+      currentActuatorId = null;
+      document.getElementById("actuator-detail").textContent = "Wähle einen Aktor aus der Liste.";
+    }
    await loadOverview();
-    await showActuator(actuatorId);
  } catch (error) {
    alert(error.message);
  }
 }

-async function createProposal() {
-  try {
-    await api("v1/automations/proposals", {method: "POST", body: JSON.stringify({
-      alias: document.getElementById("alias").value,
-      description: "Manuell im SillyHome-Dashboard erstellter und nicht automatisch ausgeführter Entwurf.",
-      trigger: {entity_id: document.getElementById("trigger").value, below: Number(document.getElementById("below").value)},
-      action: {service: document.getElementById("service").value, entity_id: document.getElementById("target").value, data: {}}
-    })});
-    await loadProposals();
-  } catch (error) {
-    alert(error.message);
-  }
-}
-
-async function decide(id, revision, action) {
-  try {
-    await api(`v1/automations/proposals/${id}/${action}`, {method: "POST", body: JSON.stringify({expected_revision: revision})});
-    await loadProposals();
-  } catch (error) {
-    alert(error.message);
-  }
-}
-
-async function loadProposals() {
-  const box = document.getElementById("proposals");
-  try {
-    const rows = await api("v1/automations/proposals");
-    box.innerHTML = rows.length ? `
-      <table>
-        <tr><th>Name</th><th>Status</th><th>Aktion</th></tr>
-        ${rows.map(item => `
-          <tr>
-            <td>${item.alias}</td>
-            <td>${item.status}</td>
-            <td>${item.status === "draft"
-              ? `<button onclick="decide('${item.proposal_id}',${item.revision},'approve')">Freigeben</button><button class="secondary" onclick="decide('${item.proposal_id}',${item.revision},'reject')">Ablehnen</button>`
-              : item.status === "approved"
-                ? `<a href="v1/automations/proposals/${item.proposal_id}/yaml">YAML laden</a>`
-                : "-"}</td>
-          </tr>
-        `).join("")}
-      </table>` : "<p>Keine Entwürfe.</p>";
-  } catch (error) {
-    box.textContent = error.message;
-  }
-}
-
 loadOverview();
 </script>
 </body>
				`@@ -0,0 +1 @@`
				`"""Learning and prediction for actuator behavior."""`