CONTROL-001: add safe HA automation handoff

app/actuators/models.py

@@ -107,6 +107,7 @@ class BehaviorPrediction(BaseModel):
     reason: str
     matching_patterns: int = Field(default=0, ge=0)
     executed: bool = False
+    execution_reason: str = "Vorhersage wurde noch nicht ausgeführt."
 
 
 class ExecutionEvent(BaseModel):
@@ -114,6 +115,13 @@ class ExecutionEvent(BaseModel):
     executed_at: datetime
 
 
+class RelatedAutomation(BaseModel):
+    entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    config_id: str = Field(min_length=1, max_length=120)
+    friendly_name: str = Field(min_length=1, max_length=200)
+    enabled: bool
+
+
 class BehaviorState(BaseModel):
     mode: BehaviorMode = BehaviorMode.SHADOW
     status: BehaviorStatus = BehaviorStatus.COLLECTING
@@ -126,6 +134,10 @@ class BehaviorState(BaseModel):
     last_evaluated_at: datetime | None = None
     last_executed_at: datetime | None = None
     execution_events: list[ExecutionEvent] = Field(default_factory=list)
+    activation_ready: bool = False
+    activation_reason: str = "Noch nicht genügend Verhalten für eine Freigabe gelernt."
+    related_automations: list[RelatedAutomation] = Field(default_factory=list)
+    paused_automation_entity_ids: list[str] = Field(default_factory=list)
     reason: str = "Historische Aktorhandlungen werden analysiert."
 
 

app/api/v1/actuators.py

@@ -9,6 +9,7 @@ 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.exceptions import HaClientError
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 
@@ -22,6 +23,13 @@ class ConfigureActuatorRequest(BaseModel):
 
 class ActivationRequest(BaseModel):
     active: bool
+    pause_matching_automations: bool = False
+    restore_paused_automations: bool = False
+
+
+class AutomationControlRequest(BaseModel):
+    automation_entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
+    enabled: bool
 
 
 @router.get("/discovery", response_model=list[HaEntitySummary])
@@ -96,13 +104,55 @@ def set_activation(
     request: Request,
 ) -> ActuatorRecord:
     try:
-        return _behavior(request).set_active(actuator_entity_id, active=payload.active)
+        return _behavior(request).set_active(
+            actuator_entity_id,
+            active=payload.active,
+            pause_matching_automations=payload.pause_matching_automations,
+            restore_paused_automations=payload.restore_paused_automations,
+        )
     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.post(
+    "/{actuator_entity_id}/related-automations/refresh",
+    response_model=ActuatorRecord,
+)
+def refresh_related_automations(
+    actuator_entity_id: str,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).refresh_related_automations(actuator_entity_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (ValueError, HaClientError) as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
+@router.post(
+    "/{actuator_entity_id}/related-automations/control",
+    response_model=ActuatorRecord,
+)
+def control_related_automation(
+    actuator_entity_id: str,
+    payload: AutomationControlRequest,
+    request: Request,
+) -> ActuatorRecord:
+    try:
+        return _behavior(request).set_automation_enabled(
+            actuator_entity_id,
+            payload.automation_entity_id,
+            enabled=payload.enabled,
+        )
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except (ValueError, HaClientError) 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)

app/behavior/engine.py

@@ -12,6 +12,7 @@ from app.actuators.models import (
     BehaviorState,
     BehaviorStatus,
     ExecutionEvent,
+    RelatedAutomation,
 )
 from app.actuators.store import ActuatorStore
 from app.config import Settings
@@ -71,6 +72,10 @@ class BehaviorEngine:
                 record.behavior.model_copy(
                     update={
                         "status": BehaviorStatus.COLLECTING,
+                        "activation_ready": False,
+                        "activation_reason": (
+                            "Freigabe gesperrt: Noch kein geeigneter Kontext erkannt."
+                        ),
                         "last_trained_at": now,
                         "reason": "Noch kein geeigneter Kontext für Verhaltenslernen vorhanden.",
                     }
@@ -105,6 +110,11 @@ class BehaviorEngine:
                         "status": BehaviorStatus.COLLECTING,
                         "sample_count": 0,
                         "high_confidence_sample_count": 0,
+                        "activation_ready": False,
+                        "activation_reason": (
+                            "Freigabe gesperrt: Noch keine historischen "
+                            "Aktorhandlungen gefunden."
+                        ),
                         "patterns": [],
                         "last_trained_at": now,
                         "reason": "Noch keine historischen Aktorhandlungen gefunden.",
@@ -140,11 +150,26 @@ class BehaviorEngine:
                 "benötigten Handlungen gelernt."
             )
         )
+        activation_ready = (
+            status is BehaviorStatus.TRAINED
+            and trusted_actions >= self._settings.min_behavior_actions
+        )
+        activation_reason = (
+            "Freigabe bereit: Genügend eindeutig zugeordnete Handlungen gelernt."
+            if activation_ready
+            else (
+                "Freigabe gesperrt: "
+                f"{max(0, self._settings.min_behavior_actions - trusted_actions)} "
+                "eindeutig zugeordnete Handlungen fehlen."
+            )
+        )
         behavior = record.behavior.model_copy(
             update={
                 "status": status,
                 "sample_count": len(patterns),
                 "high_confidence_sample_count": trusted_actions,
+                "activation_ready": activation_ready,
+                "activation_reason": activation_reason,
                 "patterns": patterns[-_MAX_PATTERNS:],
                 "last_trained_at": now,
                 "reason": reason,
@@ -215,6 +240,17 @@ class BehaviorEngine:
             causal_window_seconds=self._settings.prediction_interval_seconds * 2,
             timezone_name=self._settings.timezone,
         )
+        if prediction is not None:
+            prediction = prediction.model_copy(
+                update={
+                    "execution_reason": self._prediction_execution_reason(
+                        record,
+                        actuator.state,
+                        prediction,
+                        now,
+                    )
+                }
+            )
         behavior = record.behavior.model_copy(
             update={
                 "last_evaluated_at": now,
@@ -231,7 +267,11 @@ class BehaviorEngine:
             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)
+            and self._cooldown_elapsed(
+                behavior,
+                now,
+                prediction.target_state,
+            )
         ):
             domain = actuator_entity_id.split(".", 1)[0]
             service = service_for_state(domain, prediction.target_state)
@@ -260,7 +300,14 @@ class BehaviorEngine:
                 )
                 behavior = behavior.model_copy(
                     update={
-                        "prediction": prediction.model_copy(update={"executed": True}),
+                        "prediction": prediction.model_copy(
+                            update={
+                                "executed": True,
+                                "execution_reason": (
+                                    f"Ausgeführt mit {prediction.confidence:.0%} Sicherheit."
+                                ),
+                            }
+                        ),
                         "last_executed_at": now,
                         "execution_events": [
                             *behavior.execution_events,
@@ -282,8 +329,71 @@ class BehaviorEngine:
                 )
         return self._save_behavior(record, behavior)
 
-    def set_active(self, actuator_entity_id: str, *, active: bool) -> ActuatorRecord:
+    def refresh_related_automations(self, actuator_entity_id: str) -> ActuatorRecord:
         record = self._store.get(actuator_entity_id)
+        related = [
+            RelatedAutomation(
+                entity_id=item.entity_id,
+                config_id=item.config_id,
+                friendly_name=item.friendly_name,
+                enabled=item.enabled,
+            )
+            for item in self._ha_reader.find_automations_for_entity(
+                actuator_entity_id
+            )
+        ]
+        behavior = record.behavior.model_copy(
+            update={"related_automations": related}
+        )
+        return self._save_behavior(record, behavior)
+
+    def set_automation_enabled(
+        self,
+        actuator_entity_id: str,
+        automation_entity_id: str,
+        *,
+        enabled: bool,
+    ) -> ActuatorRecord:
+        record = self.refresh_related_automations(actuator_entity_id)
+        if automation_entity_id not in {
+            item.entity_id for item in record.behavior.related_automations
+        }:
+            raise ValueError(
+                "Die Automation ist diesem Aktor nicht eindeutig zugeordnet."
+            )
+        self._ha_reader.call_service(
+            "automation",
+            "turn_on" if enabled else "turn_off",
+            {"entity_id": automation_entity_id},
+        )
+        related = [
+            item.model_copy(update={"enabled": enabled})
+            if item.entity_id == automation_entity_id
+            else item
+            for item in record.behavior.related_automations
+        ]
+        paused = [
+            entity_id
+            for entity_id in record.behavior.paused_automation_entity_ids
+            if entity_id != automation_entity_id
+        ]
+        behavior = record.behavior.model_copy(
+            update={
+                "related_automations": related,
+                "paused_automation_entity_ids": paused,
+            }
+        )
+        return self._save_behavior(record, behavior)
+
+    def set_active(
+        self,
+        actuator_entity_id: str,
+        *,
+        active: bool,
+        pause_matching_automations: bool = False,
+        restore_paused_automations: bool = False,
+    ) -> ActuatorRecord:
+        record = self.refresh_related_automations(actuator_entity_id)
         now = datetime.now(timezone.utc)
         if active:
             domain = actuator_entity_id.split(".", 1)[0]
@@ -293,30 +403,138 @@ class BehaviorEngine:
                 )
             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 zugeordnete manuelle "
-                    "oder automatisierte Handlungen."
-                )
+            if not record.behavior.activation_ready:
+                raise ValueError(record.behavior.activation_reason)
             mode = BehaviorMode.ACTIVE
             approved_at = now
-            reason = "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
+            behavior = record.behavior.model_copy(
+                update={
+                    "mode": mode,
+                    "approved_at": approved_at,
+                    "reason": (
+                        "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
+                    ),
+                }
+            )
+            record = self._save_behavior(record, behavior)
+            if pause_matching_automations:
+                paused: list[str] = []
+                try:
+                    for automation in record.behavior.related_automations:
+                        if not automation.enabled:
+                            continue
+                        self._ha_reader.call_service(
+                            "automation",
+                            "turn_off",
+                            {"entity_id": automation.entity_id},
+                        )
+                        paused.append(automation.entity_id)
+                except (HaClientError, ValueError):
+                    for entity_id in paused:
+                        try:
+                            self._ha_reader.call_service(
+                                "automation",
+                                "turn_on",
+                                {"entity_id": entity_id},
+                            )
+                        except (HaClientError, ValueError):
+                            logger.exception(
+                                "Failed to restore automation %s after handoff error",
+                                entity_id,
+                            )
+                    rollback = record.behavior.model_copy(
+                        update={
+                            "mode": BehaviorMode.SHADOW,
+                            "approved_at": None,
+                            "reason": (
+                                "Übernahme fehlgeschlagen; SillyHome bleibt im "
+                                "Shadow-Modus."
+                            ),
+                        }
+                    )
+                    self._save_behavior(record, rollback)
+                    raise
+                related = [
+                    automation.model_copy(update={"enabled": False})
+                    if automation.entity_id in paused
+                    else automation
+                    for automation in record.behavior.related_automations
+                ]
+                behavior = record.behavior.model_copy(
+                    update={
+                        "related_automations": related,
+                        "paused_automation_entity_ids": paused,
+                        "reason": (
+                            "SillyHome steuert aktiv; passende HA-Automationen "
+                            "wurden pausiert."
+                        ),
+                    }
+                )
+                return self._save_behavior(record, behavior)
+            return record
         else:
+            if restore_paused_automations:
+                for entity_id in record.behavior.paused_automation_entity_ids:
+                    self._ha_reader.call_service(
+                        "automation",
+                        "turn_on",
+                        {"entity_id": entity_id},
+                    )
             mode = BehaviorMode.SHADOW
             approved_at = None
-            reason = "Shadow-Modus aktiv; Vorhersagen werden nicht ausgeführt."
+            reason = (
+                "Shadow-Modus aktiv; pausierte HA-Automationen wurden fortgesetzt."
+                if restore_paused_automations
+                else "Shadow-Modus aktiv; Vorhersagen werden nicht ausgeführt."
+            )
         behavior = record.behavior.model_copy(
             update={
                 "mode": mode,
                 "approved_at": approved_at,
+                "related_automations": [
+                    automation.model_copy(update={"enabled": True})
+                    if (
+                        restore_paused_automations
+                        and automation.entity_id
+                        in record.behavior.paused_automation_entity_ids
+                    )
+                    else automation
+                    for automation in record.behavior.related_automations
+                ],
+                "paused_automation_entity_ids": (
+                    []
+                    if restore_paused_automations
+                    else record.behavior.paused_automation_entity_ids
+                ),
                 "reason": reason,
             }
         )
         return self._save_behavior(record, behavior)
 
+    def _prediction_execution_reason(
+        self,
+        record: ActuatorRecord,
+        current_state: str | None,
+        prediction: BehaviorPrediction,
+        now: datetime,
+    ) -> str:
+        if record.behavior.mode is not BehaviorMode.ACTIVE:
+            return "Nicht ausgeführt: SillyHome ist im Shadow-Modus."
+        if prediction.confidence < self._settings.prediction_confidence:
+            return (
+                "Nicht ausgeführt: Sicherheit liegt unter der "
+                f"Schaltschwelle von {self._settings.prediction_confidence:.0%}."
+            )
+        if current_state == prediction.target_state:
+            return "Nicht ausgeführt: Zielzustand ist bereits erreicht."
+        if not self._cooldown_elapsed(
+            record.behavior,
+            now,
+            prediction.target_state,
+        ):
+            return "Nicht ausgeführt: Sicherheits-Cooldown ist noch aktiv."
+        return "Ausführung ist freigegeben."
+
     def _build_patterns(
         self,
         *,
@@ -362,10 +580,20 @@ class BehaviorEngine:
             )
         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 _cooldown_elapsed(
+        self,
+        behavior: BehaviorState,
+        now: datetime,
+        target_state: str,
+    ) -> bool:
+        if behavior.last_executed_at is None:
+            return True
+        last_event = behavior.execution_events[-1] if behavior.execution_events else None
+        if last_event is not None and last_event.target_state != target_state:
+            return True
+        return (now - behavior.last_executed_at) >= timedelta(
+            seconds=self._settings.execution_cooldown_seconds
+        )
 
     def _save_behavior(
         self,

app/ha/client.py

@@ -107,6 +107,18 @@ class HaClient:
             )
         return payload
 
+    def get_automation_config(self, automation_id: str) -> dict[str, object]:
+        if not automation_id or len(automation_id) > 120:
+            raise ValueError("Ungültige Automation-ID.")
+        payload = self._get_json(
+            f"/api/config/automation/config/{quote(automation_id, safe='')}"
+        )
+        if not isinstance(payload, dict):
+            raise HaUnexpectedPayloadError(
+                "Automation-Konfiguration hat ein unerwartetes Format."
+            )
+        return payload
+
     def call_service(
         self,
         domain: str,

app/ha/models.py

@@ -26,3 +26,10 @@ class HaEntitySummary(BaseModel):
     area_name: str | None = None
     device_id: str | None = None
     device_name: str | None = None
+
+
+class HaAutomationSummary(BaseModel):
+    entity_id: str
+    config_id: str
+    friendly_name: str
+    enabled: bool

app/ha/reader.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
+from threading import RLock
 from typing import Any
 import logging
 
@@ -17,7 +18,7 @@ from app.ha.history import (
     normalize_logbook_payload,
     normalize_state_history_payload,
 )
-from app.ha.models import HaEntitySummary
+from app.ha.models import HaAutomationSummary, HaEntitySummary
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +26,11 @@ logger = logging.getLogger(__name__)
 class HaReader:
     def __init__(self, client: HaClient) -> None:
         self._client = client
+        self._automation_cache: list[
+            tuple[HaAutomationSummary, dict[str, object]]
+        ] = []
+        self._automation_cache_at: datetime | None = None
+        self._automation_cache_lock = RLock()
 
     def read_entities(self) -> Sequence[HaEntitySummary]:
         entities = self._client.list_entities()
@@ -112,6 +118,79 @@ class HaReader:
     ) -> Sequence[object]:
         return self._client.call_service(domain, service, service_data)
 
+    def find_automations_for_entity(
+        self,
+        entity_id: str,
+    ) -> list[HaAutomationSummary]:
+        current_states = {
+            raw_entity_id: item.get("state") == "on"
+            for item in self._client.list_entities()
+            if isinstance((raw_entity_id := item.get("entity_id")), str)
+            and raw_entity_id.startswith("automation.")
+        }
+        matches = [
+            summary.model_copy(
+                update={
+                    "enabled": current_states.get(
+                        summary.entity_id,
+                        summary.enabled,
+                    )
+                }
+            )
+            for summary, config in self._read_automation_configs()
+            if _contains_exact_value(config, entity_id)
+        ]
+        return sorted(matches, key=lambda item: item.entity_id)
+
+    def _read_automation_configs(
+        self,
+    ) -> list[tuple[HaAutomationSummary, dict[str, object]]]:
+        now = datetime.now(timezone.utc)
+        with self._automation_cache_lock:
+            if (
+                self._automation_cache_at is not None
+                and now - self._automation_cache_at < timedelta(minutes=10)
+            ):
+                return list(self._automation_cache)
+            configs: list[tuple[HaAutomationSummary, dict[str, object]]] = []
+            for item in self._client.list_entities():
+                raw_entity_id = item.get("entity_id")
+                if not isinstance(raw_entity_id, str) or not raw_entity_id.startswith(
+                    "automation."
+                ):
+                    continue
+                attributes = item.get("attributes")
+                if not isinstance(attributes, dict):
+                    continue
+                config_id = attributes.get("id")
+                if not isinstance(config_id, str) or not config_id:
+                    continue
+                try:
+                    config = self._client.get_automation_config(config_id)
+                except (HaClientError, ValueError) as exc:
+                    logger.warning(
+                        "Automation config unavailable for %s: %s",
+                        raw_entity_id,
+                        exc,
+                    )
+                    continue
+                configs.append(
+                    (
+                        HaAutomationSummary(
+                            entity_id=raw_entity_id,
+                            config_id=config_id,
+                            friendly_name=str(
+                                attributes.get("friendly_name") or raw_entity_id
+                            ),
+                            enabled=item.get("state") == "on",
+                        ),
+                        config,
+                    )
+                )
+            self._automation_cache = configs
+            self._automation_cache_at = now
+            return list(configs)
+
 
 def _optional_str(value: object) -> str | None:
     if value is None or value == "":
@@ -127,3 +206,13 @@ def _optional_datetime(value: object) -> datetime | None:
     except ValueError:
         return None
     return parsed if parsed.tzinfo is not None else None
+
+
+def _contains_exact_value(value: object, expected: str) -> bool:
+    if value == expected:
+        return True
+    if isinstance(value, dict):
+        return any(_contains_exact_value(item, expected) for item in value.values())
+    if isinstance(value, list):
+        return any(_contains_exact_value(item, expected) for item in value)
+    return False

app/main.py

@@ -77,7 +77,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
     title="SillyHome Next API",
     description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.5.2",
+    version="0.7.0",
     lifespan=lifespan,
 )
 app.state.settings = load_settings()
@@ -97,7 +97,10 @@ def health() -> dict[str, str]:
 
 @app.get("/")
 def root() -> FileResponse:
-    return FileResponse(STATIC_DIR / "index.html")
+    return FileResponse(
+        STATIC_DIR / "index.html",
+        headers={"Cache-Control": "no-store, max-age=0"},
+    )
 
 
 async def _periodic_reconciliation(app: FastAPI) -> None:

app/static/index.html

@@ -21,7 +21,7 @@
     .warn { color: #f3c969; }
     .bad { color: #ff8f8f; }
     label { display: block; margin: 9px 0 4px; color: #b9c9d6; }
-    select,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; }
+    select,input,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; }
     button { margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
     button.secondary { background: #37495c; }
     button.danger { background: #7b3434; }
@@ -77,8 +77,9 @@
   <section>
     <h2>1. Gerät zum Lernen auswählen</h2>
     <p class="muted">Wähle eine Lampe, einen Rollladen oder einen anderen unterstützten Aktor. Du wählst keine Sensoren und erstellst keine Regeln.</p>
-    <label for="actuator-select">Gerät aus Home Assistant</label>
-    <select id="actuator-select"></select>
+    <label for="actuator-input">Entitätsname oder Gerät aus Home Assistant</label>
+    <input id="actuator-input" list="actuator-options" placeholder="z. B. light.licht_abstellraum" autocomplete="off">
+    <datalist id="actuator-options"></datalist>
     <button onclick="configureActuator()">Gerät hinzufügen und Beobachtung starten</button>
     <p id="actuator-config-result" class="muted">Noch kein Aktor ausgewählt.</p>
   </section>
@@ -163,7 +164,7 @@ async function loadOverview() {
 }
 
 async function loadActuatorDiscovery() {
-  const select = document.getElementById("actuator-select");
+  const options = document.getElementById("actuator-options");
   try {
     const [available, configured] = await Promise.all([
       api("v1/actuators/discovery"),
@@ -171,16 +172,16 @@ async function loadActuatorDiscovery() {
     ]);
     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>";
+    options.innerHTML = 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("");
   } catch (error) {
-    select.innerHTML = `<option value="">${escapeHtml(error.message)}</option>`;
+    options.innerHTML = "";
   }
 }
 
 async function configureActuator() {
-  const actuatorId = document.getElementById("actuator-select").value;
+  const actuatorId = document.getElementById("actuator-input").value.trim();
   const result = document.getElementById("actuator-config-result");
   if (!actuatorId) return;
   result.textContent = "Kontext wird automatisch analysiert ...";
@@ -204,17 +205,23 @@ async function loadConfiguredActuators() {
     const rows = await api("v1/actuators");
     box.innerHTML = rows.length ? `
       <table>
-        <tr><th>Gerät</th><th>Lernstatus</th><th>Gelernte Handlungen</th><th>Letzte Vorhersage</th><th>Aktionen</th></tr>
+        <tr><th>Gerät</th><th>Lernstatus</th><th>Freigabe</th><th>Gelernte Handlungen</th><th>Letzte Vorhersage</th><th>Aktionen</th></tr>
         ${rows.map(record => `
           <tr>
             <td>${escapeHtml(record.actuator_entity_id)}</td>
             <td class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</td>
+            <td class="${record.behavior.activation_ready ? "ok" : "warn"}">${escapeHtml(record.behavior.activation_ready ? "bereit" : record.behavior.activation_reason)}</td>
             <td>${record.behavior.sample_count}</td>
             <td>${record.behavior.prediction
               ? `${escapeHtml(record.behavior.prediction.target_state)} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
               : "-"}</td>
             <td>
               <button onclick="showActuator('${escapeHtml(record.actuator_entity_id)}')">Details</button>
+              ${record.behavior.mode === "active"
+                ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, true)">Stoppen + HA-Automationen fortsetzen</button>`
+                : record.behavior.activation_ready
+                  ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true, true, false)">SillyHome übernehmen lassen</button>`
+                  : ""}
               <button class="danger" onclick="removeActuator('${escapeHtml(record.actuator_entity_id)}')">Entfernen</button>
             </td>
           </tr>
@@ -229,7 +236,12 @@ async function showActuator(actuatorId, evaluationMessage = "") {
   currentActuatorId = actuatorId;
   const box = document.getElementById("actuator-detail");
   try {
-    const record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
+    let record;
+    try {
+      record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}/related-automations/refresh`, {method: "POST"});
+    } catch (_) {
+      record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
+    }
     const contexts = [
       record.assignment.selected_numeric_entity_id,
       ...record.assignment.selected_context_entity_ids,
@@ -239,21 +251,26 @@ async function showActuator(actuatorId, evaluationMessage = "") {
       .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 requiredTrustedActions = 3;
     const learnedAutomationActions = record.behavior.patterns.filter(
       pattern => pattern.source === "automation",
     ).length;
-    const missingTrustedActions = Math.max(
-      0,
-      requiredTrustedActions - record.behavior.high_confidence_sample_count,
-    );
+    const relatedAutomations = record.behavior.related_automations || [];
     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" && missingTrustedActions === 0
-        ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true)">Lernen und Schalten freigeben</button>`
-        : record.behavior.status === "trained"
-          ? `<p class='muted'>Freigabe noch gesperrt: ${missingTrustedActions} eindeutig zugeordnete manuelle oder automatisierte Handlung${missingTrustedActions === 1 ? "" : "en"} fehlen.</p>`
-          : "<p class='muted'>Freigabe wird möglich, sobald genügend Handlungen gelernt wurden.</p>";
+      ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, true)">SillyHome stoppen und pausierte HA-Automationen fortsetzen</button>
+         <button class="secondary" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false, false, false)">SillyHome stoppen; HA-Automationen pausiert lassen</button>`
+      : record.behavior.activation_ready
+        ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true, true, false)">SillyHome übernehmen lassen und passende HA-Automationen pausieren</button>
+           <button class="secondary" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true, false, false)">SillyHome parallel aktivieren</button>`
+        : `<p class='warn'>${escapeHtml(record.behavior.activation_reason)}</p>`;
+    const automationControls = relatedAutomations.length
+      ? `<ul>${relatedAutomations.map(automation => `
+          <li>
+            <strong>${escapeHtml(automation.friendly_name)}</strong>
+            <code>${escapeHtml(automation.entity_id)}</code>:
+            <span class="${automation.enabled ? "ok" : "warn"}">${automation.enabled ? "aktiv" : "pausiert"}</span>
+            <button class="secondary" onclick="setRelatedAutomation('${escapeHtml(record.actuator_entity_id)}', '${escapeHtml(automation.entity_id)}', ${automation.enabled ? "false" : "true"})">${automation.enabled ? "Pausieren" : "Fortsetzen"}</button>
+          </li>`).join("")}</ul>`
+      : "<p class='muted'>Keine eindeutig passende HA-Automation gefunden.</p>";
     box.innerHTML = `
       <div class="grid-two">
         <div>
@@ -272,6 +289,7 @@ async function showActuator(actuatorId, evaluationMessage = "") {
           <p><strong>Davon erkannte HA-Automationen:</strong> ${learnedAutomationActions}</p>
           <p><strong>Letztes Training:</strong> ${escapeHtml(record.behavior.last_trained_at || "noch nicht")}</p>
           <p><strong>Was noch passiert:</strong> ${escapeHtml(record.behavior.reason)}</p>
+          <p><strong>Freigabestatus:</strong> <span class="${record.behavior.activation_ready ? "ok" : "warn"}">${escapeHtml(record.behavior.activation_reason)}</span></p>
           ${activationButton}
           <button class="secondary" onclick="evaluateActuator('${escapeHtml(record.actuator_entity_id)}')">Aktuelle Situation auswerten</button>
           <p class="muted">Die Prüfung simuliert keinen Sensorwechsel und schaltet keinen Aktor.</p>
@@ -280,8 +298,11 @@ async function showActuator(actuatorId, evaluationMessage = "") {
       </div>
       <h3>Was SillyHome aktuell vorhersagt</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><strong>${escapeHtml(prediction.target_state)}</strong> mit ${Math.round(prediction.confidence * 100)} % Sicherheit. ${escapeHtml(prediction.reason)} <span class="${prediction.executed ? "ok" : "muted"}">${escapeHtml(prediction.execution_reason)}</span></p>`
         : "<p class='muted'>Aktuell ist kein gelerntes Handlungsmuster fällig.</p>"}
+      <h3>Passende Home-Assistant-Automationen</h3>
+      <p class="muted">Bei einer Übernahme pausiert SillyHome diese Automationen. Beim Stoppen können sie gezielt fortgesetzt werden.</p>
+      ${automationControls}
       <h3>Welche Zusammenhänge automatisch verwendet werden</h3>
       ${evidence ? `<ul>${evidence}</ul>` : "<p class='warn'>Noch kein geeigneter Kontext erkannt. SillyHome prüft bei neuen HA-Daten erneut.</p>"}
     `;
@@ -309,15 +330,41 @@ async function evaluateActuator(actuatorId) {
   }
 }
 
-async function setActivation(actuatorId, active) {
+async function setActivation(actuatorId, active, pauseMatchingAutomations, restorePausedAutomations) {
   const question = active
-    ? `${actuatorId} wirklich für autonomes Lernen und Schalten freigeben?`
-    : `${actuatorId} wieder in den Shadow-Modus setzen?`;
+    ? pauseMatchingAutomations
+      ? `${actuatorId}: SillyHome aktivieren und passende HA-Automationen pausieren?`
+      : `${actuatorId}: SillyHome parallel zu den HA-Automationen aktivieren?`
+    : restorePausedAutomations
+      ? `${actuatorId}: SillyHome stoppen und pausierte HA-Automationen fortsetzen?`
+      : `${actuatorId}: SillyHome stoppen und HA-Automationen pausiert lassen?`;
   if (!confirm(question)) return;
   try {
     await api(`v1/actuators/${encodeURIComponent(actuatorId)}/activation`, {
       method: "POST",
-      body: JSON.stringify({active}),
+      body: JSON.stringify({
+        active,
+        pause_matching_automations: pauseMatchingAutomations,
+        restore_paused_automations: restorePausedAutomations,
+      }),
+    });
+    await loadConfiguredActuators();
+    await showActuator(actuatorId);
+  } catch (error) {
+    alert(error.message);
+  }
+}
+
+async function setRelatedAutomation(actuatorId, automationEntityId, enabled) {
+  const action = enabled ? "fortsetzen" : "pausieren";
+  if (!confirm(`${automationEntityId} wirklich ${action}?`)) return;
+  try {
+    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/related-automations/control`, {
+      method: "POST",
+      body: JSON.stringify({
+        automation_entity_id: automationEntityId,
+        enabled,
+      }),
     });
     await loadConfiguredActuators();
     await showActuator(actuatorId);