From 809b9e3a980a102815ee945fb76b96a60ade7325 Mon Sep 17 00:00:00 2001
From: slemeur91 <sylvain.le.meur@orange.fr>
Date: Thu, 1 Oct 2026 19:12:57 +0200
Subject: [PATCH] evolutions

CoverAutomatic 2.0.0 - Major release consolidating all changes since 1.61.1

New features
- French language added alongside English and German (panel, card, services, logs, entities, built-in scenarios).
- Rules: Home Assistant conditions (form or YAML), condition groups with NOT, scenarios per rule, dawn/dusk conditions, outdoor vs room temperature, room occupancy, safety rule, rule duplication.
- Covers: keep position when the window opens, learned travel time, automatic resume when the position matches the rule, resend of lost commands.
- Settings: wind protection position, thresholds driven by entities, configurable sun-on-facade behaviour, temperature colour choice.
- Dashboard card, per-cover sensors and global entities (wind protection, paused/manual/locked counters).
- Log filter per cover.

Improvements
- Reorganised cover sheet and settings, clearer rule editor, safety badge in scenarios, better mobile layout, lighter live updates.

Fixes
- Window lock keeps priority over wind and survives restarts; unknown window sensors never lower a cover.
- False manual pauses removed.
- Complete export and validated import of backups.
- Many stability fixes after three full code audits; 1325 automated tests.
---
 CHANGELOG.md                                  |   57 +
 README.md                                     |   44 +-
 custom_components/cover_automatic/__init__.py |  103 +-
 custom_components/cover_automatic/api.py      |  505 +-
 .../cover_automatic/binary_sensor.py          |   62 +
 custom_components/cover_automatic/const.py    |    8 +-
 .../cover_automatic/coordinator.py            | 2059 +++++-
 custom_components/cover_automatic/engine.py   | 1031 ++-
 custom_components/cover_automatic/entities.py |   81 +
 .../cover_automatic/ha_condition.py           |  218 +
 custom_components/cover_automatic/i18n.py     |  124 +
 .../cover_automatic/manifest.json             |   20 +-
 custom_components/cover_automatic/models.py   |  361 +-
 .../panel/cover-automatic-card.js             |  656 ++
 .../panel/cover-automatic-panel.js            | 5938 +++++++++++++++--
 custom_components/cover_automatic/select.py   |   22 +-
 custom_components/cover_automatic/sensor.py   |  325 +-
 custom_components/cover_automatic/services.py |  100 +-
 .../cover_automatic/services.yaml             |   24 -
 custom_components/cover_automatic/storage.py  | 1048 ++-
 .../cover_automatic/strings.json              |  120 +-
 custom_components/cover_automatic/sun.py      |  138 +-
 custom_components/cover_automatic/switch.py   |   23 +-
 .../cover_automatic/translations/de.json      |  120 +-
 .../cover_automatic/translations/en.json      |  120 +-
 .../cover_automatic/translations/fr.json      |  174 +
 tests/test_api.py                             |   44 +-
 tests/test_condition_groups.py                |  197 +
 tests/test_coordinator.py                     |   59 +-
 tests/test_dawn_dusk.py                       |   92 +
 tests/test_engine.py                          |    3 +
 tests/test_ha_condition.py                    |  299 +
 tests/test_i18n.py                            |  197 +
 tests/test_integration.py                     |    9 +
 tests/test_lock_hold.py                       |   76 +
 tests/test_models.py                          |   12 +-
 tests/test_regressions.py                     |  524 ++
 tests/test_rule_scenarios.py                  |  158 +
 tests/test_services.py                        |   34 +-
 tests/test_storage.py                         |   73 +-
 tests/test_sun.py                             |  130 +
 tests/test_sun_comfort_switches.py            |  378 ++
 tests/test_travel.py                          |  308 +
 43 files changed, 14560 insertions(+), 1514 deletions(-)
 create mode 100644 custom_components/cover_automatic/binary_sensor.py
 create mode 100644 custom_components/cover_automatic/entities.py
 create mode 100644 custom_components/cover_automatic/ha_condition.py
 create mode 100644 custom_components/cover_automatic/i18n.py
 create mode 100644 custom_components/cover_automatic/panel/cover-automatic-card.js
 create mode 100644 custom_components/cover_automatic/translations/fr.json
 create mode 100644 tests/test_condition_groups.py
 create mode 100644 tests/test_dawn_dusk.py
 create mode 100644 tests/test_ha_condition.py
 create mode 100644 tests/test_i18n.py
 create mode 100644 tests/test_lock_hold.py
 create mode 100644 tests/test_regressions.py
 create mode 100644 tests/test_rule_scenarios.py
 create mode 100644 tests/test_sun_comfort_switches.py
 create mode 100644 tests/test_travel.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b7cff87..66b9582 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+<<<<<<< Updated upstream
 ## [1.62.1] - 2026-10-01
 
 ### Fixed
@@ -23,6 +24,62 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 ### Fixed
 
 - Reloading the integration failed with "RuntimeError: Added route will never be executed" followed by "has already been setup!" errors for the switch, sensor and select platforms, leaving the entities unavailable until a Home Assistant restart. The panel's static path is now registered once per Home Assistant runtime instead of on every entry setup ([#3](https://github.com/crandler/CoverAutomatic/issues/3)).
+=======
+## [2.0.0] - 2026-10-01
+
+Major release consolidating all changes since 1.61.1.
+
+### Added
+
+**French language**
+- French added alongside English and German throughout the integration: configuration panel, dashboard card, services and error messages, activity log and HA logbook, entities, facade devices, weather states and built-in scenarios (Everyday → Quotidien…). Follows the Home Assistant language, with French typography (narrow no-break space before ":"). The three languages share the same set of texts.
+
+**Rules**
+- **Home Assistant conditions**: any automation condition (state, numeric state, template, zone, sun…), edited with a form or in YAML and validated live.
+- **Condition groups and NOT**: e.g. (A OR B) AND (C OR D). A negated condition is never met while its input is unavailable.
+- **Scenarios per rule**: each rule selects the scenarios it applies in.
+- **Dawn and dusk** conditions with an offset in minutes; sunrise/sunset and dawn/dusk pairs are complementary.
+- **Outdoor air compared to the room** and **Room occupied** conditions, with an occupancy sensor per cover.
+- **Safety rule**: acts even when the cover is paused, in manual mode, wind protected or with automation off. Never overrides the window lock; between rules, priority decides.
+- **Duplicate a rule**; ▲▼ buttons to order conditions, groups and priorities.
+
+**Covers**
+- **Keep current position when the window opens**.
+- **Travel time** entered or learned automatically, with a global default; removes false "manual" pauses on slow covers.
+- **Resume when the position matches the rule** (only pauses caused by a manual move).
+- **Lost commands resent automatically** (radio frame lost), never after a manual counter-order.
+
+**Global settings**
+- Configurable **wind protection position**.
+- **Thresholds driven by an entity** (temperature setpoints, sunshine threshold), with the typed value as fallback.
+- Configurable **"sun on facade" behaviour**, globally and per cover.
+- **Room temperature colours**: by action needed or like a thermometer.
+
+**Entities and dashboard**
+- **Dashboard card** `custom:cover-automatic-card`: one line per cover; header with scenario, master switch, wind, counters and a "Resume all" button.
+- **Sensors per cover**: active rule, target, position, comfort mode, pause end.
+- **Global entities**: wind protection and number of covers paused / manual / locked.
+
+**Log**
+- **Per-cover filter**, with a button on the cover sheet.
+
+### Changed
+
+- **Cover sheet** reorganised into collapsible sections: General, Window, Room, Sun exposure, Automation.
+- **Settings** reorganised (Sensors, Sun exposure…), with "How does it work?" blocks and options greyed when they have no effect.
+- **Rule editor**: collapsible conditions, draft kept, warning before losing unsaved changes.
+- **Scenarios tab**: rules listed by priority, disabled rules greyed, **Safety** badge.
+- **Mobile**: cover sheet header reachable under the notch, shorter labels, focus and scroll position kept.
+- Panel live updates through a dedicated WebSocket subscription instead of a bus event written to the recorder.
+
+### Fixed
+
+- **Window and wind**: the lock (window open) keeps priority over the wind during the whole storm; lock / wind state survives a restart; an unknown window sensor never lowers the cover; a removed sensor no longer blocks the cover forever.
+- **False manual pauses removed**: slow covers, rule change during a move, window closed while the cover moves to the lock position.
+- **Backups**: complete export; validated import (out-of-range values, unknown references, migrations); runtime state no longer restored from the file.
+- Reloading the integration no longer fails; HA deprecation warning fixed; calculation cycles can no longer interleave; an unreadable rule is disabled instead of applying everywhere.
+- Three full code audits; 1325 automated tests.
+>>>>>>> Stashed changes
 
 ## [1.61.1] - 2026-08-18
 
diff --git a/README.md b/README.md
index cd87880..31544a1 100644
--- a/README.md
+++ b/README.md
@@ -166,8 +166,13 @@ After installation, all configuration is done via the **CoverAutomatic** sidebar
 
 1. **Covers** - Add cover entities to manage
 2. **Facades** - Define building facades by cardinal direction (with compass visualization)
+<<<<<<< Updated upstream
 3. **Rules** - Create automation rules with conditions (sun, temperature, time, weather, etc.); duplicate an existing rule to use it as a starting point
 4. **Scenarios** - Define modes like "Summer", "Winter", "Vacation" to disable specific rules
+=======
+3. **Rules** - Create automation rules with conditions (sun, temperature, time, weather, etc.). Conditions can be negated (NOT) and organised in groups, e.g. (A OR B) AND (C OR D)
+4. **Scenarios** - Define modes like "Summer", "Winter", "Vacation". Each rule chooses the scenarios it belongs to (all by default); inside a scenario a member rule can still be switched off temporarily
+>>>>>>> Stashed changes
 5. **Settings** - Configure sensors, comfort temperatures, wind protection, and more
 
 ### Example: heat protection by outdoor temperature
@@ -188,6 +193,34 @@ The rule closes the cover only while the sun actually hits that facade **and**
 the outdoor temperature is above the threshold, and releases it again once
 either condition clears.
 
+### Conditions on any entity (Home Assistant conditions)
+
+The **Entities** group of the *Add condition* menu adds a condition evaluated
+by Home Assistant itself, in the same format as the `condition:` section of an
+automation:
+
+- **Entity state** / **Entity numeric value** open a form: pick the entity,
+  optionally an attribute, then the states (proposed as buttons, e.g. the zones
+  of a person), *is / is not*, a minimum duration, or above / below / between.
+- **Home Assistant condition (YAML)** accepts any automation condition —
+  templates, zones, devices, nested `and` / `or` / `not`:
+
+```yaml
+condition: or
+conditions:
+  - condition: state
+    entity_id: media_player.living_room
+    state: [playing, paused]
+  - condition: template
+    value_template: "{{ states('sensor.lux') | float(0) > 20000 }}"
+```
+
+Each card has a **Form / YAML** switch, is checked by Home Assistant while you
+type and shows the entities it watches (rules react to them immediately). An
+invalid or incomplete condition is kept but never matches and is marked in red.
+Existing "State is" / "Numeric value" conditions keep working and can be
+converted with one click.
+
 ### Created Entities
 
 For each managed cover, the integration creates:
@@ -201,8 +234,15 @@ For each facade:
 | Entity | Description |
 |--------|-------------|
 | `sensor.*_sun` | Sun on facade indicator (on/off) |
+<<<<<<< Updated upstream
 | `sensor.*_sun_entry` | Time when sun enters facade today (real sun path at your location) |
 | `sensor.*_sun_exit` | Time when sun leaves facade today |
+=======
+| `sensor.*_sun_entry` | Time when sun enters facade (today, computed from the real solar path of your location) |
+| `sensor.*_sun_exit` | Time when sun leaves facade |
+>>>>>>> Stashed changes
+
+Entities are created and removed automatically when covers or facades are added or deleted in the panel -- no reload needed.
 
 Global:
 - `select.cover_automatic_scenario` - Active scenario selector
@@ -235,13 +275,15 @@ By design. After startup, CoverAutomatic waits **120 seconds** before applying a
 
 CoverAutomatic detected a **manual override**: the cover was moved by something other than CoverAutomatic itself — a wall switch, a remote, another automation, or the HA UI. Automation for that cover pauses for the configured pause duration (global or per-cover) so your manual choice is respected, then resumes automatically. Resume earlier via the **X** button in the panel or the `cover_automatic.resume` service.
 
+For slow covers that report neither intermediate positions nor *opening* / *closing*, the integration waits for the cover's **travel time** (measured automatically, or set per cover under *Advanced → Travel time*) before judging a position as manual. If a slow cover is still paused wrongly right after an automatic move, set its travel time a little above the real one.
+
 ### A rule matches but the cover doesn't move
 
 Check in this order:
 
 1. **Status priority** — WIND_PROTECTED, LOCKED (window open), VENTING (window tilted) and PAUSED all override rule evaluation. The covers table in the panel shows the current status and the winning rule per cover.
 2. **Master switch / per-cover automation toggle** — both must be on.
-3. **Active scenario** — scenarios can disable specific rules.
+3. **Active scenario** — only rules that belong to the active scenario (and are not switched off in it) are considered.
 4. **Minimum time between changes** — position changes are rate-limited by the configured interval; the move happens on a later scan.
 
 ### A sun rule doesn't shade
diff --git a/custom_components/cover_automatic/__init__.py b/custom_components/cover_automatic/__init__.py
index 49d8748..6de9c25 100644
--- a/custom_components/cover_automatic/__init__.py
+++ b/custom_components/cover_automatic/__init__.py
@@ -5,7 +5,11 @@
 import pathlib
 from dataclasses import dataclass
 
-from homeassistant.components.frontend import async_register_built_in_panel, async_remove_panel
+from homeassistant.components.frontend import (
+    add_extra_js_url,
+    async_register_built_in_panel,
+    async_remove_panel,
+)
 from homeassistant.components.http import StaticPathConfig
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
@@ -18,6 +22,7 @@
 from .api import async_setup_api
 from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
 from .coordinator import CoverAutomaticCoordinator
+from .entities import async_cleanup_orphan_entities
 from .services import async_setup_services, async_unload_services
 from .storage import ActivityLogStorage, CoverAutomaticStorage
 
@@ -35,6 +40,7 @@ class CoverAutomaticRuntimeData:
 type CoverAutomaticConfigEntry = ConfigEntry[CoverAutomaticRuntimeData]
 
 PLATFORMS_LIST: list[Platform] = [
+    Platform.BINARY_SENSOR,
     Platform.SWITCH,
     Platform.SENSOR,
     Platform.SELECT,
@@ -42,6 +48,48 @@ class CoverAutomaticRuntimeData:
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
+PANEL_JS_URL = "/cover_automatic/panel.js"
+# Dashboard card, loaded on every frontend page (custom:cover-automatic-card)
+CARD_JS_URL = "/cover_automatic/cover-automatic-card.js"
+# hass.data[DOMAIN] flag: static panel route already registered this HA run
+_STATIC_PATH_REGISTERED = "static_path_registered"
+
+
+async def _async_register_card_resource(hass: HomeAssistant, url: str) -> bool:
+    """Declare the dashboard card as a Lovelace resource (storage mode).
+
+    Lovelace resources are loaded with the dashboards, so the card is
+    defined when they are built (the extra module URL could arrive too late
+    and the card then showed "Configuration error" until a refresh). The
+    entry is updated when the version changes. Returns False when the
+    resources cannot be managed (YAML mode, Lovelace not loaded).
+    """
+    try:
+        from homeassistant.components.lovelace.const import LOVELACE_DATA
+        from homeassistant.components.lovelace.resources import ResourceStorageCollection
+    except ImportError:
+        return False
+    data = hass.data.get(LOVELACE_DATA)
+    resources = getattr(data, "resources", None)
+    if not isinstance(resources, ResourceStorageCollection):
+        return False
+    try:
+        if not resources.loaded:
+            await resources.async_load()
+            resources.loaded = True
+        base = url.split("?", 1)[0]
+        for item in resources.async_items():
+            if str(item.get("url", "")).split("?", 1)[0] != base:
+                continue
+            if item.get("url") != url or item.get("type") != "module":
+                await resources.async_update_item(item["id"], {"res_type": "module", "url": url})
+            return True
+        await resources.async_create_item({"res_type": "module", "url": url})
+    except Exception as err:  # noqa: BLE001 -- never block the integration setup
+        _LOGGER.warning("Could not register the dashboard card resource: %s", err)
+        return False
+    return True
+
 
 def _cleanup_removed_entities(hass: HomeAssistant) -> None:
     """Remove orphan entities from prior versions (pre-1.52.0: per-cover pause_duration)."""
@@ -85,6 +133,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: CoverAutomaticConfigEntr
     await log_storage.async_load()
 
     _cleanup_removed_entities(hass)
+    # Entities of covers/facades deleted while HA was running an older
+    # version (or deleted before a restart) are dropped here.
+    async_cleanup_orphan_entities(hass, entry, storage)
 
     async def async_options_updated(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
         """Handle options update by reloading entry to recreate entities."""
@@ -137,8 +188,31 @@ async def async_options_updated(hass: HomeAssistant, config_entry: ConfigEntry)
     # Setup WebSocket API for config panel
     async_setup_api(hass, storage, coordinator, version=panel_version)
 
+<<<<<<< Updated upstream
     # Register custom panel (version query for cache busting); the static path
     # behind js_url is registered once in async_setup
+=======
+    # Register custom panel (version query for cache busting). aiohttp routes
+    # cannot be removed, and registering the same GET route twice raises
+    # RuntimeError -- so the static path is registered once per HA run and
+    # survives config entry reloads.
+    domain_data: dict = hass.data.setdefault(DOMAIN, {})
+    panel_dir = pathlib.Path(__file__).parent / "panel"
+    panel_stamp = await _async_asset_stamp(hass, panel_dir / "cover-automatic-panel.js")
+    if not domain_data.get(_STATIC_PATH_REGISTERED):
+        await hass.http.async_register_static_paths(
+            [
+                StaticPathConfig(PANEL_JS_URL, str(panel_dir / "cover-automatic-panel.js"), False),
+                StaticPathConfig(CARD_JS_URL, str(panel_dir / "cover-automatic-card.js"), False),
+            ]
+        )
+        domain_data[_STATIC_PATH_REGISTERED] = True
+        card_stamp = await _async_asset_stamp(hass, panel_dir / "cover-automatic-card.js")
+        card_url = f"{CARD_JS_URL}?v={panel_version}{card_stamp}"
+        if not await _async_register_card_resource(hass, card_url):
+            # YAML resources / no Lovelace: load the card with every page.
+            add_extra_js_url(hass, card_url)
+>>>>>>> Stashed changes
     async_register_built_in_panel(
         hass,
         component_name="custom",
@@ -146,20 +220,43 @@ async def async_options_updated(hass: HomeAssistant, config_entry: ConfigEntry)
         sidebar_icon="mdi:blinds",
         frontend_url_path="cover-automatic",
         require_admin=True,
+        # update=True: a failed unload can leave the panel registered; a
+        # later setup must replace it instead of raising "Overwriting panel".
+        update=True,
         config={
             "_panel_custom": {
                 "name": "cover-automatic-panel",
-                "js_url": f"/cover_automatic/panel.js?v={panel_version}",
+                "js_url": f"{PANEL_JS_URL}?v={panel_version}{panel_stamp}",
                 "embed_iframe": False,
             }
         },
     )
 
-    entry.async_on_unload(coordinator.async_shutdown)
+    # coordinator.async_shutdown is registered on unload by
+    # DataUpdateCoordinator itself (config_entry is passed to it).
 
     return True
 
 
+async def _async_asset_stamp(hass: HomeAssistant, path: pathlib.Path) -> str:
+    """Modification time of a bundled asset, for cache busting.
+
+    The version alone is not enough: files updated without a version bump
+    would keep being served from the browser cache. Read in the executor
+    (stat is file I/O); "" when unavailable, the version is then used alone.
+    """
+    try:
+        mtime = await hass.async_add_executor_job(_asset_mtime, path)
+    except (OSError, TypeError):
+        return ""
+    return f"-{mtime}" if isinstance(mtime, int) else ""
+
+
+def _asset_mtime(path: pathlib.Path) -> int:
+    """Integer mtime of a file (executor)."""
+    return int(path.stat().st_mtime)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: CoverAutomaticConfigEntry) -> bool:
     """Unload a config entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS_LIST)
diff --git a/custom_components/cover_automatic/api.py b/custom_components/cover_automatic/api.py
index 4a67507..991eace 100644
--- a/custom_components/cover_automatic/api.py
+++ b/custom_components/cover_automatic/api.py
@@ -4,14 +4,31 @@
 import copy
 import logging
 import re
+import unicodedata
 from typing import TYPE_CHECKING, Any
 
 import voluptuous as vol
 from homeassistant.components import websocket_api
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import callback
 from homeassistant.helpers import config_validation as cv
-
-from .const import DOMAIN, FACADE_PRESETS
-from .models import Condition, CoverConfig, Facade, Rule, Scenario
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+from .const import DOMAIN, FACADE_PRESETS, SIGNAL_DATA_UPDATED
+from . import ha_condition as hac
+from .models import (
+    MAX_CONDITION_GROUPS,
+    Condition,
+    ConditionType,
+    CoverConfig,
+    Facade,
+    Rule,
+    Scenario,
+    finite_float,
+    finite_range,
+    optional_entity_id,
+)
+from .storage import SETTING_VALIDATORS, settings_cross_error
 
 # Integration version shown in the panel. Set once by async_setup_api() from
 # the cached integration manifest -- reading manifest.json here would be a
@@ -32,8 +49,13 @@
     "lock_sensor", "lock_position", "vent_sensor", "vent_position",
     "inverted", "supports_tilt", "lock_tilt_position", "vent_tilt_position",
     "inverted_tilt", "indoor_temp_sensor", "comfort_temp_min", "comfort_temp_max",
-    "preemptive_shading",
+    "preemptive_shading", "lock_hold_position",
     "min_position_change", "min_time_between_changes",
+    "travel_time", "measured_travel_time",
+    "comfort_temp_min_entity", "comfort_temp_max_entity",
+    "sun_heating_ignore", "sun_neutral_ignore",
+    "occupancy_sensor", "occupancy_states",
+    "pause_resume_on_match",
 )
 
 # Settings fields that can be updated via WS API
@@ -50,6 +72,11 @@
     "command_stagger",
     "solar_sensor", "solar_threshold", "solar_hysteresis",
     "logbook_enabled", "update_check_enabled",
+    "default_travel_time",
+    "wind_position",
+    "comfort_temp_min_entity", "comfort_temp_max_entity", "solar_threshold_entity",
+    "sun_heating_ignore", "sun_neutral_ignore", "preemptive_shading",
+    "temp_color_thermometer", "pause_resume_on_match",
 )
 
 # Umlaut replacement map
@@ -73,6 +100,10 @@ def _sanitize_id(name: str) -> str:
     result = name
     for char, replacement in _UMLAUT_MAP.items():
         result = result.replace(char, replacement)
+    # Other accents (é, è, à, ç…) become their base letter: "Météo" -> "meteo"
+    result = "".join(
+        c for c in unicodedata.normalize("NFKD", result) if not unicodedata.combining(c)
+    )
     result = result.lower()
     result = re.sub(r"[^a-z0-9]", "_", result)
     result = re.sub(r"_+", "_", result)
@@ -80,6 +111,43 @@ def _sanitize_id(name: str) -> str:
     return result or "unnamed"
 
 
+# Optional entity id: None/"" -> None, else "domain.object" (shared validator)
+_optional_entity_id = optional_entity_id
+
+
+def _normalize_azimuth(value: float) -> float:
+    """Compass bearing in [0, 360): any finite number is taken modulo 360.
+
+    As before v1.87, -90 means 270 and 450 means 90; 360 is stored as 0
+    (a facade with start == end covers the full circle).
+    """
+    bearing = value % 360
+    # A tiny negative value rounds up to 360.0; + 0.0 turns -0.0 into 0.0
+    return 0.0 if bearing >= 360 else bearing + 0.0
+
+
+# Facade geometry: any finite bearing, normalised to 0-360 before the range
+# check (360 is stored as 0), sun elevation -90-90
+_AZIMUTH = vol.All(finite_float, _normalize_azimuth, vol.Range(min=0, max=360))
+_ELEVATION = finite_range(-90, 90)
+# Per-cover comfort band (same bounds as the global settings)
+_COVER_COMFORT_TEMP = vol.Any(None, finite_range(-50, 60))
+
+
+def _rule_id_for_name(rule_id: str, name: str, rules: dict[str, Any]) -> str:
+    """Id a rule should have for its name.
+
+    The current id is kept when it already is the sanitized name, or that
+    name plus a numeric uniqueness suffix; otherwise a unique id is derived
+    from the name (ignoring the rule itself).
+    """
+    desired = _sanitize_id(name)
+    if rule_id == desired or re.fullmatch(re.escape(desired) + r"_\d+", rule_id):
+        return rule_id
+    others = {key: value for key, value in rules.items() if key != rule_id}
+    return _unique_id(desired, others)
+
+
 def _unique_id(base_id: str, existing: dict[str, Any]) -> str:
     """Ensure ID is unique by appending a numeric suffix if needed."""
     if base_id not in existing:
@@ -129,6 +197,16 @@ def _build_config_response(
             "solar_hysteresis": storage.solar_hysteresis,
             "logbook_enabled": storage.logbook_enabled,
             "update_check_enabled": storage.update_check_enabled,
+            "default_travel_time": storage.default_travel_time,
+            "wind_position": storage.wind_position,
+            "comfort_temp_min_entity": storage.comfort_temp_min_entity,
+            "comfort_temp_max_entity": storage.comfort_temp_max_entity,
+            "solar_threshold_entity": storage.solar_threshold_entity,
+            "sun_heating_ignore": storage.sun_heating_ignore,
+            "sun_neutral_ignore": storage.sun_neutral_ignore,
+            "preemptive_shading": storage.preemptive_shading,
+            "temp_color_thermometer": storage.temp_color_thermometer,
+            "pause_resume_on_match": storage.pause_resume_on_match,
         },
     }
     if hass:
@@ -139,6 +217,15 @@ def _build_config_response(
             if s.entity_id not in managed
         ]
     if coordinator:
+        # Validation status of native HA conditions: {rule_id: {idx: status}}
+        status: dict[str, dict[str, Any]] = {}
+        engine = getattr(coordinator, "engine", None)
+        if engine is not None:
+            for rule_id, rule in storage.rules.items():
+                for idx, cond in enumerate(rule.conditions):
+                    if cond.type == ConditionType.HA_CONDITION:
+                        status.setdefault(rule_id, {})[str(idx)] = engine.ha_condition_status(cond)
+        result["condition_status"] = status
         result["active_rules"] = coordinator.get_active_rules()
         result["live_covers"] = coordinator.get_live_cover_data()
         result["live_facades"] = coordinator.get_live_facade_data()
@@ -194,10 +281,15 @@ def _parse_conditions(raw: list[dict[str, Any]]) -> tuple[list[Condition], list[
     """Parse condition dicts, collecting errors for invalid ones."""
     conditions: list[Condition] = []
     errors: list[str] = []
+    if not isinstance(raw, list):
+        return conditions, [f"conditions must be a list, got {type(raw).__name__}"]
     for idx, item in enumerate(raw):
+        if not isinstance(item, dict):
+            errors.append(f"Condition {idx}: must be a dict, got {type(item).__name__}")
+            continue
         try:
             conditions.append(Condition.from_dict(item))
-        except (ValueError, KeyError) as err:
+        except (ValueError, KeyError, TypeError) as err:
             errors.append(f"Condition {idx}: {err}")
     return conditions, errors
 
@@ -251,6 +343,18 @@ async def ws_cover_update(
         connection.send_error(msg["id"], "not_found", f"Facade '{msg['facade_id']}' not found")
         return
 
+    # Per-cover comfort band (falls back to the global values when unset)
+    def _eff_comfort(key: str) -> float:
+        value = msg[key] if key in msg else raw.get(key)
+        return value if value is not None else getattr(storage, key)
+
+    if _eff_comfort("comfort_temp_min") >= _eff_comfort("comfort_temp_max"):
+        connection.send_error(
+            msg["id"], "invalid_comfort_range",
+            "comfort_temp_min must be lower than comfort_temp_max",
+        )
+        return
+
     # Track facade change for bidirectional sync
     old_facade_id = raw.get("facade_id")
     # Track auto_enabled change to mirror the switch entity's status transition
@@ -303,6 +407,7 @@ async def ws_cover_add(
     if added:
         await storage.async_save()
     coordinator.refresh_state_tracking()
+    coordinator.async_sync_entities()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
@@ -316,6 +421,7 @@ async def ws_cover_delete(
     """Handle cover_automatic/cover/delete."""
     await storage.async_remove_cover(msg["entity_id"])
     coordinator.refresh_state_tracking()
+    coordinator.async_sync_entities()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
@@ -349,6 +455,7 @@ async def ws_facade_add(
     await storage.async_add_facade(facade, save=False)
     _sync_cover_facade_ids(storage, facade_id, new_cover_ids)
     await storage.async_save()
+    coordinator.async_sync_entities()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
@@ -386,6 +493,11 @@ async def ws_facade_update(
     # Sync cover.facade_id with facade.cover_ids
     _sync_cover_facade_ids(storage, facade_id, new_cover_ids)
     await storage.async_save()
+    # Like the other updates: a new azimuth/elevation or name must take
+    # effect now, not at the next periodic refresh.
+    coordinator.refresh_state_tracking()
+    coordinator.async_sync_entities()
+    await coordinator.async_request_refresh()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
@@ -403,6 +515,7 @@ async def ws_facade_delete(
         return
 
     await storage.async_remove_facade(facade_id)
+    coordinator.async_sync_entities()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
@@ -426,19 +539,40 @@ async def ws_rule_add(
         connection.send_error(msg["id"], "not_found", _unknown_refs_msg(unknown_f, unknown_c))
         return
 
+    # New rules belong to every scenario unless told otherwise.
+    scenario_ids = list(msg.get("scenario_ids", list(storage.scenarios.keys())))
+    unknown_s = _missing_ids(scenario_ids, storage.scenarios)
+    if unknown_s:
+        connection.send_error(msg["id"], "not_found", f"Unknown scenarios: {', '.join(unknown_s)}")
+        return
+
     rule = Rule(
         id=_unique_id(_sanitize_id(name), storage.rules),
         name=name,
         enabled=msg.get("enabled", True),
         priority=msg.get("priority", 10),
         condition_operator=msg.get("condition_operator", "and"),
+        # Without explicit groups the operator applies inside the single group.
+        group_operators=list(msg.get("group_operators") or [msg.get("condition_operator", "and")]),
         facade_ids=msg.get("facade_ids", []),
         cover_ids=msg.get("cover_ids", []),
         conditions=conditions,
         target_position=msg.get("target_position", 0),
         target_tilt_position=msg.get("target_tilt_position"),
+        scenario_ids=scenario_ids,
+        safety=bool(msg.get("safety", False)),
     )
-    await storage.async_add_rule(rule)
+    if "priority" in msg:
+        await storage.async_add_rule(rule)
+    else:
+        # A new rule goes to the bottom of the list with its own priority
+        # (a shared default priority made its place depend on the id).
+        order = storage.rule_order()
+        await storage.async_add_rule(rule, save=False)
+        storage.renumber_priorities([*order, rule.id])
+        await storage.async_save()
+    await _async_prepare_ha_conditions(coordinator)
+    coordinator.refresh_state_tracking()
     await coordinator.async_request_refresh()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
@@ -471,9 +605,35 @@ async def ws_rule_update(
         connection.send_error(msg["id"], "not_found", _unknown_refs_msg(unknown_f, unknown_c))
         return
 
+    group_operators = existing.effective_group_operators()
+    if "group_operators" in msg:
+        group_operators = list(msg["group_operators"]) or ["and"]
+    elif "condition_operator" in msg and len(existing.condition_groups()) <= 1:
+        # Legacy clients: the operator of a single-group rule is its group's.
+        group_operators = [msg["condition_operator"], *group_operators[1:]]
+
+    scenario_ids = existing.scenario_ids
+    if "scenario_ids" in msg:
+        scenario_ids = list(msg["scenario_ids"])
+        unknown_s = _missing_ids(scenario_ids, storage.scenarios)
+        if unknown_s:
+            connection.send_error(msg["id"], "not_found", f"Unknown scenarios: {', '.join(unknown_s)}")
+            return
+
+    # The id follows a new name (only when the name actually changed: an
+    # unchanged name keeps whatever id the rule has); references move with it
+    name = msg.get("name", existing.name)
+    new_id = rule_id
+    if name != existing.name:
+        new_id = _rule_id_for_name(rule_id, name, storage.rules)
+    if new_id != rule_id:
+        await storage.async_rename_rule(rule_id, new_id, save=False)
+        coordinator.rename_rule_references(rule_id, new_id)
+        _LOGGER.info("Rule '%s' renamed: id %s -> %s", name, rule_id, new_id)
+
     updated = Rule(
-        id=rule_id,
-        name=msg.get("name", existing.name),
+        id=new_id,
+        name=name,
         enabled=msg.get("enabled", existing.enabled),
         priority=msg.get("priority", existing.priority),
         condition_operator=msg.get("condition_operator", existing.condition_operator),
@@ -482,10 +642,18 @@ async def ws_rule_update(
         conditions=conditions,
         target_position=msg.get("target_position", existing.target_position),
         target_tilt_position=msg.get("target_tilt_position", existing.target_tilt_position),
+        scenario_ids=scenario_ids,
+        group_operators=group_operators,
+        safety=bool(msg.get("safety", existing.safety)),
     )
     await storage.async_add_rule(updated)
+    await _async_prepare_ha_conditions(coordinator)
+    coordinator.refresh_state_tracking()
     await coordinator.async_request_refresh()
-    connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
+    response = _build_config_response(storage, hass, coordinator)
+    if new_id != rule_id:
+        response["renamed_rule"] = {"from": rule_id, "to": new_id}
+    connection.send_result(msg["id"], response)
 
 
 async def ws_rule_delete(
@@ -502,6 +670,7 @@ async def ws_rule_delete(
         return
 
     await storage.async_remove_rule(rule_id)
+    coordinator.refresh_state_tracking()
     await coordinator.async_request_refresh()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
@@ -563,7 +732,7 @@ async def ws_rule_reorder(
     Array position determines priority: first = highest priority.
     Top of the list wins over bottom.
     """
-    rule_ids: list[str] = msg["rule_ids"]
+    rule_ids: list[str] = list(dict.fromkeys(msg["rule_ids"]))  # drop duplicates
     rules_data = storage._data.get("rules", {})
 
     unknown = _missing_ids(rule_ids, rules_data)
@@ -573,9 +742,10 @@ async def ws_rule_reorder(
         )
         return
 
-    total = len(rule_ids)
-    for idx, rid in enumerate(rule_ids):
-        rules_data[rid]["priority"] = (total - idx) * 10
+    # Rules missing from a partial list keep their relative order below the
+    # given ones, so no two rules end up sharing a priority.
+    rest = [rid for rid in storage.rule_order() if rid not in rule_ids]
+    storage.renumber_priorities([*rule_ids, *rest])
 
     storage._invalidate_cache()
     await storage.async_save()
@@ -583,6 +753,53 @@ async def ws_rule_reorder(
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
+# Rule names: shown in entity states (max 255 chars), keep them readable
+RULE_NAME_MAX = 100
+_RULE_NAME = vol.All(str, vol.Length(min=1, max=RULE_NAME_MAX))
+
+
+def _copy_name(base: str, rules: dict[str, Any]) -> str:
+    """base, or base plus " 2", " 3"... when a rule already has that name."""
+    taken = {getattr(rule, "name", None) for rule in rules.values()}
+    if base not in taken:
+        return base
+    counter = 2
+    while f"{base} {counter}" in taken:
+        counter += 1
+    return f"{base} {counter}"
+
+
+async def ws_rule_duplicate(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+    storage: CoverAutomaticStorage,
+    coordinator: CoverAutomaticCoordinator,
+) -> None:
+    """Handle cover_automatic/rule/duplicate.
+
+    The copy is placed right below the original and created active: with the
+    same conditions it never wins over the original until it is edited.
+    """
+    rule_id = msg["rule_id"]
+    original = storage.rules.get(rule_id)
+    if original is None:
+        connection.send_error(msg["id"], "not_found", f"Rule '{rule_id}' not found")
+        return
+    base = (msg.get("name") or "").strip() or f"{original.name} - copy"
+    # Leave room for a " 99" uniqueness suffix within the name limit
+    base = base[: RULE_NAME_MAX - 3].rstrip()
+    name = _copy_name(base, storage.rules)
+    new_id = _unique_id(_sanitize_id(name) or f"{rule_id}_copy", storage.rules)
+    await storage.async_duplicate_rule(rule_id, new_id, name)
+    await _async_prepare_ha_conditions(coordinator)
+    coordinator.refresh_state_tracking()
+    await coordinator.async_request_refresh()
+    response = _build_config_response(storage, hass, coordinator)
+    response["new_rule_id"] = new_id
+    connection.send_result(msg["id"], response)
+
+
 async def ws_rule_preview_conditions(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
@@ -600,10 +817,80 @@ async def ws_rule_preview_conditions(
     if errors:
         connection.send_error(msg["id"], "invalid_conditions", "; ".join(errors))
         return
+    await _async_prepare_ha_conditions(coordinator, conditions)
     results = [coordinator.engine.preview_condition(c) for c in conditions]
     connection.send_result(msg["id"], {"results": results})
 
 
+async def _async_prepare_ha_conditions(
+    coordinator: CoverAutomaticCoordinator, conditions: list[Condition] | None = None
+) -> None:
+    """Compile native HA conditions so their status/preview is current."""
+    engine = getattr(coordinator, "engine", None)
+    prepare = getattr(engine, "async_prepare_ha_conditions", None)
+    if prepare is None:
+        return
+    try:
+        await prepare(conditions)
+    except TypeError:
+        pass  # mocked engine in tests
+
+
+async def ws_condition_validate(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+    storage: CoverAutomaticStorage,
+    coordinator: CoverAutomaticCoordinator,
+) -> None:
+    """Handle cover_automatic/condition/validate.
+
+    Validates a native Home Assistant condition given as YAML text or as a
+    config dict (read-only, nothing is stored). Returns the parsed config, a
+    YAML rendering of it, the referenced entities (and those that do not
+    exist), the validation error if any, and whether it is met right now.
+    """
+    yaml_error = None
+    if "yaml" in msg:
+        text = msg["yaml"]
+        config, yaml_error = hac.parse_yaml(text)
+    else:
+        config = msg.get("config")
+        text = hac.dump_yaml(config) if isinstance(config, dict) else ""
+
+    response: dict[str, Any] = {
+        "valid": False,
+        "config": config,
+        "yaml": text,
+        "error": None,
+        "error_code": None,
+        "error_line": None,
+        "error_column": None,
+        "entities": [],
+        "unknown_entities": [],
+        "matched": None,
+    }
+    if yaml_error:
+        response.update(
+            error=yaml_error["detail"], error_code=yaml_error["code"],
+            error_line=yaml_error["line"], error_column=yaml_error["column"],
+        )
+        connection.send_result(msg["id"], response)
+        return
+
+    compiled = await hac.async_compile(hass, config)
+    entities = sorted(compiled.entities)
+    response.update(
+        valid=compiled.valid,
+        error=compiled.error,
+        error_code=compiled.error_code,
+        entities=entities,
+        unknown_entities=[e for e in entities if hass.states.get(e) is None],
+        matched=hac.evaluate(hass, compiled) if compiled.valid else None,
+    )
+    connection.send_result(msg["id"], response)
+
+
 async def ws_scenario_add(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
@@ -695,18 +982,46 @@ async def ws_settings_update(
     """Handle cover_automatic/settings/update."""
     # Validate ALL fields up front so a single rejection does not leave the
     # in-memory state half-updated while disk still has the old values.
-    if "active_scenario" in msg and msg["active_scenario"]:
-        if msg["active_scenario"] not in storage._data.get("scenarios", {}):
+    if "active_scenario" in msg:
+        # An empty or unknown id is rejected (it would otherwise be stored)
+        if not msg["active_scenario"] or msg["active_scenario"] not in storage._data.get("scenarios", {}):
             connection.send_error(
                 msg["id"], "not_found", f"Scenario '{msg['active_scenario']}' not found"
             )
             return
 
+    # Cross-field checks against the resulting values (new or existing).
+    def _effective(key: str) -> Any:
+        return msg[key] if key in msg else getattr(storage, key)
+
+    # Comfort band (invalid_comfort_range), wind and solar deadbands
+    # (invalid_wind_hysteresis, invalid_solar_hysteresis): shared with import.
+    # Only the checks touching a field actually sent: an inconsistent pair
+    # stored by an older version must not block saving anything else.
+    cross_error = settings_cross_error(_effective, msg.keys())
+    if cross_error:
+        connection.send_error(msg["id"], *cross_error)
+        return
+
+    old_rotation = storage.house_rotation
+
     # All validations passed -- now apply atomically.
     for key in _SETTINGS_FIELDS:
         if key in msg:
             setattr(storage, key, msg[key])
 
+    # Facade azimuths are stored as real compass bearings with the house
+    # rotation already applied. Rotating the house must therefore rotate the
+    # existing facades too, or they keep pointing at the old orientation.
+    rotation_delta = storage.house_rotation - old_rotation
+    if rotation_delta:
+        for facade_raw in storage._data.get("facades", {}).values():
+            for az_key in ("azimuth_start", "azimuth_end"):
+                facade_raw[az_key] = round(
+                    (float(facade_raw.get(az_key, 0.0)) + rotation_delta) % 360, 2
+                )
+        storage._invalidate_cache()
+
     await storage.async_save()
     coordinator.refresh_state_tracking()
     await coordinator.async_request_refresh()
@@ -745,6 +1060,7 @@ async def ws_get_log(
         event_type=msg.get("event_type"),
         entity_id=msg.get("entity_id"),
         limit=msg.get("limit", 500),
+        include_global=msg.get("include_global", False),
     )
     connection.send_result(msg["id"], {"entries": entries})
 
@@ -770,7 +1086,7 @@ async def ws_export_config(
     coordinator: CoverAutomaticCoordinator,
 ) -> None:
     """Handle cover_automatic/export -- return raw config as JSON."""
-    connection.send_result(msg["id"], {"data": storage.get_raw_data()})
+    connection.send_result(msg["id"], {"data": storage.get_export_data()})
 
 
 _MAX_IMPORT_ENTRIES = 1000
@@ -798,11 +1114,39 @@ async def ws_import_config(
     except (ValueError, TypeError) as err:
         connection.send_error(msg["id"], "invalid_data", str(err))
         return
+    # Let the coordinator drop runtime state that no longer matches the
+    # imported configuration (removed covers, wind protection...).
+    reconcile = getattr(coordinator, "reconcile_after_import", None)
+    if callable(reconcile):
+        reconcile()
     coordinator.refresh_state_tracking()
+    coordinator.async_sync_entities()
     await coordinator.async_request_refresh()
     connection.send_result(msg["id"], _build_config_response(storage, hass, coordinator))
 
 
+@callback
+def ws_subscribe_updates(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Handle cover_automatic/subscribe -- push a message on every data update.
+
+    Uses a dispatcher signal (not a bus event) so updates are not written to
+    the recorder database, and the subscription survives entry reloads.
+    """
+
+    @callback
+    def _forward() -> None:
+        connection.send_message(websocket_api.event_message(msg["id"], {}))
+
+    connection.subscriptions[msg["id"]] = async_dispatcher_connect(
+        hass, SIGNAL_DATA_UPDATED, _forward
+    )
+    connection.send_result(msg["id"])
+
+
 # ---------------------------------------------------------------------------
 # Registration
 # ---------------------------------------------------------------------------
@@ -836,22 +1180,35 @@ def async_setup_api(
                 vol.Optional("name"): str,
                 vol.Optional("facade_id"): vol.Any(str, None),
                 vol.Optional("auto_enabled"): bool,
-                vol.Optional("pause_duration"): vol.Any(vol.All(int, vol.Range(min=0, max=480)), None),
-                vol.Optional("lock_sensor"): vol.Any(str, None),
+                # None follows the global pause duration
+                vol.Optional("pause_duration"): vol.Any(vol.All(int, vol.Range(min=1, max=480)), None),
+                vol.Optional("lock_sensor"): _optional_entity_id,
                 vol.Optional("lock_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
-                vol.Optional("vent_sensor"): vol.Any(str, None),
+                vol.Optional("vent_sensor"): _optional_entity_id,
                 vol.Optional("vent_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
                 vol.Optional("inverted"): bool,
                 vol.Optional("supports_tilt"): bool,
-                vol.Optional("lock_tilt_position"): vol.Any(int, None),
-                vol.Optional("vent_tilt_position"): vol.Any(int, None),
+                vol.Optional("lock_tilt_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
+                vol.Optional("vent_tilt_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
                 vol.Optional("inverted_tilt"): bool,
-                vol.Optional("indoor_temp_sensor"): vol.Any(str, None),
-                vol.Optional("comfort_temp_min"): vol.Any(vol.Coerce(float), None),
-                vol.Optional("comfort_temp_max"): vol.Any(vol.Coerce(float), None),
-                vol.Optional("preemptive_shading"): bool,
+                vol.Optional("indoor_temp_sensor"): _optional_entity_id,
+                vol.Optional("comfort_temp_min"): _COVER_COMFORT_TEMP,
+                vol.Optional("comfort_temp_max"): _COVER_COMFORT_TEMP,
+                # Tri-state: None follows the global setting
+                vol.Optional("preemptive_shading"): vol.Any(bool, None),
+                vol.Optional("sun_heating_ignore"): vol.Any(bool, None),
+                vol.Optional("pause_resume_on_match"): vol.Any(bool, None),
+                vol.Optional("sun_neutral_ignore"): vol.Any(bool, None),
+                vol.Optional("lock_hold_position"): bool,
                 vol.Optional("min_position_change"): vol.Any(vol.All(int, vol.Range(min=1, max=50)), None),
                 vol.Optional("min_time_between_changes"): vol.Any(vol.All(int, vol.Range(min=60, max=3600)), None),
+                vol.Optional("travel_time"): vol.Any(vol.All(int, vol.Range(min=1, max=300)), None),
+                # Only reset is allowed: the measured value is learned by the coordinator
+                vol.Optional("measured_travel_time"): None,
+                vol.Optional("comfort_temp_min_entity"): _optional_entity_id,
+                vol.Optional("comfort_temp_max_entity"): _optional_entity_id,
+                vol.Optional("occupancy_sensor"): _optional_entity_id,
+                vol.Optional("occupancy_states"): vol.Any(None, vol.All(str, vol.Length(max=200))),
             },
         ),
         (
@@ -874,9 +1231,9 @@ def async_setup_api(
             {
                 vol.Required("name"): str,
                 vol.Optional("direction", default="south"): str,
-                vol.Optional("azimuth_start"): vol.Coerce(float),
-                vol.Optional("azimuth_end"): vol.Coerce(float),
-                vol.Optional("min_elevation"): vol.Coerce(float),
+                vol.Optional("azimuth_start"): _AZIMUTH,
+                vol.Optional("azimuth_end"): _AZIMUTH,
+                vol.Optional("min_elevation"): _ELEVATION,
                 vol.Optional("cover_ids"): [str],
             },
         ),
@@ -887,9 +1244,9 @@ def async_setup_api(
                 vol.Required("facade_id"): str,
                 vol.Optional("name"): str,
                 vol.Optional("direction"): str,
-                vol.Optional("azimuth_start"): vol.Coerce(float),
-                vol.Optional("azimuth_end"): vol.Coerce(float),
-                vol.Optional("min_elevation"): vol.Coerce(float),
+                vol.Optional("azimuth_start"): _AZIMUTH,
+                vol.Optional("azimuth_end"): _AZIMUTH,
+                vol.Optional("min_elevation"): _ELEVATION,
                 vol.Optional("cover_ids"): [str],
             },
         ),
@@ -904,15 +1261,20 @@ def async_setup_api(
             f"{DOMAIN}/rule/add",
             ws_rule_add,
             {
-                vol.Required("name"): str,
+                vol.Required("name"): _RULE_NAME,
                 vol.Optional("enabled"): bool,
                 vol.Optional("priority"): int,
-                vol.Optional("condition_operator"): str,
+                vol.Optional("condition_operator"): vol.In(["and", "or"]),
+                vol.Optional("group_operators"): vol.All(
+                    [vol.In(["and", "or"])], vol.Length(max=MAX_CONDITION_GROUPS)
+                ),
                 vol.Optional("facade_ids"): [str],
                 vol.Optional("cover_ids"): [str],
                 vol.Optional("conditions"): list,
-                vol.Optional("target_position"): int,
-                vol.Optional("target_tilt_position"): vol.Any(int, None),
+                vol.Optional("target_position"): vol.All(int, vol.Range(min=0, max=100)),
+                vol.Optional("target_tilt_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
+                vol.Optional("scenario_ids"): [str],
+                vol.Optional("safety"): bool,
             },
         ),
         (
@@ -920,15 +1282,20 @@ def async_setup_api(
             ws_rule_update,
             {
                 vol.Required("rule_id"): str,
-                vol.Optional("name"): str,
+                vol.Optional("name"): _RULE_NAME,
                 vol.Optional("enabled"): bool,
                 vol.Optional("priority"): int,
-                vol.Optional("condition_operator"): str,
+                vol.Optional("condition_operator"): vol.In(["and", "or"]),
+                vol.Optional("group_operators"): vol.All(
+                    [vol.In(["and", "or"])], vol.Length(max=MAX_CONDITION_GROUPS)
+                ),
                 vol.Optional("facade_ids"): [str],
                 vol.Optional("cover_ids"): [str],
                 vol.Optional("conditions"): list,
-                vol.Optional("target_position"): int,
-                vol.Optional("target_tilt_position"): vol.Any(int, None),
+                vol.Optional("target_position"): vol.All(int, vol.Range(min=0, max=100)),
+                vol.Optional("target_tilt_position"): vol.Any(vol.All(int, vol.Range(min=0, max=100)), None),
+                vol.Optional("scenario_ids"): [str],
+                vol.Optional("safety"): bool,
             },
         ),
         (
@@ -943,7 +1310,11 @@ def async_setup_api(
             ws_rule_duplicate,
             {
                 vol.Required("rule_id"): str,
+<<<<<<< Updated upstream
                 vol.Optional("name"): str,
+=======
+                vol.Optional("name"): vol.All(str, vol.Length(max=200)),  # truncated below
+>>>>>>> Stashed changes
             },
         ),
         (
@@ -960,6 +1331,14 @@ def async_setup_api(
                 vol.Optional("conditions"): list,
             },
         ),
+        (
+            f"{DOMAIN}/condition/validate",
+            ws_condition_validate,
+            {
+                vol.Exclusive("yaml", "source"): str,
+                vol.Exclusive("config", "source"): vol.Any(dict, None),
+            },
+        ),
         (
             f"{DOMAIN}/scenario/add",
             ws_scenario_add,
@@ -991,33 +1370,9 @@ def async_setup_api(
             f"{DOMAIN}/settings/update",
             ws_settings_update,
             {
-                vol.Optional("enabled"): bool,
-                vol.Optional("outdoor_temp_sensor"): vol.Any(str, None),
-                vol.Optional("indoor_temp_sensor"): vol.Any(str, None),
-                vol.Optional("weather_entity"): vol.Any(str, None),
-                vol.Optional("comfort_temp_min"): vol.Coerce(float),
-                vol.Optional("comfort_temp_max"): vol.Coerce(float),
-                vol.Optional("comfort_hysteresis"): vol.All(vol.Coerce(float), vol.Range(min=0.1, max=5.0)),
-                vol.Optional("threshold_hysteresis"): vol.All(vol.Coerce(float), vol.Range(min=0, max=5.0)),
-                vol.Optional("pause_duration"): vol.All(vol.Coerce(int), vol.Range(min=1, max=480)),
-                vol.Optional("lock_position"): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
-                vol.Optional("vent_position"): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
-                vol.Optional("lock_tilt_position"): vol.Any(vol.All(vol.Coerce(int), vol.Range(min=0, max=100)), None),
-                vol.Optional("vent_tilt_position"): vol.Any(vol.All(vol.Coerce(int), vol.Range(min=0, max=100)), None),
-                vol.Optional("min_position_change"): vol.All(vol.Coerce(int), vol.Range(min=1, max=50)),
-                vol.Optional("min_time_between_changes"): vol.All(vol.Coerce(int), vol.Range(min=60, max=3600)),
-                vol.Optional("house_rotation"): vol.All(vol.Coerce(float), vol.Range(min=-180, max=180)),
+                # Same bounds as the import (storage.SETTING_VALIDATORS)
+                **{vol.Optional(key): validator for key, validator in SETTING_VALIDATORS.items()},
                 vol.Optional("active_scenario"): str,
-                vol.Optional("workday_sensor"): vol.Any(str, None),
-                vol.Optional("wind_sensor"): vol.Any(str, None),
-                vol.Optional("wind_speed_threshold"): vol.All(vol.Coerce(float), vol.Range(min=0)),
-                vol.Optional("wind_speed_hysteresis"): vol.All(vol.Coerce(float), vol.Range(min=0)),
-                vol.Optional("command_stagger"): vol.All(vol.Coerce(float), vol.Range(min=0, max=2.0)),
-                vol.Optional("solar_sensor"): vol.Any(str, None),
-                vol.Optional("solar_threshold"): vol.All(vol.Coerce(float), vol.Range(min=0)),
-                vol.Optional("solar_hysteresis"): vol.All(vol.Coerce(float), vol.Range(min=0)),
-                vol.Optional("logbook_enabled"): bool,
-                vol.Optional("update_check_enabled"): bool,
             },
         ),
         (
@@ -1033,6 +1388,7 @@ def async_setup_api(
             {
                 vol.Optional("event_type"): str,
                 vol.Optional("entity_id"): str,
+                vol.Optional("include_global"): bool,
                 vol.Optional("limit"): vol.All(int, vol.Range(min=1, max=2000)),
             },
         ),
@@ -1070,6 +1426,16 @@ async def _handler(
                 connection: websocket_api.ActiveConnection,
                 msg: dict[str, Any],
             ) -> None:
+                # After the entry was unloaded (and not set up again, which
+                # re-registers these commands) the bound storage/coordinator
+                # are dead: refuse instead of mutating and saving them.
+                entry = getattr(coordinator, "config_entry", None)
+                state = getattr(entry, "state", None)
+                if isinstance(state, ConfigEntryState) and state is not ConfigEntryState.LOADED:
+                    connection.send_error(
+                        msg["id"], "not_loaded", "CoverAutomatic is not loaded"
+                    )
+                    return
                 await fn(hass, connection, msg, storage, coordinator)
             if ct not in read_only_commands:
                 return websocket_api.require_admin(_handler)
@@ -1081,3 +1447,12 @@ async def _handler(
         websocket_api.async_register_command(
             hass, command_type, _make_handler(handler_fn, command_type), schema
         )
+
+    websocket_api.async_register_command(
+        hass,
+        f"{DOMAIN}/subscribe",
+        ws_subscribe_updates,
+        websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend(
+            {vol.Required("type"): f"{DOMAIN}/subscribe"}
+        ),
+    )
diff --git a/custom_components/cover_automatic/binary_sensor.py b/custom_components/cover_automatic/binary_sensor.py
new file mode 100644
index 0000000..c79113b
--- /dev/null
+++ b/custom_components/cover_automatic/binary_sensor.py
@@ -0,0 +1,62 @@
+"""Binary sensor platform for CoverAutomatic."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from . import i18n
+from .const import DOMAIN
+from .coordinator import CoverAutomaticCoordinator
+
+if TYPE_CHECKING:
+    from homeassistant.core import HomeAssistant
+    from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+    from . import CoverAutomaticConfigEntry
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CoverAutomaticConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up binary sensor entities."""
+    coordinator = entry.runtime_data.coordinator
+    async_add_entities([WindProtectionBinarySensor(coordinator, entry.entry_id)])
+
+
+class WindProtectionBinarySensor(CoordinatorEntity[CoverAutomaticCoordinator], BinarySensorEntity):
+    """On while wind protection drives the covers."""
+
+    _attr_has_entity_name = True
+    _attr_translation_key = "wind_protection"
+    _attr_icon = "mdi:weather-windy"
+
+    def __init__(self, coordinator: CoverAutomaticCoordinator, entry_id: str) -> None:
+        """Initialize the binary sensor."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{DOMAIN}_{entry_id}_wind_protection"
+        self._attr_device_info = {
+            "identifiers": {(DOMAIN, entry_id)},
+            "name": "CoverAutomatic",
+            "manufacturer": "CoverAutomatic",
+            "model": i18n.text(coordinator.hass, "model_controller"),
+        }
+
+    @property
+    def is_on(self) -> bool:
+        """Whether wind protection is active."""
+        return self.coordinator.wind_protected
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Wind speed, threshold and hysteresis."""
+        storage = self.coordinator.storage
+        return {
+            "wind_speed": self.coordinator.get_wind_speed(),
+            "threshold": storage.wind_speed_threshold,
+            "hysteresis": storage.wind_speed_hysteresis,
+            "wind_sensor": storage.wind_sensor,
+        }
diff --git a/custom_components/cover_automatic/const.py b/custom_components/cover_automatic/const.py
index 2c68589..5f1ac3b 100644
--- a/custom_components/cover_automatic/const.py
+++ b/custom_components/cover_automatic/const.py
@@ -19,6 +19,8 @@
 # Tilt / slat control
 TILT_COMMAND_DELAY: Final = 1.5  # seconds between position and tilt command
 TILT_FEATURE_FLAG: Final = CoverEntityFeature.SET_TILT_POSITION
+# Covers lacking this feature only support open/close commands
+SET_POSITION_FEATURE_FLAG: Final = CoverEntityFeature.SET_POSITION
 
 # Binary sensor on-states for contact sensors
 BINARY_SENSOR_ON_STATES: Final = frozenset({"on", "open", "true", "1"})
@@ -35,5 +37,7 @@
 LOG_EVENT_RULE: Final = "rule"
 LOG_EVENT_WIND: Final = "wind"
 
-# Panel push event (fired when coordinator data changes)
-EVENT_DATA_UPDATED: Final = f"{DOMAIN}_updated"
+# Panel push signal (dispatched when coordinator data changes). A dispatcher
+# signal instead of a bus event: bus events are written to the recorder
+# database, which grew by one row per update cycle.
+SIGNAL_DATA_UPDATED: Final = f"{DOMAIN}_updated"
diff --git a/custom_components/cover_automatic/coordinator.py b/custom_components/cover_automatic/coordinator.py
index 4eeca62..ac93088 100644
--- a/custom_components/cover_automatic/coordinator.py
+++ b/custom_components/cover_automatic/coordinator.py
@@ -4,11 +4,12 @@
 import asyncio
 import logging
 import time as time_mod
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.logbook import async_log_entry
 from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.event import async_track_state_change_event
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
@@ -17,14 +18,16 @@
     BINARY_SENSOR_ON_STATES,
     DEFAULT_SCAN_INTERVAL,
     DOMAIN,
-    EVENT_DATA_UPDATED,
+    SIGNAL_DATA_UPDATED,
     LOG_EVENT_POSITION,
     LOG_EVENT_RULE,
     LOG_EVENT_STATUS,
     LOG_EVENT_WIND,
+    SET_POSITION_FEATURE_FLAG,
     TILT_COMMAND_DELAY,
     TILT_FEATURE_FLAG,
 )
+from . import i18n
 from .engine import RuleEngine
 from .models import CoverConfig, CoverStatus
 from .storage import ActivityLogStorage, CoverAutomaticStorage
@@ -42,13 +45,76 @@
 # Seconds to ignore position changes after our own commands
 SETTLE_TIME = 30
 
+# Margin added to a cover's travel time to get its settle time (seconds)
+TRAVEL_TIME_MARGIN = 5
+
+# Travel time measurement: minimum move (%) and maximum duration (seconds).
+# Short moves of polled covers are dominated by the polling interval (the
+# arrival is only seen at the next poll), which inflated the learned value:
+# only moves of at least half the full travel are used.
+MIN_MEASURED_DISTANCE = 50
+MAX_MEASURED_TRAVEL = 300
+# A new travel sample may exceed the previous measurement by this factor at
+# most (one late poll must not double the settle time).
+MAX_TRAVEL_GROWTH = 1.5
+
+# Resends of a position command the cover did not react to at all (lost
+# radio/cloud command) before it is treated as a manual override.
+MAX_LOST_COMMAND_RETRIES = 2
+
+# Keys written by the coordinator into storage._data (runtime state only,
+# never part of the configuration): wind protection and pre-lock statuses,
+# so protections survive a Home Assistant restart.
+WIND_STATE_KEY = "wind_protected_state"
+PRE_LOCK_STATES_KEY = "pre_lock_states"
+
+_UNUSABLE_STATES = ("unavailable", "unknown")
+
+# Resume on match (manual pause ended when the cover is back at its rule's
+# position): no check during the first seconds of a pause -- a cover moved by
+# hand still reports its start position, which may be the rule's target --
+# and the cover must be still (no report for SETTLE_TIME).
+RESUME_MATCH_GRACE = 60
+
 # Seconds after startup before applying positions (sensor stabilization)
 STARTUP_GRACE_PERIOD = 120
 
 
+def _is_safety(result: Any) -> bool:
+    """Whether an engine result comes from a safety rule."""
+    return result is not None and getattr(result, "safety", False) is True
+
+
 class CoverAutomaticCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Coordinate data updates and rule evaluation."""
 
+    # Runtime helpers created lazily (see their accessors): the class
+    # defaults keep coordinators built without __init__ (tests) working.
+    _wind_tasks: set[asyncio.Task[None]] | None = None
+    _lost_command_retries: dict[str, int] | None = None
+    _apply_lock: asyncio.Lock | None = None
+    _paused_at: dict[str, float] | None = None
+    # Origin of each pause: True = manual override detected, False = explicit
+    # pause (service). Unknown (e.g. restored after a restart) = manual.
+    _pause_manual: dict[str, bool] | None = None
+    # Covers that moved at all since our last position command (even during
+    # the settle time): a lost-command resend is only for covers that did not
+    # react at all -- a user counter-order also ends at the start position.
+    _moved_since_command: set[str] | None = None
+    # Monotonic time of the last position / motion change of each cover
+    # (attribute-only reports such as Zigbee linkquality do not count)
+    _position_changed_at: dict[str, float] | None = None
+    # Covers whose lock sensor entity no longer exists (logged once)
+    _lock_sensor_missing: set[str] | None = None
+    # Covers whose move is blocked by an unknown window state (logged once
+    # per blocking episode)
+    _move_blocked_logged: set[str] | None = None
+    # Wind protection restored from storage, still to be confirmed by the
+    # wind sensor before the end of the startup grace period
+    _wind_restore_pending: bool = False
+    # The wind sensor gave a valid numeric value since startup
+    _wind_value_seen: bool = False
+
     def __init__(
         self,
         hass: HomeAssistant,
@@ -79,17 +145,65 @@ def __init__(
         self._hysteresis_info: dict[str, str | None] = {}
         self._last_matching_rules: dict[str, str | None] = {}
         self._last_move_rule: dict[str, str | None] = {}
+        # Last position actually commanded by the apply cycle (raw, inverted)
+        self._last_sent_target: dict[str, int] = {}
+        # Moves commanded by the apply cycle, for travel time measurement:
+        # entity_id -> (monotonic start, start position, target), raw positions
+        self._move_start: dict[str, tuple[float, int, int]] = {}
         # Covers that just exited a protective status (LOCKED / VENTING) and
         # need to bypass the time hysteresis once -- otherwise a long
         # min_time_between_changes leaves the cover at vent/lock position
         # long after the sensor has cleared.
         self._post_protective_exit: set[str] = set()
+        # Covers currently driven by a safety rule: entity_id -> rule id
+        self._safety_holds: dict[str, str] = {}
+        # Covers whose protective status is kept because a lock/vent sensor
+        # is unavailable (logged once per outage)
+        self._sensor_unknown_kept: set[str] = set()
+        # Wind sensor unavailable while protected (warned once per outage)
+        self._wind_sensor_warned: bool = False
+        # Pending wind command tasks (staggered sends), cancelled when the
+        # wind protection ends or is re-activated and on shutdown
+        self._wind_tasks = set()
+        # Resends of lost position commands per cover (bounded)
+        self._lost_command_retries = {}
+        # Serialises apply cycles: one may sleep during the command stagger
+        self._apply_lock = asyncio.Lock()
+        # Start of each manual pause (monotonic), for the resume-on-match grace
+        self._paused_at = {}
+        self._pause_manual = {}
+        self._moved_since_command = set()
+        self._position_changed_at = {}
+        self._lock_sensor_missing = set()
+        self._move_blocked_logged = set()
+        self._wind_restore_pending = False
+        self._wind_value_seen = False
         self._startup_time: float = time_mod.monotonic()
         self._startup_skip: bool = True
         self._grace_synced: bool = False
         self._unsub_update_listener: Any = None
         self.log_storage: ActivityLogStorage | None = None
 
+    def _runtime_set(self, name: str) -> set[str]:
+        """Per-cover runtime set created lazily (coordinators built without __init__)."""
+        value = getattr(self, name, None)
+        if value is None:
+            value = set()
+            setattr(self, name, value)
+        return value
+
+    def _runtime_dict(self, name: str) -> dict[str, Any]:
+        """Per-cover runtime dict created lazily (see _runtime_set)."""
+        value = getattr(self, name, None)
+        if value is None:
+            value = {}
+            setattr(self, name, value)
+        return value
+
+    def _in_startup_grace(self) -> bool:
+        """Whether the startup grace period (sensor stabilisation) is running."""
+        return (time_mod.monotonic() - self._startup_time) < STARTUP_GRACE_PERIOD
+
     def _cover_val(self, cover_raw: dict[str, Any], key: str) -> Any:
         """Get cover config value with global fallback from storage."""
         val = cover_raw.get(key)
@@ -118,22 +232,54 @@ async def async_setup(self) -> None:
 
     @callback
     def _fire_update_event(self) -> None:
-        """Fire HA event to notify panel of data changes."""
-        self.hass.bus.async_fire(EVENT_DATA_UPDATED)
+        """Notify panel subscriptions (WebSocket) of data changes."""
+        async_dispatcher_send(self.hass, SIGNAL_DATA_UPDATED)
 
     def _restore_cover_states(self) -> None:
         """Restore cover states from persisted storage data.
 
-        Only restores PAUSED (with unexpired timer). All other statuses start
-        as AUTO and get re-derived from sensor states by _sync_cover_statuses.
+        Restores PAUSED (with unexpired timer), the protective statuses
+        LOCKED / VENTING (with their pre-lock status) and, when the wind
+        protection was active and is still configured, WIND_PROTECTED.
+        Everything else starts as AUTO and is re-derived by
+        _sync_cover_statuses.
+
+        The protective statuses must survive a restart: battery sensors
+        (Zigbee) or alarm integrations often report "unknown" for minutes
+        after startup, and an AUTO cover whose window state is unknown would
+        otherwise be closed by the next night rule on an open window. While
+        the sensor stays unknown the sync keeps the restored status; once it
+        reports "closed" the cover is unlocked normally.
         """
-        for entity_id, cover_data in self.storage._data.get("covers", {}).items():
+        data = self.storage._data
+        wind_configured = bool(self.storage.wind_sensor) and self.storage.wind_speed_threshold > 0
+        self._wind_protected = data.get(WIND_STATE_KEY) is True and wind_configured
+        # Confirmed by the wind sensor before the end of the grace period,
+        # otherwise dropped (see _drop_unconfirmed_wind_restore)
+        self._wind_restore_pending = self._wind_protected
+        if self._wind_protected:
+            _LOGGER.info("Startup: wind protection was active, kept until the wind sensor reports")
+        stored_pre_lock = data.get(PRE_LOCK_STATES_KEY)
+        if not isinstance(stored_pre_lock, dict):
+            stored_pre_lock = {}
+        kept = {CoverStatus.LOCKED.value, CoverStatus.VENTING.value}
+        if self._wind_protected:
+            kept.add(CoverStatus.WIND_PROTECTED.value)
+        for entity_id, cover_data in data.get("covers", {}).items():
             stored_status = cover_data.get("status", "auto")
             if stored_status == CoverStatus.PAUSED.value:
                 pause_until = cover_data.get("pause_until")
                 if pause_until and dt_util.now().timestamp() < pause_until:
                     self._cover_states[entity_id] = CoverStatus.PAUSED
                     continue
+            if stored_status in kept:
+                self._cover_states[entity_id] = CoverStatus(stored_status)
+                try:
+                    self._pre_lock_states[entity_id] = CoverStatus(stored_pre_lock.get(entity_id))
+                except ValueError:
+                    pass  # no (or invalid) pre-lock status: unlock falls back to AUTO
+                _LOGGER.debug("[%s] Startup: restored %s", entity_id, stored_status)
+                continue
             # Reset everything else to AUTO (lock/vent re-detected from sensors)
             if stored_status != CoverStatus.AUTO.value:
                 _LOGGER.debug("[%s] Startup: reset %s -> AUTO", entity_id, stored_status)
@@ -142,46 +288,81 @@ def _restore_cover_states(self) -> None:
                 self.storage.update_cover_status(
                     entity_id, CoverStatus.AUTO.value, None
                 )
+        self._persist_runtime_state()
+
+    def _persist_runtime_state(self) -> None:
+        """Write the wind state and the pre-lock statuses into the store.
+
+        Only written (debounced save) when changed. Called after every sync
+        cycle as well, which also rewrites the keys after an import replaced
+        the whole store content.
+        """
+        data = self.storage._data
+        pre_lock = {
+            entity_id: status.value
+            for entity_id, status in self._pre_lock_states.items()
+            if isinstance(status, CoverStatus)
+        }
+        if data.get(WIND_STATE_KEY) is self._wind_protected and data.get(PRE_LOCK_STATES_KEY) == pre_lock:
+            return
+        data[WIND_STATE_KEY] = self._wind_protected
+        data[PRE_LOCK_STATES_KEY] = pre_lock
+        self.storage._schedule_save()
+
+    def _set_wind_protected(self, active: bool) -> None:
+        """Change the global wind protection state and persist it.
+
+        Any real change ends the pending confirmation of a wind state
+        restored at startup (the sensor has spoken, or settings changed).
+        """
+        self._wind_protected = active
+        self._wind_restore_pending = False
+        self._persist_runtime_state()
 
     async def _async_setup_default_scenarios(self) -> None:
-        """Create default scenarios if none exist."""
+        """Create default scenarios (named in the HA language) if none exist.
+
+        Existing default scenarios whose name was never changed (still one of
+        the built-in names in any language) are renamed to the current HA
+        language, so an English-named "Everyday" becomes "Quotidien" on a
+        French installation. User-chosen names are left untouched.
+        """
+        from .models import Scenario
+
+        icons = {
+            "everyday": "mdi:home",
+            "summer": "mdi:white-balance-sunny",
+            "winter": "mdi:snowflake",
+            "vacation": "mdi:airplane",
+            "cinema": "mdi:movie",
+            "manual": "mdi:hand-back-right",
+        }
         if not self.storage.scenarios:
-            from .models import Scenario
-
-            defaults = [
-                Scenario(
-                    id="everyday",
-                    name="Everyday",
-                    icon="mdi:home",
-                ),
-                Scenario(
-                    id="summer",
-                    name="Summer",
-                    icon="mdi:white-balance-sunny",
-                ),
-                Scenario(
-                    id="winter",
-                    name="Winter",
-                    icon="mdi:snowflake",
-                ),
-                Scenario(
-                    id="vacation",
-                    name="Vacation",
-                    icon="mdi:airplane",
-                ),
-                Scenario(
-                    id="cinema",
-                    name="Cinema",
-                    icon="mdi:movie",
-                ),
-                Scenario(
-                    id="manual",
-                    name="Manual",
-                    icon="mdi:hand-back-right",
-                ),
-            ]
-            for scenario in defaults:
-                await self.storage.async_add_scenario(scenario)
+            for scenario_id in i18n.DEFAULT_SCENARIO_IDS:
+                await self.storage.async_add_scenario(
+                    Scenario(
+                        id=scenario_id,
+                        name=i18n.text(self.hass, f"scenario_{scenario_id}"),
+                        icon=icons[scenario_id],
+                    ),
+                    save=False,
+                )
+            await self.storage.async_save()
+            return
+
+        renamed = False
+        for scenario_id in i18n.DEFAULT_SCENARIO_IDS:
+            raw = self.storage._data.get("scenarios", {}).get(scenario_id)
+            if not isinstance(raw, dict):
+                continue
+            localized = i18n.text(self.hass, f"scenario_{scenario_id}")
+            name = raw.get("name")
+            if name != localized and name in i18n.default_scenario_names(scenario_id):
+                raw["name"] = localized
+                renamed = True
+        if renamed:
+            self.storage._invalidate_cache()
+            await self.storage.async_save()
 
     def _setup_state_tracking(self, full_refresh: bool = False) -> None:
         """Set up state change tracking for relevant entities.
@@ -209,15 +390,37 @@ def _setup_state_tracking(self, full_refresh: bool = False) -> None:
                 self._hysteresis_info,
                 self._last_matching_rules,
                 self._last_move_rule,
+                self._last_sent_target,
+                self._move_start,
+                self._safety_holds,
             ):
                 orphaned = set(state_dict.keys()) - current_covers
                 for entity_id in orphaned:
                     value = state_dict.pop(entity_id)
                     if isinstance(value, asyncio.Task) and not value.done():
                         value.cancel()
+            if self._lost_command_retries:
+                for entity_id in set(self._lost_command_retries) - current_covers:
+                    self._lost_command_retries.pop(entity_id, None)
+            if self._paused_at:
+                for entity_id in set(self._paused_at) - current_covers:
+                    self._paused_at.pop(entity_id, None)
+            for name in ("_pause_manual", "_position_changed_at"):
+                mapping = self._runtime_dict(name)
+                for entity_id in set(mapping) - current_covers:
+                    mapping.pop(entity_id, None)
+            for name in ("_moved_since_command", "_lock_sensor_missing", "_move_blocked_logged"):
+                entries = self._runtime_set(name)
+                entries -= set(entries) - current_covers
             # Per-entity sets: drop orphaned entity ids as well
-            for state_set in (self._pending_settle, self._post_protective_exit):
+            for state_set in (
+                self._pending_settle, self._post_protective_exit, self._sensor_unknown_kept,
+            ):
                 state_set -= set(state_set) - current_covers
+            # Rule engine per-cover caches (comfort mode, warnings)
+            engine = getattr(self, "engine", None)
+            if engine is not None:
+                engine.forget_covers_except(current_covers)
 
         entities_to_track: set[str] = {SUN_ENTITY_ID}
 
@@ -229,6 +432,12 @@ def _setup_state_tracking(self, full_refresh: bool = False) -> None:
                 entities_to_track.add(vent_sensor)
             if indoor_sensor := cover_data.get("indoor_temp_sensor"):
                 entities_to_track.add(indoor_sensor)
+            if isinstance(occupancy := cover_data.get("occupancy_sensor"), str) and occupancy:
+                entities_to_track.add(occupancy)
+            # Entities holding a per-cover comfort band
+            for key in ("comfort_temp_min_entity", "comfort_temp_max_entity"):
+                if isinstance(ref := cover_data.get(key), str) and ref:
+                    entities_to_track.add(ref)
 
         if self.storage.outdoor_temp_sensor:
             entities_to_track.add(self.storage.outdoor_temp_sensor)
@@ -245,12 +454,31 @@ def _setup_state_tracking(self, full_refresh: bool = False) -> None:
         if self.storage.solar_sensor:
             entities_to_track.add(self.storage.solar_sensor)
 
+        if self.storage.workday_sensor:
+            entities_to_track.add(self.storage.workday_sensor)
+
+        # Entities holding global thresholds (a change re-evaluates the rules)
+        for key in ("comfort_temp_min_entity", "comfort_temp_max_entity", "solar_threshold_entity"):
+            if isinstance(ref := getattr(self.storage, key, None), str) and ref:
+                entities_to_track.add(ref)
+
         for rule_data in self.storage._data.get("rules", {}).values():
             for condition in rule_data.get("conditions", []):
-                if sensor := condition.get("params", {}).get("sensor"):
-                    entities_to_track.add(sensor)
-                if entity := condition.get("params", {}).get("entity"):
-                    entities_to_track.add(entity)
+                params = condition.get("params") or {}
+                if not isinstance(params, dict):
+                    continue
+                # The panel stores entities under "entity_id" (state_is,
+                # numeric_state, workday); "sensor"/"entity" are legacy keys.
+                for key in ("sensor", "entity", "entity_id"):
+                    ref = params.get(key)
+                    if isinstance(ref, str) and ref:
+                        entities_to_track.add(ref)
+
+        # Entities referenced by native Home Assistant conditions (incl. templates)
+        try:
+            entities_to_track |= set(self.engine.ha_condition_entities())
+        except (AttributeError, TypeError):
+            pass
 
         new_entities = entities_to_track - self._tracked_entities
 
@@ -294,9 +522,13 @@ def _get_wind_speed(self) -> float | None:
         if state is None:
             return None
         try:
-            return float(state.state)
+            speed = float(state.state)
         except (ValueError, TypeError):
             return None
+        if speed != speed:  # NaN is no valid reading
+            return None
+        self._wind_value_seen = True
+        return speed
 
     def _check_wind_protection(self) -> None:
         """Check wind sensor and update global wind protection state.
@@ -304,36 +536,179 @@ def _check_wind_protection(self) -> None:
         Uses hysteresis: activates at threshold, deactivates at
         threshold - hysteresis to prevent oscillation in gusty wind.
         """
+        threshold = self.storage.wind_speed_threshold
+        hysteresis = self.storage.wind_speed_hysteresis
+
+        # Feature switched off (sensor removed or threshold set to 0) while
+        # protection is active: release it, otherwise covers stay blocked.
+        if self._wind_protected and (not self.storage.wind_sensor or threshold <= 0):
+            _LOGGER.info("Wind protection DEACTIVATED (wind protection disabled in settings)")
+            self._set_wind_protected(False)
+            self._log(LOG_EVENT_WIND, None, "Deactivated (disabled in settings)",
+                      {"key": "wind_disabled"})
+            self._logbook(i18n.text(self.hass, "wind_disabled"))
+            self._deactivate_wind_protection()
+            return
+
         wind_speed = self._get_wind_speed()
+        if self._drop_unconfirmed_wind_restore():
+            return
         if wind_speed is None:
-            if self._wind_protected:
+            if self._wind_protected and not self._wind_sensor_warned:
+                self._wind_sensor_warned = True
                 _LOGGER.warning("Wind sensor unavailable while WIND_PROTECTED, keeping protection active")
             return
+        self._wind_sensor_warned = False
 
-        threshold = self.storage.wind_speed_threshold
-        hysteresis = self.storage.wind_speed_hysteresis
+        if hysteresis >= threshold > 0:
+            # Invalid config (e.g. older storage/import): the release level
+            # threshold - hysteresis would be <= 0 and never reached.
+            _LOGGER.debug(
+                "wind_speed_hysteresis (%.1f) >= threshold (%.1f), ignoring hysteresis",
+                hysteresis, threshold,
+            )
+            hysteresis = 0.0
 
         if not self._wind_protected and wind_speed >= threshold > 0:
-            _LOGGER.info("Wind protection ACTIVATED (%.1f >= %.1f)", wind_speed, threshold)
-            self._wind_protected = True
-            self._log(LOG_EVENT_WIND, None, f"Activated ({wind_speed:.1f} >= {threshold:.1f})")
-            self._logbook(f"wind protection activated ({wind_speed:.1f} >= {threshold:.1f})")
+            wind_pos = self._wind_position()
+            _LOGGER.info(
+                "Wind protection ACTIVATED (%.1f >= %.1f), covers -> %d%%",
+                wind_speed, threshold, wind_pos,
+            )
+            self._set_wind_protected(True)
+            self._log(LOG_EVENT_WIND, None, f"Activated ({wind_speed:.1f} >= {threshold:.1f})",
+                      {"key": "wind_activated", "speed": round(wind_speed, 1),
+                       "threshold": round(threshold, 1), "position": wind_pos})
+            self._logbook(i18n.text(
+                self.hass, "wind_activated",
+                speed=f"{wind_speed:.1f}", threshold=f"{threshold:.1f}",
+            ))
             self._activate_wind_protection()
         elif self._wind_protected and wind_speed <= threshold - hysteresis:
             _LOGGER.info("Wind protection DEACTIVATED (%.1f <= %.1f)", wind_speed, threshold - hysteresis)
-            self._wind_protected = False
-            self._log(LOG_EVENT_WIND, None, f"Deactivated ({wind_speed:.1f} <= {threshold - hysteresis:.1f})")
-            self._logbook(f"wind protection deactivated ({wind_speed:.1f} <= {threshold - hysteresis:.1f})")
+            self._set_wind_protected(False)
+            release = threshold - hysteresis
+            self._log(LOG_EVENT_WIND, None, f"Deactivated ({wind_speed:.1f} <= {release:.1f})",
+                      {"key": "wind_deactivated", "speed": round(wind_speed, 1),
+                       "threshold": round(release, 1)})
+            self._logbook(i18n.text(
+                self.hass, "wind_deactivated",
+                speed=f"{wind_speed:.1f}", threshold=f"{release:.1f}",
+            ))
             self._deactivate_wind_protection()
 
+    def _drop_unconfirmed_wind_restore(self) -> bool:
+        """Drop a wind protection restored at startup the sensor never confirmed.
+
+        The restored state is kept during the startup grace period (wind
+        sensors often report late). At its end, a wind sensor entity that
+        does not exist (renamed / removed) or that never gave a valid value
+        since startup cannot release the protection: the covers would stay
+        blocked at the wind position forever. The protection is then ended
+        normally (covers back to their previous status) and logged once.
+        Returns True when it was dropped.
+        """
+        if not self._wind_restore_pending or self._in_startup_grace():
+            return False
+        self._wind_restore_pending = False
+        if not self._wind_protected:
+            return False
+        sensor_id = self.storage.wind_sensor
+        if self.hass.states.get(sensor_id) is not None and self._wind_value_seen:
+            return False
+        _LOGGER.warning(
+            "Wind protection restored at startup dropped: wind sensor %s %s",
+            sensor_id,
+            "does not exist" if self.hass.states.get(sensor_id) is None else "never reported a value",
+        )
+        self._set_wind_protected(False)
+        self._log(LOG_EVENT_WIND, None, f"Restored wind protection dropped (sensor {sensor_id})",
+                  {"key": "wind_restore_dropped", "sensor": sensor_id})
+        self._deactivate_wind_protection()
+        return True
+
+    def _wind_position(self) -> int:
+        """Logical position covers move to while wind protection is active."""
+        value = getattr(self.storage, "wind_position", 100)
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            return 100
+        return max(0, min(100, int(value)))
+
+    def _lock_open_window(self, entity_id: str, cover_raw: dict[str, Any]) -> None:
+        """Lock a cover whose window is open (lock position, or held in place)."""
+        if self._cover_states.get(entity_id) == CoverStatus.LOCKED:
+            return
+        lock_pos = self._cover_val(cover_raw, "lock_position")
+        current = self._get_current_position(entity_id)
+        if self._lock_moves(cover_raw, current, lock_pos):
+            lock_tilt = self._cover_val(cover_raw, "lock_tilt_position")
+            self._lock_cover(entity_id, lock_pos, lock_tilt=lock_tilt)
+        else:
+            if entity_id not in self._pre_lock_states:
+                prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+                self._pre_lock_states[entity_id] = CoverStatus.AUTO if prev == CoverStatus.PAUSED else prev
+            self._lock_in_place(entity_id, cover_raw)
+
+    def _keeps_lock_sensor_unknown(self, entity_id: str, cover_raw: dict[str, Any]) -> bool:
+        """Whether a LOCKED cover must stay locked: its window state is unknown.
+
+        Never close a cover on a possibly open window: an unavailable lock
+        sensor is not "closed".
+        """
+        return (
+            self._cover_states.get(entity_id) == CoverStatus.LOCKED
+            and self._is_sensor_unknown(cover_raw, "lock_sensor")
+        )
+
+    def _protect_one_from_wind(self, entity_id: str, cover_raw: dict[str, Any]) -> None:
+        """Wind protection for one cover while it is active.
+
+        An open window (lock sensor) wins over the wind: the cover stays or
+        gets locked (emergency exit). Otherwise the cover takes the wind
+        status and position -- only this cover is commanded, not all.
+        """
+        if self._is_sensor_open(cover_raw, "lock_sensor"):
+            self._lock_open_window(entity_id, cover_raw)
+            return
+        status = self._cover_states.get(entity_id)
+        if status == CoverStatus.WIND_PROTECTED:
+            return
+        if self._keeps_lock_sensor_unknown(entity_id, cover_raw):
+            return
+        prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        if entity_id not in self._pre_lock_states:
+            self._pre_lock_states[entity_id] = CoverStatus.AUTO if prev == CoverStatus.PAUSED else prev
+        self._cover_states[entity_id] = CoverStatus.WIND_PROTECTED
+        self.storage.update_cover_status(entity_id, CoverStatus.WIND_PROTECTED.value, None)
+        self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> wind_protected",
+                  {"key": "status_change", "from": prev.value, "to": "wind_protected"})
+        if entity_id not in self._safety_holds:
+            self._send_wind_position(entity_id)
+
     def _activate_wind_protection(self) -> None:
-        """Set all covers to WIND_PROTECTED and move to fully open."""
+        """Set all covers to WIND_PROTECTED and move them to the wind position.
+
+        Covers whose window is open are locked instead: the lock (emergency
+        exit) has priority over the wind. A LOCKED cover whose window state
+        is unknown stays locked (same guard as _protect_one_from_wind).
+        """
+        # A previous activation may still be sending: never run two
+        # staggered wind sequences in parallel.
+        self._cancel_wind_tasks()
+        wind_pos = self._wind_position()
         commands: list[tuple[str, int]] = []
         for entity_id in self.storage._data.get("covers", {}):
             cover_raw = self.storage.get_cover_raw(entity_id)
             if cover_raw is None:
                 continue
 
+            if self._is_sensor_open(cover_raw, "lock_sensor"):
+                self._lock_open_window(entity_id, cover_raw)
+                continue
+            if self._keeps_lock_sensor_unknown(entity_id, cover_raw):
+                _LOGGER.debug("[%s] Wind protection: kept LOCKED (window state unknown)", entity_id)
+                continue
+
             prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
             if prev not in (CoverStatus.WIND_PROTECTED,):
                 if entity_id not in self._pre_lock_states:
@@ -342,40 +717,94 @@ def _activate_wind_protection(self) -> None:
             self._cover_states[entity_id] = CoverStatus.WIND_PROTECTED
             self.storage.update_cover_status(entity_id, CoverStatus.WIND_PROTECTED.value, None)
 
-            # Move to fully open (position 100)
+            if entity_id in self._safety_holds:
+                # A safety rule drives this cover: it keeps the rule's position
+                _LOGGER.debug("[%s] Wind protection: kept by safety rule", entity_id)
+                continue
+
+            # Move to the wind position (logical, inverted covers mirrored)
             inverted = cover_raw.get("inverted", False)
-            actual_position = 0 if inverted else 100
+            actual_position = (100 - wind_pos) if inverted else wind_pos
             self._last_positions[entity_id] = actual_position
             self._last_command_time[entity_id] = time_mod.monotonic()
             commands.append((entity_id, actual_position))
 
         if commands:
-            self.hass.async_create_task(self._send_staggered_commands(commands))
+            self._start_wind_commands(commands)
 
+        self._persist_runtime_state()
         if self.data is not None:
             self.async_set_updated_data(self.data)
 
+    def _send_wind_position(self, entity_id: str) -> None:
+        """Move one wind protected cover to the wind position."""
+        cover_raw = self.storage.get_cover_raw(entity_id)
+        if cover_raw is None:
+            return
+        wind_pos = self._wind_position()
+        actual = (100 - wind_pos) if cover_raw.get("inverted", False) else wind_pos
+        self._last_positions[entity_id] = actual
+        self._last_command_time[entity_id] = time_mod.monotonic()
+        _LOGGER.debug("[%s] Wind protection re-applied -> %d%%", entity_id, wind_pos)
+        self._start_wind_commands([(entity_id, actual)])
+
+    def _wind_task_set(self) -> set[asyncio.Task[None]]:
+        """Pending wind command tasks (created lazily)."""
+        if self._wind_tasks is None:
+            self._wind_tasks = set()
+        return self._wind_tasks
+
+    def _start_wind_commands(self, commands: list[tuple[str, int]]) -> None:
+        """Send wind commands in a tracked task (cancellable on release)."""
+        task = self.hass.async_create_task(self._send_staggered_commands(commands))
+        if isinstance(task, asyncio.Task):
+            tasks = self._wind_task_set()
+            tasks.add(task)
+            task.add_done_callback(tasks.discard)
+
+    def _cancel_wind_tasks(self) -> None:
+        """Cancel pending (staggered) wind commands."""
+        tasks = self._wind_task_set()
+        for task in list(tasks):
+            if not task.done():
+                task.cancel()
+        tasks.clear()
+
     async def _send_staggered_commands(
         self, commands: list[tuple[str, int]]
     ) -> None:
-        """Send position commands with optional stagger delay between them."""
+        """Send wind position commands with optional stagger delay between them.
+
+        The wind may drop, a window may open (LOCKED) or a safety rule may
+        take over during the stagger sleeps: each command is re-checked
+        right before it is sent, and the settle window starts at the actual
+        send time (a late command must not be read as a manual move).
+        """
         stagger = self.storage.command_stagger
         for i, (entity_id, position) in enumerate(commands):
             if i > 0 and stagger > 0:
                 await asyncio.sleep(stagger)
-            await self.hass.services.async_call(
-                "cover", "set_cover_position",
-                {"entity_id": entity_id, "position": position},
-                blocking=False,
-            )
+            if (
+                not self._wind_protected
+                or self._cover_states.get(entity_id) != CoverStatus.WIND_PROTECTED
+                or entity_id in self._safety_holds
+            ):
+                _LOGGER.debug("[%s] Wind command dropped: status changed meanwhile", entity_id)
+                continue
+            self._last_positions[entity_id] = self._effective_position(entity_id, position)
+            self._last_command_time[entity_id] = time_mod.monotonic()
+            await self._async_send_position(entity_id, position)
 
     def _deactivate_wind_protection(self) -> None:
         """Remove WIND_PROTECTED status from all covers, re-derive from sensors.
 
         Evaluates lock/vent sensors inline so covers with open windows
         transition directly to LOCKED/VENTING instead of briefly landing in
-        AUTO and waiting for the next scan tick.
+        AUTO and waiting for the next scan tick. A cover whose window state
+        is unknown is locked in place (possibly open window).
         """
+        # Wind commands still waiting for their stagger slot are obsolete
+        self._cancel_wind_tasks()
         for entity_id in list(self.storage._data.get("covers", {})):
             if self._cover_states.get(entity_id) != CoverStatus.WIND_PROTECTED:
                 continue
@@ -384,46 +813,49 @@ def _deactivate_wind_protection(self) -> None:
             if cover_raw is None:
                 continue
 
-            self._pre_lock_states.pop(entity_id, None)
+            pre_wind = self._pre_lock_states.pop(entity_id, None)
 
             if self._is_sensor_open(cover_raw, "lock_sensor"):
                 lock_pos = self._cover_val(cover_raw, "lock_position")
                 current = self._get_current_position(entity_id)
-                if current is None or current < lock_pos:
+                if self._lock_moves(cover_raw, current, lock_pos):
                     lock_tilt = self._cover_val(cover_raw, "lock_tilt_position")
                     self._lock_cover(entity_id, lock_pos, lock_tilt=lock_tilt)
                 else:
-                    self._cover_states[entity_id] = CoverStatus.LOCKED
-                    self.storage.update_cover_status(entity_id, CoverStatus.LOCKED.value, None)
-                    self._update_last_position_from_state(entity_id)
+                    # Record a pre-lock state (the pre-wind one was just
+                    # dropped) so the window-closed unlock restores AUTO.
+                    self._pre_lock_states[entity_id] = CoverStatus.AUTO
+                    self._lock_in_place(entity_id, cover_raw)
                 continue
 
-            if self._is_sensor_open(cover_raw, "vent_sensor"):
-                vent_pos = self._cover_val(cover_raw, "vent_position")
-                current = self._get_current_position(entity_id)
-                if current is not None and current < vent_pos:
-                    inverted = cover_raw.get("inverted", False)
-                    actual = (100 - vent_pos) if inverted else vent_pos
-                    self._last_positions[entity_id] = actual
-                    self._last_command_time[entity_id] = time_mod.monotonic()
-                    self._pending_settle.add(entity_id)
-                    self.hass.async_create_task(
-                        self.hass.services.async_call(
-                            "cover", "set_cover_position",
-                            {"entity_id": entity_id, "position": actual},
-                            blocking=False,
-                        )
-                    )
-                else:
-                    self._update_last_position_from_state(entity_id)
-                self._cover_states[entity_id] = CoverStatus.VENTING
-                self.storage.update_cover_status(entity_id, CoverStatus.VENTING.value, None)
+            if self._is_sensor_unknown(cover_raw, "lock_sensor"):
+                # Window state unknown (sensor unavailable): treat it as
+                # possibly open. Handing the cover back to AUTO would let the
+                # next rule close it on an open window; it stays where it is
+                # (LOCKED) until the sensor reports again.
+                self._pre_lock_states[entity_id] = self._status_for_automation(
+                    pre_wind if pre_wind in (CoverStatus.AUTO, CoverStatus.MANUAL) else CoverStatus.AUTO,
+                    cover_raw,
+                )
+                self._lock_in_place(entity_id, cover_raw, sensor_unknown=True)
                 continue
 
-            self._cover_states[entity_id] = CoverStatus.AUTO
-            self.storage.update_cover_status(entity_id, CoverStatus.AUTO.value, None)
-            self._update_last_position_from_state(entity_id)
+            if self._is_sensor_open(cover_raw, "vent_sensor"):
+                self._enter_venting(entity_id, cover_raw, "wind protection ended")
+                continue
 
+            # Automation switched off during the storm: MANUAL right away
+            # (not AUTO until the next sync), whatever the pre-wind status.
+            target = self._status_for_automation(CoverStatus.AUTO, cover_raw)
+            self._cover_states[entity_id] = target
+            self.storage.update_cover_status(entity_id, target.value, None)
+            self._sync_expected_after_protective_exit(entity_id)
+            # Like the lock/vent exits: return to the rule right away instead
+            # of waiting for min_time_between_changes.
+            if target == CoverStatus.AUTO:
+                self._post_protective_exit.add(entity_id)
+
+        self._persist_runtime_state()
         if self.data is not None:
             self.async_set_updated_data(self.data)
 
@@ -447,6 +879,9 @@ def _async_on_state_change(self, event: Event) -> None:
 
         if entity_id in self.storage._data.get("covers", {}):
             self._handle_cover_state_change(entity_id, old_state, new_state)
+            # A managed cover may also feed a rule condition
+            if self._is_rule_entity(entity_id):
+                self.hass.async_create_task(self.async_request_refresh())
         elif entity_id == self.storage.wind_sensor:
             self._handle_wind_sensor_change(new_state)
         else:
@@ -455,9 +890,28 @@ def _async_on_state_change(self, event: Event) -> None:
                 self._handle_contact_sensor_change(
                     entity_id, lock_covers, vent_covers, old_state, new_state
                 )
+                # The same entity may also feed a rule condition
+                if self._is_rule_entity(entity_id):
+                    self.hass.async_create_task(self.async_request_refresh())
             else:
                 self.hass.async_create_task(self.async_request_refresh())
 
+    def _is_rule_entity(self, entity_id: str) -> bool:
+        """Return True if a rule condition references this entity."""
+        try:
+            if entity_id in self.engine.ha_condition_entities():
+                return True
+        except (AttributeError, TypeError):
+            pass
+        for rule_data in self.storage._data.get("rules", {}).values():
+            for condition in rule_data.get("conditions", []):
+                params = condition.get("params") or {}
+                if isinstance(params, dict) and entity_id in (
+                    params.get("sensor"), params.get("entity"), params.get("entity_id"),
+                ):
+                    return True
+        return False
+
     def _is_sensor_open(self, cover_raw: dict[str, Any], key: str) -> bool:
         """Check if a binary sensor (lock/vent) for a cover is open."""
         sensor = cover_raw.get(key)
@@ -468,6 +922,58 @@ def _is_sensor_open(self, cover_raw: dict[str, Any], key: str) -> bool:
             return False
         return sensor_state.state in BINARY_SENSOR_ON_STATES
 
+    def _is_sensor_unknown(self, cover_raw: dict[str, Any], key: str) -> bool:
+        """Check if a configured lock/vent sensor has no usable state.
+
+        "unavailable" / "unknown" always count as unknown (possibly open
+        window). A sensor entity that does not exist at all (state None) is
+        only unknown during the startup grace period, while integrations are
+        still loading: afterwards it was renamed or removed and would block
+        the cover forever (restored LOCKED never released, moves down never
+        sent), so it is treated like no sensor configured.
+        """
+        sensor = cover_raw.get(key)
+        if not sensor:
+            return False
+        sensor_state = self.hass.states.get(sensor)
+        if sensor_state is None:
+            return self._in_startup_grace()
+        return sensor_state.state in _UNUSABLE_STATES
+
+    def _track_missing_lock_sensor(self, entity_id: str, cover_raw: dict[str, Any]) -> None:
+        """Log once per cover that its lock sensor entity no longer exists.
+
+        Such a sensor is ignored after the grace period (_is_sensor_unknown):
+        the activity log tells the user why the window lock no longer acts.
+        Logged again only after the sensor came back and disappeared again.
+        """
+        missing = self._runtime_set("_lock_sensor_missing")
+        sensor = cover_raw.get("lock_sensor")
+        if (
+            not sensor
+            or self.hass.states.get(sensor) is not None
+            or self._in_startup_grace()
+        ):
+            missing.discard(entity_id)
+            return
+        if entity_id in missing:
+            return
+        missing.add(entity_id)
+        _LOGGER.warning(
+            "[%s] Lock sensor %s does not exist: window lock ignored", entity_id, sensor
+        )
+        self._log(LOG_EVENT_STATUS, entity_id, f"Lock sensor {sensor} missing, ignored",
+                  {"key": "lock_sensor_missing", "sensor": sensor})
+
+    @staticmethod
+    def _is_real_transition(old_state: Any, new_state: Any) -> bool:
+        """Whether a sensor event is a real change between two usable states."""
+        return (
+            old_state is not None
+            and old_state.state not in _UNUSABLE_STATES
+            and old_state.state != new_state.state
+        )
+
     def _handle_contact_sensor_change(
         self,
         sensor_id: str,
@@ -510,50 +1016,47 @@ def is_sensor_open_cached(cover_raw: dict[str, Any], key: str) -> bool:
             if is_open:
                 lock_pos = self._cover_val(cover_raw, "lock_position")
                 current = self._get_current_position(cover_id)
-                if current is None or current < lock_pos:
-                    _LOGGER.info("[%s] Lock sensor open -> LOCKED at %d%%", cover_id, lock_pos)
+                if self._lock_moves(cover_raw, current, lock_pos):
                     self._lock_cover(cover_id, lock_pos, lock_tilt=self._cover_val(cover_raw, "lock_tilt_position"))
                 else:
-                    _LOGGER.info("[%s] Lock sensor open -> LOCKED (already at %d%%)", cover_id, current)
                     if cover_id not in self._pre_lock_states:
                         prev = self._cover_states.get(cover_id, CoverStatus.AUTO)
                         self._pre_lock_states[cover_id] = CoverStatus.AUTO if prev == CoverStatus.PAUSED else prev
-                    self._cover_states[cover_id] = CoverStatus.LOCKED
-                    self.storage.update_cover_status(cover_id, CoverStatus.LOCKED.value, None)
-                    self._update_last_position_from_state(cover_id)
+                    self._lock_in_place(cover_id, cover_raw)
                     if self.data is not None:
                         self.async_set_updated_data(self.data)
+            elif self._cover_states.get(cover_id) == CoverStatus.LOCKED and self._wind_protected:
+                # Window closed during a storm: back to the wind protection
+                # (this cover only).
+                self._protect_one_from_wind(cover_id, cover_raw)
+                if self.data is not None:
+                    self.async_set_updated_data(self.data)
             elif self._cover_states.get(cover_id) == CoverStatus.LOCKED:
                 # Only unlock if vent sensor is also not open
                 if not is_sensor_open_cached(cover_raw, "vent_sensor"):
-                    _LOGGER.info("[%s] Lock sensor closed -> unlocking", cover_id)
+                    _LOGGER.debug("[%s] Lock sensor %s closed -> unlocking", cover_id, sensor_id)
                     self._unlock_cover(cover_id)
                 else:
-                    _LOGGER.info("[%s] Lock sensor closed, vent still open -> VENTING", cover_id)
                     # Move to vent position if currently below it
-                    vent_pos = self._cover_val(cover_raw, "vent_position")
-                    current = self._get_current_position(cover_id)
-                    if current is not None and current < vent_pos:
-                        inverted = cover_raw.get("inverted", False)
-                        actual = (100 - vent_pos) if inverted else vent_pos
-                        self._last_positions[cover_id] = actual
-                        self._last_command_time[cover_id] = time_mod.monotonic()
-                        self._pending_settle.add(cover_id)
-                        self.hass.async_create_task(
-                            self.hass.services.async_call(
-                                "cover", "set_cover_position",
-                                {"entity_id": cover_id, "position": actual},
-                                blocking=False,
-                            )
-                        )
-                    else:
-                        self._update_last_position_from_state(cover_id)
                     self._pre_lock_states.pop(cover_id, None)
-                    self._cover_states[cover_id] = CoverStatus.VENTING
-                    self.storage.update_cover_status(cover_id, CoverStatus.VENTING.value, None)
+                    self._enter_venting(
+                        cover_id, cover_raw, f"window {sensor_id} closed, vent still open"
+                    )
                     if self.data is not None:
                         self.async_set_updated_data(self.data)
 
+        # A vent sensor coming back from unavailable/unknown (or an event
+        # without a state change, e.g. an attribute update) is no real
+        # transition: acting on it would e.g. cancel a manual pause. The
+        # periodic sync reconciles the status from the current sensor state.
+        if not self._is_real_transition(old_state, new_state):
+            if vent_covers:
+                _LOGGER.debug(
+                    "[%s] Vent sensor event without transition (%s -> %s), left to sync",
+                    sensor_id, getattr(old_state, "state", None), new_state.state,
+                )
+            vent_covers = []
+
         # Handle vent sensor covers (vent open -> min position, automation continues)
         for cover_id in vent_covers:
             cover_raw = self.storage.get_cover_raw(cover_id)
@@ -563,38 +1066,29 @@ def is_sensor_open_cached(cover_raw: dict[str, Any], key: str) -> bool:
             # Skip if lock sensor is open (lock has priority)
             if is_sensor_open_cached(cover_raw, "lock_sensor"):
                 continue
+            # A tilted window does not override the wind protection
+            if self._wind_protected:
+                continue
 
             current_status = self._cover_states.get(cover_id, CoverStatus.AUTO)
 
-            if is_open and current_status not in (CoverStatus.LOCKED, CoverStatus.VENTING):
-                vent_pos = self._cover_val(cover_raw, "vent_position")
-                current = self._get_current_position(cover_id)
+            if is_open and current_status == CoverStatus.PAUSED:
+                # A (manual) pause is kept, like the periodic sync does: a
+                # window tilted for a few seconds must not cancel it. Only
+                # the airflow is ensured (raised to the vent position when
+                # below); the pause timer is unchanged.
+                _LOGGER.debug(
+                    "[%s] Vent sensor %s open while paused: pause kept", cover_id, sensor_id,
+                )
+                self._raise_to_vent_floor(cover_id, cover_raw)
+            elif is_open and current_status not in (CoverStatus.LOCKED, CoverStatus.VENTING):
                 # Move up to vent_position if currently below it
-                if current is not None and current < vent_pos:
-                    _LOGGER.info("[%s] Vent sensor open -> VENTING, moving %d%% -> %d%%", cover_id, current, vent_pos)
-                    inverted = cover_raw.get("inverted", False)
-                    actual = (100 - vent_pos) if inverted else vent_pos
-                    self._last_positions[cover_id] = actual
-                    self._last_command_time[cover_id] = time_mod.monotonic()
-                    self._pending_settle.add(cover_id)
-                    self.hass.async_create_task(
-                        self.hass.services.async_call(
-                            "cover", "set_cover_position",
-                            {"entity_id": cover_id, "position": actual},
-                            blocking=False,
-                        )
-                    )
-                else:
-                    _LOGGER.info(
-                        "[%s] Vent sensor open -> VENTING (at %d%%, min %d%%)",
-                        cover_id, current if current is not None else 0, vent_pos,
-                    )
-                    self._update_last_position_from_state(cover_id)
-                self._cover_states[cover_id] = CoverStatus.VENTING
-                self.storage.update_cover_status(cover_id, CoverStatus.VENTING.value, None)
+                self._enter_venting(cover_id, cover_raw, f"vent sensor {sensor_id} open")
                 if self.data is not None:
                     self.async_set_updated_data(self.data)
-            elif not is_open and current_status in (CoverStatus.VENTING, CoverStatus.PAUSED):
+            elif not is_open and current_status == CoverStatus.VENTING:
+                # A PAUSED cover stays PAUSED (pause timer unchanged): the
+                # vent sensor closing is no reason to end a manual pause.
                 # Mirror the _sync_cover_statuses branch: a cover with automation
                 # disabled returns to MANUAL, not AUTO, so the refresh triggered
                 # below does not run an AUTO apply cycle (which could move a
@@ -604,10 +1098,16 @@ def is_sensor_open_cached(cover_raw: dict[str, Any], key: str) -> bool:
                     if cover_raw.get("auto_enabled", True)
                     else CoverStatus.MANUAL
                 )
-                _LOGGER.info("[%s] Vent sensor closed -> %s", cover_id, target.value)
+                _LOGGER.info(
+                    "[%s] Vent sensor %s closed: %s -> %s",
+                    cover_id, sensor_id, current_status.value, target.value,
+                )
+                self._log(LOG_EVENT_STATUS, cover_id, f"{current_status.value} -> {target.value}",
+                          {"key": "status_change", "from": current_status.value,
+                           "to": target.value, "sensor": sensor_id})
                 self._cover_states[cover_id] = target
                 self.storage.update_cover_status(cover_id, target.value, None)
-                self._update_last_position_from_state(cover_id)
+                self._sync_expected_after_protective_exit(cover_id)
                 # Mark for one-shot time-hysteresis bypass so the next apply
                 # cycle re-applies the matching rule even when
                 # min_time_between_changes has not elapsed.
@@ -616,20 +1116,168 @@ def is_sensor_open_cached(cover_raw: dict[str, Any], key: str) -> bool:
                     self.async_set_updated_data(self.data)
                 self.hass.async_create_task(self.async_request_refresh())
 
+        # Pre-lock statuses may have changed (lock/unlock): persist them now
+        # rather than at the next sync cycle.
+        self._persist_runtime_state()
+
+    @staticmethod
+    def _raw_position(state: Any) -> int | None:
+        """HA position of a cover state (raw, not inverted).
+
+        Covers without a current_position attribute (open/close only) are
+        read from their state instead of being taken for closed (0).
+        """
+        value = state.attributes.get("current_position")
+        if value is None:
+            return {"open": 100, "closed": 0}.get(state.state)
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return None
+
+    def _supports_set_position(self, entity_id: str) -> bool:
+        """Whether a cover accepts set_cover_position.
+
+        Covers that only support open/close (some RTS / relay covers) must
+        get open_cover / close_cover instead; set_cover_position is rejected
+        by them. Without a supported_features attribute the cover is assumed
+        to support positions (previous behaviour).
+        """
+        state = self.hass.states.get(entity_id)
+        if state is None:
+            return True
+        features = state.attributes.get("supported_features")
+        if isinstance(features, bool) or not isinstance(features, int):
+            return True
+        return bool(features & SET_POSITION_FEATURE_FLAG)
+
+    def _effective_position(self, entity_id: str, position: int) -> int:
+        """Raw position a command really reaches (open/close-only: 0 or 100)."""
+        if self._supports_set_position(entity_id):
+            return position
+        return 100 if position >= 50 else 0
+
+    def _position_call(self, entity_id: str, position: int) -> Any:
+        """Service call moving a cover to a raw position (awaitable).
+
+        Open/close-only covers are opened from 50 % up, closed below.
+        """
+        if self._supports_set_position(entity_id):
+            return self.hass.services.async_call(
+                "cover", "set_cover_position",
+                {"entity_id": entity_id, "position": position},
+                blocking=False,
+            )
+        service = "open_cover" if position >= 50 else "close_cover"
+        return self.hass.services.async_call(
+            "cover", service, {"entity_id": entity_id}, blocking=False,
+        )
+
+    async def _async_send_position(self, entity_id: str, position: int) -> None:
+        """Send a raw position to a cover (see _position_call)."""
+        await self._position_call(entity_id, position)
+
     def _get_current_position(self, entity_id: str) -> int | None:
         """Get current cover position (handles inverted covers)."""
         state = self.hass.states.get(entity_id)
         if state is None or state.state in ("unavailable", "unknown"):
             return None
-        try:
-            pos = int(state.attributes.get("current_position", 0))
-        except (ValueError, TypeError):
+        pos = self._raw_position(state)
+        if pos is None:
             return None
         cover_raw = self.storage.get_cover_raw(entity_id)
         if cover_raw and cover_raw.get("inverted", False):
             pos = 100 - pos
         return pos
 
+    @staticmethod
+    def _lock_moves(cover_raw: dict[str, Any], current: int | None, lock_pos: int) -> bool:
+        """Whether locking moves the cover to its lock position.
+
+        With lock_hold_position the cover stays where it is (no position or
+        tilt command); otherwise it only moves up to lock_pos, never down.
+        """
+        if cover_raw.get("lock_hold_position"):
+            return False
+        return current is None or current < lock_pos
+
+    def _lock_in_place(
+        self, entity_id: str, cover_raw: dict[str, Any], *, sensor_unknown: bool = False
+    ) -> None:
+        """Set a cover LOCKED without moving it (hold option or already above).
+
+        With sensor_unknown the window state is unknown (sensor unavailable)
+        rather than open: the cover is held as a precaution. The caller
+        records the pre-lock state.
+        """
+        prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        self._cover_states[entity_id] = CoverStatus.LOCKED
+        self.storage.update_cover_status(entity_id, CoverStatus.LOCKED.value, None)
+        self._update_last_position_from_state(entity_id)
+        if prev == CoverStatus.LOCKED:
+            return
+        current = self._get_current_position(entity_id)
+        sensor = cover_raw.get("lock_sensor")
+        _LOGGER.info(
+            "[%s] Window %s %s: %s -> locked (kept at %s%%)",
+            entity_id, sensor, "state unknown" if sensor_unknown else "open", prev.value, current,
+        )
+        self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> locked (kept at {current}%)",
+                  {"key": "status_change", "from": prev.value, "to": "locked",
+                   "sensor": sensor, "position": current, "kept": True})
+
+    def _raise_to_vent_floor(self, entity_id: str, cover_raw: dict[str, Any]) -> bool:
+        """Raise a cover below its vent position to it (with the vent tilt).
+
+        Returns True when a command was sent; otherwise the expected
+        position is synced to where the cover is. Does not change the status:
+        shared by _enter_venting and by a paused cover whose vent opens (the
+        pause is kept, only the airflow is ensured).
+        """
+        vent_pos = self._cover_val(cover_raw, "vent_position")
+        current = self._get_current_position(entity_id)
+        if current is None or current >= vent_pos:
+            self._update_last_position_from_state(entity_id)
+            return False
+        inverted = cover_raw.get("inverted", False)
+        actual = (100 - vent_pos) if inverted else vent_pos
+        self._last_positions[entity_id] = self._effective_position(entity_id, actual)
+        self._last_command_time[entity_id] = time_mod.monotonic()
+        self._pending_settle.add(entity_id)
+        self.hass.async_create_task(self._position_call(entity_id, actual))
+        vent_tilt = self._cover_val(cover_raw, "vent_tilt_position")
+        if (
+            isinstance(vent_tilt, int)
+            and not isinstance(vent_tilt, bool)
+            and cover_raw.get("supports_tilt", False)
+        ):
+            actual_tilt = 100 - vent_tilt if cover_raw.get("inverted_tilt", False) else vent_tilt
+            self._last_tilt_positions[entity_id] = actual_tilt
+            self._schedule_tilt(entity_id, actual_tilt, TILT_COMMAND_DELAY)
+        return True
+
+    def _enter_venting(self, entity_id: str, cover_raw: dict[str, Any], reason: str) -> None:
+        """Set a cover VENTING, raising it to the vent position when below.
+
+        When the cover is raised, the vent tilt (slats) is sent after the
+        move like the lock tilt, so the configured airflow angle is applied.
+        """
+        prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        vent_pos = self._cover_val(cover_raw, "vent_position")
+        current = self._get_current_position(entity_id)
+        if self._raise_to_vent_floor(entity_id, cover_raw):
+            detail = f"moving {current}% -> {vent_pos}%"
+        else:
+            detail = f"kept at {current}%, min {vent_pos}%"
+        self._cover_states[entity_id] = CoverStatus.VENTING
+        self.storage.update_cover_status(entity_id, CoverStatus.VENTING.value, None)
+        if prev == CoverStatus.VENTING:
+            return
+        _LOGGER.info("[%s] %s: %s -> venting (%s)", entity_id, reason, prev.value, detail)
+        self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> venting ({detail})",
+                  {"key": "status_change", "from": prev.value, "to": "venting",
+                   "sensor": cover_raw.get("vent_sensor"), "position": vent_pos})
+
     def _lock_cover(
         self, entity_id: str, lock_position: int, *, lock_tilt: int | None = None
     ) -> None:
@@ -639,14 +1287,22 @@ def _lock_cover(
         if entity_id not in self._pre_lock_states:
             prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
             self._pre_lock_states[entity_id] = CoverStatus.AUTO if prev == CoverStatus.PAUSED else prev
+        prev_status = self._cover_states.get(entity_id, CoverStatus.AUTO)
         self._cover_states[entity_id] = CoverStatus.LOCKED
         prev_val = self._pre_lock_states.get(entity_id, CoverStatus.AUTO).value
-        self._log(LOG_EVENT_STATUS, entity_id, f"{prev_val} -> locked")
-        self._logbook(f"locked at {lock_position}% (window open)", entity_id)
+        cover_raw = self.storage.get_cover_raw(entity_id)
+        sensor = cover_raw.get("lock_sensor") if cover_raw else None
+        _LOGGER.info(
+            "[%s] Window %s open: %s -> locked, moving to %s%%",
+            entity_id, sensor, prev_status.value, lock_position,
+        )
+        self._log(LOG_EVENT_STATUS, entity_id, f"{prev_val} -> locked",
+                  {"key": "status_change", "from": prev_val, "to": "locked",
+                   "sensor": sensor, "position": lock_position})
+        self._logbook(i18n.text(self.hass, "locked", position=lock_position), entity_id)
         self.storage.update_cover_status(entity_id, CoverStatus.LOCKED.value, None)
 
         # Handle inverted covers
-        cover_raw = self.storage.get_cover_raw(entity_id)
         actual_position = lock_position
         if cover_raw and cover_raw.get("inverted", False):
             actual_position = 100 - lock_position
@@ -654,17 +1310,10 @@ def _lock_cover(
         _LOGGER.debug("Locking cover %s at position %s (actual: %s)", entity_id, lock_position, actual_position)
 
         # Update expected position to prevent false manual override
-        self._last_positions[entity_id] = actual_position
+        self._last_positions[entity_id] = self._effective_position(entity_id, actual_position)
 
         self._last_command_time[entity_id] = time_mod.monotonic()
-        self.hass.async_create_task(
-            self.hass.services.async_call(
-                "cover",
-                "set_cover_position",
-                {"entity_id": entity_id, "position": actual_position},
-                blocking=False,
-            )
-        )
+        self.hass.async_create_task(self._position_call(entity_id, actual_position))
 
         # Send tilt command if supported and configured
         if lock_tilt is not None and cover_raw and cover_raw.get("supports_tilt", False):
@@ -678,72 +1327,118 @@ def _lock_cover(
             self.async_set_updated_data(self.data)
 
     def _unlock_cover(self, entity_id: str) -> None:
-        """Unlock a cover when contact sensor closes."""
-        if entity_id not in self._pre_lock_states:
+        """Unlock a cover when its contact sensors are closed (or removed).
+
+        Only acts on covers that are actually LOCKED or VENTING. A missing
+        pre-lock state (e.g. VENTING entered directly, or a sensor removed
+        from the cover config) falls back to AUTO instead of leaving the
+        cover stuck in its protective status forever.
+        """
+        current = self._cover_states.get(entity_id)
+        if current not in (CoverStatus.LOCKED, CoverStatus.VENTING):
+            self._pre_lock_states.pop(entity_id, None)
             return
 
-        _LOGGER.debug("Unlocking cover %s", entity_id)
-        self._log(LOG_EVENT_STATUS, entity_id, "locked -> unlocked")
-        self._logbook("unlocked (window closed)", entity_id)
+        self._log(LOG_EVENT_STATUS, entity_id, f"{current.value} -> unlocked",
+                  {"key": "status_change", "from": current.value, "to": "unlocked"})
+        self._logbook(i18n.text(self.hass, "unlocked"), entity_id)
 
-        # Restore previous state if was PAUSED and pause not expired
+        cover_raw = self.storage.get_cover_raw(entity_id)
         previous = self._pre_lock_states.pop(entity_id, CoverStatus.AUTO)
+        # Restore PAUSED (pause not expired), MANUAL, or VENTING (vent
+        # sensor still open); everything else returns to AUTO.
+        target = CoverStatus.AUTO
+        pause_until = None
         if previous == CoverStatus.PAUSED:
-            cover_raw = self.storage.get_cover_raw(entity_id)
             pause_until = cover_raw.get("pause_until") if cover_raw else None
             if pause_until and dt_util.now().timestamp() < pause_until:
-                self._cover_states[entity_id] = CoverStatus.PAUSED
-                self.storage.update_cover_status(
-                    entity_id, CoverStatus.PAUSED.value, pause_until
-                )
-                # Update expected position to current to prevent false override
-                self._update_last_position_from_state(entity_id)
-                if self.data is not None:
-                    self.async_set_updated_data(self.data)
-                return
+                target = CoverStatus.PAUSED
+        elif previous == CoverStatus.MANUAL:
+            target = CoverStatus.MANUAL
+        elif previous == CoverStatus.VENTING:
+            if cover_raw and self._is_sensor_open(cover_raw, "vent_sensor"):
+                target = CoverStatus.VENTING
+        # The automation may have been switched on/off during the lock
+        target = self._status_for_automation(target, cover_raw)
+
+        sensors = ", ".join(
+            s for s in ((cover_raw or {}).get("lock_sensor"), (cover_raw or {}).get("vent_sensor")) if s
+        ) or "-"
+        _LOGGER.info(
+            "[%s] Window %s closed: %s -> %s (kept at %s%%)",
+            entity_id, sensors, current.value, target.value,
+            self._get_current_position(entity_id),
+        )
 
-        # Restore MANUAL if cover was manual before lock
-        if previous == CoverStatus.MANUAL:
-            self._cover_states[entity_id] = CoverStatus.MANUAL
-            self.storage.update_cover_status(
-                entity_id, CoverStatus.MANUAL.value, None
-            )
-            self._update_last_position_from_state(entity_id)
+        self._cover_states[entity_id] = target
+        self.storage.update_cover_status(
+            entity_id, target.value, pause_until if target == CoverStatus.PAUSED else None
+        )
+        # Expected position: where the cover is (or is still going), so
+        # neither a finished lock move nor the stop is taken as manual
+        self._sync_expected_after_protective_exit(entity_id)
+        if target != CoverStatus.AUTO:
             if self.data is not None:
                 self.async_set_updated_data(self.data)
             return
-
-        # Restore VENTING if vent sensor is still open
-        if previous == CoverStatus.VENTING:
-            cover_raw = self.storage.get_cover_raw(entity_id)
-            if cover_raw and self._is_sensor_open(cover_raw, "vent_sensor"):
-                self._cover_states[entity_id] = CoverStatus.VENTING
-                self.storage.update_cover_status(
-                    entity_id, CoverStatus.VENTING.value, None
-                )
-                self._update_last_position_from_state(entity_id)
-                if self.data is not None:
-                    self.async_set_updated_data(self.data)
-                return
-
-        self._cover_states[entity_id] = CoverStatus.AUTO
-        self.storage.update_cover_status(entity_id, CoverStatus.AUTO.value, None)
-        # Update expected position to current to prevent false override
-        self._update_last_position_from_state(entity_id)
         # One-shot time-hysteresis bypass for the next apply cycle.
         self._post_protective_exit.add(entity_id)
         self.hass.async_create_task(self.async_request_refresh())
 
+    @staticmethod
+    def _status_for_automation(
+        status: CoverStatus, cover_raw: dict[str, Any] | None
+    ) -> CoverStatus:
+        """Align a status restored after a protection with auto_enabled.
+
+        The pre-lock / pre-wind status was recorded when the protection
+        started; the automation may have been switched on or off since then
+        (switch, import, resume refused while locked). A MANUAL status with
+        the automation now on becomes AUTO -- the cover would otherwise never
+        be driven again -- and AUTO / PAUSED with the automation off becomes
+        MANUAL. Other statuses (VENTING) are returned unchanged.
+        """
+        auto_enabled = bool((cover_raw or {}).get("auto_enabled", True))
+        if status == CoverStatus.MANUAL and auto_enabled:
+            return CoverStatus.AUTO
+        if status in (CoverStatus.AUTO, CoverStatus.PAUSED) and not auto_enabled:
+            return CoverStatus.MANUAL
+        return status
+
+    def _sync_expected_after_protective_exit(self, entity_id: str) -> None:
+        """Expected position when a cover leaves LOCKED / VENTING / wind protection.
+
+        Normally the current position (the cover stays where the protection
+        left it). But when the window closes while the cover is still
+        travelling to its lock / vent / wind position, the current reading is
+        a mid-travel value (e.g. 34 % on the way to 100 %): taking it as the
+        expected position made the end of our own move look like a manual
+        command a few seconds later, and the cover was paused. While our
+        command is still settling, the commanded position is kept instead;
+        the post-settle check then syncs to where the cover really stopped.
+        """
+        last_cmd = self._last_command_time.get(entity_id, 0)
+        if (
+            entity_id in self._pending_settle
+            and self._last_positions.get(entity_id) is not None
+            and (time_mod.monotonic() - last_cmd) < self._settle_time(entity_id)
+        ):
+            _LOGGER.debug(
+                "[%s] Protection ended during our move: expected position kept at %s%%",
+                entity_id, self._last_positions.get(entity_id),
+            )
+            return
+        self._update_last_position_from_state(entity_id)
+
     def _update_last_position_from_state(self, entity_id: str) -> None:
         """Update _last_positions and _last_tilt_positions from current HA state."""
         state = self.hass.states.get(entity_id)
         if state and state.state not in ("unavailable", "unknown"):
-            try:
-                self._last_positions[entity_id] = int(
-                    state.attributes.get("current_position", 0)
-                )
-            except (ValueError, TypeError):
-                _LOGGER.warning(
+            position = self._raw_position(state)
+            if position is not None:
+                self._last_positions[entity_id] = position
+            else:
+                _LOGGER.debug(
                     "Invalid position attribute for %s, resetting tracked position",
                     entity_id,
                 )
@@ -770,6 +1465,13 @@ def _handle_cover_state_change(
         if new_state.state in ("unavailable", "unknown"):
             return
 
+        # Motion bookkeeping first: it must also see the reports received
+        # during the grace, wind and settle periods ignored below.
+        self._record_motion(entity_id, old_state, new_state)
+
+        # Learn the cover's travel time from our own moves (feeds the settle time)
+        self._measure_travel(entity_id, new_state)
+
         # Ignore during startup grace period (device reconnection can report
         # positions that differ from HA's persisted state)
         if (time_mod.monotonic() - self._startup_time) < STARTUP_GRACE_PERIOD:
@@ -785,12 +1487,21 @@ def _handle_cover_state_change(
 
         # Ignore position changes during settle time after our own commands
         last_cmd = self._last_command_time.get(entity_id, 0)
-        if (time_mod.monotonic() - last_cmd) < SETTLE_TIME:
+        if (time_mod.monotonic() - last_cmd) < self._settle_time(entity_id):
             return
 
-        try:
-            current_position = int(new_state.attributes.get("current_position", 0))
-        except (ValueError, TypeError):
+        current_position = self._raw_position(new_state)
+        if current_position is None:
+            return
+
+        # Slow covers that do not report opening/closing: while the position
+        # keeps moving towards our own target, the cover is still travelling
+        # from our command -- extend the settle window instead of reading the
+        # intermediate position as a manual override.
+        if entity_id in self._pending_settle and self._is_progressing_to_target(
+            entity_id, old_state, current_position
+        ):
+            self._last_command_time[entity_id] = time_mod.monotonic()
             return
 
         # After settle time, sync actual position before override check
@@ -807,6 +1518,8 @@ def _handle_cover_state_change(
                     "[%s] Post-settle: large deviation %d%% vs expected %d%%, checking override",
                     entity_id, current_position, expected_target,
                 )
+                if self._resend_if_lost(entity_id, current_position):
+                    return
                 # Fall through to override check below
             else:
                 self._last_positions[entity_id] = current_position
@@ -838,6 +1551,11 @@ def _handle_cover_state_change(
                     pass
 
         if position_mismatch or tilt_mismatch:
+            if entity_id in self._safety_holds:
+                # A safety rule drives the cover: no pause, the next cycle
+                # re-applies the rule's position.
+                _LOGGER.debug("[%s] Position change ignored: safety rule active", entity_id)
+                return
             if cover.auto_enabled and self._cover_states.get(entity_id) in (CoverStatus.AUTO, CoverStatus.VENTING):
                 _LOGGER.info(
                     "[%s] Manual override -> PAUSED (expected pos %s, got %s, expected tilt %s)",
@@ -848,12 +1566,267 @@ def _handle_cover_state_change(
                 )
                 self.pause_cover(cover)
 
-    def pause_cover(self, cover: CoverConfig) -> None:
-        """Pause automation for a cover."""
+    def _record_motion(self, entity_id: str, old_state: Any, new_state: Any) -> None:
+        """Record position/motion changes of a cover (not attribute-only reports).
+
+        Two uses:
+        - the time of the last real change (position, state, opening /
+          closing) feeds the stillness check of resume-on-match: Zigbee
+          covers re-report attributes (linkquality) every few seconds, so
+          state.last_updated never looks still;
+        - whether the cover moved at all since our last command, even during
+          the settle time: a user counter-order (up/stop) during our move
+          brings the cover back to its start position, which must not be
+          read as a lost command and resent.
+        """
+        new_pos = self._raw_position(new_state)
+        moving = new_state.state in ("opening", "closing")
+        old_usable = old_state is not None and old_state.state not in _UNUSABLE_STATES
+        old_pos = self._raw_position(old_state) if old_usable else None
+        if moving or not old_usable or old_state.state != new_state.state or old_pos != new_pos:
+            self._runtime_dict("_position_changed_at")[entity_id] = time_mod.monotonic()
+        move = self._move_start.get(entity_id)
+        if move is not None and (
+            moving or (new_pos is not None and abs(new_pos - move[1]) > MANUAL_OVERRIDE_TOLERANCE)
+        ):
+            self._runtime_set("_moved_since_command").add(entity_id)
+
+    def _data_raw_target(
+        self, entity_id: str, cover_raw: dict[str, Any], status: CoverStatus
+    ) -> int | None:
+        """Raw position the current cycle data asks for (as the apply cycle sends it)."""
+        cover_data = ((self.data or {}).get("covers") or {}).get(entity_id) or {}
+        target = cover_data.get("target_position")
+        if not isinstance(target, (int, float)) or isinstance(target, bool):
+            return None
+        target = int(target)
+        if status == CoverStatus.VENTING:
+            vent_min = self._cover_val(cover_raw, "vent_position")
+            if isinstance(vent_min, (int, float)) and not isinstance(vent_min, bool):
+                target = max(target, int(vent_min))
+        if cover_raw.get("inverted", False):
+            target = 100 - target
+        return self._effective_position(entity_id, target)
+
+    def _resend_if_lost(self, entity_id: str, current: int) -> bool:
+        """Resend a position command the cover did not react to at all.
+
+        After the settle time, a cover still at the start position of our
+        own move (raw positions) most likely never received the command
+        (radio/cloud command lost). That is not a manual override: resend
+        the command, at most MAX_LOST_COMMAND_RETRIES times, instead of
+        pausing the automation. Returns True when the command was resent.
+
+        Never resent when the cover moved at all since the command (a user
+        counter-order also ends at the start position), when the automation
+        is off, or when the command is no longer what the rules ask for.
+        """
+        if not self.storage.enabled:
+            return False
+        move = self._move_start.get(entity_id)
+        if move is None:
+            return False
+        if entity_id in self._runtime_set("_moved_since_command"):
+            _LOGGER.debug("[%s] Cover moved since our command: not a lost command", entity_id)
+            return False
+        _, start_pos, target = move
+        if (
+            abs(current - start_pos) > MANUAL_OVERRIDE_TOLERANCE
+            or abs(current - target) <= MANUAL_OVERRIDE_TOLERANCE
+            or self._last_positions.get(entity_id) != target
+            or self._wind_protected
+        ):
+            return False
+        # Only moves the apply cycle may still drive: AUTO/VENTING, or a
+        # paused/manual cover held by a safety rule (never LOCKED / wind).
+        status = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        if status in (CoverStatus.LOCKED, CoverStatus.WIND_PROTECTED) or (
+            status not in (CoverStatus.AUTO, CoverStatus.VENTING)
+            and entity_id not in self._safety_holds
+        ):
+            return False
+        cover_raw = self.storage.get_cover_raw(entity_id)
+        if cover_raw is None or self._data_raw_target(entity_id, cover_raw, status) != target:
+            return False
+        if self._blocked_by_unknown_lock(entity_id, cover_raw, target, current):
+            return False
+        if self._lost_command_retries is None:
+            self._lost_command_retries = {}
+        retries = self._lost_command_retries.get(entity_id, 0)
+        if retries >= MAX_LOST_COMMAND_RETRIES:
+            _LOGGER.warning(
+                "[%s] Cover did not move to %d%% after %d resends (still at %d%%)",
+                entity_id, target, retries, current,
+            )
+            self._lost_command_retries.pop(entity_id, None)
+            self._move_start.pop(entity_id, None)
+            return False
+        self._lost_command_retries[entity_id] = retries + 1
+        _LOGGER.warning(
+            "[%s] Command %d%% apparently lost (cover still at %d%%), resending (%d/%d)",
+            entity_id, target, current, retries + 1, MAX_LOST_COMMAND_RETRIES,
+        )
+        now = time_mod.monotonic()
+        self._last_command_time[entity_id] = now
+        self._move_start[entity_id] = (now, start_pos, target)
+        self._pending_settle.add(entity_id)
+        self.hass.async_create_task(self._position_call(entity_id, target))
+        return True
+
+    def _blocked_by_unknown_lock(
+        self, entity_id: str, cover_raw: dict[str, Any], raw_target: int, raw_current: int
+    ) -> bool:
+        """Whether a move must wait: it closes a cover on a possibly open window.
+
+        While the lock sensor (window contact) is unavailable/unknown the
+        window may be open: a cover is never driven down below its
+        lock_position then. Upward moves stay allowed. Positions are raw
+        (HA scale); inverted covers are mirrored here.
+        """
+        blocked_logged = self._runtime_set("_move_blocked_logged")
+        if not self._is_sensor_unknown(cover_raw, "lock_sensor"):
+            blocked_logged.discard(entity_id)
+            return False
+        if cover_raw.get("inverted", False):
+            target, current = 100 - raw_target, 100 - raw_current
+        else:
+            target, current = raw_target, raw_current
+        lock_pos = self._cover_val(cover_raw, "lock_position")
+        if not isinstance(lock_pos, (int, float)) or isinstance(lock_pos, bool):
+            lock_pos = 100
+        if target < current and target < lock_pos:
+            _LOGGER.debug(
+                "[%s] Window state unknown: not lowering %d%% -> %d%% (lock position %d%%)",
+                entity_id, current, target, lock_pos,
+            )
+            # Once per blocking episode: the apply cycle re-checks every scan
+            if entity_id not in blocked_logged:
+                blocked_logged.add(entity_id)
+                sensor = cover_raw.get("lock_sensor")
+                self._log(LOG_EVENT_STATUS, entity_id,
+                          f"Move to {target}% blocked: window {sensor} state unknown",
+                          {"key": "move_blocked_window_unknown", "sensor": sensor,
+                           "position": target})
+            return True
+        blocked_logged.discard(entity_id)
+        return False
+
+    def _travel_time(self, entity_id: str) -> float | None:
+        """Full travel time of a cover.
+
+        Order: value entered on the cover, then the measured value, then the
+        global default travel time; None when none is known (30 s settle).
+        """
+        def _positive(value: Any) -> float | None:
+            if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0:
+                return float(value)
+            return None
+
+        cover_raw = self.storage.get_cover_raw(entity_id)
+        if isinstance(cover_raw, dict):
+            for key in ("travel_time", "measured_travel_time"):
+                if (value := _positive(cover_raw.get(key))) is not None:
+                    return value
+        return _positive(getattr(self.storage, "default_travel_time", None))
+
+    def _settle_time(self, entity_id: str) -> float:
+        """Seconds after our own command during which moves are not manual.
+
+        At least SETTLE_TIME; longer for slow covers whose full travel time
+        (configured or measured) plus a margin exceeds it.
+        """
+        travel = self._travel_time(entity_id)
+        if travel is None:
+            return SETTLE_TIME
+        return max(SETTLE_TIME, travel + TRAVEL_TIME_MARGIN)
+
+    def _measure_travel(self, entity_id: str, new_state: Any) -> None:
+        """Measure the full travel time when a commanded move reaches its target.
+
+        Only moves of at least MIN_MEASURED_DISTANCE % are used, scaled to a
+        full 0-100 % travel, and smoothed with the previous measurement. A
+        polled cover reports its arrival late (next poll): a new sample is
+        capped at MAX_TRAVEL_GROWTH x the previous value so one late poll
+        cannot inflate the settle time.
+        """
+        start = self._move_start.get(entity_id)
+        if start is None:
+            return
+        started_at, start_pos, target = start
+        elapsed = time_mod.monotonic() - started_at
+        if elapsed > MAX_MEASURED_TRAVEL:
+            self._move_start.pop(entity_id, None)
+            return
+        if new_state.state in ("opening", "closing"):
+            return
+        try:
+            position = int(new_state.attributes.get("current_position"))
+        except (ValueError, TypeError):
+            return
+        if abs(position - target) > MANUAL_OVERRIDE_TOLERANCE:
+            return
+        self._move_start.pop(entity_id, None)
+        # The command arrived: a later lost command gets fresh resends
+        if self._lost_command_retries:
+            self._lost_command_retries.pop(entity_id, None)
+        distance = abs(start_pos - target)
+        if distance < MIN_MEASURED_DISTANCE or elapsed < 1:
+            return
+        full = min(elapsed * 100 / distance, MAX_MEASURED_TRAVEL)
+        cover_raw = self.storage.get_cover_raw(entity_id)
+        previous = cover_raw.get("measured_travel_time") if isinstance(cover_raw, dict) else None
+        if isinstance(previous, (int, float)) and not isinstance(previous, bool) and previous > 0:
+            if full > previous * MAX_TRAVEL_GROWTH:
+                # Capped sample: already a bounded step up. Averaging it with
+                # the previous value again halved the growth, so a cover whose
+                # first measurement was too short needed many moves to reach
+                # its real travel time (settle time too short meanwhile).
+                full = previous * MAX_TRAVEL_GROWTH
+            else:
+                full = (previous + full) / 2
+        full = round(full, 1)
+        _LOGGER.debug("[%s] Measured travel time: %.1f s", entity_id, full)
+        self.storage.update_cover_measured_travel(entity_id, full)
+
+    def _is_progressing_to_target(
+        self, entity_id: str, old_state: Any, current_position: int
+    ) -> bool:
+        """Return True if the cover moved strictly closer to its commanded target."""
+        target = self._last_positions.get(entity_id)
+        if target is None or old_state is None:
+            return False
+        try:
+            old_position = int(old_state.attributes.get("current_position"))
+        except (ValueError, TypeError):
+            return False
+        return abs(current_position - target) < abs(old_position - target)
+
+    def pause_cover(self, cover: CoverConfig, manual: bool = True) -> None:
+        """Pause automation for a cover.
+
+        Protective statuses (wind, window lock) and disabled automation
+        (MANUAL) take precedence over a pause: overwriting them would only be
+        undone by the next sync cycle, re-sending protective commands.
+
+        manual: the pause comes from a detected manual override (the cover
+        was moved by hand). Explicit pauses (pause / pause_all services) pass
+        False: resume-on-match must not end them -- the user asked for a
+        pause, not for a one-off position.
+        """
         prev = self._cover_states.get(cover.entity_id, CoverStatus.AUTO)
+        if prev in (CoverStatus.WIND_PROTECTED, CoverStatus.LOCKED, CoverStatus.MANUAL):
+            _LOGGER.debug(
+                "[%s] Pause ignored: cover is %s", cover.entity_id, prev.value
+            )
+            return
         self._cover_states[cover.entity_id] = CoverStatus.PAUSED
+        self._runtime_dict("_pause_manual")[cover.entity_id] = manual
         if prev != CoverStatus.PAUSED:
-            self._log(LOG_EVENT_STATUS, cover.entity_id, f"{prev.value} -> paused")
+            if self._paused_at is None:
+                self._paused_at = {}
+            self._paused_at[cover.entity_id] = time_mod.monotonic()
+            self._log(LOG_EVENT_STATUS, cover.entity_id, f"{prev.value} -> paused",
+                      {"key": "status_change", "from": prev.value, "to": "paused"})
         duration = cover.pause_duration if cover.pause_duration is not None else self.storage.pause_duration
         pause_until = dt_util.now().timestamp() + (duration * 60)
         self.storage.update_cover_status(
@@ -861,32 +1834,57 @@ def pause_cover(self, cover: CoverConfig) -> None:
         )
         if prev != CoverStatus.PAUSED:
             self._logbook(
-                f"paused for {duration} min (manual override)",
+                i18n.text(self.hass, "paused", minutes=duration),
                 cover.entity_id,
             )
         if self.data is not None:
             self.async_set_updated_data(self.data)
 
-    def resume_cover(self, entity_id: str) -> None:
-        """Resume automation for a cover."""
+    def resume_cover(self, entity_id: str, logbook_text: str | None = None) -> None:
+        """Resume automation for a cover.
+
+        logbook_text replaces the plain "resumed" logbook entry (automatic
+        resume, with its reason).
+        """
         # Wind protection cannot be overridden manually
         if self._wind_protected:
             return
         cover_raw = self.storage.get_cover_raw(entity_id)
         if cover_raw:
-            # Don't override LOCKED status if lock/vent sensor is still active
+            # Don't override LOCKED status if lock/vent sensor is still active,
+            # nor while the window state is unknown (possibly open window).
+            # A refused resume is still the user's wish: the unlock restores
+            # AUTO instead of the recorded pre-lock status (e.g. MANUAL).
             if self._cover_states.get(entity_id) == CoverStatus.LOCKED:
                 if self._is_sensor_open(cover_raw, "lock_sensor") or self._is_sensor_open(cover_raw, "vent_sensor"):
+                    self._pre_lock_states[entity_id] = CoverStatus.AUTO
+                    self._persist_runtime_state()
+                    return
+                if self._is_sensor_unknown(cover_raw, "lock_sensor"):
+                    _LOGGER.info("[%s] Resume refused: window state unknown, cover stays locked", entity_id)
+                    self._pre_lock_states[entity_id] = CoverStatus.AUTO
+                    self._persist_runtime_state()
                     return
+            prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+            # Resuming ends any protective episode: a stale pre-lock status
+            # would otherwise be restored by a later unlock.
+            self._pre_lock_states.pop(entity_id, None)
+            self._runtime_dict("_pause_manual").pop(entity_id, None)
             # Resume to VENTING if vent sensor is still open
             if self._is_sensor_open(cover_raw, "vent_sensor"):
+                target = CoverStatus.VENTING
                 self._cover_states[entity_id] = CoverStatus.VENTING
                 self.storage.update_cover_status(entity_id, CoverStatus.VENTING.value, None)
-                self._logbook("resumed (venting)", entity_id)
+                self._logbook(i18n.text(self.hass, "resumed_venting"), entity_id)
             else:
+                target = CoverStatus.AUTO
                 self._cover_states[entity_id] = CoverStatus.AUTO
                 self.storage.update_cover_status(entity_id, CoverStatus.AUTO.value, None)
-                self._logbook("resumed", entity_id)
+                self._logbook(logbook_text or i18n.text(self.hass, "resumed"), entity_id)
+            if prev != target:
+                _LOGGER.debug("[%s] Resumed: %s -> %s", entity_id, prev.value, target.value)
+                self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> {target.value}",
+                          {"key": "status_change", "from": prev.value, "to": target.value})
             # Sync expected position to current to prevent immediate re-pause
             self._update_last_position_from_state(entity_id)
             if self.data is not None:
@@ -897,37 +1895,53 @@ def _sync_cover_statuses(self) -> None:
 
         Updates _cover_states and storage for all covers. Called once per
         update cycle to avoid side effects in property accessors.
-        Priority: WIND_PROTECTED > LOCKED > VENTING > PAUSED > AUTO > MANUAL.
+        Priority: LOCKED (window open) > WIND_PROTECTED > VENTING > PAUSED
+        > AUTO > MANUAL.
         """
-        # Check wind protection first (global, highest priority)
+        # Check wind protection first (global)
         self._check_wind_protection()
 
         for entity_id in self.storage._data.get("covers", {}):
             cover_raw = self.storage.get_cover_raw(entity_id)
             if cover_raw is None:
                 continue
+            self._track_missing_lock_sensor(entity_id, cover_raw)
 
-            # Wind protection has highest priority - skip all other checks
+            # Wind protection: above everything except an open window (lock)
             if self._wind_protected:
-                if self._cover_states.get(entity_id) != CoverStatus.WIND_PROTECTED:
-                    self._activate_wind_protection()
+                self._protect_one_from_wind(entity_id, cover_raw)
                 continue
 
+            # An unavailable lock/vent sensor is not "closed": keep the
+            # protective status unchanged this cycle (no lock, no unlock).
+            sensor_unknown = (
+                self._is_sensor_unknown(cover_raw, "lock_sensor")
+                or self._is_sensor_unknown(cover_raw, "vent_sensor")
+            )
+
             # Check lock sensor state (window contact)
             if self._is_sensor_open(cover_raw, "lock_sensor"):
                 if self._cover_states.get(entity_id) != CoverStatus.LOCKED:
                     lock_pos = self._cover_val(cover_raw, "lock_position")
                     current = self._get_current_position(entity_id)
-                    if current is None or current < lock_pos:
+                    if self._lock_moves(cover_raw, current, lock_pos):
                         lock_tilt = self._cover_val(cover_raw, "lock_tilt_position")
                         self._lock_cover(entity_id, lock_pos, lock_tilt=lock_tilt)
                     else:
                         prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
                         self._pre_lock_states[entity_id] = CoverStatus.AUTO if prev == CoverStatus.PAUSED else prev
-                        self._cover_states[entity_id] = CoverStatus.LOCKED
-                        self.storage.update_cover_status(entity_id, CoverStatus.LOCKED.value, None)
-                        self._update_last_position_from_state(entity_id)
+                        self._lock_in_place(entity_id, cover_raw)
+                self._sensor_unknown_kept.discard(entity_id)
+                continue
+
+            if sensor_unknown and self._cover_states.get(entity_id) in (
+                CoverStatus.LOCKED, CoverStatus.VENTING,
+            ):
+                self._keep_status_sensor_unknown(entity_id, cover_raw)
                 continue
+            if entity_id in self._sensor_unknown_kept:
+                self._sensor_unknown_kept.discard(entity_id)
+                _LOGGER.debug("[%s] Lock/vent sensor available again", entity_id)
 
             # Check vent sensor state - also above auto_enabled
             if self._is_sensor_open(cover_raw, "vent_sensor"):
@@ -936,30 +1950,15 @@ def _sync_cover_statuses(self) -> None:
                 if current_status == CoverStatus.PAUSED:
                     pause_until = cover_raw.get("pause_until")
                     if pause_until and dt_util.now().timestamp() > pause_until:
-                        # Pause expired -> back to VENTING
-                        self._cover_states[entity_id] = CoverStatus.VENTING
-                        self.storage.update_cover_status(entity_id, CoverStatus.VENTING.value, None)
-                        self._update_last_position_from_state(entity_id)
+                        # Pause expired -> back to VENTING. The cover may have
+                        # been lowered manually during the pause: raise it to
+                        # the vent position again (logs the status change).
+                        _LOGGER.debug("[%s] Pause expired: paused -> venting", entity_id)
+                        self._enter_venting(entity_id, cover_raw, "pause expired, vent open")
                 elif current_status != CoverStatus.VENTING:
-                    vent_pos = self._cover_val(cover_raw, "vent_position")
-                    current = self._get_current_position(entity_id)
-                    if current is not None and current < vent_pos:
-                        inverted = cover_raw.get("inverted", False)
-                        actual = (100 - vent_pos) if inverted else vent_pos
-                        self._last_positions[entity_id] = actual
-                        self._last_command_time[entity_id] = time_mod.monotonic()
-                        self._pending_settle.add(entity_id)
-                        self.hass.async_create_task(
-                            self.hass.services.async_call(
-                                "cover", "set_cover_position",
-                                {"entity_id": entity_id, "position": actual},
-                                blocking=False,
-                            )
-                        )
-                    else:
-                        self._update_last_position_from_state(entity_id)
-                    self._cover_states[entity_id] = CoverStatus.VENTING
-                    self.storage.update_cover_status(entity_id, CoverStatus.VENTING.value, None)
+                    self._enter_venting(
+                        entity_id, cover_raw, f"vent sensor {cover_raw.get('vent_sensor')} open"
+                    )
                 continue
 
             # If was locked/venting but sensors now closed, restore auto
@@ -972,7 +1971,11 @@ def _sync_cover_statuses(self) -> None:
                 # status survives a restart (which resets all statuses to AUTO)
                 # and the panel, which renders the persisted cover status,
                 # reflects the disabled automation instead of showing AUTO.
-                if self._cover_states.get(entity_id) != CoverStatus.MANUAL:
+                prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+                if prev != CoverStatus.MANUAL:
+                    _LOGGER.debug("[%s] Automation disabled: %s -> manual", entity_id, prev.value)
+                    self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> manual",
+                              {"key": "status_change", "from": prev.value, "to": "manual"})
                     self._cover_states[entity_id] = CoverStatus.MANUAL
                     self.storage.update_cover_status(entity_id, CoverStatus.MANUAL.value, None)
                 continue
@@ -982,21 +1985,51 @@ def _sync_cover_statuses(self) -> None:
             if status == CoverStatus.PAUSED:
                 pause_until = cover_raw.get("pause_until")
                 if pause_until and dt_util.now().timestamp() > pause_until:
+                    _LOGGER.debug("[%s] Pause expired: paused -> auto", entity_id)
+                    self._log(LOG_EVENT_STATUS, entity_id, "paused -> auto",
+                              {"key": "status_change", "from": "paused", "to": "auto"})
                     self._cover_states[entity_id] = CoverStatus.AUTO
                     self.storage.update_cover_status(entity_id, CoverStatus.AUTO.value, None)
                     # Sync expected position to prevent false override after resume
                     self._update_last_position_from_state(entity_id)
 
+        # Protective state must survive a restart (see _restore_cover_states)
+        self._persist_runtime_state()
+
+    def _keep_status_sensor_unknown(self, entity_id: str, cover_raw: dict[str, Any]) -> None:
+        """Keep LOCKED/VENTING while a lock/vent sensor is unavailable (log once)."""
+        status = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        if entity_id in self._sensor_unknown_kept:
+            _LOGGER.debug("[%s] Lock/vent sensor unavailable, keeping %s", entity_id, status.value)
+            return
+        self._sensor_unknown_kept.add(entity_id)
+        sensors = ", ".join(
+            s for s in (cover_raw.get("lock_sensor"), cover_raw.get("vent_sensor")) if s
+        )
+        current = self._get_current_position(entity_id)
+        _LOGGER.debug(
+            "[%s] Sensor %s unavailable: keeping %s (kept at %s%%)",
+            entity_id, sensors, status.value, current,
+        )
+        self._log(LOG_EVENT_STATUS, entity_id, f"{status.value} kept (sensor unavailable)",
+                  {"key": "sensor_unavailable", "status": status.value,
+                   "sensor": sensors, "position": current})
+
     def get_cover_status(self, entity_id: str) -> CoverStatus:
         """Get automation status for a cover (read-only, no side effects)."""
         cover_raw = self.storage.get_cover_raw(entity_id)
         if cover_raw is None:
             return CoverStatus.MANUAL
 
+        live = self._cover_states.get(entity_id, CoverStatus.AUTO)
         if not cover_raw.get("auto_enabled", True):
+            # Protective statuses also act on covers with automation off
+            # (window open -> locked, storm -> wind position): report them.
+            if live in (CoverStatus.LOCKED, CoverStatus.WIND_PROTECTED):
+                return live
             return CoverStatus.MANUAL
 
-        return self._cover_states.get(entity_id, CoverStatus.AUTO)
+        return live
 
     def get_active_rules(self) -> dict[str, list[str]]:
         """Get currently active rules and their matched covers.
@@ -1044,6 +2077,41 @@ def _live_cover_entry(self, entity_id: str, cover_data: dict[str, Any]) -> dict[
             "last_change": cover_raw.get("last_position_change") if cover_raw else None,
         }
 
+    # ---- Public read-only accessors for entities / dashboard card ----
+
+    @property
+    def wind_protected(self) -> bool:
+        """Whether wind protection is currently active."""
+        return self._wind_protected
+
+    def get_wind_speed(self) -> float | None:
+        """Current wind speed from the configured sensor (None if unknown)."""
+        return self._get_wind_speed()
+
+    def get_logical_position(self, entity_id: str) -> int | None:
+        """Current position on the rules' scale (inverted covers mirrored)."""
+        return self._get_current_position(entity_id)
+
+    def get_cover_live(self, entity_id: str) -> dict[str, Any]:
+        """Live runtime data of one cover (rule, target, pause, comfort)."""
+        cover_data = (self.data or {}).get("covers", {}).get(entity_id, {})
+        cover_raw = self.storage.get_cover_raw(entity_id) or {}
+        rule_id = cover_data.get("matching_rule_id")
+        rule_name = None
+        if rule_id:
+            rule = self.storage.rules.get(rule_id)
+            rule_name = rule.name if rule else rule_id
+        comfort = self.engine._last_comfort_mode.get(entity_id)
+        return {
+            "target_position": cover_data.get("target_position"),
+            "rule_id": rule_id,
+            "rule_name": rule_name,
+            "safety": bool(cover_data.get("safety", False)),
+            "pause_until": cover_raw.get("pause_until"),
+            "comfort_mode": comfort.value if comfort else None,
+            "last_change": cover_raw.get("last_position_change"),
+        }
+
     def get_live_facade_data(self) -> dict[str, dict[str, Any]]:
         """Get live runtime data for facades (sun on facade)."""
         if self.data:
@@ -1064,7 +2132,7 @@ def _logbook(self, message: str, entity_id: str | None = None) -> None:
             return
         async_log_entry(
             self.hass,
-            "Cover Automatic",
+            i18n.text(self.hass, "logbook_name"),
             message,
             domain=DOMAIN,
             entity_id=entity_id,
@@ -1072,6 +2140,14 @@ def _logbook(self, message: str, entity_id: str | None = None) -> None:
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update data and evaluate rules."""
+        # Compile native Home Assistant conditions (async) so the rule
+        # evaluation below can run them synchronously; track new entities.
+        try:
+            if await self.engine.async_prepare_ha_conditions():
+                self._setup_state_tracking()
+        except Exception:  # noqa: BLE001 -- never block the update cycle
+            _LOGGER.exception("Failed to prepare Home Assistant conditions")
+
         # Sync cover statuses from sensors before evaluation
         self._sync_cover_statuses()
 
@@ -1088,20 +2164,32 @@ async def _async_update_data(self) -> dict[str, Any]:
                 "sun_on_facade": is_sun_on_facade(self.hass, facade),
             }
 
+        # Safety takeovers/releases only act once commands may be sent
+        in_grace = (time_mod.monotonic() - self._startup_time) < STARTUP_GRACE_PERIOD
+
         for entity_id, cover in self.storage.covers.items():
             status = self.get_cover_status(entity_id)
             target_position: int | None = None
             target_tilt_position: int | None = None
             matching_rule_id: str | None = None
 
-            if status in (CoverStatus.AUTO, CoverStatus.VENTING) and self.storage.enabled:
-                engine_result = self.engine.evaluate_cover(cover)
-                if engine_result is not None:
-                    target_position = engine_result.position
-                    target_tilt_position = engine_result.tilt_position
-                    matching_rule_id = engine_result.rule_id
-                    if matching_rule_id:
-                        active_rules.setdefault(matching_rule_id, []).append(entity_id)
+            if not in_grace and status == CoverStatus.PAUSED and self._resume_on_match(cover):
+                status = self.get_cover_status(entity_id)
+            engine_result = self._evaluate_cover_rules(cover, status)
+            safety = _is_safety(engine_result)
+            if not in_grace and self._update_safety_hold(
+                entity_id, engine_result if safety else None, status
+            ):
+                # Released a paused cover: evaluate it as AUTO right away
+                status = self.get_cover_status(entity_id)
+                engine_result = self._evaluate_cover_rules(cover, status)
+                safety = _is_safety(engine_result)
+            if engine_result is not None:
+                target_position = engine_result.position
+                target_tilt_position = engine_result.tilt_position
+                matching_rule_id = engine_result.rule_id
+                if matching_rule_id:
+                    active_rules.setdefault(matching_rule_id, []).append(entity_id)
 
             # Always refresh comfort mode for live display (independent of rules)
             self.engine._get_comfort_mode(cover)
@@ -1115,7 +2203,8 @@ async def _async_update_data(self) -> dict[str, Any]:
                     rn = rule_name.name if rule_name else matching_rule_id
                     self._log(
                         LOG_EVENT_RULE, entity_id, f"{rn} -> {target_position}%",
-                        {"rule_id": matching_rule_id, "position": target_position},
+                        {"key": "rule", "rule_id": matching_rule_id, "rule_name": rn,
+                         "position": target_position},
                     )
 
             result["covers"][entity_id] = {
@@ -1124,6 +2213,7 @@ async def _async_update_data(self) -> dict[str, Any]:
                 "target_tilt_position": target_tilt_position,
                 "facade_id": cover.facade_id,
                 "matching_rule_id": matching_rule_id,
+                "safety": safety,
             }
 
         result["active_rules"] = active_rules
@@ -1162,8 +2252,197 @@ async def _async_update_data(self) -> dict[str, Any]:
 
         return result
 
+    def _resume_on_match(self, cover: CoverConfig) -> bool:
+        """End a manual pause when the cover is back at its rule's position.
+
+        Two cases: the cover was put back by hand where the rule wants it, or
+        the winning rule changed and now asks for the position the cover was
+        left at. Only a PAUSED cover (never MANUAL, i.e. automation switched
+        off, nor a protective status). Conditions: option enabled (cover or
+        Settings), grace period after the pause started, cover still (not
+        moving, no position report for SETTLE_TIME), a rule gives a target
+        and the position (and the rule's tilt, when set) match it within the
+        minimum position change. Returns True when the cover was resumed.
+        """
+        entity_id = cover.entity_id
+        if self._cover_states.get(entity_id) != CoverStatus.PAUSED or not self.storage.enabled:
+            return False
+        enabled = cover.pause_resume_on_match
+        if enabled is None:
+            enabled = self.storage.pause_resume_on_match
+        if not enabled:
+            return False
+        # Only pauses from a manual override; an explicit pause (service)
+        # lasts its duration. Origin unknown (restored after a restart):
+        # treated as manual, the previous behaviour.
+        if not self._runtime_dict("_pause_manual").get(entity_id, True):
+            return False
+        now_mono = time_mod.monotonic()
+        paused_at = (self._paused_at or {}).get(entity_id)
+        if paused_at is not None and now_mono - paused_at < RESUME_MATCH_GRACE:
+            return False
+        state = self.hass.states.get(entity_id)
+        if state is None or state.state in (*_UNUSABLE_STATES, "opening", "closing"):
+            return False
+        # Stillness from the last real position/motion change: last_updated
+        # also moves on attribute-only reports (Zigbee linkquality), so a
+        # still cover never looked still. Unknown (no change seen since
+        # startup): fall back to the state's last_changed.
+        changed_at = self._runtime_dict("_position_changed_at").get(entity_id)
+        if changed_at is not None:
+            if now_mono - changed_at < SETTLE_TIME:
+                return False
+        else:
+            last_changed = getattr(state, "last_changed", None)
+            if isinstance(last_changed, datetime) and (
+                (dt_util.utcnow() - last_changed).total_seconds() < SETTLE_TIME
+            ):
+                return False
+        current = self._raw_position(state)
+        if current is None:
+            return False
+        result = self.engine.evaluate_cover(cover)
+        if result is None or result.position is None:
+            return False
+        cover_raw = self.storage.get_cover_raw(entity_id) or {}
+        target = int(result.position)
+        if self._is_sensor_open(cover_raw, "vent_sensor"):
+            target = max(target, int(self._cover_val(cover_raw, "vent_position")))
+        if cover_raw.get("inverted", False):
+            target = 100 - target
+        target = self._effective_position(entity_id, target)
+        tolerance = self._cover_val(cover_raw, "min_position_change")
+        if not isinstance(tolerance, (int, float)) or isinstance(tolerance, bool):
+            tolerance = MANUAL_OVERRIDE_TOLERANCE
+        if abs(current - target) > tolerance:
+            return False
+        tilt_target = getattr(result, "tilt_position", None)
+        if tilt_target is not None and cover_raw.get("supports_tilt", False):
+            tilt_now = state.attributes.get("current_tilt_position")
+            if tilt_now is not None:
+                try:
+                    tilt_now = int(tilt_now)
+                except (TypeError, ValueError):
+                    tilt_now = None
+            if tilt_now is not None:
+                wanted = 100 - int(tilt_target) if cover_raw.get("inverted_tilt", False) else int(tilt_target)
+                if abs(tilt_now - wanted) > tolerance:
+                    return False
+        rule = self.storage.rules.get(result.rule_id) if result.rule_id else None
+        rule_name = rule.name if rule else (result.rule_id or "-")
+        _LOGGER.info(
+            "[%s] Pause ended: position %d%% matches rule %s", entity_id, current, rule_name,
+        )
+        self.resume_cover(
+            entity_id, logbook_text=i18n.text(self.hass, "resumed_match", rule=rule_name),
+        )
+        if self._cover_states.get(entity_id) == CoverStatus.PAUSED:
+            return False  # resume refused (wind protection)
+        (self._paused_at or {}).pop(entity_id, None)
+        return True
+
+    def _evaluate_cover_rules(self, cover: CoverConfig, status: CoverStatus) -> Any:
+        """Evaluate the rules that may drive a cover in its current status.
+
+        AUTO/VENTING covers with the automation enabled use all rules. Covers
+        that are paused, manual, wind protected, or with the global automation
+        disabled only follow safety rules. LOCKED covers follow none.
+        """
+        if status in (CoverStatus.AUTO, CoverStatus.VENTING) and self.storage.enabled:
+            return self.engine.evaluate_cover(cover)
+        if status == CoverStatus.LOCKED:
+            return None
+        result = self.engine.evaluate_cover(cover, safety_only=True)
+        return result if _is_safety(result) else None
+
+    def _update_safety_hold(
+        self, entity_id: str, target: Any, status: CoverStatus
+    ) -> bool:
+        """Track which covers a safety rule drives; handle takeover/release.
+
+        On release a paused cover returns to AUTO, a wind protected one goes
+        back to the wind position (wind still active), manual covers and a
+        disabled automation get no further command.
+        Returns True when the cover status changed (pause cancelled).
+        """
+        new_rule = target.rule_id if target is not None else None
+        prev_rule = self._safety_holds.get(entity_id)
+        if new_rule == prev_rule:
+            return False
+        if new_rule:
+            self._safety_holds[entity_id] = new_rule
+            if prev_rule is not None:
+                _LOGGER.debug("[%s] Safety rule %s -> %s", entity_id, prev_rule, new_rule)
+                return False
+            rule_name = target.rule_name or new_rule
+            status_val = status.value if self.storage.enabled else f"{status.value}, automation off"
+            _LOGGER.info(
+                "[%s] Safety rule '%s' takes over (%s) -> %d%%",
+                entity_id, rule_name, status_val, target.position,
+            )
+            self._log(LOG_EVENT_RULE, entity_id,
+                      f"Safety rule {rule_name} takes over ({status_val}) -> {target.position}%",
+                      {"key": "safety_takeover", "rule_id": new_rule, "rule_name": rule_name,
+                       "status": status.value, "position": target.position})
+            return False
+
+        # Released
+        self._safety_holds.pop(entity_id, None)
+        rule = self.storage.rules.get(prev_rule)
+        rule_name = rule.name if rule else prev_rule
+        live = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        changed = False
+        if status == CoverStatus.PAUSED and live == CoverStatus.PAUSED:
+            # The pause is cancelled: the cover returns to normal automation
+            self._cover_states[entity_id] = CoverStatus.AUTO
+            self.storage.update_cover_status(entity_id, CoverStatus.AUTO.value, None)
+            self._update_last_position_from_state(entity_id)
+            self._log(LOG_EVENT_STATUS, entity_id, "paused -> auto",
+                      {"key": "status_change", "from": "paused", "to": "auto"})
+            released_to = "paused -> auto"
+            changed = True
+        elif live == CoverStatus.WIND_PROTECTED and self._wind_protected:
+            self._send_wind_position(entity_id)
+            released_to = f"wind protection -> {self._wind_position()}%"
+        else:
+            released_to = status.value if self.storage.enabled else "automation off"
+        _LOGGER.info("[%s] Safety rule '%s' released (%s)", entity_id, rule_name, released_to)
+        self._log(LOG_EVENT_RULE, entity_id, f"Safety rule {rule_name} released ({released_to})",
+                  {"key": "safety_release", "rule_id": prev_rule, "rule_name": rule_name,
+                   "status": status.value})
+        return changed
+
+    def rename_rule_references(self, old_id: str, new_id: str) -> None:
+        """Follow a rule id rename in runtime state (no spurious rule change)."""
+        for mapping in (self._last_move_rule, self._last_matching_rules, self._safety_holds):
+            for key, value in mapping.items():
+                if value == old_id:
+                    mapping[key] = new_id
+        if not isinstance(self.data, dict):
+            return
+        for cover_data in (self.data.get("covers") or {}).values():
+            if isinstance(cover_data, dict) and cover_data.get("matching_rule_id") == old_id:
+                cover_data["matching_rule_id"] = new_id
+        active = self.data.get("active_rules")
+        if isinstance(active, dict) and old_id in active:
+            self.data["active_rules"] = {
+                (new_id if key == old_id else key): value for key, value in active.items()
+            }
+
     async def async_apply_positions(self) -> None:
-        """Apply calculated positions to covers with hysteresis."""
+        """Apply calculated positions to covers with hysteresis.
+
+        Serialised: an apply cycle sleeping in the command stagger must not
+        interleave with the next one (a stale target could be sent after a
+        newer one, or both cycles command the same cover).
+        """
+        if self._apply_lock is None:
+            self._apply_lock = asyncio.Lock()
+        async with self._apply_lock:
+            await self._async_apply_positions_locked()
+
+    async def _async_apply_positions_locked(self) -> None:
+        """Apply calculated positions (caller holds the apply lock)."""
         if not self.data:
             return
 
@@ -1174,12 +2453,16 @@ async def async_apply_positions(self) -> None:
         for entity_id, cover_data in self.data.get("covers", {}).items():
             # Use live status from _cover_states instead of snapshot
             status = self._cover_states.get(entity_id, CoverStatus.AUTO)
-            if status not in (CoverStatus.AUTO, CoverStatus.VENTING):
+            # A safety rule also drives paused/manual/wind covers (never LOCKED)
+            safety = cover_data.get("safety") is True and status != CoverStatus.LOCKED
+            if status not in (CoverStatus.AUTO, CoverStatus.VENTING) and not safety:
                 # A new protective/paused state supersedes a pending
                 # protective-exit bypass -- drop it so it cannot skip the
                 # time hysteresis on an unrelated move later.
                 self._post_protective_exit.discard(entity_id)
                 self._hysteresis_info[entity_id] = None
+                if cover_data.get("target_position") is not None:
+                    _LOGGER.debug("[%s] No command: status %s", entity_id, status.value)
                 continue
 
             target = cover_data.get("target_position")
@@ -1204,15 +2487,48 @@ async def async_apply_positions(self) -> None:
             if state.state in ("opening", "closing"):
                 continue
 
-            try:
-                current = int(state.attributes.get("current_position", 0))
-            except (ValueError, TypeError):
+            current = self._raw_position(state)
+            if current is None:
                 continue
 
+            # Enforce vent minimum position (logical, before inversion)
+            original_target = target
+            if status == CoverStatus.VENTING:
+                vent_min = self._cover_val(cover_raw, "vent_position")
+                if target < vent_min:
+                    target = vent_min
+                    _LOGGER.debug("[%s] VENTING: clamped %d%% -> %d%% (vent min)", entity_id, original_target, target)
+
+            # Handle inverted covers (100% = closed)
+            if cover_raw.get("inverted", False):
+                target = 100 - target
+            # Open/close-only covers reach 0 or 100 only: compare with that,
+            # otherwise an intermediate target is re-commanded every cycle.
+            target = self._effective_position(entity_id, target)
+
+            # Our own target changed (rule / scenario / rule disabled / rule
+            # edited) while the cover is still travelling to the position this
+            # cycle commanded before. The stale position it reports is not a
+            # manual override: send the new target right away instead of
+            # waiting for the settle time and misreading the travel.
+            expected_before = self._last_positions.get(entity_id)
+            own_target_change = (
+                entity_id in self._pending_settle
+                and expected_before is not None
+                and self._last_sent_target.get(entity_id) == expected_before
+                and target != expected_before
+            )
+            if own_target_change:
+                _LOGGER.info(
+                    "[%s] Target changed during travel (%d%% -> %d%%), re-commanding",
+                    entity_id, expected_before, target,
+                )
+                self._pending_settle.discard(entity_id)
+
             # Skip covers still settling after our commands (vent/lock moves, rule commands)
             last_cmd_t = self._last_command_time.get(entity_id, 0)
             if entity_id in self._pending_settle:
-                if (time_mod.monotonic() - last_cmd_t) < SETTLE_TIME:
+                if (time_mod.monotonic() - last_cmd_t) < self._settle_time(entity_id):
                     continue
                 # Settle time passed: check if position deviated significantly (manual override)
                 self._pending_settle.discard(entity_id)
@@ -1223,6 +2539,9 @@ async def async_apply_positions(self) -> None:
                         "[%s] Post-settle: large deviation %d%% vs expected %d%%",
                         entity_id, current, expected_target,
                     )
+                    # Not moved at all: lost command, resent (not a manual move)
+                    if self._resend_if_lost(entity_id, current):
+                        continue
                     # Don't sync -- let override check below detect the manual move
                 else:
                     self._last_positions[entity_id] = current
@@ -1232,9 +2551,12 @@ async def async_apply_positions(self) -> None:
             # Detect manual override missed by state-change handler (e.g. during settle time)
             expected = self._last_positions.get(entity_id)
             if (
-                expected is not None
+                not own_target_change
+                and not safety
+                and expected is not None
                 and abs(current - expected) > MANUAL_OVERRIDE_TOLERANCE
-                and (time_mod.monotonic() - self._last_command_time.get(entity_id, 0)) >= SETTLE_TIME
+                and (time_mod.monotonic() - self._last_command_time.get(entity_id, 0))
+                >= self._settle_time(entity_id)
                 and entity_id not in self._pending_settle
                 and status in (CoverStatus.AUTO, CoverStatus.VENTING)
             ):
@@ -1247,22 +2569,27 @@ async def async_apply_positions(self) -> None:
                     self.pause_cover(cover)
                     continue
 
-            # Enforce vent minimum position (logical, before inversion)
-            original_target = target
-            if status == CoverStatus.VENTING:
-                vent_min = self._cover_val(cover_raw, "vent_position")
-                if target < vent_min:
-                    target = vent_min
-                    _LOGGER.debug("[%s] VENTING: clamped %d%% -> %d%% (vent min)", entity_id, original_target, target)
-
-            # Handle inverted covers (100% = closed)
-            if cover_raw.get("inverted", False):
-                target = 100 - target
+            # Window state unknown (lock sensor unavailable, e.g. after a
+            # restart): never lower the cover below its lock position.
+            if self._blocked_by_unknown_lock(entity_id, cover_raw, target, current):
+                self._hysteresis_info[entity_id] = None
+                continue
 
             # Check hysteresis: minimum position change
+            # Fully open/closed targets are honoured once even below
+            # min_change: otherwise a cover resting a few percent short of an
+            # end stop (e.g. 3% vs 0%) would never reach it. Once that end
+            # stop has been commanded, normal hysteresis applies again so a
+            # motor that settles at 1% is not re-commanded forever.
             min_change = self._cover_val(cover_raw, "min_position_change")
             position_diff = abs(current - target)
-            if position_diff < min_change and position_diff > 0:
+            endpoint_pending = (
+                target in (0, 100)
+                and self._last_sent_target.get(entity_id) != target
+            )
+            # A safety rule's new target is sent once regardless of min_change
+            safety_pending = safety and self._last_sent_target.get(entity_id) != target
+            if 0 < position_diff < min_change and not endpoint_pending and not safety_pending:
                 _LOGGER.debug(
                     "Skipping %s: position change %d < min %d",
                     entity_id, position_diff, min_change
@@ -1270,6 +2597,9 @@ async def async_apply_positions(self) -> None:
                 self._hysteresis_info[entity_id] = "position"
                 self._last_positions[entity_id] = current
                 self._sync_tilt_from_state(entity_id, state)
+                # The position is close enough, but a tilt-only change of the
+                # rule must still reach the slats.
+                self._apply_rule_tilt(entity_id, cover_raw, cover_data, position_changed=False)
                 continue
 
             # Check hysteresis: minimum time between changes.
@@ -1291,6 +2621,8 @@ async def async_apply_positions(self) -> None:
                 and (now - last_change) < min_time
                 and not rule_changed
                 and not status_just_reset
+                and not own_target_change
+                and not safety
             ):
                 _LOGGER.debug(
                     "Skipping %s: only %ds since last change (min %ds)",
@@ -1299,46 +2631,58 @@ async def async_apply_positions(self) -> None:
                 self._hysteresis_info[entity_id] = "time"
                 self._last_positions[entity_id] = current
                 self._sync_tilt_from_state(entity_id, state)
+                self._apply_rule_tilt(entity_id, cover_raw, cover_data, position_changed=False)
                 continue
             # Past the time-hysteresis check: consume the one-shot bypass.
             self._post_protective_exit.discard(entity_id)
 
-            # Determine target tilt (if applicable)
-            target_tilt = cover_data.get("target_tilt_position")
-            supports_tilt = cover_raw.get("supports_tilt", False) and self._supports_tilt(entity_id)
-            actual_tilt: int | None = None
-            if target_tilt is not None and supports_tilt:
-                actual_tilt = target_tilt
-                if cover_raw.get("inverted_tilt", False):
-                    actual_tilt = 100 - target_tilt
-
             position_changed = current != target
             if position_changed:
                 if command_sent and stagger > 0:
                     await asyncio.sleep(stagger)
+                    # The status may have changed during the stagger (manual
+                    # pause, window opened, wind): don't send a stale command.
+                    if (
+                        (not safety and (self._wind_protected or not self.storage.enabled))
+                        or self._cover_states.get(entity_id, CoverStatus.AUTO) != status
+                    ):
+                        _LOGGER.debug(
+                            "[%s] Status changed during stagger, skipping command", entity_id
+                        )
+                        continue
                 _LOGGER.info("[%s] Moving %d%% -> %d%%", entity_id, current, target)
                 self._hysteresis_info[entity_id] = None
                 self._last_positions[entity_id] = target
+                self._last_sent_target[entity_id] = target
                 self._last_command_time[entity_id] = time_mod.monotonic()
+                self._move_start[entity_id] = (time_mod.monotonic(), current, target)
+                self._runtime_set("_moved_since_command").discard(entity_id)
                 self._last_move_rule[entity_id] = cover_data.get("matching_rule_id")
                 self._pending_settle.add(entity_id)
+                # A new command: lost-command resends start from zero
+                if self._lost_command_retries:
+                    self._lost_command_retries.pop(entity_id, None)
                 self._log(
                     LOG_EVENT_POSITION, entity_id, f"{current}% -> {target}%",
-                    {"from": current, "to": target, "rule_id": cover_data.get("matching_rule_id")},
+                    {"key": "position", "from": current, "to": target,
+                     "rule_id": cover_data.get("matching_rule_id")},
                 )
                 rule_id = cover_data.get("matching_rule_id")
                 rule_obj = self.storage.rules.get(rule_id) if rule_id else None
-                rule_suffix = f" (rule: {rule_obj.name})" if rule_obj else ""
+                if rule_obj:
+                    logbook_msg = i18n.text(
+                        self.hass, "moved_rule",
+                        from_pos=current, to_pos=target, rule=rule_obj.name,
+                    )
+                else:
+                    logbook_msg = i18n.text(
+                        self.hass, "moved", from_pos=current, to_pos=target
+                    )
                 self._logbook(
-                    f"moved {current}% -> {target}%{rule_suffix}",
+                    logbook_msg,
                     entity_id,
                 )
-                await self.hass.services.async_call(
-                    "cover",
-                    "set_cover_position",
-                    {"entity_id": entity_id, "position": target},
-                    blocking=False,
-                )
+                await self._async_send_position(entity_id, target)
                 self.storage.update_cover_last_change(entity_id, now)
                 command_sent = True
             else:
@@ -1346,15 +2690,36 @@ async def async_apply_positions(self) -> None:
                 self._last_positions[entity_id] = current
                 self._sync_tilt_from_state(entity_id, state)
 
-            # Send tilt if changed (after position with delay, or immediately)
-            if actual_tilt is not None:
-                last_tilt = self._last_tilt_positions.get(entity_id)
-                if last_tilt is None or abs(actual_tilt - last_tilt) > MANUAL_OVERRIDE_TOLERANCE:
-                    self._last_tilt_positions[entity_id] = actual_tilt
-                    tilt_delay = TILT_COMMAND_DELAY if position_changed else 0
-                    if not position_changed:
-                        self._last_command_time[entity_id] = time_mod.monotonic()
-                    self._schedule_tilt(entity_id, actual_tilt, tilt_delay)
+            self._apply_rule_tilt(entity_id, cover_raw, cover_data, position_changed)
+
+    def _apply_rule_tilt(
+        self,
+        entity_id: str,
+        cover_raw: dict[str, Any],
+        cover_data: dict[str, Any],
+        position_changed: bool,
+    ) -> None:
+        """Send the rule's tilt when it differs (after a move with a delay)."""
+        target_tilt = cover_data.get("target_tilt_position")
+        if target_tilt is None:
+            return
+        if not (cover_raw.get("supports_tilt", False) and self._supports_tilt(entity_id)):
+            return
+        actual_tilt = 100 - target_tilt if cover_raw.get("inverted_tilt", False) else target_tilt
+        last_tilt = self._last_tilt_positions.get(entity_id)
+        # Always re-send after a position move: most venetian blind
+        # actuators reset the slat angle while travelling, so an
+        # unchanged target tilt would otherwise be lost.
+        if (
+            position_changed
+            or last_tilt is None
+            or abs(actual_tilt - last_tilt) > MANUAL_OVERRIDE_TOLERANCE
+        ):
+            self._last_tilt_positions[entity_id] = actual_tilt
+            tilt_delay = TILT_COMMAND_DELAY if position_changed else 0
+            if not position_changed:
+                self._last_command_time[entity_id] = time_mod.monotonic()
+            self._schedule_tilt(entity_id, actual_tilt, tilt_delay)
 
     def _supports_tilt(self, entity_id: str) -> bool:
         """Check if a cover entity supports tilt via HA features."""
@@ -1396,17 +2761,67 @@ async def _send_tilt_delayed(
             if self._tilt_tasks.get(entity_id) is asyncio.current_task():
                 del self._tilt_tasks[entity_id]
 
+    @callback
+    def async_sync_entities(self) -> None:
+        """Sync HA entities with the configured covers/facades.
+
+        Removes registry entries of deleted covers/facades and notifies the
+        platforms (coordinator listeners) so they add entities for new ones.
+        """
+        entry = getattr(self, "config_entry", None)
+        if entry is not None:
+            from .entities import async_cleanup_orphan_entities
+
+            async_cleanup_orphan_entities(self.hass, entry, self.storage)
+        self.async_update_listeners()
+
     def set_cover_manual(self, entity_id: str) -> None:
         """Set a cover's status to MANUAL (public API for platforms)."""
+        prev = self._cover_states.get(entity_id, CoverStatus.AUTO)
+        if prev in (CoverStatus.LOCKED, CoverStatus.VENTING) or (
+            self._wind_protected and prev == CoverStatus.WIND_PROTECTED
+        ):
+            # Protections keep acting on a disabled cover: the status stays
+            # (no re-broadcast of the wind position to every cover, no lost
+            # window lock). Overwriting LOCKED/VENTING would also make the
+            # next sync lock/vent the cover again. After the protection ends
+            # the sync sets MANUAL from auto_enabled=False.
+            _LOGGER.debug("[%s] Automation disabled while %s: status kept", entity_id, prev.value)
+            return
+        if prev != CoverStatus.MANUAL:
+            _LOGGER.debug("[%s] Automation disabled: %s -> manual", entity_id, prev.value)
+            self._log(LOG_EVENT_STATUS, entity_id, f"{prev.value} -> manual",
+                      {"key": "status_change", "from": prev.value, "to": "manual"})
         self._cover_states[entity_id] = CoverStatus.MANUAL
         self.storage.update_cover_status(entity_id, CoverStatus.MANUAL.value, None)
 
+    def reconcile_after_import(self) -> None:
+        """Align the cover statuses with auto_enabled after an import.
+
+        An import can switch a cover's automation on or off without going
+        through the switch entity: a re-enabled cover would stay MANUAL (and
+        never be driven again), a disabled one would stay AUTO until the next
+        sync. Protective statuses are kept by resume_cover/set_cover_manual.
+        """
+        for entity_id, cover_raw in list(self.storage._data.get("covers", {}).items()):
+            if not isinstance(cover_raw, dict):
+                continue
+            if cover_raw.get("auto_enabled", True):
+                if self._cover_states.get(entity_id, CoverStatus.AUTO) == CoverStatus.MANUAL:
+                    self.resume_cover(entity_id)
+            else:
+                self.set_cover_manual(entity_id)
+
     async def async_shutdown(self) -> None:
         """Shut down coordinator."""
         if self._unsub_update_listener:
             self._unsub_update_listener()
             self._unsub_update_listener = None
 
+        # Pending staggered wind commands must not run after unload
+        self._cancel_wind_tasks()
+        self._persist_runtime_state()
+
         # Cancel pending tilt tasks
         for task in self._tilt_tasks.values():
             if not task.done():
@@ -1426,3 +2841,7 @@ async def async_shutdown(self) -> None:
                 await self.log_storage.async_save()
         except Exception:
             _LOGGER.warning("Failed to flush pending save during shutdown")
+
+        # Base class: cancel the scheduled refresh and shut the debouncer
+        # down, so no refresh (and no cover command) can run after unload.
+        await super().async_shutdown()
diff --git a/custom_components/cover_automatic/engine.py b/custom_components/cover_automatic/engine.py
index 943c945..c74d0e9 100644
--- a/custom_components/cover_automatic/engine.py
+++ b/custom_components/cover_automatic/engine.py
@@ -6,10 +6,22 @@
 from time import monotonic
 from typing import TYPE_CHECKING, Any
 
+from homeassistant.const import SUN_EVENT_SUNSET
 from homeassistant.util import dt as dt_util
 
+from . import ha_condition as hac
 from .models import ComfortMode, Condition, ConditionType, CoverConfig, CoverTarget, Rule
-from .sun import get_sun_position, get_sunrise_time, get_sunset_time, is_sun_on_facade
+from .storage import resolve_active_scenario
+from .sun import (
+    SUN_EVENT_DUSK,
+    get_dawn_time,
+    get_dusk_time,
+    get_sun_event_time,
+    get_sun_position,
+    get_sunrise_time,
+    get_sunset_time,
+    is_sun_on_facade,
+)
 
 if TYPE_CHECKING:
     from homeassistant.core import HomeAssistant
@@ -23,20 +35,45 @@
 # outages from dropping the shading rule and triggering a fallback movement.
 COMFORT_SENSOR_GRACE_PERIOD = 900  # seconds
 
+# Minimum delay before a failed ha_condition compilation is retried (a
+# transient failure at startup must recover, a truly invalid one must not be
+# recompiled on every refresh).
+HA_CONDITION_RETRY_INTERVAL = 60  # seconds
+
+# Age beyond which a remembered hysteresis state (threshold deadband, previous
+# comfort mode) is no longer trusted: about 10x the default update interval
+# (60 s). A condition that was not evaluated for that long (e.g. its rule was
+# skipped, or sun_on_facade short-circuited before the comfort check) starts
+# again from the hard boundary instead of a state from hours ago.
+HYSTERESIS_STATE_MAX_AGE = 600  # seconds
+
+_UNAVAILABLE_STATES = ("unavailable", "unknown")
+
 _WEATHER_MAP: dict[str, set[str]] = {
     "sunny": {"sunny", "clear", "clear-night"},
     "clear": {"clear", "clear-night"},
     "cloudy": {"cloudy", "fog", "hazy", "overcast", "partlycloudy", "partly-cloudy"},
     "rainy": {"rainy", "pouring", "lightning", "lightning-rainy", "hail"},
     "snowy": {"snowy", "snowy-rainy"},
-    "windy": {"windy", "exceptional"},
+    "windy": {"windy", "windy-variant", "exceptional"},
 }
 
 # Condition types whose result depends on a specific cover/facade context
 # (facade azimuth, per-cover comfort range/sensor). They cannot be previewed
 # in the rule editor without one and report evaluable=False.
 _CONTEXT_DEPENDENT_TYPES: frozenset = frozenset(
-    {ConditionType.SUN_ON_FACADE, ConditionType.TEMPERATURE_COMFORT}
+    {
+        ConditionType.SUN_ON_FACADE,
+        ConditionType.TEMPERATURE_COMFORT,
+        ConditionType.OUTDOOR_VS_INDOOR,
+        ConditionType.ROOM_OCCUPIED,
+    }
+)
+
+# States meaning "occupied" when a cover sets no explicit list (compared
+# case-insensitively): binary sensors, person/device trackers, input_select.
+_DEFAULT_OCCUPIED_STATES = frozenset(
+    {"on", "home", "present", "présent", "occupied", "occupé", "detected", "true", "1"}
 )
 
 
@@ -53,20 +90,75 @@ def __init__(self, hass: HomeAssistant, storage: CoverAutomaticStorage) -> None:
         # (sensor_id, threshold, above, hysteresis) so it survives rule edits
         # and is shared only by genuinely identical checks.
         self._threshold_states: dict[tuple[str, float, bool, float], bool] = {}
-
-    def evaluate_cover(self, cover: CoverConfig) -> CoverTarget | None:
+        # monotonic() of the last update of each _threshold_states entry: an
+        # entry older than HYSTERESIS_STATE_MAX_AGE is ignored, then purged.
+        self._threshold_stamps: dict[tuple[str, float, bool, float], float] = {}
+        self._threshold_purged_at = monotonic()
+        # Compiled native HA conditions, keyed by hac.config_key(config)
+        self._ha_compiled: dict[str, hac.CompiledCondition] = {}
+        # monotonic() of the last failed compilation per key (for retries)
+        self._ha_failed_at: dict[str, float] = {}
+        # Covers already warned about an invalid comfort range override
+        self._comfort_range_warned: set[str] = set()
+        # Threshold entities currently unreadable (warned once per outage)
+        self._threshold_entity_failed: set[str] = set()
+        # Condition errors already logged with a traceback (once each)
+        self._condition_errors_logged: set[str] = set()
+
+    def _log_condition_error(self, condition: Condition, err: Exception) -> None:
+        """Log a failing condition once with its traceback, then at debug level.
+
+        The same error would otherwise fill the log every cycle for every cover.
+        """
+        key = f"{condition.type}:{type(err).__name__}:{err}"
+        if key in self._condition_errors_logged:
+            _LOGGER.debug("Error evaluating condition %s: %s", condition.type, err)
+            return
+        if len(self._condition_errors_logged) > 200:
+            self._condition_errors_logged.clear()
+        self._condition_errors_logged.add(key)
+        _LOGGER.error("Error evaluating condition %s: %s", condition.type, err, exc_info=True)
+
+    def forget_covers_except(self, keep: set[str]) -> None:
+        """Drop per-cover caches of covers that no longer exist."""
+        for cache in (self._last_comfort_mode, self._last_comfort_read):
+            for entity_id in set(cache) - keep:
+                cache.pop(entity_id, None)
+        self._comfort_range_warned &= keep
+
+    def _forget_comfort(self, entity_id: str) -> None:
+        """No usable comfort mode any more: stop reporting a stale one."""
+        self._last_comfort_mode.pop(entity_id, None)
+        self._last_comfort_read.pop(entity_id, None)
+
+    def evaluate_cover(
+        self, cover: CoverConfig, *, safety_only: bool = False
+    ) -> CoverTarget | None:
         """Evaluate rules for a cover and return target position/tilt.
 
+        safety_only=True considers safety rules only (covers that are paused,
+        manual, wind protected or with the automation disabled).
+
+        Among matching rules the highest priority wins, ties broken by rule
+        id. The safety flag never changes that order: it only lets a rule act
+        while the cover is paused/manual/wind protected.
+
         Returns:
             CoverTarget with position (and optional tilt) or None if no rule matches.
         """
-        active_scenario = self.storage.active_scenario
+        # Unknown/empty scenario resolves like the select entity (first one)
+        active_scenario = resolve_active_scenario(
+            self.storage.active_scenario, self.storage.scenarios
+        )
         matching_rules: list[tuple[int, str, Rule]] = []
 
         for rule in self.storage.rules.values():
             if not rule.enabled:
                 continue
 
+            if safety_only and not rule.safety:
+                continue
+
             if not self._rule_applies_to_cover(rule, cover):
                 continue
 
@@ -77,23 +169,117 @@ def evaluate_cover(self, cover: CoverConfig) -> CoverTarget | None:
                 matching_rules.append((rule.priority, rule.id, rule))
 
         if not matching_rules:
-            _LOGGER.debug("[%s] No rule matched", cover.entity_id)
+            _LOGGER.debug(
+                "[%s] No %srule matched", cover.entity_id, "safety " if safety_only else ""
+            )
             return None
 
         # Sort by priority desc, then by rule ID asc for deterministic order
         matching_rules.sort(key=lambda x: (-x[0], x[1]))
         winner = matching_rules[0][2]
         _LOGGER.debug(
-            "[%s] Rule '%s' (P%d) -> position %d",
-            cover.entity_id, winner.name, winner.priority, winner.target_position,
+            "[%s] Rule '%s' (P%d%s) -> position %d",
+            cover.entity_id, winner.name, winner.priority,
+            ", safety" if winner.safety else "", winner.target_position,
         )
         return CoverTarget(
             position=winner.target_position,
             tilt_position=winner.target_tilt_position,
             rule_id=winner.id,
             rule_name=winner.name,
+            safety=bool(winner.safety),
         )
 
+    # ------------------------------------------------------------------
+    # Native Home Assistant conditions
+    # ------------------------------------------------------------------
+
+    def ha_compiled(self, condition: Condition) -> hac.CompiledCondition | None:
+        """Return the compiled form of an ha_condition (None if not prepared)."""
+        return self._ha_compiled.get(hac.config_key(condition.params.get("config")))
+
+    async def async_prepare_ha_conditions(
+        self, conditions: list[Condition] | None = None
+    ) -> bool:
+        """Compile the ha_conditions of all rules (or the given ones).
+
+        Compilation is async in Home Assistant, evaluation is sync: rules are
+        compiled here before each update cycle, then evaluated cheaply.
+        Unused compiled entries are dropped when preparing all rules.
+        Returns True if the set of referenced entities changed.
+        """
+        before = self.ha_condition_entities()
+        if conditions is None:
+            conditions = [
+                c for rule in self.storage.rules.values() for c in rule.conditions
+                if c.type == ConditionType.HA_CONDITION
+            ]
+            wanted = {hac.config_key(c.params.get("config")) for c in conditions}
+            for key in list(self._ha_compiled):
+                if key not in wanted:
+                    del self._ha_compiled[key]
+                    self._ha_failed_at.pop(key, None)
+        for cond in conditions:
+            if cond.type != ConditionType.HA_CONDITION:
+                continue
+            # One broken condition must never stop the others from compiling
+            try:
+                await self._async_prepare_one(cond)
+            except Exception as err:  # noqa: BLE001
+                config = cond.params.get("config")
+                _LOGGER.warning("Cannot compile Home Assistant condition %s: %s", config, err)
+                key = hac.config_key(config)
+                self._ha_compiled[key] = hac.CompiledCondition(
+                    error=str(err), error_code="invalid"
+                )
+                self._ha_failed_at[key] = monotonic()
+        return self.ha_condition_entities() != before
+
+    async def _async_prepare_one(self, cond: Condition) -> None:
+        """Compile one ha_condition (or refresh its template entities)."""
+        config = cond.params.get("config")
+        key = hac.config_key(config)
+        compiled = self._ha_compiled.get(key)
+        if compiled is not None:
+            failed_at = self._ha_failed_at.get(key)
+            if failed_at is None:
+                # Valid: templates may reference other entities now (e.g.
+                # {{ states(states('input_text.x')) }}), re-read them so the
+                # coordinator listens to the right entities.
+                hac.refresh_template_entities(self.hass, compiled)
+                return
+            # Failed compilations are retried after a delay (the failed
+            # entry stays cached meanwhile so the panel sees the error).
+            if monotonic() - failed_at < HA_CONDITION_RETRY_INTERVAL:
+                return
+        compiled = await hac.async_compile(self.hass, config)
+        if compiled.error:
+            _LOGGER.debug("Invalid Home Assistant condition %s: %s", config, compiled.error)
+            self._ha_failed_at[key] = monotonic()
+        else:
+            self._ha_failed_at.pop(key, None)
+        self._ha_compiled[key] = compiled
+
+    def ha_condition_entities(self) -> set[str]:
+        """Entities referenced by the compiled Home Assistant conditions."""
+        entities: set[str] = set()
+        for compiled in self._ha_compiled.values():
+            entities |= compiled.entities
+        return entities
+
+    def ha_condition_status(self, condition: Condition) -> dict[str, Any] | None:
+        """Validation status of an ha_condition for the panel."""
+        if condition.type != ConditionType.HA_CONDITION:
+            return None
+        compiled = self.ha_compiled(condition)
+        if compiled is None:
+            return {"valid": False, "error": None, "error_code": "pending"}
+        return {
+            "valid": compiled.valid,
+            "error": compiled.error,
+            "error_code": compiled.error_code,
+        }
+
     def _rule_applies_to_cover(self, rule: Rule, cover: CoverConfig) -> bool:
         """Check if rule applies to cover.
 
@@ -115,26 +301,259 @@ def _rule_applies_to_cover(self, rule: Rule, cover: CoverConfig) -> bool:
     def _rule_active_in_scenario(self, rule: Rule, scenario_id: str) -> bool:
         """Check if rule is active in current scenario.
 
-        Uses simple blacklist logic: rules are active unless explicitly
-        disabled in the scenario's rules_disabled list.
+        A rule is active in a scenario when it belongs to it (its
+        scenario_ids) and is not switched off in the scenario's
+        rules_disabled list.
         """
         scenario = self.storage.scenarios.get(scenario_id)
         if scenario is None:
             return True
+        # The rule must belong to the scenario (None = all scenarios) ...
+        if rule.scenario_ids is not None and scenario_id not in rule.scenario_ids:
+            return False
+        # ... and not be switched off inside it
         return rule.id not in scenario.rules_disabled
 
     def _evaluate_conditions(self, rule: Rule, cover: CoverConfig) -> bool:
         """Evaluate all conditions of a rule.
 
-        Supports AND and OR operators:
-        - AND (default): All conditions must be true
-        - OR: At least one condition must be true
+        Conditions are organised in groups. Inside a group they are combined
+        with the group's operator (group_operators), the groups themselves
+        with the rule's condition_operator -- e.g. (A or B) and (C or D).
+        With a single group only its own operator applies. Empty groups are
+        ignored; a condition can be negated (NOT).
+        """
+        groups = rule.condition_groups()
+        if not groups:
+            return True
+
+        # Evaluate every condition first (no short-circuit) so the
+        # hysteresis state of each threshold condition stays current.
+        evaluated = [
+            (op, [self._evaluate_final(c, cover) for c in members])
+            for op, members in groups
+        ]
+
+        def group_result(op: str, results: list[bool]) -> bool:
+            return any(results) if op == "or" else all(results)
+
+        if len(evaluated) == 1:
+            return group_result(*evaluated[0])
+        group_results = [group_result(op, results) for op, results in evaluated]
+        return any(group_results) if rule.condition_operator == "or" else all(group_results)
+
+    def _evaluate_final(
+        self, condition: Condition, cover: CoverConfig | None, *, update_state: bool = True
+    ) -> bool:
+        """Evaluate a condition including its NOT flag.
+
+        A negated condition is only met when its input is actually known:
+        an unavailable sensor must not turn "NOT rain" into "met".
+        """
+        if not condition.negate:
+            return self._evaluate_condition(condition, cover, update_state=update_state)  # type: ignore[arg-type]
+        return self._evaluate_tristate(condition, cover, update_state=update_state) is False
+
+    def _evaluate_tristate(
+        self, condition: Condition, cover: CoverConfig | None, *, update_state: bool = True
+    ) -> bool | None:
+        """Evaluate a condition (without NOT): True/False, or None when unknown.
+
+        Unknown = the input cannot be read, the condition is misconfigured
+        (missing or non-numeric threshold/offset), the evaluation raised, or
+        the native HA condition failed to evaluate.
+        """
+        if condition.type == ConditionType.HA_CONDITION:
+            return hac.evaluate_tristate(self.hass, self.ha_compiled(condition))
+        if not self._params_valid(condition):
+            _LOGGER.debug("Condition %s misconfigured: %s", condition.type, condition.params)
+            return None
+        try:
+            result = self._dispatch_condition(condition, cover, update_state=update_state)  # type: ignore[arg-type]
+        except Exception as err:  # noqa: BLE001
+            self._log_condition_error(condition, err)
+            return None
+        if not self._input_available(condition, cover):
+            return None
+        return result
+
+    @staticmethod
+    def _params_valid(condition: Condition) -> bool:
+        """Whether a condition's own parameters can be evaluated.
+
+        The evaluators return False on invalid parameters; for a negated
+        condition that would read as "met", so _evaluate_tristate reports
+        such a condition as unknown instead (NOT is then not met either).
+        Mirrors the parsing done by the evaluators.
+        """
+        params = condition.params
+
+        def is_number(value: Any) -> bool:
+            try:
+                float(value)
+            except (TypeError, ValueError):
+                return False
+            return True
+
+        match condition.type:
+            case ConditionType.NUMERIC_STATE:
+                return is_number(params.get("value")) and is_number(
+                    params.get("hysteresis") or 0
+                )
+            case ConditionType.TEMPERATURE_ABOVE | ConditionType.TEMPERATURE_BELOW:
+                temp = params.get("temperature")
+                return is_number(temp if temp is not None else params.get("value", 0))
+            case ConditionType.SUN_ELEVATION_ABOVE | ConditionType.SUN_ELEVATION_BELOW:
+                elev = params.get("elevation")
+                return is_number(elev if elev is not None else params.get("value", 0))
+            case (
+                ConditionType.TIME_AFTER_SUNRISE | ConditionType.TIME_BEFORE_SUNRISE
+                | ConditionType.TIME_AFTER_SUNSET | ConditionType.TIME_BEFORE_SUNSET
+                | ConditionType.TIME_AFTER_DAWN | ConditionType.TIME_BEFORE_DAWN
+                | ConditionType.TIME_AFTER_DUSK | ConditionType.TIME_BEFORE_DUSK
+            ):
+                try:
+                    int(params.get("offset", 0))
+                except (TypeError, ValueError):
+                    return False
+                return True
+            case ConditionType.STATE_IS:
+                return params.get("state") is not None
+            case _:
+                return True
+
+    def _input_available(self, condition: Condition, cover: CoverConfig | None) -> bool:
+        """Whether the value a condition reads is currently known."""
+        params = condition.params
+        match condition.type:
+            case ConditionType.STATE_IS:
+                entity_id = params.get("entity_id") or params.get("entity")
+                if not entity_id:
+                    return False
+                if str(params.get("state")) in _UNAVAILABLE_STATES:
+                    # Checking for "unavailable" itself: any existing state is known
+                    return self.hass.states.get(entity_id) is not None
+                return self._read_state(entity_id) is not None
+            case ConditionType.NUMERIC_STATE:
+                entity_id = params.get("entity_id") or params.get("entity")
+                return self._read_float_state(entity_id) is not None
+            case ConditionType.TEMPERATURE_ABOVE | ConditionType.TEMPERATURE_BELOW:
+                sensor_id = params.get("sensor") or self.storage.outdoor_temp_sensor
+                return self._read_float_state(sensor_id) is not None
+            case ConditionType.WEATHER_IS:
+                return self._read_state(params.get("entity") or self.storage.weather_entity) is not None
+            case ConditionType.WORKDAY:
+                return self._read_state(params.get("entity_id") or self.storage.workday_sensor) is not None
+            case ConditionType.TEMPERATURE_COMFORT:
+                return cover is not None and self._comfort_known(cover)
+            case ConditionType.OUTDOOR_VS_INDOOR:
+                return cover is not None and all(
+                    self._read_float_state(s) is not None
+                    for s in self._outdoor_indoor_sensors(cover)
+                )
+            case ConditionType.ROOM_OCCUPIED:
+                sensor = cover.occupancy_sensor if cover is not None else None
+                return not sensor or self._read_state(sensor) is not None
+            case ConditionType.SUN_ON_FACADE:
+                return self._sun_on_facade_known(condition, cover)
+            case ConditionType.SUN_ELEVATION_ABOVE | ConditionType.SUN_ELEVATION_BELOW:
+                return get_sun_position(self.hass) is not None
+            case ConditionType.TIME_BEFORE_SUNRISE:
+                return get_sunrise_time(self.hass) is not None
+            case ConditionType.TIME_AFTER_SUNSET:
+                return get_sunset_time(self.hass) is not None
+            case ConditionType.TIME_BEFORE_DAWN:
+                return get_dawn_time(self.hass) is not None
+            case ConditionType.TIME_AFTER_DUSK:
+                return get_dusk_time(self.hass) is not None
+            # Daytime windows need both of today's events
+            case ConditionType.TIME_AFTER_SUNRISE | ConditionType.TIME_BEFORE_SUNSET:
+                return (
+                    get_sunrise_time(self.hass) is not None
+                    and get_sunset_time(self.hass) is not None
+                )
+            case ConditionType.TIME_AFTER_DAWN | ConditionType.TIME_BEFORE_DUSK:
+                return (
+                    get_dawn_time(self.hass) is not None
+                    and get_dusk_time(self.hass) is not None
+                )
+            case ConditionType.HA_CONDITION:
+                compiled = self.ha_compiled(condition)
+                return compiled is not None and compiled.checker is not None
+            case _:
+                return True
+
+    def _sun_on_facade_known(self, condition: Condition, cover: CoverConfig | None) -> bool:
+        """Whether sun_on_facade can be decided (mirrors _eval_sun_on_facade)."""
+        if cover is None or get_sun_position(self.hass) is None:
+            return False
+        facade_id = condition.params.get("facade") or cover.facade_id
+        facade = self.storage.facades.get(facade_id) if facade_id else None
+        if not facade:
+            return False
+        # The comfort mode only matters while the sun is on the facade
+        if not self._sun_uses_comfort(cover):
+            return True
+        if not is_sun_on_facade(self.hass, facade):
+            return True
+        if not self._comfort_known(cover):
+            return False
+        # Neutral mode with preemptive shading: the answer depends on the
+        # solar sensor, unknown while it cannot be read.
+        _, neutral_ignore, preemptive = self._sun_flags(cover)
+        if (
+            neutral_ignore
+            and preemptive
+            and self._last_comfort_mode.get(cover.entity_id) == ComfortMode.NEUTRAL
+        ):
+            return self._solar_known()
+        return True
+
+    def _solar_known(self) -> bool:
+        """Whether the preemptive-shading solar check can be decided."""
+        sensor_id = self.storage.solar_sensor
+        if not sensor_id or self.effective_solar_threshold() <= 0:
+            return True  # no sensor: preemptive shading simply never applies
+        return self._read_float_state(sensor_id) is not None
+
+    def _sun_flags(self, cover: CoverConfig) -> tuple[bool, bool, bool]:
+        """Effective (heating_ignore, neutral_ignore, preemptive) for a cover.
+
+        A per-cover value overrides the global setting when not None.
         """
-        if not rule.conditions:
+        def pick(own: bool | None, default: bool) -> bool:
+            return default if own is None else bool(own)
+
+        return (
+            pick(cover.sun_heating_ignore, self.storage.sun_heating_ignore),
+            pick(cover.sun_neutral_ignore, self.storage.sun_neutral_ignore),
+            pick(cover.preemptive_shading, self.storage.preemptive_shading),
+        )
+
+    def _sun_uses_comfort(self, cover: CoverConfig) -> bool:
+        """Whether sun_on_facade depends on the comfort mode for this cover.
+
+        Needs an indoor sensor and at least one active ignore switch;
+        otherwise only the sun position counts.
+        """
+        if not (cover.indoor_temp_sensor or self.storage.indoor_temp_sensor):
+            return False
+        heating_ignore, neutral_ignore, _ = self._sun_flags(cover)
+        return heating_ignore or neutral_ignore
+
+    def _comfort_known(self, cover: CoverConfig) -> bool:
+        """Whether a comfort mode is known (sensor readable or held in grace)."""
+        sensor_id = cover.indoor_temp_sensor or self.storage.indoor_temp_sensor
+        if not sensor_id:
+            return False
+        if self._read_float_state(sensor_id) is not None:
             return True
-        evaluator = any if rule.condition_operator == "or" else all
-        return evaluator(
-            self._evaluate_condition(c, cover) for c in rule.conditions
+        prev = self._last_comfort_mode.get(cover.entity_id)
+        last_read = self._last_comfort_read.get(cover.entity_id)
+        return (
+            prev is not None
+            and last_read is not None
+            and monotonic() - last_read < COMFORT_SENSOR_GRACE_PERIOD
         )
 
     def _evaluate_condition(
@@ -144,54 +563,93 @@ def _evaluate_condition(
 
         update_state=False keeps threshold hysteresis state untouched, so the
         rule editor's live preview cannot shift the runtime deadband.
+        Errors count as not met.
         """
         try:
-            match condition.type:
-                case ConditionType.SUN_ON_FACADE:
-                    return self._eval_sun_on_facade(condition, cover)
-                case ConditionType.SUN_ELEVATION_ABOVE:
-                    return self._eval_sun_elevation(condition, above=True)
-                case ConditionType.SUN_ELEVATION_BELOW:
-                    return self._eval_sun_elevation(condition, above=False)
-                case ConditionType.TEMPERATURE_ABOVE:
-                    return self._eval_temp_threshold(
-                        condition, above=True, update_state=update_state
-                    )
-                case ConditionType.TEMPERATURE_BELOW:
-                    return self._eval_temp_threshold(
-                        condition, above=False, update_state=update_state
-                    )
-                case ConditionType.TIME_BETWEEN:
-                    return self._eval_time_between(condition)
-                case ConditionType.TIME_AFTER_SUNRISE:
-                    return self._eval_time_after_sun_event(condition, get_sunrise_time)
-                case ConditionType.TIME_AFTER_SUNSET:
-                    return self._eval_time_after_sun_event(condition, get_sunset_time)
-                case ConditionType.TIME_BEFORE_SUNRISE:
-                    return self._eval_time_before_sun_event(condition, get_sunrise_time)
-                case ConditionType.TIME_BEFORE_SUNSET:
-                    return self._eval_time_before_sun_event(condition, get_sunset_time)
-                case ConditionType.STATE_IS:
-                    return self._eval_state_is(condition)
-                case ConditionType.NUMERIC_STATE:
-                    return self._eval_numeric_state(
-                        condition, update_state=update_state
-                    )
-                case ConditionType.TEMPERATURE_COMFORT:
-                    return self._eval_temp_comfort(condition, cover)
-                case ConditionType.WEATHER_IS:
-                    return self._eval_weather_is(condition)
-                case ConditionType.DAY_OF_WEEK:
-                    return self._eval_day_of_week(condition)
-                case ConditionType.WORKDAY:
-                    return self._eval_workday(condition)
-                case _:
-                    _LOGGER.warning("Unknown condition type: %s", condition.type)
-                    return False
-        except Exception as err:
-            _LOGGER.error("Error evaluating condition %s: %s", condition.type, err, exc_info=True)
+            return self._dispatch_condition(condition, cover, update_state=update_state)
+        except Exception as err:  # noqa: BLE001
+            self._log_condition_error(condition, err)
             return False
 
+    def _dispatch_condition(
+        self, condition: Condition, cover: CoverConfig, *, update_state: bool = True
+    ) -> bool:
+        """Run the evaluator of a condition type (may raise)."""
+        match condition.type:
+            case ConditionType.SUN_ON_FACADE:
+                return self._eval_sun_on_facade(condition, cover)
+            case ConditionType.SUN_ELEVATION_ABOVE:
+                return self._eval_sun_elevation(condition, above=True)
+            case ConditionType.SUN_ELEVATION_BELOW:
+                return self._eval_sun_elevation(condition, above=False)
+            case ConditionType.TEMPERATURE_ABOVE:
+                return self._eval_temp_threshold(
+                    condition, above=True, update_state=update_state
+                )
+            case ConditionType.TEMPERATURE_BELOW:
+                return self._eval_temp_threshold(
+                    condition, above=False, update_state=update_state
+                )
+            case ConditionType.TIME_BETWEEN:
+                return self._eval_time_between(condition)
+            case ConditionType.TIME_AFTER_SUNRISE:
+                return self._eval_time_after_morning_event(
+                    condition, get_sunrise_time, get_sunset_time,
+                    ConditionType.TIME_AFTER_SUNSET,
+                )
+            case ConditionType.TIME_AFTER_SUNSET:
+                return self._eval_time_after_sunset(condition)
+            case ConditionType.TIME_BEFORE_SUNRISE:
+                return self._eval_time_before_morning_event(
+                    condition, get_sunrise_time, get_sunset_time
+                )
+            case ConditionType.TIME_BEFORE_SUNSET:
+                return self._eval_time_before_evening_event(
+                    condition, get_sunset_time, get_sunrise_time,
+                    ConditionType.TIME_BEFORE_SUNRISE,
+                )
+            case ConditionType.TIME_AFTER_DAWN:
+                return self._eval_time_after_morning_event(
+                    condition, get_dawn_time, get_dusk_time,
+                    ConditionType.TIME_AFTER_DUSK,
+                )
+            case ConditionType.TIME_BEFORE_DAWN:
+                return self._eval_time_before_morning_event(
+                    condition, get_dawn_time, get_dusk_time
+                )
+            case ConditionType.TIME_AFTER_DUSK:
+                return self._eval_time_after_dusk(condition)
+            case ConditionType.TIME_BEFORE_DUSK:
+                return self._eval_time_before_evening_event(
+                    condition, get_dusk_time, get_dawn_time,
+                    ConditionType.TIME_BEFORE_DAWN,
+                )
+            case ConditionType.STATE_IS:
+                return self._eval_state_is(condition)
+            case ConditionType.NUMERIC_STATE:
+                return self._eval_numeric_state(
+                    condition, update_state=update_state
+                )
+            case ConditionType.TEMPERATURE_COMFORT:
+                return self._eval_temp_comfort(condition, cover)
+            case ConditionType.OUTDOOR_VS_INDOOR:
+                return self._eval_outdoor_vs_indoor(
+                    condition, cover, update_state=update_state
+                )
+            case ConditionType.ROOM_OCCUPIED:
+                return self._eval_room_occupied(cover)
+            case ConditionType.WEATHER_IS:
+                return self._eval_weather_is(condition)
+            case ConditionType.DAY_OF_WEEK:
+                return self._eval_day_of_week(condition)
+            case ConditionType.WORKDAY:
+                return self._eval_workday(condition)
+            case ConditionType.HA_CONDITION:
+                return hac.evaluate(self.hass, self.ha_compiled(condition))
+            case _:
+                _LOGGER.warning("Unknown condition type: %s", condition.type)
+                return False
+
     def preview_condition(self, condition: Condition) -> dict[str, Any]:
         """Evaluate a condition for the rule editor's live preview.
 
@@ -207,9 +665,7 @@ def preview_condition(self, condition: Condition) -> dict[str, Any]:
             return {"evaluable": False}
         try:
             # cover is unused for global condition types (filtered above)
-            matched = self._evaluate_condition(
-                condition, None, update_state=False,  # type: ignore[arg-type]
-            )
+            matched = self._evaluate_final(condition, None, update_state=False)
             actual, kind = self._preview_actual(condition)
             return {"evaluable": True, "matched": matched, "actual": actual, "kind": kind}
         except Exception as err:  # defensive: preview must never raise
@@ -219,6 +675,9 @@ def preview_condition(self, condition: Condition) -> dict[str, Any]:
     def _preview_actual(self, condition: Condition) -> tuple[Any, str | None]:
         """Return (actual_value, kind) for a global condition's current reading."""
         t = condition.type
+        if t == ConditionType.HA_CONDITION:
+            reading = hac.simple_reading(self.hass, condition.params.get("config"))
+            return reading, ("ha_reading" if reading else None)
         if t in (ConditionType.SUN_ELEVATION_ABOVE, ConditionType.SUN_ELEVATION_BELOW):
             position = get_sun_position(self.hass)
             return (round(position[1], 1) if position else None), "elevation"
@@ -230,6 +689,8 @@ def _preview_actual(self, condition: Condition) -> tuple[Any, str | None]:
         if t in (
             ConditionType.TIME_AFTER_SUNRISE, ConditionType.TIME_BEFORE_SUNRISE,
             ConditionType.TIME_AFTER_SUNSET, ConditionType.TIME_BEFORE_SUNSET,
+            ConditionType.TIME_AFTER_DAWN, ConditionType.TIME_BEFORE_DAWN,
+            ConditionType.TIME_AFTER_DUSK, ConditionType.TIME_BEFORE_DUSK,
         ):
             return self._preview_sun_time(condition), "sun_time"
         if t == ConditionType.NUMERIC_STATE:
@@ -251,9 +712,15 @@ def _preview_actual(self, condition: Condition) -> tuple[Any, str | None]:
 
     def _preview_sun_time(self, condition: Condition) -> str | None:
         """Compute the threshold clock time (sun event + offset) as HH:MM."""
-        event_fn = (
-            get_sunrise_time if "sunrise" in condition.type.value else get_sunset_time
-        )
+        value = condition.type.value
+        if "dawn" in value:
+            event_fn = get_dawn_time
+        elif "dusk" in value:
+            event_fn = get_dusk_time
+        elif "sunrise" in value:
+            event_fn = get_sunrise_time
+        else:
+            event_fn = get_sunset_time
         event_time = event_fn(self.hass)
         if event_time is None:
             return None
@@ -288,12 +755,15 @@ def _read_float_state(self, entity_id: str | None) -> float | None:
     def _eval_sun_on_facade(self, condition: Condition, cover: CoverConfig) -> bool:
         """Evaluate sun_on_facade condition.
 
-        Automatically considers indoor comfort temperature when a sensor is
-        configured (per-cover > global fallback). In HEATING mode, returns
-        False to let sunlight in and save heating energy.
-        When a sensor is configured but unavailable, the last known comfort
-        mode is held for COMFORT_SENSOR_GRACE_PERIOD; beyond that (or without
-        a prior reading) returns False (wait for reliable data before acting).
+        Considers the indoor comfort mode when a sensor is configured
+        (per-cover > global fallback) and an ignore switch is active
+        (sun_heating_ignore / sun_neutral_ignore, per-cover > global):
+        COOLING -> True; HEATING -> not heating_ignore; NEUTRAL -> True
+        unless neutral_ignore, then preemptive shading with solar above
+        threshold. With both switches off only the sun position counts.
+        When the sensor is unavailable, the last known comfort mode is held
+        for COMFORT_SENSOR_GRACE_PERIOD; beyond that (or without a prior
+        reading) returns False (wait for reliable data before acting).
         """
         facade_id = condition.params.get("facade") or cover.facade_id
         if not facade_id:
@@ -306,35 +776,35 @@ def _eval_sun_on_facade(self, condition: Condition, cover: CoverConfig) -> bool:
         if not is_sun_on_facade(self.hass, facade):
             return False
 
-        # Auto comfort check: shade in COOLING, optionally in NEUTRAL with solar trigger
-        sensor_id = cover.indoor_temp_sensor or self.storage.indoor_temp_sensor
-        if sensor_id:
-            comfort_mode = self._get_comfort_mode(cover)
-            if comfort_mode is None:
-                _LOGGER.debug(
-                    "[%s] sun_on_facade: sensor unavailable, deferring",
-                    cover.entity_id,
-                )
-                return False
-            if comfort_mode == ComfortMode.COOLING:
-                return True
-            if (
-                comfort_mode == ComfortMode.NEUTRAL
-                and cover.preemptive_shading
-                and self._check_solar_intensity()
-            ):
-                _LOGGER.debug(
-                    "[%s] sun_on_facade: preemptive shading (solar above threshold)",
-                    cover.entity_id,
-                )
-                return True
+        # Comfort check (indoor sensor + at least one ignore switch active)
+        if not self._sun_uses_comfort(cover):
+            return True
+        heating_ignore, neutral_ignore, preemptive = self._sun_flags(cover)
+        comfort_mode = self._get_comfort_mode(cover)
+        if comfort_mode is None:
             _LOGGER.debug(
-                "[%s] sun_on_facade: skipping shading (%s mode)",
-                cover.entity_id, comfort_mode.value,
+                "[%s] sun_on_facade: sensor unavailable, deferring",
+                cover.entity_id,
             )
             return False
-
-        return True
+        if comfort_mode == ComfortMode.COOLING:
+            return True
+        if comfort_mode == ComfortMode.HEATING:
+            if not heating_ignore:
+                return True
+        elif not neutral_ignore:
+            return True
+        elif preemptive and self._check_solar_intensity():
+            _LOGGER.debug(
+                "[%s] sun_on_facade: preemptive shading (solar above threshold)",
+                cover.entity_id,
+            )
+            return True
+        _LOGGER.debug(
+            "[%s] sun_on_facade: skipping shading (%s mode)",
+            cover.entity_id, comfort_mode.value,
+        )
+        return False
 
     def _get_comfort_mode(self, cover: CoverConfig) -> ComfortMode | None:
         """Determine comfort mode from indoor temperature sensor.
@@ -347,9 +817,14 @@ def _get_comfort_mode(self, cover: CoverConfig) -> ComfortMode | None:
         COMFORT_SENSOR_GRACE_PERIOD so brief outages (e.g. Zigbee bridge
         restart) do not drop active rules. Returns None if no sensor is
         configured, or unavailable beyond the grace period.
+
+        The previous mode only feeds the hysteresis when it was computed
+        less than HYSTERESIS_STATE_MAX_AGE ago; otherwise the hard
+        boundaries decide, as on the first evaluation.
         """
         sensor_id = cover.indoor_temp_sensor or self.storage.indoor_temp_sensor
         if not sensor_id:
+            self._forget_comfort(cover.entity_id)
             return None
 
         state = self.hass.states.get(sensor_id)
@@ -371,16 +846,23 @@ def _get_comfort_mode(self, cover: CoverConfig) -> ComfortMode | None:
                     cover.entity_id, sensor_id, prev.value,
                 )
                 return prev
+            self._forget_comfort(cover.entity_id)
             return None
 
-        self._last_comfort_read[cover.entity_id] = monotonic()
-        h = self.storage.comfort_hysteresis
+        now = monotonic()
+        last_read = self._last_comfort_read.get(cover.entity_id)
         prev = self._last_comfort_mode.get(cover.entity_id)
-        comfort_min = cover.comfort_temp_min if cover.comfort_temp_min is not None else self.storage.comfort_temp_min
-        comfort_max = cover.comfort_temp_max if cover.comfort_temp_max is not None else self.storage.comfort_temp_max
-
+        if last_read is None or now - last_read > HYSTERESIS_STATE_MAX_AGE:
+            # Not evaluated for a while (e.g. sun_on_facade stops before the
+            # comfort check while the sun is off the facade): a mode from
+            # hours ago must not bias the bands, use the hard boundaries.
+            prev = None
+        self._last_comfort_read[cover.entity_id] = now
+        h = self.storage.comfort_hysteresis
+        comfort_min, comfort_max = self._comfort_range(cover)
         if comfort_min >= comfort_max:
             _LOGGER.warning("[%s] comfort_min (%.1f) >= comfort_max (%.1f)", cover.entity_id, comfort_min, comfort_max)
+            self._forget_comfort(cover.entity_id)
             return None
 
         # Hard boundaries first, then hysteresis in the transition bands.
@@ -406,6 +888,111 @@ def _get_comfort_mode(self, cover: CoverConfig) -> ComfortMode | None:
         self._last_comfort_mode[cover.entity_id] = mode
         return mode
 
+    def _setting_entity(self, key: str) -> str | None:
+        """Return a global entity id setting (None when unset)."""
+        value = getattr(self.storage, key, None)
+        return value if isinstance(value, str) and value else None
+
+    def _read_threshold_entity(self, entity_id: str, fallback: Any) -> float | None:
+        """Numeric value of a threshold entity, None when not readable.
+
+        Logs once when the entity becomes unreadable (and once when it
+        recovers), not on every evaluation.
+        """
+        state = self.hass.states.get(entity_id)
+        value: float | None = None
+        if state is not None and state.state not in _UNAVAILABLE_STATES:
+            try:
+                value = float(state.state)
+            except (ValueError, TypeError):
+                value = None
+            if value is not None and (value != value or abs(value) == float("inf")):
+                value = None
+        if value is None:
+            if entity_id not in self._threshold_entity_failed:
+                self._threshold_entity_failed.add(entity_id)
+                _LOGGER.warning(
+                    "Threshold entity %s is unavailable or not numeric (%s), using %s",
+                    entity_id, state.state if state is not None else "missing",
+                    fallback if fallback is not None else "the next fallback",
+                )
+            return None
+        if entity_id in self._threshold_entity_failed:
+            self._threshold_entity_failed.discard(entity_id)
+            _LOGGER.info("Threshold entity %s is readable again (%s)", entity_id, value)
+        return value
+
+    def _threshold_level(self, entity_id: str | None, number: Any) -> Any:
+        """Value of one threshold level: the entity when readable, else the number."""
+        if entity_id:
+            value = self._read_threshold_entity(entity_id, number)
+            if value is not None:
+                return value
+        return number
+
+    def effective_solar_threshold(self) -> float:
+        """Solar threshold: entity value when readable, else the static number."""
+        return float(self._threshold_level(
+            self._setting_entity("solar_threshold_entity"), self.storage.solar_threshold
+        ))
+
+    def _global_comfort_range(self) -> tuple[float, float]:
+        """Global comfort range (entities override the static numbers).
+
+        An invalid pair coming from entities falls back to the static numbers,
+        which the API keeps valid.
+        """
+        static_min = self.storage.comfort_temp_min
+        static_max = self.storage.comfort_temp_max
+        global_min = self._threshold_level(
+            self._setting_entity("comfort_temp_min_entity"), static_min
+        )
+        global_max = self._threshold_level(
+            self._setting_entity("comfort_temp_max_entity"), static_max
+        )
+        if global_min >= global_max and (global_min, global_max) != (static_min, static_max):
+            if "__global__" not in self._comfort_range_warned:
+                self._comfort_range_warned.add("__global__")
+                _LOGGER.warning(
+                    "Invalid comfort range %.1f-%.1f from entities, using %.1f-%.1f",
+                    global_min, global_max, static_min, static_max,
+                )
+            return static_min, static_max
+        self._comfort_range_warned.discard("__global__")
+        return global_min, global_max
+
+    def _comfort_range(self, cover: CoverConfig) -> tuple[float, float]:
+        """Effective comfort range of a cover.
+
+        Per level (cover, then global) a readable entity wins over the
+        number. A per-cover override mixed with a changed global value can
+        produce min >= max; the global pair is then used instead of
+        disabling comfort.
+        """
+        global_min, global_max = self._global_comfort_range()
+        comfort_min = self._threshold_level(
+            getattr(cover, "comfort_temp_min_entity", None), cover.comfort_temp_min
+        )
+        comfort_max = self._threshold_level(
+            getattr(cover, "comfort_temp_max_entity", None), cover.comfort_temp_max
+        )
+        if comfort_min is None:
+            comfort_min = global_min
+        if comfort_max is None:
+            comfort_max = global_max
+        if comfort_min < comfort_max:
+            self._comfort_range_warned.discard(cover.entity_id)
+            return comfort_min, comfort_max
+        if (comfort_min, comfort_max) != (global_min, global_max):
+            if cover.entity_id not in self._comfort_range_warned:
+                self._comfort_range_warned.add(cover.entity_id)
+                _LOGGER.warning(
+                    "[%s] Invalid comfort range %.1f-%.1f, using global range %.1f-%.1f",
+                    cover.entity_id, comfort_min, comfort_max, global_min, global_max,
+                )
+            return global_min, global_max
+        return comfort_min, comfort_max
+
     def _check_solar_intensity(self, *, update_state: bool = True) -> bool:
         """Check if solar intensity exceeds threshold for preemptive shading.
 
@@ -417,7 +1004,8 @@ def _check_solar_intensity(self, *, update_state: bool = True) -> bool:
         sensor_id = self.storage.solar_sensor
         if not sensor_id:
             return False
-        threshold = self.storage.solar_threshold
+        threshold_entity = self._setting_entity("solar_threshold_entity")
+        threshold = self.effective_solar_threshold()
         if threshold <= 0:
             return False
         state = self.hass.states.get(sensor_id)
@@ -430,13 +1018,36 @@ def _check_solar_intensity(self, *, update_state: bool = True) -> bool:
         return self._threshold_with_hysteresis(
             sensor_id, value, float(threshold),
             above=True, update_state=update_state,
-            hysteresis=self.storage.solar_hysteresis,
+            hysteresis=self._solar_hysteresis(float(threshold)),
+            # A threshold read from an entity may change: keep one state
+            # instead of a new entry (and lost hysteresis) per value.
+            state_key=(
+                (f"{sensor_id}|{threshold_entity}", 0.0, True, self.storage.solar_hysteresis)
+                if threshold_entity else None
+            ),
         )
 
+    def _solar_hysteresis(self, threshold: float) -> float:
+        """Solar deadband, bounded so the shading can be released again.
+
+        The sensor never reads below 0, so a buffer >= threshold would put the
+        release point (threshold - h) at or below 0: once on, preemptive
+        shading would never turn off. Such a buffer is clamped to half the
+        threshold.
+        """
+        h = self.storage.solar_hysteresis
+        if threshold > 0 and h >= threshold:
+            return threshold / 2
+        return h
+
     def _eval_sun_elevation(self, condition: Condition, *, above: bool) -> bool:
         """Evaluate sun elevation above/below threshold."""
         elev = condition.params.get("elevation")
         threshold = elev if elev is not None else condition.params.get("value", 0)
+        try:
+            threshold = float(threshold)
+        except (ValueError, TypeError):
+            return False
         position = get_sun_position(self.hass)
         if position is None:
             return False
@@ -486,6 +1097,7 @@ def _threshold_with_hysteresis(
         above: bool,
         update_state: bool,
         hysteresis: float | None = None,
+        state_key: tuple[str, float, bool, float] | None = None,
     ) -> bool:
         """Compare value against threshold with a hysteresis deadband.
 
@@ -496,10 +1108,17 @@ def _threshold_with_hysteresis(
         buffers, and a shared bool would let them overwrite each other.
         hysteresis=None falls back to the global setting (degrees) -- callers
         working in other units must pass their own value.
+
+        A state older than HYSTERESIS_STATE_MAX_AGE (the condition was not
+        evaluated for a while) is ignored like a missing one: the hard
+        boundary decides, not a result remembered from hours ago.
         """
         h = self.storage.threshold_hysteresis if hysteresis is None else hysteresis
-        key = (sensor_id, threshold, above, h)
+        key = state_key or (sensor_id, threshold, above, h)
+        now = monotonic()
         prev = self._threshold_states.get(key)
+        if prev is not None and now - self._threshold_stamps.get(key, 0.0) > HYSTERESIS_STATE_MAX_AGE:
+            prev = None
 
         if prev is None or h <= 0:
             result = value > threshold if above else value < threshold
@@ -510,8 +1129,20 @@ def _threshold_with_hysteresis(
 
         if update_state:
             self._threshold_states[key] = result
+            self._threshold_stamps[key] = now
+            self._purge_threshold_states(now)
         return result
 
+    def _purge_threshold_states(self, now: float) -> None:
+        """Drop expired hysteresis states (at most once per max age)."""
+        if now - self._threshold_purged_at < HYSTERESIS_STATE_MAX_AGE:
+            return
+        self._threshold_purged_at = now
+        for key in list(self._threshold_states):
+            if now - self._threshold_stamps.get(key, 0.0) > HYSTERESIS_STATE_MAX_AGE:
+                self._threshold_states.pop(key, None)
+                self._threshold_stamps.pop(key, None)
+
     def _eval_time_between(self, condition: Condition) -> bool:
         """Evaluate time_between condition."""
         start_str = condition.params.get("start_time") or condition.params.get("start", "00:00")
@@ -529,8 +1160,8 @@ def _eval_time_between(self, condition: Condition) -> bool:
 
         now = dt_util.now().time()
 
-        # Same start and end means all day
-        if start_time == end_time:
+        # Same start and end (HH:MM) means all day
+        if (start_time.hour, start_time.minute) == (end_time.hour, end_time.minute):
             return True
 
         if start_time <= end_time:
@@ -552,6 +1183,130 @@ def _eval_time_after_sun_event(self, condition: Condition, event_fn) -> bool:
         target_time = event_time + (offset_minutes * 60)
         return dt_util.now().timestamp() >= target_time
 
+    def _eval_time_after_sunset(self, condition: Condition) -> bool:
+        """Evaluate time_after_sunset: true from (sunset + offset) until sunrise.
+
+        Comparing against today's sunset only made the condition turn false
+        at midnight, so a night rule stopped matching (and a lower-priority
+        rule could take over) in the middle of the night. After midnight the
+        condition now stays true until today's sunrise as long as yesterday's
+        sunset + offset has passed.
+        """
+        if self._eval_time_after_sun_event(condition, get_sunset_time):
+            return True
+        try:
+            offset_minutes = int(condition.params.get("offset", 0))
+        except (ValueError, TypeError):
+            return False
+        sunrise = get_sunrise_time(self.hass)
+        yesterday_sunset = get_sun_event_time(self.hass, SUN_EVENT_SUNSET, -1)
+        if sunrise is None or yesterday_sunset is None:
+            return False
+        now = dt_util.now().timestamp()
+        return yesterday_sunset + offset_minutes * 60 <= now < sunrise
+
+    def _eval_time_after_dusk(self, condition: Condition) -> bool:
+        """Evaluate time_after_dusk: true from (dusk + offset) until dawn.
+
+        Same night-spanning semantics as time_after_sunset: after midnight it
+        stays true until today's dawn when yesterday's dusk + offset passed.
+        """
+        if self._eval_time_after_sun_event(condition, get_dusk_time):
+            return True
+        try:
+            offset_minutes = int(condition.params.get("offset", 0))
+        except (ValueError, TypeError):
+            return False
+        dawn = get_dawn_time(self.hass)
+        yesterday_dusk = get_sun_event_time(self.hass, SUN_EVENT_DUSK, -1)
+        if dawn is None or yesterday_dusk is None:
+            return False
+        now = dt_util.now().timestamp()
+        return yesterday_dusk + offset_minutes * 60 <= now < dawn
+
+    def _eval_time_before_morning_event(
+        self, condition: Condition, morning_fn, evening_fn
+    ) -> bool:
+        """time_before_sunrise / time_before_dawn, spanning the night.
+
+        Mirror of time_after_sunset / time_after_dusk: true from the evening
+        event (sunset / dusk) until the next morning event + offset, not only
+        between midnight and the morning event.
+        """
+        if self._eval_time_before_sun_event(condition, morning_fn):
+            return True
+        evening = evening_fn(self.hass)
+        return evening is not None and dt_util.now().timestamp() >= evening
+
+    def _configured_offsets(self, condition_type: ConditionType) -> list[int]:
+        """Offsets (minutes) of the conditions of this type in the enabled rules.
+
+        Read from storage on each call (a few rules, cheap): always in step
+        with the configured rules.
+        """
+        offsets: list[int] = []
+        for rule in self.storage.rules.values():
+            if not rule.enabled:
+                continue
+            for cond in rule.conditions:
+                if cond.type != condition_type:
+                    continue
+                try:
+                    offsets.append(int(cond.params.get("offset", 0)))
+                except (TypeError, ValueError):
+                    continue
+        return offsets
+
+    def _eval_time_after_morning_event(
+        self, condition: Condition, morning_fn, evening_fn,
+        closing_type: ConditionType,
+    ) -> bool:
+        """time_after_sunrise / time_after_dawn: a daytime window.
+
+        True from (today's morning event + offset) until today's evening
+        event (sunset / dusk) EXTENDED by the largest positive offset of the
+        night condition taking over (closing_type: time_after_sunset /
+        time_after_dusk) in the enabled rules. Without it, a closing rule
+        "after dusk +15" left 15 minutes where neither matched and a
+        low-priority fallback rule won. Without positive offsets it ends at
+        the evening event: the exact complement of time_before_sunrise /
+        time_before_dawn. Staying true until midnight overlapped the night
+        conditions in the evening. Unknown events (polar day/night) give
+        False, reported as unknown for NOT.
+        """
+        if not self._eval_time_after_sun_event(condition, morning_fn):
+            return False
+        evening = evening_fn(self.hass)
+        if evening is None:
+            return False
+        extension = max([0, *self._configured_offsets(closing_type)])
+        return dt_util.now().timestamp() < evening + extension * 60
+
+    def _eval_time_before_evening_event(
+        self, condition: Condition, evening_fn, morning_fn,
+        night_type: ConditionType,
+    ) -> bool:
+        """time_before_sunset / time_before_dusk: a daytime window.
+
+        True from today's morning event (sunrise / dawn) until (today's
+        evening event + offset). The start is brought FORWARD by the largest
+        negative offset of the night condition ending in the morning
+        (night_type: time_before_sunrise / time_before_dawn) in the enabled
+        rules, so "before sunrise -15" followed by this condition leaves no
+        gap. Without negative offsets it starts at the morning event: the
+        exact complement of time_after_sunset / time_after_dusk. Being true
+        from midnight overlapped the night conditions before sunrise.
+        Unknown events (polar day/night) give False, reported as unknown
+        for NOT.
+        """
+        if not self._eval_time_before_sun_event(condition, evening_fn):
+            return False
+        morning = morning_fn(self.hass)
+        if morning is None:
+            return False
+        lead = -min([0, *self._configured_offsets(night_type)])
+        return dt_util.now().timestamp() >= morning - lead * 60
+
     def _eval_time_before_sun_event(self, condition: Condition, event_fn) -> bool:
         """Evaluate time before sunrise/sunset with offset.
 
@@ -617,6 +1372,62 @@ def _eval_numeric_state(
             above=above, update_state=update_state, hysteresis=hysteresis,
         )
 
+    def _outdoor_indoor_sensors(self, cover: CoverConfig) -> tuple[str | None, str | None]:
+        """(outdoor sensor, indoor sensor of the cover's room)."""
+        return (
+            self.storage.outdoor_temp_sensor,
+            cover.indoor_temp_sensor or self.storage.indoor_temp_sensor,
+        )
+
+    def _eval_outdoor_vs_indoor(
+        self, condition: Condition, cover: CoverConfig | None, *, update_state: bool = True
+    ) -> bool:
+        """Outdoor air warmer/cooler than the cover's room.
+
+        operator "warmer": outdoor > indoor + delta; "cooler": outdoor <
+        indoor - delta. The rule temperature hysteresis applies to the
+        difference, so two sensors a few tenths apart do not flip the rule
+        on every reading. False when a temperature cannot be read.
+        """
+        if cover is None:
+            return False
+        outdoor_id, indoor_id = self._outdoor_indoor_sensors(cover)
+        outdoor = self._read_float_state(outdoor_id)
+        indoor = self._read_float_state(indoor_id)
+        if outdoor is None or indoor is None:
+            return False
+        try:
+            delta = abs(float(condition.params.get("delta") or 0))
+        except (TypeError, ValueError):
+            delta = 0.0
+        warmer = str(condition.params.get("operator", "cooler")) == "warmer"
+        threshold = delta if warmer else -delta
+        h = self.storage.threshold_hysteresis
+        return self._threshold_with_hysteresis(
+            f"{outdoor_id}|{indoor_id}", round(outdoor - indoor, 1), threshold,
+            above=warmer, update_state=update_state,
+            state_key=(f"ovi|{outdoor_id}|{indoor_id}", threshold, warmer, h),
+        )
+
+    def _eval_room_occupied(self, cover: CoverConfig | None) -> bool:
+        """The cover's room is occupied according to its occupancy sensor.
+
+        No sensor: never occupied. Unavailable sensor: False, and the input
+        is reported unknown so "NOT occupied" is not met either (the cover
+        does not open onto a possibly occupied room).
+        """
+        sensor = cover.occupancy_sensor if cover is not None else None
+        if not sensor:
+            return False
+        state = self._read_state(sensor)
+        if state is None:
+            return False
+        if cover.occupancy_states:
+            occupied = {s.strip().casefold() for s in cover.occupancy_states.split(",") if s.strip()}
+        else:
+            occupied = _DEFAULT_OCCUPIED_STATES
+        return state.strip().casefold() in occupied
+
     def _eval_temp_comfort(self, condition: Condition, cover: CoverConfig) -> bool:
         """Evaluate temperature_comfort condition.
 
diff --git a/custom_components/cover_automatic/entities.py b/custom_components/cover_automatic/entities.py
new file mode 100644
index 0000000..e8c6419
--- /dev/null
+++ b/custom_components/cover_automatic/entities.py
@@ -0,0 +1,81 @@
+"""Entity/device registry housekeeping for CoverAutomatic.
+
+Entities are created per managed cover and per facade. Covers and facades can
+be added or removed at runtime from the panel, so the registries have to be
+kept in sync: new objects get entities via coordinator listeners in the
+platforms, removed objects are cleaned up here.
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from homeassistant.core import callback
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import entity_registry as er
+
+from .const import DOMAIN
+
+if TYPE_CHECKING:
+    from homeassistant.config_entries import ConfigEntry
+    from homeassistant.core import HomeAssistant
+
+    from .storage import CoverAutomaticStorage
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def expected_unique_ids(entry_id: str, storage: CoverAutomaticStorage) -> set[str]:
+    """Return the unique_ids of all entities the current config should have."""
+    ids = {
+        f"{DOMAIN}_master",
+        f"{DOMAIN}_{entry_id}_scenario",
+        f"{DOMAIN}_{entry_id}_wind_protection",
+        f"{DOMAIN}_{entry_id}_covers_paused",
+        f"{DOMAIN}_{entry_id}_covers_manual",
+        f"{DOMAIN}_{entry_id}_covers_locked",
+    }
+    for entity_id in storage._data.get("covers", {}):
+        ids.add(f"{DOMAIN}_{entity_id}_auto")
+        for suffix in ("status", "rule", "target", "position", "comfort", "pause_end"):
+            ids.add(f"{DOMAIN}_{entity_id}_{suffix}")
+    for facade_id in storage._data.get("facades", {}):
+        ids.add(f"{DOMAIN}_facade_{facade_id}_sun")
+        ids.add(f"{DOMAIN}_facade_{facade_id}_sun_entry")
+        ids.add(f"{DOMAIN}_facade_{facade_id}_sun_exit")
+    return ids
+
+
+def expected_device_identifiers(entry_id: str, storage: CoverAutomaticStorage) -> set[str]:
+    """Return the (DOMAIN, x) identifier values the current config should have."""
+    idents = {entry_id}
+    idents.update(storage._data.get("covers", {}).keys())
+    idents.update(f"facade_{fid}" for fid in storage._data.get("facades", {}))
+    return idents
+
+
+@callback
+def async_cleanup_orphan_entities(
+    hass: HomeAssistant, entry: ConfigEntry, storage: CoverAutomaticStorage
+) -> None:
+    """Remove registry entities/devices whose cover or facade no longer exists.
+
+    Also removes legacy entities from older versions (e.g. the per-cover
+    pause_duration number entities removed in 1.52.0).
+    """
+    expected = expected_unique_ids(entry.entry_id, storage)
+    ent_reg = er.async_get(hass)
+    for reg_entry in er.async_entries_for_config_entry(ent_reg, entry.entry_id):
+        if reg_entry.platform == DOMAIN and reg_entry.unique_id not in expected:
+            _LOGGER.info("Removing orphan entity %s", reg_entry.entity_id)
+            ent_reg.async_remove(reg_entry.entity_id)
+
+    expected_devices = expected_device_identifiers(entry.entry_id, storage)
+    dev_reg = dr.async_get(hass)
+    for device in dr.async_entries_for_config_entry(dev_reg, entry.entry_id):
+        own = {value for (domain, value) in device.identifiers if domain == DOMAIN}
+        if own and not own & expected_devices:
+            _LOGGER.info("Removing orphan device %s", device.name)
+            dev_reg.async_update_device(
+                device.id, remove_config_entry_id=entry.entry_id
+            )
diff --git a/custom_components/cover_automatic/ha_condition.py b/custom_components/cover_automatic/ha_condition.py
new file mode 100644
index 0000000..966f926
--- /dev/null
+++ b/custom_components/cover_automatic/ha_condition.py
@@ -0,0 +1,218 @@
+"""Native Home Assistant conditions inside CoverAutomatic rules.
+
+A rule condition of type ``ha_condition`` stores a condition written in the
+same format as the ``condition:`` section of a Home Assistant automation
+(state, numeric_state, template, zone, and/or/not, ...). Home Assistant
+validates and evaluates it; this module wraps that for the rule engine.
+
+The raw configuration (plain JSON-compatible dict) is what gets stored. It is
+compiled into a checker once and cached by the engine; evaluation is then a
+cheap synchronous call.
+"""
+from __future__ import annotations
+
+import copy
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import voluptuous as vol
+import yaml
+
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import condition as ha_condition
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.template import Template
+
+if TYPE_CHECKING:
+    from homeassistant.core import HomeAssistant
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class CompiledCondition:
+    """A validated and compiled Home Assistant condition."""
+
+    checker: Any = None
+    entities: set[str] = field(default_factory=set)
+    error: str | None = None
+    error_code: str | None = None
+    # Entities found statically (entity_id fields) and the templates whose
+    # referenced entities are re-read by refresh_template_entities().
+    static_entities: set[str] = field(default_factory=set)
+    templates: list[Any] = field(default_factory=list)
+
+    @property
+    def valid(self) -> bool:
+        """Return True if the condition compiled successfully."""
+        return self.checker is not None
+
+
+def config_key(config: Any) -> str:
+    """Stable cache key for a raw condition configuration."""
+    return json.dumps(config, sort_keys=True, default=str)
+
+
+def parse_yaml(text: str) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+    """Parse YAML text into a condition config.
+
+    A list of conditions is accepted and wrapped in an ``and`` condition,
+    like the ``condition:`` list of an automation.
+    Returns (config, error). error is a dict {code, detail, line, column}
+    so the panel can localize the message.
+    """
+    if not isinstance(text, str) or not text.strip():
+        return None, None
+    try:
+        data = yaml.safe_load(text)
+    except yaml.YAMLError as err:
+        mark = getattr(err, "problem_mark", None)
+        return None, {
+            "code": "yaml",
+            "detail": getattr(err, "problem", None) or str(err),
+            "line": mark.line + 1 if mark else None,
+            "column": mark.column + 1 if mark else None,
+        }
+    if isinstance(data, list):
+        data = {"condition": "and", "conditions": data}
+    if not isinstance(data, dict):
+        return None, {"code": "not_mapping", "detail": None, "line": None, "column": None}
+    return data, None
+
+
+def dump_yaml(config: dict[str, Any] | None) -> str:
+    """Serialize a condition config to YAML (key order preserved)."""
+    if not config:
+        return ""
+    return yaml.safe_dump(config, allow_unicode=True, sort_keys=False, default_flow_style=False)
+
+
+def _find_templates(validated: Any) -> list[Template]:
+    """Templates contained in a validated config."""
+    templates: list[Template] = []
+    stack = [validated]
+    while stack:
+        item = stack.pop()
+        if isinstance(item, Template):
+            templates.append(item)
+        elif isinstance(item, dict):
+            stack.extend(item.values())
+        elif isinstance(item, (list, tuple)):
+            stack.extend(item)
+    return templates
+
+
+def _render_entities(hass: HomeAssistant, templates: list[Template]) -> set[str]:
+    """Entities the templates currently reference (best effort).
+
+    A template's entities can change from one rendering to the next (e.g.
+    {{ states(states('input_text.target')) }}), so this is re-run by
+    refresh_template_entities() before every update cycle. Limitation: the
+    referenced set is only as current as the last refresh; a change of the
+    indirection entity is picked up at the next cycle, not instantly.
+    """
+    entities: set[str] = set()
+    for template in templates:
+        try:
+            if template.hass is None:
+                template.hass = hass
+            entities |= set(template.async_render_to_info().entities)
+        except Exception:  # noqa: BLE001 -- best effort, rendering may fail
+            pass
+    return entities
+
+
+def _template_entities(hass: HomeAssistant, validated: Any) -> set[str]:
+    """Collect entities referenced by templates inside a validated config."""
+    return _render_entities(hass, _find_templates(validated))
+
+
+def refresh_template_entities(hass: HomeAssistant, compiled: CompiledCondition) -> bool:
+    """Re-render the templates of a compiled condition; True if entities changed."""
+    if compiled.checker is None or not compiled.templates:
+        return False
+    entities = compiled.static_entities | _render_entities(hass, compiled.templates)
+    if entities == compiled.entities:
+        return False
+    compiled.entities = entities
+    return True
+
+
+async def async_compile(hass: HomeAssistant, config: Any) -> CompiledCondition:
+    """Validate and compile a raw condition config (never raises)."""
+    if not isinstance(config, dict) or not config:
+        return CompiledCondition(error="empty condition", error_code="empty")
+    try:
+        validated = cv.CONDITION_SCHEMA(copy.deepcopy(config))
+        validated = await ha_condition.async_validate_condition_config(hass, validated)
+        checker = await ha_condition.async_from_config(hass, validated)
+    except (vol.Invalid, HomeAssistantError, ValueError, KeyError, TypeError) as err:
+        return CompiledCondition(error=str(err), error_code="invalid")
+    except Exception as err:  # noqa: BLE001 -- e.g. a failing integration platform
+        _LOGGER.warning("Unexpected error compiling Home Assistant condition %s: %s", config, err)
+        return CompiledCondition(error=str(err) or type(err).__name__, error_code="invalid")
+    try:
+        static = set(ha_condition.async_extract_entities(validated))
+    except Exception as err:  # noqa: BLE001 -- entities are only used to listen
+        _LOGGER.debug("Cannot extract entities of %s: %s", config, err)
+        static = set()
+    templates = _find_templates(validated)
+    entities = static | _render_entities(hass, templates)
+    return CompiledCondition(
+        checker=checker, entities=entities,
+        static_entities=static, templates=templates,
+    )
+
+
+def evaluate(hass: HomeAssistant, compiled: CompiledCondition | None) -> bool:
+    """Evaluate a compiled condition. Invalid or failing conditions are False.
+
+    A disabled condition (``enabled: false``) returns None from HA and is
+    treated as met, like HA ignores it inside an automation.
+    """
+    return evaluate_tristate(hass, compiled) is True
+
+
+def evaluate_tristate(hass: HomeAssistant, compiled: CompiledCondition | None) -> bool | None:
+    """Evaluate a compiled condition: True/False, or None when unknown.
+
+    None = not compiled, invalid, or the evaluation raised (e.g. an entity
+    without a numeric state), so a negated condition is never met by it.
+    """
+    if compiled is None or compiled.checker is None:
+        return None
+    try:
+        result = compiled.checker(hass, None)
+    except Exception as err:  # noqa: BLE001 -- ConditionError & template errors
+        _LOGGER.debug("Home Assistant condition not evaluable (error: %s)", err)
+        return None
+    return True if result is None else bool(result)
+
+
+def simple_reading(hass: HomeAssistant, config: Any) -> dict[str, Any] | None:
+    """Return the current value a simple state/numeric_state condition reads.
+
+    Used by the rule editor preview to show e.g. "Absent" next to the
+    condition. Only for a single entity (optionally inside one ``not``).
+    """
+    cfg = config
+    if isinstance(cfg, dict) and cfg.get("condition") == "not":
+        subs = cfg.get("conditions") or []
+        cfg = subs[0] if len(subs) == 1 else None
+    if not isinstance(cfg, dict) or cfg.get("condition") not in ("state", "numeric_state"):
+        return None
+    entity_id = cfg.get("entity_id")
+    if isinstance(entity_id, list):
+        entity_id = entity_id[0] if len(entity_id) == 1 else None
+    if not isinstance(entity_id, str):
+        return None
+    state = hass.states.get(entity_id)
+    if state is None:
+        return None
+    attribute = cfg.get("attribute")
+    value = state.attributes.get(attribute) if attribute else state.state
+    if value is None:
+        return None
+    return {"entity_id": entity_id, "attribute": attribute, "value": value}
diff --git a/custom_components/cover_automatic/i18n.py b/custom_components/cover_automatic/i18n.py
new file mode 100644
index 0000000..0dbe536
--- /dev/null
+++ b/custom_components/cover_automatic/i18n.py
@@ -0,0 +1,124 @@
+"""Backend texts that Home Assistant's translation files cannot cover.
+
+Entity names/states, device names, services and exceptions are translated
+through strings.json / translations/*.json. The texts below are generated at
+runtime and stored as plain strings (HA logbook entries, default scenario
+names, device models), so they are localized here using the language
+configured in Home Assistant (hass.config.language).
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from homeassistant.core import HomeAssistant
+
+SUPPORTED_LANGUAGES = ("en", "de", "fr")
+
+_TEXTS: dict[str, dict[str, str]] = {
+    "en": {
+        # HA logbook entries
+        "logbook_name": "Cover Automatic",
+        "wind_activated": "wind protection activated ({speed} >= {threshold})",
+        "wind_deactivated": "wind protection deactivated ({speed} <= {threshold})",
+        "wind_disabled": "wind protection deactivated (disabled in settings)",
+        "locked": "locked at {position}% (window open)",
+        "unlocked": "unlocked (window closed)",
+        "paused": "paused for {minutes} min (manual override)",
+        "resumed": "resumed",
+        "resumed_venting": "resumed (venting)",
+        "resumed_match": "resumed: position matches the rule ({rule})",
+        "moved": "moved {from_pos}% -> {to_pos}%",
+        "moved_rule": "moved {from_pos}% -> {to_pos}% (rule: {rule})",
+        # Default scenario names
+        "scenario_everyday": "Everyday",
+        "scenario_summer": "Summer",
+        "scenario_winter": "Winter",
+        "scenario_vacation": "Vacation",
+        "scenario_cinema": "Cinema",
+        "scenario_manual": "Manual",
+        # Device models
+        "model_controller": "Controller",
+        "model_cover": "Cover controller",
+        "no_rule": "No rule",
+        "model_facade": "Facade",
+    },
+    "de": {
+        "logbook_name": "Cover Automatic",
+        "wind_activated": "Windschutz aktiviert ({speed} >= {threshold})",
+        "wind_deactivated": "Windschutz deaktiviert ({speed} <= {threshold})",
+        "wind_disabled": "Windschutz deaktiviert (in den Einstellungen ausgeschaltet)",
+        "locked": "gesperrt bei {position}% (Fenster offen)",
+        "unlocked": "entsperrt (Fenster geschlossen)",
+        "paused": "für {minutes} min pausiert (manuelle Bedienung)",
+        "resumed": "fortgesetzt",
+        "resumed_venting": "fortgesetzt (Lüften)",
+        "resumed_match": "fortgesetzt: Position entspricht der Regel ({rule})",
+        "moved": "gefahren {from_pos}% -> {to_pos}%",
+        "moved_rule": "gefahren {from_pos}% -> {to_pos}% (Regel: {rule})",
+        "scenario_everyday": "Alltag",
+        "scenario_summer": "Sommer",
+        "scenario_winter": "Winter",
+        "scenario_vacation": "Urlaub",
+        "scenario_cinema": "Kino",
+        "scenario_manual": "Manuell",
+        "model_controller": "Steuerung",
+        "model_cover": "Rollladensteuerung",
+        "no_rule": "Keine Regel",
+        "model_facade": "Fassade",
+    },
+    "fr": {
+        "logbook_name": "Cover Automatic",
+        "wind_activated": "protection vent activée ({speed} >= {threshold})",
+        "wind_deactivated": "protection vent désactivée ({speed} <= {threshold})",
+        "wind_disabled": "protection vent désactivée (désactivée dans les réglages)",
+        "locked": "verrouillé à {position} % (fenêtre ouverte)",
+        "unlocked": "déverrouillé (fenêtre fermée)",
+        "paused": "en pause pendant {minutes} min (commande manuelle)",
+        "resumed": "reprise de l'automatisation",
+        "resumed_venting": "reprise de l'automatisation (aération)",
+        "resumed_match": "reprise automatique : position conforme à la règle ({rule})",
+        "moved": "déplacé {from_pos} % -> {to_pos} %",
+        "moved_rule": "déplacé {from_pos} % -> {to_pos} % (règle : {rule})",
+        "scenario_everyday": "Quotidien",
+        "scenario_summer": "Été",
+        "scenario_winter": "Hiver",
+        "scenario_vacation": "Vacances",
+        "scenario_cinema": "Cinéma",
+        "scenario_manual": "Manuel",
+        "model_controller": "Contrôleur",
+        "model_cover": "Contrôleur de volet",
+        "no_rule": "Aucune règle",
+        "model_facade": "Façade",
+    },
+}
+
+# Default scenario ids created on first setup
+DEFAULT_SCENARIO_IDS = ("everyday", "summer", "winter", "vacation", "cinema", "manual")
+
+
+def language(hass: HomeAssistant | None) -> str:
+    """Return the supported language matching the HA configuration (fallback en)."""
+    lang = getattr(getattr(hass, "config", None), "language", None)
+    if not isinstance(lang, str):
+        return "en"
+    lang = lang.lower()
+    if lang in _TEXTS:
+        return lang
+    base = lang.split("-")[0].split("_")[0]
+    return base if base in _TEXTS else "en"
+
+
+def text(hass: HomeAssistant | None, key: str, **params: Any) -> str:
+    """Return the localized text for key, formatted with params."""
+    template = _TEXTS[language(hass)].get(key) or _TEXTS["en"].get(key, key)
+    try:
+        return template.format(**params)
+    except (KeyError, IndexError, ValueError):
+        return template
+
+
+def default_scenario_names(scenario_id: str) -> set[str]:
+    """Return the default names of a built-in scenario in all languages."""
+    key = f"scenario_{scenario_id}"
+    return {texts[key] for texts in _TEXTS.values() if key in texts}
diff --git a/custom_components/cover_automatic/manifest.json b/custom_components/cover_automatic/manifest.json
index 0442a5d..e0c0e69 100644
--- a/custom_components/cover_automatic/manifest.json
+++ b/custom_components/cover_automatic/manifest.json
@@ -1,15 +1,29 @@
 {
   "domain": "cover_automatic",
   "name": "CoverAutomatic",
-  "after_dependencies": ["logbook"],
-  "codeowners": ["@crandler"],
+  "after_dependencies": [
+    "logbook",
+    "lovelace"
+  ],
+  "codeowners": [
+    "@crandler"
+  ],
   "config_flow": true,
-  "dependencies": ["frontend", "http", "sun", "websocket_api"],
+  "dependencies": [
+    "frontend",
+    "http",
+    "sun",
+    "websocket_api"
+  ],
   "documentation": "https://github.com/crandler/CoverAutomatic",
   "integration_type": "service",
   "iot_class": "calculated",
   "issue_tracker": "https://github.com/crandler/CoverAutomatic/issues",
   "requirements": [],
   "single_config_entry": true,
+<<<<<<< Updated upstream
   "version": "1.62.1"
+=======
+  "version": "2.0.0"
+>>>>>>> Stashed changes
 }
diff --git a/custom_components/cover_automatic/models.py b/custom_components/cover_automatic/models.py
index ca01d59..eec92e7 100644
--- a/custom_components/cover_automatic/models.py
+++ b/custom_components/cover_automatic/models.py
@@ -2,12 +2,148 @@
 from __future__ import annotations
 
 import logging
+import math
 from dataclasses import dataclass, field
 from enum import StrEnum
 from typing import Any
 
+import voluptuous as vol
+
 _LOGGER = logging.getLogger(__name__)
 
+# Upper bound on condition groups per rule (keeps the editor readable).
+MAX_CONDITION_GROUPS = 10
+
+
+def _to_int(
+    value: Any, default: int | None, *, lo: int | None = None, hi: int | None = None
+) -> int | None:
+    """Coerce a stored/imported value to int (clamped), default on garbage.
+
+    Accepts ints, floats and numeric strings ("10", "10.0"); None, booleans
+    and anything unparsable fall back to the default.
+    """
+    if value is None or isinstance(value, bool):
+        return default
+    try:
+        result = int(float(value))
+    except (TypeError, ValueError, OverflowError):
+        return default
+    if lo is not None:
+        result = max(lo, result)
+    if hi is not None:
+        result = min(hi, result)
+    return result
+
+
+def _opt_bool(value: Any) -> bool | None:
+    """Coerce a tri-state flag (None = follow the global setting)."""
+    if value is None or isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        text = value.strip().lower()
+        if text in ("true", "on", "yes", "1"):
+            return True
+        if text in ("false", "off", "no", "0"):
+            return False
+    return None
+
+
+def _to_float(value: Any, default: float | None) -> float | None:
+    """Coerce a stored/imported value to a finite float, default on garbage."""
+    if value is None or isinstance(value, bool):
+        return default
+    try:
+        result = float(value)
+    except (TypeError, ValueError, OverflowError):
+        return default
+    return result if math.isfinite(result) else default
+
+
+def _to_bool(value: Any, default: bool) -> bool:
+    """Coerce a stored/imported flag ("false"/"0" strings are False)."""
+    if value is None:
+        return default
+    if isinstance(value, str):
+        return value.strip().lower() in ("true", "1", "yes", "on")
+    return bool(value)
+
+
+def _entity_id(value: Any) -> str | None:
+    """Coerce an optional entity id (non-empty string, else None)."""
+    return value if isinstance(value, str) and value else None
+
+
+def _str_list(value: Any) -> list[str]:
+    """Coerce a list of ids: only a list/tuple of non-empty strings is kept.
+
+    Anything else (notably a bare string, which list() would split into
+    characters) gives an empty list. Duplicates are dropped, order kept.
+    """
+    if not isinstance(value, (list, tuple)):
+        return []
+    return list(dict.fromkeys(v for v in value if isinstance(v, str) and v))
+
+
+def finite_float(value: Any) -> float:
+    """Voluptuous validator: a finite float (rejects NaN/inf, "nan", booleans)."""
+    if isinstance(value, bool):
+        raise vol.Invalid("expected a number")
+    try:
+        result = float(value)
+    except (TypeError, ValueError, OverflowError) as err:
+        raise vol.Invalid(f"expected a number, got {value!r}") from err
+    if not math.isfinite(result):
+        raise vol.Invalid(f"expected a finite number, got {value!r}")
+    return result
+
+
+def finite_range(min_value: float | None = None, max_value: float | None = None) -> Any:
+    """Validator: finite float within [min_value, max_value]."""
+    return vol.All(finite_float, vol.Range(min=min_value, max=max_value))
+
+
+def int_range(min_value: int | None = None, max_value: int | None = None) -> Any:
+    """Validator: integer (from a finite number) within [min_value, max_value]."""
+    return vol.All(finite_float, vol.Coerce(int), vol.Range(min=min_value, max=max_value))
+
+
+def optional_entity_id(value: Any) -> str | None:
+    """Validate an optional entity id: None/"" -> None, else "domain.object"."""
+    if value is None or value == "":
+        return None
+    if isinstance(value, str):
+        domain, dot, object_id = value.strip().partition(".")
+        if dot and domain and object_id:
+            return value.strip()
+    raise vol.Invalid(f"Invalid entity id: {value!r}")
+
+
+# Condition params read as numbers by the engine: a non-finite value (NaN,
+# inf, "nan") is refused so it can neither be stored nor crash an update.
+_NUMERIC_PARAMS = ("value", "elevation", "temperature", "hysteresis", "delta", "offset")
+
+
+def _check_numeric_params(params: dict[str, Any]) -> None:
+    """Raise ValueError when a numeric condition param is not finite."""
+    for key in _NUMERIC_PARAMS:
+        raw = params.get(key)
+        if raw is None or isinstance(raw, bool):
+            continue
+        try:
+            number = float(raw)
+        except (TypeError, ValueError, OverflowError):
+            continue  # not numeric: left to the engine (e.g. an entity state)
+        if not math.isfinite(number):
+            raise ValueError(f"param '{key}' must be a finite number, got {raw!r}")
+
+
+def _position(value: Any, default: int | None) -> int | None:
+    """Coerce a 0-100 position."""
+    return _to_int(value, default, lo=0, hi=100)
+
 
 class CoverStatus(StrEnum):
     """Cover automation status."""
@@ -29,16 +165,26 @@ class ConditionType(StrEnum):
     TEMPERATURE_ABOVE = "temperature_above"
     TEMPERATURE_BELOW = "temperature_below"
     TEMPERATURE_COMFORT = "temperature_comfort"
+    # Outdoor air warmer/cooler than the cover's room (params: operator, delta)
+    OUTDOOR_VS_INDOOR = "outdoor_vs_indoor"
+    # The cover's room is occupied (per-cover occupancy sensor)
+    ROOM_OCCUPIED = "room_occupied"
     TIME_BETWEEN = "time_between"
     TIME_AFTER_SUNRISE = "time_after_sunrise"
     TIME_AFTER_SUNSET = "time_after_sunset"
     TIME_BEFORE_SUNRISE = "time_before_sunrise"
     TIME_BEFORE_SUNSET = "time_before_sunset"
+    TIME_AFTER_DAWN = "time_after_dawn"
+    TIME_BEFORE_DAWN = "time_before_dawn"
+    TIME_AFTER_DUSK = "time_after_dusk"
+    TIME_BEFORE_DUSK = "time_before_dusk"
     STATE_IS = "state_is"
     NUMERIC_STATE = "numeric_state"
     WEATHER_IS = "weather_is"
     DAY_OF_WEEK = "day_of_week"
     WORKDAY = "workday"
+    # Native Home Assistant condition (params: {"config": {...}, "yaml": str, "ui": str})
+    HA_CONDITION = "ha_condition"
 
 
 class ComfortMode(StrEnum):
@@ -57,6 +203,8 @@ class CoverTarget:
     tilt_position: int | None = None
     rule_id: str | None = None
     rule_name: str | None = None
+    # True when the winning rule is a safety rule (overrides pause/manual/wind)
+    safety: bool = False
 
 
 @dataclass(slots=True)
@@ -86,14 +234,22 @@ def to_dict(self) -> dict[str, Any]:
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Facade:
         """Create from dictionary."""
+        azimuths = []
+        for key in ("azimuth_start", "azimuth_end"):
+            value = _to_float(data[key], None)
+            if value is None:
+                # No sensible default for an orientation: the entry is corrupt
+                raise ValueError(f"{key} must be a finite number, got {data[key]!r}")
+            azimuths.append(value % 360)
+        min_elevation = _to_float(data.get("min_elevation"), 0.0)
         return cls(
             id=data["id"],
             name=data["name"],
-            azimuth_start=float(data["azimuth_start"]) % 360,
-            azimuth_end=float(data["azimuth_end"]) % 360,
+            azimuth_start=azimuths[0],
+            azimuth_end=azimuths[1],
             direction=data.get("direction", "south"),
-            min_elevation=float(data.get("min_elevation", 0.0)),
-            cover_ids=list(data.get("cover_ids") or []),
+            min_elevation=max(-90.0, min(90.0, min_elevation)),
+            cover_ids=_str_list(data.get("cover_ids")),
         )
 
 
@@ -103,20 +259,38 @@ class Condition:
 
     type: ConditionType
     params: dict[str, Any] = field(default_factory=dict)
+    # Index of the condition group this condition belongs to (0 = first).
+    group: int = 0
+    # Invert the result (NOT). An unavailable input never becomes "met".
+    negate: bool = False
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
-        return {"type": self.type.value, "params": self.params}
+        return {
+            "type": self.type.value,
+            "params": self.params,
+            "group": self.group,
+            "negate": self.negate,
+        }
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Condition:
         """Create from dictionary."""
+        if not isinstance(data, dict):
+            raise ValueError(f"condition must be a dict, got {type(data).__name__}")
         raw_params = data.get("params", {})
         if not isinstance(raw_params, dict):
             raise ValueError(f"params must be a dict, got {type(raw_params).__name__}")
+        _check_numeric_params(raw_params)
+        try:
+            group = max(0, int(data.get("group") or 0))
+        except (TypeError, ValueError):
+            group = 0
         return cls(
             type=ConditionType(data["type"]),
             params=dict(raw_params),
+            group=min(group, MAX_CONDITION_GROUPS - 1),
+            negate=_to_bool(data.get("negate"), False),
         )
 
 
@@ -128,12 +302,42 @@ class Rule:
     name: str
     enabled: bool = True
     priority: int = 10
-    condition_operator: str = "and"  # "and" or "or"
+    # Operator BETWEEN condition groups ("and"/"or"). With a single group it
+    # is unused: the group's own operator (group_operators[0]) applies.
+    condition_operator: str = "and"
     facade_ids: list[str] = field(default_factory=list)
     cover_ids: list[str] = field(default_factory=list)
     conditions: list[Condition] = field(default_factory=list)
     target_position: int = 0
     target_tilt_position: int | None = None
+    # Scenarios this rule belongs to (None = all scenarios). Within a member
+    # scenario the rule can still be switched off via Scenario.rules_disabled.
+    scenario_ids: list[str] | None = None
+    # Operator INSIDE each condition group ("and"/"or"), one per group.
+    # None = a single group using condition_operator (pre-groups behaviour).
+    group_operators: list[str] | None = None
+    # Safety rule: also drives covers that are paused, manual, wind protected
+    # or with the automation disabled (never window-locked ones).
+    safety: bool = False
+
+    def effective_group_operators(self) -> list[str]:
+        """Operators per group, falling back to the single-group form."""
+        return list(self.group_operators or [self.condition_operator])
+
+    def condition_groups(self) -> list[tuple[str, list[Condition]]]:
+        """Return (operator, conditions) per group, empty groups skipped."""
+        operators = self.effective_group_operators()
+        count = len(operators)
+        for cond in self.conditions:
+            count = max(count, cond.group + 1)
+        groups: list[tuple[str, list[Condition]]] = []
+        for index in range(count):
+            members = [c for c in self.conditions if c.group == index]
+            if not members:
+                continue
+            op = operators[index] if index < len(operators) else "and"
+            groups.append((op, members))
+        return groups
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
@@ -148,29 +352,74 @@ def to_dict(self) -> dict[str, Any]:
             "conditions": [c.to_dict() for c in self.conditions],
             "target_position": self.target_position,
             "target_tilt_position": self.target_tilt_position,
+            "scenario_ids": self.scenario_ids,
+            "group_operators": self.effective_group_operators(),
+            "safety": self.safety,
         }
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Rule:
         """Create from dictionary."""
         conditions: list[Condition] = []
-        for c in data.get("conditions", []):
+        dropped = 0
+        raw_conditions = data.get("conditions")
+        for c in raw_conditions if isinstance(raw_conditions, list) else []:
             try:
                 conditions.append(Condition.from_dict(c))
             except (ValueError, KeyError) as err:
+                dropped += 1
                 _LOGGER.warning("Skipping invalid condition in rule '%s': %s", data.get("name", "?"), err)
         operator = data.get("condition_operator", "and")
+        if operator not in ("and", "or"):
+            operator = "and"
+        raw_groups = data.get("group_operators")
+        if isinstance(raw_groups, list) and raw_groups:
+            group_operators = [
+                op if op in ("and", "or") else "and"
+                for op in raw_groups[:MAX_CONDITION_GROUPS]
+            ]
+        else:
+            # Before condition groups: one group using the rule's operator.
+            group_operators = [operator]
+        facade_ids = _str_list(data.get("facade_ids"))
+        cover_ids = _str_list(data.get("cover_ids"))
+        enabled = _to_bool(data.get("enabled"), True)
+        if enabled and not (facade_ids or cover_ids) and (
+            data.get("facade_ids") or data.get("cover_ids")
+        ):
+            # Unusable assignments must not turn the rule into a global one
+            _LOGGER.warning(
+                "Rule '%s' has invalid cover/facade references and was disabled",
+                data.get("name", "?"),
+            )
+            enabled = False
+        if enabled and dropped:
+            # Without the dropped condition(s) the rule would match more
+            # often than configured -- always, when none is left. Keep it
+            # (the user can fix it) but disabled. A rule configured without
+            # conditions is not concerned (dropped == 0).
+            _LOGGER.warning(
+                "Rule '%s' had %d invalid condition(s) and was disabled",
+                data.get("name", "?"), dropped,
+            )
+            enabled = False
+        # Missing or not a list (never split a string): every scenario
+        raw_scenarios = data.get("scenario_ids")
+        scenario_ids = _str_list(raw_scenarios) if isinstance(raw_scenarios, list) else None
         return cls(
             id=data["id"],
             name=data["name"],
-            enabled=data.get("enabled", True),
-            priority=data.get("priority", 10),
-            condition_operator=operator if operator in ("and", "or") else "and",
-            facade_ids=list(data.get("facade_ids") or []),
-            cover_ids=list(data.get("cover_ids") or []),
+            enabled=enabled,
+            priority=_to_int(data.get("priority"), 10),
+            condition_operator=operator,
+            facade_ids=facade_ids,
+            cover_ids=cover_ids,
             conditions=conditions,
-            target_position=data.get("target_position", 0),
-            target_tilt_position=data.get("target_tilt_position"),
+            target_position=_position(data.get("target_position"), 0),
+            target_tilt_position=_position(data.get("target_tilt_position"), None),
+            scenario_ids=scenario_ids,
+            group_operators=group_operators,
+            safety=_to_bool(data.get("safety"), False),
         )
 
 
@@ -199,7 +448,7 @@ def from_dict(cls, data: dict[str, Any]) -> Scenario:
             id=data["id"],
             name=data["name"],
             icon=data.get("icon", "mdi:home"),
-            rules_disabled=list(data.get("rules_disabled") or []),
+            rules_disabled=_str_list(data.get("rules_disabled")),
         )
 
 
@@ -226,10 +475,28 @@ class CoverConfig:
     indoor_temp_sensor: str | None = None
     comfort_temp_min: float | None = None
     comfort_temp_max: float | None = None
-    preemptive_shading: bool = True
+    # Entities (input_number/number/sensor) overriding the comfort band
+    comfort_temp_min_entity: str | None = None
+    comfort_temp_max_entity: str | None = None
+    # Sun-on-facade comfort switches: None = follow the global setting
+    preemptive_shading: bool | None = None
+    sun_heating_ignore: bool | None = None
+    sun_neutral_ignore: bool | None = None
+    # End a manual pause once the cover is back at its rule's position
+    # (None = follow the global setting)
+    pause_resume_on_match: bool | None = None
+    # Window open: keep the current position (True) instead of moving to lock_position
+    lock_hold_position: bool = False
+    # Room occupancy (condition "room occupied"): entity and the states that
+    # mean occupied (comma-separated; None = usual defaults, e.g. on/home/Présent)
+    occupancy_sensor: str | None = None
+    occupancy_states: str | None = None
     min_position_change: int | None = None
     min_time_between_changes: int | None = None
     last_position_change: float | None = None
+    # Full 0-100 % travel time in seconds: configured, and learned from moves
+    travel_time: int | None = None
+    measured_travel_time: float | None = None
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
@@ -253,10 +520,20 @@ def to_dict(self) -> dict[str, Any]:
             "indoor_temp_sensor": self.indoor_temp_sensor,
             "comfort_temp_min": self.comfort_temp_min,
             "comfort_temp_max": self.comfort_temp_max,
+            "comfort_temp_min_entity": self.comfort_temp_min_entity,
+            "comfort_temp_max_entity": self.comfort_temp_max_entity,
             "preemptive_shading": self.preemptive_shading,
+            "sun_heating_ignore": self.sun_heating_ignore,
+            "sun_neutral_ignore": self.sun_neutral_ignore,
+            "pause_resume_on_match": self.pause_resume_on_match,
+            "lock_hold_position": self.lock_hold_position,
+            "occupancy_sensor": self.occupancy_sensor,
+            "occupancy_states": self.occupancy_states,
             "min_position_change": self.min_position_change,
             "min_time_between_changes": self.min_time_between_changes,
             "last_position_change": self.last_position_change,
+            "travel_time": self.travel_time,
+            "measured_travel_time": self.measured_travel_time,
         }
 
     @classmethod
@@ -279,25 +556,37 @@ def from_dict(cls, data: dict[str, Any]) -> CoverConfig:
         return cls(
             entity_id=data["entity_id"],
             name=data["name"],
-            facade_id=data.get("facade_id"),
-            auto_enabled=data.get("auto_enabled", True),
-            pause_duration=data.get("pause_duration"),
+            facade_id=_entity_id(data.get("facade_id")),
+            auto_enabled=_to_bool(data.get("auto_enabled"), True),
+            # Minimum 1 minute (a 0 stored by an older version becomes 1)
+            pause_duration=_to_int(data.get("pause_duration"), None, lo=1),
             status=status,
-            pause_until=data.get("pause_until"),
-            lock_sensor=data.get("lock_sensor"),
-            lock_position=data.get("lock_position"),
-            vent_sensor=data.get("vent_sensor"),
-            vent_position=data.get("vent_position"),
-            inverted=data.get("inverted", False),
-            supports_tilt=data.get("supports_tilt", False),
-            lock_tilt_position=data.get("lock_tilt_position"),
-            vent_tilt_position=data.get("vent_tilt_position"),
-            inverted_tilt=data.get("inverted_tilt", False),
-            indoor_temp_sensor=data.get("indoor_temp_sensor"),
-            comfort_temp_min=data.get("comfort_temp_min"),
-            comfort_temp_max=data.get("comfort_temp_max"),
-            preemptive_shading=data.get("preemptive_shading", True),
-            min_position_change=data.get("min_position_change"),
-            min_time_between_changes=data.get("min_time_between_changes"),
-            last_position_change=data.get("last_position_change"),
+            pause_until=_to_float(data.get("pause_until"), None),
+            lock_sensor=_entity_id(data.get("lock_sensor")),
+            lock_position=_position(data.get("lock_position"), None),
+            vent_sensor=_entity_id(data.get("vent_sensor")),
+            vent_position=_position(data.get("vent_position"), None),
+            inverted=_to_bool(data.get("inverted"), False),
+            supports_tilt=_to_bool(data.get("supports_tilt"), False),
+            lock_tilt_position=_position(data.get("lock_tilt_position"), None),
+            vent_tilt_position=_position(data.get("vent_tilt_position"), None),
+            inverted_tilt=_to_bool(data.get("inverted_tilt"), False),
+            indoor_temp_sensor=_entity_id(data.get("indoor_temp_sensor")),
+            comfort_temp_min=_to_float(data.get("comfort_temp_min"), None),
+            comfort_temp_max=_to_float(data.get("comfort_temp_max"), None),
+            comfort_temp_min_entity=_entity_id(data.get("comfort_temp_min_entity")),
+            comfort_temp_max_entity=_entity_id(data.get("comfort_temp_max_entity")),
+            preemptive_shading=_opt_bool(data.get("preemptive_shading")),
+            sun_heating_ignore=_opt_bool(data.get("sun_heating_ignore")),
+            sun_neutral_ignore=_opt_bool(data.get("sun_neutral_ignore")),
+            pause_resume_on_match=_opt_bool(data.get("pause_resume_on_match")),
+            lock_hold_position=_to_bool(data.get("lock_hold_position"), False),
+            occupancy_sensor=_entity_id(data.get("occupancy_sensor")),
+            occupancy_states=(str(data["occupancy_states"]).strip() or None)
+            if data.get("occupancy_states") is not None else None,
+            min_position_change=_to_int(data.get("min_position_change"), None, lo=0, hi=100),
+            min_time_between_changes=_to_int(data.get("min_time_between_changes"), None, lo=0),
+            last_position_change=_to_float(data.get("last_position_change"), None),
+            travel_time=_to_int(data.get("travel_time"), None, lo=0),
+            measured_travel_time=_to_float(data.get("measured_travel_time"), None),
         )
diff --git a/custom_components/cover_automatic/panel/cover-automatic-card.js b/custom_components/cover_automatic/panel/cover-automatic-card.js
new file mode 100644
index 0000000..424bb09
--- /dev/null
+++ b/custom_components/cover_automatic/panel/cover-automatic-card.js
@@ -0,0 +1,656 @@
+/*
+ * CoverAutomatic dashboard card.
+ *
+ *   type: custom:cover-automatic-card
+ *   title: Volets            # optional
+ *   covers:                  # optional, default: every managed cover
+ *     - cover.volet_du_salon
+ *   show_rule: true          # optional
+ *   show_auto: true          # optional (automation switch + resume button)
+ *
+ * Everything comes from the per-cover "Status" sensors of the integration
+ * (their attributes carry the rule, target, pause end and the automation
+ * switch), plus the live cover state for the position. No websocket calls,
+ * so it works for non-admin users too.
+ */
+(() => {
+  const CARD_TAG = "cover-automatic-card";
+  const EDITOR_TAG = "cover-automatic-card-editor";
+  if (customElements.get(CARD_TAG)) return;
+
+  const I18N = {
+    en: {
+      no_covers: "No CoverAutomatic cover found. Is the integration set up (version 1.79 or later)?",
+      no_rule: "No rule",
+      resume: "Resume automation",
+      auto: "Automation",
+      safety: "Safety rule",
+      target: "Target",
+      remaining: "{m} min left",
+      inverted: "Inverted cover: HA reports {raw}%",
+      ed_title: "Title",
+      ed_covers: "Covers (empty = all)",
+      ed_show_rule: "Show the active rule",
+      ed_show_auto: "Show the automation switch and the resume button",
+      desc: "Covers managed by CoverAutomatic: position, active rule and status.",
+      scenario: "Scenario",
+      master: "Automation",
+      resume_all: "Resume all",
+      resume_all_title: "End every pause (covers moved by hand)",
+      wind: "Wind",
+      wind_active: "Wind protection",
+      paused: "paused",
+      manual: "manual",
+      locked: "locked",
+      render_error: "Display error, retrying…",
+      ed_show_header: "Show the global part (scenario, automation, statuses)",
+      missing: "Covers not found (not managed by CoverAutomatic?): {ids}",
+    },
+    de: {
+      no_covers: "Kein CoverAutomatic-Rollladen gefunden. Ist die Integration eingerichtet (ab Version 1.79)?",
+      no_rule: "Keine Regel",
+      resume: "Automatik fortsetzen",
+      auto: "Automatik",
+      safety: "Sicherheitsregel",
+      target: "Ziel",
+      remaining: "noch {m} Min.",
+      inverted: "Invertierter Rollladen: HA meldet {raw} %",
+      ed_title: "Titel",
+      ed_covers: "Rollläden (leer = alle)",
+      ed_show_rule: "Aktive Regel anzeigen",
+      ed_show_auto: "Automatik-Schalter und Fortsetzen-Knopf anzeigen",
+      desc: "Von CoverAutomatic gesteuerte Rollläden: Position, aktive Regel und Status.",
+      scenario: "Szenario",
+      master: "Automatik",
+      resume_all: "Alle fortsetzen",
+      resume_all_title: "Alle Pausen beenden (von Hand bewegte Rollläden)",
+      wind: "Wind",
+      wind_active: "Windschutz",
+      paused: "pausiert",
+      manual: "manuell",
+      locked: "gesperrt",
+      render_error: "Anzeigefehler, neuer Versuch…",
+      ed_show_header: "Globalen Teil anzeigen (Szenario, Automatik, Status)",
+      missing: "Rollläden nicht gefunden (nicht von CoverAutomatic gesteuert?): {ids}",
+    },
+    fr: {
+      no_covers: "Aucun volet CoverAutomatic trouvé. L'intégration est-elle installée (version 1.79 ou plus) ?",
+      no_rule: "Aucune règle",
+      resume: "Reprendre l'automatisation",
+      auto: "Automatisation",
+      safety: "Règle de sécurité",
+      target: "Cible",
+      remaining: "encore {m} min",
+      inverted: "Volet inversé : HA indique {raw} %",
+      ed_title: "Titre",
+      ed_covers: "Volets (vide = tous)",
+      ed_show_rule: "Afficher la règle active",
+      ed_show_auto: "Afficher l'interrupteur d'automatisation et le bouton de reprise",
+      desc: "Volets gérés par CoverAutomatic : position, règle active et statut.",
+      scenario: "Scénario",
+      master: "Automatisation",
+      resume_all: "Tout reprendre",
+      resume_all_title: "Lever toutes les pauses (volets bougés à la main)",
+      wind: "Vent",
+      wind_active: "Protection vent",
+      paused: "en pause",
+      manual: "en manuel",
+      locked: "verrouillé(s)",
+      render_error: "Erreur d'affichage, nouvel essai…",
+      ed_show_header: "Afficher la partie globale (scénario, automatisation, statuts)",
+      missing: "Volets introuvables (non gérés par CoverAutomatic\u00A0?)\u00A0: {ids}",
+    },
+  };
+
+  const lang = (hass) => {
+    const l = ((hass && (hass.locale?.language || hass.language)) || "en").slice(0, 2);
+    return I18N[l] ? l : "en";
+  };
+  const t = (hass, key) => I18N[lang(hass)][key] ?? I18N.en[key] ?? key;
+  const esc = (v) => String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+
+  const STATUS_COLORS = {
+    auto: "var(--success-color, #43a047)",
+    paused: "var(--warning-color, #ff9800)",
+    manual: "var(--secondary-text-color, #727272)",
+    locked: "var(--error-color, #db4437)",
+    venting: "var(--info-color, #039be5)",
+    wind_protected: "var(--info-color, #039be5)",
+  };
+
+  // Candidate sensor ids, cached per registry object (hass.entities only
+  // changes when the entity registry does) instead of scanning every state
+  // on every update.
+  const _candidateCache = new WeakMap();
+  function candidateIds(hass) {
+    if (hass.entities) {
+      let ids = _candidateCache.get(hass.entities);
+      if (!ids) {
+        ids = Object.values(hass.entities)
+          .filter((e) => e && e.platform === "cover_automatic" && String(e.entity_id).startsWith("sensor."))
+          .map((e) => e.entity_id);
+        _candidateCache.set(hass.entities, ids);
+      }
+      return ids;
+    }
+    // Older frontends without the registry map: scan the states
+    return Object.keys(hass.states).filter((eid) => eid.startsWith("sensor."));
+  }
+
+  // Status sensors of the integration, keyed by cover entity id.
+  function findStatusSensors(hass) {
+    const out = {};
+    if (!hass || !hass.states) return out;
+    for (const eid of candidateIds(hass)) {
+      const st = hass.states[eid];
+      const cover = st && st.attributes && st.attributes.cover_entity_id;
+      if (cover) out[cover] = st;
+    }
+    return out;
+  }
+
+  // Global entities of the integration, keyed by their translation key
+  const _globalCache = new WeakMap();
+  const GLOBAL_KEYS = {
+    scenario: "scenario", master_enabled: "master", wind_protection: "wind",
+    covers_paused: "paused", covers_manual: "manual", covers_locked: "locked",
+  };
+  function findGlobals(hass) {
+    if (!hass || !hass.entities) return {};
+    let out = _globalCache.get(hass.entities);
+    if (!out) {
+      out = {};
+      for (const e of Object.values(hass.entities)) {
+        if (!e || e.platform !== "cover_automatic") continue;
+        const key = GLOBAL_KEYS[e.translation_key];
+        if (key) out[key] = e.entity_id;
+      }
+      _globalCache.set(hass.entities, out);
+    }
+    return out;
+  }
+
+  const num = (v) => (v == null || v === "" || isNaN(Number(v)) ? null : Math.round(Number(v)));
+
+  class CoverAutomaticCard extends HTMLElement {
+    constructor() {
+      super();
+      this.attachShadow({ mode: "open" });
+      this._config = {};
+      this._hass = null;
+      this._rowSigs = new Map();
+      this._skeleton = "";
+      this._timer = null;
+      this.shadowRoot.addEventListener("click", (e) => this._onClick(e));
+      this.shadowRoot.addEventListener("change", (e) => this._onChange(e));
+    }
+
+    static getConfigElement() {
+      return document.createElement(EDITOR_TAG);
+    }
+
+    static getStubConfig() {
+      return { show_header: true, show_rule: true, show_auto: true };
+    }
+
+    // Never throws on a questionable option (a thrown error shows a red
+    // "Configuration error" card): odd values fall back to the defaults.
+    setConfig(config) {
+      const c = config && typeof config === "object" ? { ...config } : {};
+      if (c.covers != null && !Array.isArray(c.covers)) c.covers = typeof c.covers === "string" ? [c.covers] : undefined;
+      this._config = { show_header: true, show_rule: true, show_auto: true, ...c };
+      this._skeleton = "";
+      this._render();
+    }
+
+    set hass(hass) {
+      this._hass = hass;
+      this._render();
+    }
+
+    // A failed render (unexpected state while HA reconnects...) must not
+    // leave a broken card: show a short notice and retry on the next update.
+    _render() {
+      try {
+        this._renderInner();
+      } catch (err) {
+        console.error("cover-automatic-card:", err);
+        this._skeleton = "";
+        if (this.shadowRoot) {
+          this.shadowRoot.innerHTML = `<style>${STYLE}</style><ha-card><div class="rows no-title"><div class="empty">${esc(t(this._hass, "render_error"))}</div></div></ha-card>`;
+        }
+      }
+    }
+
+    get hass() {
+      return this._hass;
+    }
+
+    connectedCallback() {
+      // Pause countdown refresh: only rows whose text changes are redrawn
+      this._timer = setInterval(() => this._render(), 30000);
+    }
+
+    disconnectedCallback() {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+
+    getCardSize() {
+      return 1 + this._rows().length;
+    }
+
+    getGridOptions() {
+      return { columns: 12, min_columns: 6 };
+    }
+
+    _rows() {
+      return this._rowInfo().rows;
+    }
+
+    // Rows to show, plus the configured covers without a status sensor
+    // (typo, cover no longer managed): listed in a warning, not hidden.
+    _rowInfo() {
+      const sensors = findStatusSensors(this._hass);
+      const configured = Array.isArray(this._config.covers) && this._config.covers.length ? this._config.covers : null;
+      const ids = configured
+        ? configured.filter((id) => sensors[id])
+        : Object.keys(sensors).sort((a, b) => this._name(a, sensors[a]).localeCompare(this._name(b, sensors[b])));
+      const missing = configured ? configured.filter((id) => !sensors[id]) : [];
+      return {
+        rows: ids.map((id) => ({ id, status: sensors[id], cover: this._hass.states[id] })),
+        missing,
+        anySensor: Object.keys(sensors).length > 0,
+      };
+    }
+
+    _name(id, status) {
+      const cover = this._hass && this._hass.states[id];
+      return (cover && cover.attributes.friendly_name) || status.attributes.cover_name || id;
+    }
+
+    _position(row) {
+      const attrs = row.status.attributes;
+      let rawVal = row.cover && row.cover.attributes ? row.cover.attributes.current_position : null;
+      if (rawVal == null && row.cover) rawVal = { open: 100, closed: 0 }[row.cover.state] ?? null;
+      const raw = num(rawVal);
+      if (raw == null) return { pos: num(attrs.position), raw: null };
+      return { pos: attrs.inverted ? 100 - raw : raw, raw };
+    }
+
+    _bar(pos, rawTarget) {
+      const target = num(rawTarget);
+      if (pos == null) return '<span class="dash">–</span>';
+      const cur = pos ?? target;
+      const diverges = pos != null && target != null && Math.abs(pos - target) >= 1;
+      const width = Math.max(0, Math.min(100, cur));
+      let label = `${cur}%`;
+      let marker = "";
+      if (diverges) {
+        label = `${pos}% <span class="arrow">→</span> ${target}%`;
+        marker = `<span class="marker" style="left:${Math.max(0, Math.min(100, target))}%"></span>`;
+      }
+      return `<span class="bar"><span class="track"><span class="fill" style="width:${width}%"></span>${marker}</span><span class="label">${label}</span></span>`;
+    }
+
+    // Keyed, incremental render: only rows whose HTML changed are replaced,
+    // so an unchanged row keeps focus (keyboard users) and its state.
+    _renderInner() {
+      if (!this.shadowRoot) return;
+      const hass = this._hass;
+      const title = this._config.title || "";
+      const skeleton = `${title}|${hass ? lang(hass) : ""}`;
+      if (skeleton !== this._skeleton) {
+        this._skeleton = skeleton;
+        this._rowSigs = new Map();
+        this.shadowRoot.innerHTML = `<style>${STYLE}</style>
+          <ha-card${title ? ` header="${esc(title)}"` : ""}>
+            <div class="globals${title ? "" : " no-title"}">
+              <div class="g-line g-controls"></div>
+              <div class="g-line g-status"></div>
+            </div>
+            <div class="missing" role="status" hidden></div>
+            <div class="rows"></div>
+          </ha-card>`;
+        this._ctrlSig = null;
+        this._statusSig = null;
+        this._missingSig = null;
+      }
+      const container = this.shadowRoot.querySelector(".rows");
+      if (!container || !hass) return;
+      const globalsEl = this.shadowRoot.querySelector(".globals");
+      if (globalsEl) {
+        // Controls (scenario select, master switch) and status chips are
+        // redrawn separately: a chip update must not close an open select.
+        const g = this._config.show_header ? this._renderGlobals() : { controls: "", status: "" };
+        const patch = (sel, html, sigKey) => {
+          const el = globalsEl.querySelector(sel);
+          if (!el || html === this[sigKey]) return;
+          const focusKey = this._focusKey(el);
+          el.innerHTML = html;
+          el.hidden = !html;
+          this[sigKey] = html;
+          if (focusKey) el.querySelector(focusKey)?.focus();
+        };
+        patch(".g-controls", g.controls, "_ctrlSig");
+        patch(".g-status", g.status, "_statusSig");
+        const any = !!(g.controls || g.status);
+        globalsEl.hidden = !any;
+        container.classList.toggle("no-title", !any && !title);
+      }
+      const info = this._rowInfo();
+      const rows = info.rows;
+      const missingEl = this.shadowRoot.querySelector(".missing");
+      if (missingEl) {
+        // Only once the integration's sensors exist: at HA startup every
+        // configured cover would briefly be listed as missing.
+        const txt = info.missing.length && info.anySensor ? t(hass, "missing").replace("{ids}", info.missing.join(", ")) : "";
+        if (txt !== this._missingSig) {
+          this._missingSig = txt;
+          missingEl.textContent = txt;
+          missingEl.hidden = !txt;
+        }
+      }
+      if (!rows.length) {
+        this._rowSigs = new Map();
+        // Configured covers all missing while the integration is there: the
+        // warning above says which ones.
+        container.innerHTML = info.missing.length && info.anySensor ? "" : `<div class="empty">${esc(t(hass, "no_covers"))}</div>`;
+        return;
+      }
+      container.querySelector(".empty")?.remove();
+      const wanted = new Set(rows.map((r) => r.id));
+      for (const el of [...container.children]) {
+        if (!wanted.has(el.dataset.row)) {
+          el.remove();
+          this._rowSigs.delete(el.dataset.row);
+        }
+      }
+      let prev = null;
+      for (const r of rows) {
+        const html = this._renderRow(r);
+        let el = [...container.children].find((c) => c.dataset.row === r.id);
+        if (!el) {
+          el = document.createElement("div");
+          el.dataset.row = r.id;
+        }
+        if (this._rowSigs.get(r.id) !== html) {
+          const focusKey = this._focusKey(el);
+          el.innerHTML = html;
+          this._rowSigs.set(r.id, html);
+          if (focusKey) el.querySelector(focusKey)?.focus();
+        }
+        // Keep the requested order
+        const expected = prev ? prev.nextSibling : container.firstChild;
+        if (expected !== el) container.insertBefore(el, expected);
+        prev = el;
+      }
+    }
+
+    // Selector of the focused control inside a row, to restore it after a redraw.
+    _focusKey(rowEl) {
+      const active = this.shadowRoot.activeElement;
+      if (!active || !rowEl.contains(active)) return null;
+      for (const attr of ["data-auto", "data-resume", "data-more", "data-scenario", "data-master", "data-resume-all"]) {
+        const v = active.getAttribute(attr);
+        if (v != null) return `[${attr}="${CSS.escape(v)}"]`;
+      }
+      return null;
+    }
+
+    // Global part: scenario, master automation switch, statuses, resume all
+    _renderGlobals() {
+      const hass = this._hass;
+      const g = findGlobals(hass);
+      const st = (id) => (id ? hass.states[id] : null);
+      const parts = [];
+      const scen = st(g.scenario);
+      if (scen) {
+        const names = scen.attributes.scenario_names || {};
+        const opts = (scen.attributes.options || []).map((o) => {
+          const label = names[o] || (hass.formatEntityState ? hass.formatEntityState(scen, o) : o);
+          return `<option value="${esc(o)}"${o === scen.state ? " selected" : ""}>${esc(label)}</option>`;
+        }).join("");
+        parts.push(`<label class="g-field"><span>${esc(t(hass, "scenario"))}</span>
+          <select data-scenario="${esc(g.scenario)}" aria-label="${esc(t(hass, "scenario"))}">${opts}</select></label>`);
+      }
+      const master = st(g.master);
+      if (master) {
+        parts.push(`<label class="g-field g-switch"><span>${esc(t(hass, "master"))}</span>
+          <span class="switch"><input type="checkbox" data-master="${esc(g.master)}" ${master.state === "on" ? "checked" : ""} aria-label="${esc(t(hass, "master"))}"><span class="slider"></span></span></label>`);
+      }
+      const chips = [];
+      const wind = st(g.wind);
+      if (wind && wind.attributes.wind_sensor) {
+        const speed = wind.attributes.wind_speed;
+        const sensor = hass.states[wind.attributes.wind_sensor];
+        const unit = sensor && sensor.attributes.unit_of_measurement ? " " + sensor.attributes.unit_of_measurement : "";
+        const on = wind.state === "on";
+        const value = speed == null ? "–" : `${Math.round(speed)}${unit}`;
+        chips.push(`<span class="chip${on ? " warn" : ""}" title="${esc(t(hass, "wind"))}"><ha-icon icon="mdi:weather-windy"></ha-icon>${esc(on ? t(hass, "wind_active") + " · " + value : t(hass, "wind") + " " + value)}</span>`);
+      }
+      for (const [key, icon] of [["paused", "mdi:pause-circle"], ["manual", "mdi:hand-back-right"], ["locked", "mdi:lock"]]) {
+        const s = st(g[key]);
+        if (!s) continue;
+        const n = parseInt(s.state, 10) || 0;
+        const names = (s.attributes.covers || []).join(", ");
+        chips.push(`<span class="chip${n ? " on" : " zero"}"${names ? ` title="${esc(names)}"` : ""}><ha-icon icon="${icon}"></ha-icon>${n} ${esc(t(hass, key))}</span>`);
+      }
+      const paused = parseInt((st(g.paused) || {}).state, 10) || 0;
+      const resume = `<button class="g-btn" data-resume-all ${paused ? "" : "disabled"} title="${esc(t(hass, "resume_all_title"))}"><ha-icon icon="mdi:play-circle-outline"></ha-icon>${esc(t(hass, "resume_all"))}</button>`;
+      if (!parts.length && !chips.length) return { controls: "", status: "" };
+      return { controls: parts.join(""), status: chips.join("") + resume };
+    }
+
+    _renderRow(r) {
+      const hass = this._hass;
+      const a = r.status.attributes;
+      const state = r.status.state;
+      const { pos, raw } = this._position(r);
+      const stateLabel = hass.formatEntityState ? hass.formatEntityState(r.status) : state;
+      const color = STATUS_COLORS[state] || STATUS_COLORS.manual;
+      const unavailable = !r.cover || r.cover.state === "unavailable";
+      let pause = "";
+      if (state === "paused" && a.pause_until) {
+        const mins = Math.max(0, Math.ceil((new Date(a.pause_until).getTime() - Date.now()) / 60000));
+        pause = `<span class="pause">${esc(t(hass, "remaining").replace("{m}", mins))}</span>`;
+      }
+      const invTip = a.inverted && raw != null ? ` title="${esc(t(hass, "inverted").replace("{raw}", raw))}"` : "";
+      const rule = this._config.show_rule
+        ? `<div class="rule${a.rule ? "" : " none"}">${a.safety_rule ? `<ha-icon icon="mdi:shield-alert" title="${esc(t(hass, "safety"))}"></ha-icon>` : ""}${esc(a.rule || t(hass, "no_rule"))}</div>`
+        : "";
+      let controls = "";
+      if (this._config.show_auto) {
+        const sw = a.auto_switch ? hass.states[a.auto_switch] : null;
+        // Screen readers: say which cover the button/switch belongs to
+        const name = this._name(r.id, r.status);
+        const resumeLbl = `${t(hass, "resume")} – ${name}`;
+        const autoLbl = `${t(hass, "auto")} – ${name}`;
+        controls = `<div class="controls">
+          ${state === "paused" ? `<button class="resume" data-resume="${esc(r.id)}" title="${esc(t(hass, "resume"))}" aria-label="${esc(resumeLbl)}"><ha-icon icon="mdi:play-circle-outline"></ha-icon></button>` : ""}
+          ${sw ? `<label class="switch" title="${esc(t(hass, "auto"))}"><input type="checkbox" data-auto="${esc(a.auto_switch)}" ${sw.state === "on" ? "checked" : ""} aria-label="${esc(autoLbl)}"><span class="slider"></span></label>` : ""}
+        </div>`;
+      }
+      return `<div class="row${unavailable ? " unavailable" : ""}${this._config.show_auto ? "" : " no-auto"}">
+        <div class="main">
+          <button class="name" data-more="${esc(r.id)}">${esc(this._name(r.id, r.status))}</button>
+          ${rule}
+        </div>
+        <div class="pos"${invTip}>${unavailable ? '<span class="dash">–</span>' : this._bar(pos, a.target_position)}${a.inverted ? '<span class="inv">⇅</span>' : ""}</div>
+        <div class="status"><span class="pill" style="--pill:${color}">${esc(stateLabel)}</span>${pause}</div>
+        ${controls}
+      </div>`;
+    }
+
+    _onClick(e) {
+      const more = e.target.closest("[data-more]");
+      if (more) {
+        const ev = new Event("hass-more-info", { bubbles: true, composed: true });
+        ev.detail = { entityId: more.dataset.more };
+        this.dispatchEvent(ev);
+        return;
+      }
+      if (e.target.closest("[data-resume-all]") && this._hass) {
+        Promise.resolve(this._hass.callService("cover_automatic", "resume_all", {}))
+          .catch((err) => console.error("cover-automatic-card:", err));
+        return;
+      }
+      const resume = e.target.closest("[data-resume]");
+      if (resume && this._hass) {
+        Promise.resolve(
+          this._hass.callService("cover_automatic", "resume", { entity_id: resume.dataset.resume })
+        ).catch((err) => console.error("cover-automatic-card:", err));
+      }
+    }
+
+    _onChange(e) {
+      const el = e.target;
+      if (el.dataset && el.dataset.scenario && this._hass) {
+        Promise.resolve(this._hass.callService("select", "select_option",
+          { entity_id: el.dataset.scenario, option: el.value }))
+          .catch((err) => { console.error("cover-automatic-card:", err); this._ctrlSig = null; this._render(); });
+        return;
+      }
+      if (el.dataset && el.dataset.master && this._hass) {
+        const wanted = el.checked;
+        Promise.resolve(this._hass.callService("switch", wanted ? "turn_on" : "turn_off", { entity_id: el.dataset.master }))
+          .catch((err) => { console.error("cover-automatic-card:", err); el.checked = !wanted; });
+        return;
+      }
+      if (el.dataset && el.dataset.auto && this._hass) {
+        const wanted = el.checked;
+        Promise.resolve(
+          this._hass.callService("switch", wanted ? "turn_on" : "turn_off", { entity_id: el.dataset.auto })
+        ).catch((err) => {
+          // Service refused (e.g. no permission): show the real state again
+          console.error("cover-automatic-card:", err);
+          el.checked = !wanted;
+        });
+      }
+    }
+  }
+
+  const STYLE = `
+    :host { display: block; container-type: inline-size; }
+    .rows { padding: 0 16px 12px; }
+    .globals { padding: 0 16px 10px; border-bottom: 1px solid var(--divider-color, rgba(0,0,0,.12)); margin-bottom: 4px; }
+    .globals.no-title { padding-top: 12px; }
+    .g-line { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 16px; }
+    .g-line + .g-line { margin-top: 8px; }
+    .g-line[hidden] { display: none; }
+    .g-line[hidden] + .g-line { margin-top: 0; }
+    .missing { margin: 8px 16px; padding: 6px 10px; border-radius: 8px; font-size: 13px; color: var(--primary-text-color); border-left: 3px solid var(--warning-color, #ff9800); background: color-mix(in srgb, var(--warning-color, #ff9800) 12%, transparent); overflow-wrap: anywhere; }
+    .missing[hidden] { display: none; }
+    .g-field { display: flex; align-items: center; gap: 8px; font-size: 14px; color: var(--primary-text-color); }
+    .g-field > span:first-child { color: var(--secondary-text-color); font-size: 13px; }
+    .g-field select { font: inherit; font-size: 14px; padding: 4px 6px; border-radius: 6px; border: 1px solid var(--divider-color, #ccc); background: var(--card-background-color, #fff); color: var(--primary-text-color); max-width: 180px; }
+    .g-status { gap: 6px; }
+    .chip { display: inline-flex; align-items: center; gap: 4px; font-size: 12px; padding: 3px 8px; border-radius: 12px; background: color-mix(in srgb, var(--primary-text-color) 7%, transparent); color: var(--primary-text-color); white-space: nowrap; }
+    .chip ha-icon { --mdc-icon-size: 14px; }
+    .chip.zero { color: var(--secondary-text-color); }
+    .chip.on { background: color-mix(in srgb, var(--warning-color, #ff9800) 16%, transparent); }
+    .chip.warn { background: color-mix(in srgb, var(--error-color, #db4437) 16%, transparent); color: var(--error-color, #db4437); }
+    .g-btn { margin-left: auto; display: inline-flex; align-items: center; gap: 4px; font: inherit; font-size: 13px; padding: 4px 10px; border-radius: 14px; border: 1px solid var(--primary-color); background: transparent; color: var(--primary-color); cursor: pointer; }
+    .g-btn ha-icon { --mdc-icon-size: 16px; }
+    .g-btn:disabled { opacity: .4; cursor: default; }
+    .row.no-auto { grid-template-columns: minmax(0, 1.5fr) minmax(110px, 1.4fr) 100px; }
+    .rows.no-title { padding-top: 12px; }
+    .globals[hidden] { display: none; }
+    .row { display: grid; grid-template-columns: minmax(0, 1.5fr) minmax(110px, 1.4fr) 100px 64px; align-items: center; gap: 12px; padding: 8px 0; border-bottom: 1px solid var(--divider-color, rgba(0,0,0,.12)); }
+    .rows > div:last-child > .row { border-bottom: 0; }
+    .row.unavailable { opacity: .5; }
+    .main { min-width: 0; }
+    .name { all: unset; cursor: pointer; font-weight: 500; color: var(--primary-text-color); display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%; }
+    .name:focus-visible { outline: 2px solid var(--primary-color); border-radius: 4px; }
+    .rule { font-size: 12px; color: var(--primary-color); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; display: flex; align-items: center; gap: 3px; }
+    .rule.none { color: var(--secondary-text-color); }
+    .rule ha-icon { --mdc-icon-size: 14px; color: var(--error-color, #db4437); }
+    .pos { display: flex; align-items: center; gap: 4px; min-width: 0; }
+    .bar { display: flex; align-items: center; gap: 6px; min-width: 0; width: 100%; }
+    .track { position: relative; flex: 1 1 auto; min-width: 30px; height: 6px; border-radius: 3px; background: var(--divider-color, rgba(0,0,0,.12)); }
+    .fill { position: absolute; left: 0; top: 0; bottom: 0; border-radius: 3px; background: var(--primary-color); }
+    .marker { position: absolute; top: -3px; width: 2px; height: 12px; margin-left: -1px; background: var(--primary-text-color); border-radius: 1px; }
+    .label { font-size: 12px; white-space: nowrap; min-width: 66px; text-align: right; color: var(--primary-text-color); font-variant-numeric: tabular-nums; }
+    .arrow { color: var(--primary-color); }
+    .inv { font-size: 11px; color: var(--secondary-text-color); cursor: help; }
+    .dash { color: var(--secondary-text-color); }
+    .status { display: flex; flex-direction: column; align-items: flex-end; gap: 2px; }
+    .pill { font-size: 12px; padding: 2px 8px; border-radius: 10px; white-space: nowrap; color: var(--pill); background: color-mix(in srgb, var(--pill) 14%, transparent); }
+    .pause { font-size: 11px; color: var(--secondary-text-color); white-space: nowrap; }
+    .controls { display: flex; align-items: center; gap: 6px; justify-content: flex-end; }
+    .resume { all: unset; cursor: pointer; color: var(--primary-color); display: flex; }
+    .resume:focus-visible { outline: 2px solid var(--primary-color); border-radius: 50%; }
+    .switch { position: relative; display: inline-block; width: 34px; height: 18px; flex: none; }
+    .switch input { opacity: 0; width: 0; height: 0; }
+    .slider { position: absolute; inset: 0; cursor: pointer; border-radius: 9px; background: var(--disabled-color, #bdbdbd); transition: background .2s; }
+    .slider::before { content: ""; position: absolute; width: 14px; height: 14px; left: 2px; top: 2px; border-radius: 50%; background: #fff; transition: transform .2s; }
+    .switch input:checked + .slider { background: var(--primary-color); }
+    .switch input:checked + .slider::before { transform: translateX(16px); }
+    .switch input:focus-visible + .slider { outline: 2px solid var(--primary-color); outline-offset: 2px; }
+    .empty { padding: 8px 0; color: var(--secondary-text-color); }
+    /* Narrow card (phone, sections column): two lines per cover */
+    @container (max-width: 480px) {
+      .row, .row.no-auto { grid-template-columns: minmax(0, 1fr) auto; grid-template-areas: "main status" "pos controls"; row-gap: 6px; }
+      .row.no-auto { grid-template-areas: "main status" "pos pos"; }
+      .main { grid-area: main; } .status { grid-area: status; } .pos { grid-area: pos; } .controls { grid-area: controls; }
+    }
+  `;
+
+  class CoverAutomaticCardEditor extends HTMLElement {
+    setConfig(config) {
+      this._config = { ...config };
+      this._render();
+    }
+
+    set hass(hass) {
+      const first = !this._hass;
+      this._hass = hass;
+      if (this._form) this._form.hass = hass;
+      if (first) this._render();
+    }
+
+    _render() {
+      if (!this._hass || !this._config) return;
+      const covers = Object.keys(findStatusSensors(this._hass));
+      const schema = [
+        { name: "title", selector: { text: {} } },
+        { name: "covers", selector: { entity: { multiple: true, include_entities: covers } } },
+        { name: "show_header", selector: { boolean: {} } },
+        { name: "show_rule", selector: { boolean: {} } },
+        { name: "show_auto", selector: { boolean: {} } },
+      ];
+      if (!this._form) {
+        this._form = document.createElement("ha-form");
+        this._form.addEventListener("value-changed", (e) => {
+          const value = { ...e.detail.value };
+          if (Array.isArray(value.covers) && !value.covers.length) delete value.covers;
+          if (!value.title) delete value.title;
+          this._config = value;
+          const ev = new Event("config-changed", { bubbles: true, composed: true });
+          ev.detail = { config: value };
+          this.dispatchEvent(ev);
+        });
+        this.appendChild(this._form);
+      }
+      const labels = { title: "ed_title", covers: "ed_covers", show_header: "ed_show_header", show_rule: "ed_show_rule", show_auto: "ed_show_auto" };
+      this._form.hass = this._hass;
+      this._form.schema = schema;
+      this._form.data = { show_header: true, show_rule: true, show_auto: true, ...this._config };
+      this._form.computeLabel = (s) => t(this._hass, labels[s.name] || s.name);
+    }
+  }
+
+  customElements.define(CARD_TAG, CoverAutomaticCard);
+  customElements.define(EDITOR_TAG, CoverAutomaticCardEditor);
+
+  window.customCards = window.customCards || [];
+  if (!window.customCards.some((c) => c.type === CARD_TAG)) {
+    window.customCards.push({
+      type: CARD_TAG,
+      name: "CoverAutomatic",
+      description: I18N[(navigator.language || "en").slice(0, 2)]?.desc || I18N.en.desc,
+      preview: true,
+      documentationURL: "https://github.com/crandler/CoverAutomatic",
+    });
+  }
+})();
diff --git a/custom_components/cover_automatic/panel/cover-automatic-panel.js b/custom_components/cover_automatic/panel/cover-automatic-panel.js
index 04ab030..406621b 100644
--- a/custom_components/cover_automatic/panel/cover-automatic-panel.js
+++ b/custom_components/cover_automatic/panel/cover-automatic-panel.js
@@ -7,6 +7,9 @@
 /* ============================================================
  * Curated scenario icon choices (Material Design Icons)
  * ============================================================ */
+// Keep in sync with MAX_CONDITION_GROUPS in models.py
+const MAX_CONDITION_GROUPS = 10;
+
 const SCENARIO_ICON_CHOICES = [
   "mdi:home", "mdi:home-variant",
   "mdi:white-balance-sunny", "mdi:weather-sunny",
@@ -40,9 +43,155 @@ const I18N = {
     error_load: "Failed to load configuration.",
     retry: "Retry",
     saved: "Saved",
+    cond_time_after_dawn: "Time after dawn",
+    cond_time_before_dawn: "Time before dawn",
+    cond_time_after_dusk: "Time after dusk",
+    cond_time_before_dusk: "Time before dusk",
+    cond_time_after_dawn_hint: "From dawn (+ offset) until dusk. Complement: “{other}”.",
+    cond_time_before_dawn_hint: "From dusk until the next dawn (+ offset). Complement: “{other}”.",
+    cond_time_after_dusk_hint: "From dusk (+ offset) until the next dawn. Complement: “{other}”.",
+    cond_time_before_dusk_hint: "From dawn until dusk (+ offset). Complement: “{other}”.",
+    cond_time_after_sunrise_hint: "From sunrise (+ offset) until sunset. Complement: “{other}”.",
+    cond_time_before_sunrise_hint: "From sunset until the next sunrise (+ offset). Complement: “{other}”.",
+    cond_time_after_sunset_hint: "From sunset (+ offset) until the next sunrise. Complement: “{other}”.",
+    cond_time_before_sunset_hint: "From sunrise until sunset (+ offset). Complement: “{other}”.",
+    cover_travel_auto_default: "default: {s} s",
+    cover_travel_not_measured: "Measured: not yet (on the next move of at least 20 %).",
+    cover_travel_used: "Used: {s} s ({src}) · wait before detecting a manual move: {wait} s",
+    cover_travel_used_none: "Used: none · wait before detecting a manual move: {wait} s",
+    cover_travel_src_manual: "entered",
+    cover_travel_src_measured: "measured",
+    cover_travel_src_default: "global default",
+    cover_travel_src_none: "none",
+    settings_default_travel_time: "Default travel time (s)",
+    settings_default_travel_time_placeholder: "none (30 s wait)",
+    settings_default_travel_time_hint: "Travel time used for covers with no value entered and none measured yet. Order: value entered on the cover, then measured value, then this default. Empty = 30 s wait.",
+    cover_travel_time: "Travel time (s)",
+    cover_travel_auto: "auto (measured on the first moves)",
+    cover_travel_auto_measured: "auto: {s} s measured",
+    cover_travel_measured: "Measured: {s} s for a full travel.",
+    cover_travel_reset: "Reset",
+    cover_travel_time_hint: "Time for a full 0 → 100 % travel. After its own command, the integration waits this long (plus 5 s, at least 30 s) before treating a position change as a manual action. Leave empty to use the measured value, or else the default travel time from Settings.",
+    scenario_rule_off: "disabled in Rules",
+    scenario_rule_off_hint: "This rule is switched off in the Rules tab, so it never runs. The setting below applies again once the rule is enabled.",
+    ha_ctype_and: "and",
+    ha_ctype_or: "or",
+    ha_ctype_not: "not",
+    ha_ctype_template: "template",
+    ha_ctype_state: "state",
+    ha_ctype_numeric_state: "numeric value",
+    ha_ctype_zone: "zone",
+    ha_ctype_time: "time",
+    ha_ctype_sun: "sun",
+    ha_ctype_device: "device",
+    ha_ctype_trigger: "trigger",
+    cond_group_sun: "Sun",
+    cond_group_temperature: "Temperature",
+    cond_group_time: "Time",
+    cond_group_weather: "Weather",
+    cond_group_entities: "Entities",
+    cond_menu_ha_state: "Entity state",
+    cond_menu_ha_numeric: "Entity numeric value",
+    cond_menu_ha_yaml: "Home Assistant condition (YAML)",
+    cond_ha_condition: "Home Assistant condition",
+    cond_ha_state: "Entity state",
+    cond_ha_numeric: "Entity numeric value",
+    ha_tab_form: "Form",
+    ha_tab_yaml: "YAML",
+    ha_kind: "Type",
+    ha_kind_state: "State",
+    ha_kind_numeric: "Numeric value",
+    ha_entity: "Entity",
+    ha_current: "currently",
+    ha_attribute: "Attribute",
+    ha_attribute_none: "— entity state —",
+    ha_compare: "Comparison",
+    ha_is: "is",
+    ha_is_not: "is not",
+    ha_for: "For at least (min)",
+    ha_for_negate_hint: "Not available with “is not”.",
+    ha_states: "States",
+    ha_state_other: "Other value…",
+    ha_state_add: "Add",
+    ha_operator: "Operator",
+    ha_op_above: "above",
+    ha_op_below: "below",
+    ha_op_between: "between",
+    ha_value: "Value",
+    ha_min: "Minimum",
+    ha_max: "Maximum",
+    ha_form_unsupported: "This condition cannot be shown as a form (template, zone, nested conditions…). It stays editable in YAML.",
+    ha_yaml_label: "Condition",
+    ha_yaml_placeholder: "condition: state\nentity_id: person.me\nstate: not_home\nfor: \"00:15:00\"",
+    ha_yaml_help: "Same format as the “condition” section of a Home Assistant automation. A list of conditions is combined with AND.",
+    ha_valid: "Valid condition",
+    ha_entities: "Watched entities",
+    ha_unknown_entities: "Entities not found (check the id)",
+    ha_err_yaml: "YAML syntax error at line {line}, column {column}",
+    ha_err_not_mapping: "The YAML must describe one condition (e.g. “condition: state”).",
+    ha_err_invalid: "Invalid condition",
+    ha_err_empty: "Empty condition",
+    ha_checking: "Checking…",
+    ha_incomplete_entity: "Choose an entity.",
+    ha_incomplete_states: "Choose at least one state.",
+    ha_incomplete_value: "Enter a value.",
+    cond_convert: "Convert to enhanced condition",
+    cond_convert_hint: "Adds attribute, “is not”, duration and state choices. Applied when the rule is saved.",
+    ha_chip_is: "{entity} is {states}",
+    ha_chip_is_not: "{entity} is not {states}",
+    ha_chip_for: " for {min} min",
+    ha_chip_or: " or ",
+    ha_chip_above: "{entity} > {value}",
+    ha_chip_below: "{entity} < {value}",
+    ha_chip_between: "{entity} between {min} and {max}",
+    ha_chip_other: "HA condition: {type}",
+    rule_op_short_and: "AND", rule_op_short_or: "OR",
+    compass_n: "N", compass_e: "E", compass_s: "S", compass_w: "W",
+    error_generic: "Could not save the change",
+    error_not_found: "Item not found (it may have been deleted meanwhile)",
+    error_invalid_format: "Invalid value",
+    error_invalid_conditions: "Invalid rule condition",
+    error_invalid_data: "Invalid configuration data",
+    error_too_large: "Import file is too large",
+    error_unauthorized: "Administrator rights required",
+    error_invalid_comfort_range: "The cold setpoint must be lower than the hot setpoint",
+    error_invalid_wind_hysteresis: "The wind hysteresis must be lower than the wind threshold",
+    rule_priority_up: "Raise priority",
+    rule_priority_down: "Lower priority",
+    rule_enabled_aria: "Rule {name} enabled",
+    rule_invalid_fields: "Fix the fields marked in red (empty or invalid value) before saving",
+    ha_err_request: "Check failed",
+    error_not_loaded: "CoverAutomatic is not loaded (reload the integration or restart Home Assistant)",
+    error_invalid_solar_hysteresis: "The sunshine hysteresis must be lower than the sunshine threshold",
+    error_invalid_value: "Invalid number",
+    drag_handle: "Drag to reorder",
+    settings_nav_label: "Settings",
+    import_invalid_json: "Invalid JSON",
+    status_unlocked: "Unlocked",
+    log_msg_wind_activated: "Activated ({speed} ≥ {threshold})",
+    log_msg_wind_deactivated: "Deactivated ({speed} ≤ {threshold})",
+    log_msg_wind_disabled: "Deactivated (disabled in settings)",
+    log_msg_status_change: "{from} → {to}",
+    log_msg_rule: "{rule} → {position} %",
+    log_msg_position: "{from} % → {to} %",
+    log_msg_safety_takeover: "Safety rule {rule} takes over ({status}) → {position} %",
+    log_msg_safety_release: "Safety rule {rule} released ({status})",
+    log_msg_sensor_unavailable: "{status} kept: sensor {sensor} unavailable",
+    log_msg_lock_sensor_missing: "Window sensor {sensor} not found: ignored",
+    log_msg_move_blocked_window_unknown: "Move to {position} % held: window state unknown ({sensor})",
+    log_msg_wind_restore_dropped: "Wind protection restore dropped: sensor {sensor} missing or without value",
     save: "Save",
     cancel: "Cancel",
     delete: "Delete",
+    rule_duplicate: "Duplicate (the copy is created right below)",
+    rule_copy_suffix: "copy",
+    settings_wind_off_note: "Choose a wind sensor to enable wind protection.",
+    settings_solar_off_note: "Choose a sensor to set the threshold and hysteresis.",
+    settings_solar_nested_off: "Only used by the option “Only with strong sunshine” (here or on a cover).",
+    cover_lock_box_title: "Window open",
+    cover_lock_off_note: "Choose a window sensor to enable these settings.",
+    cover_vent_box_title: "Window tilted (ventilation)",
+    cover_vent_off_note: "Choose a tilt sensor to set the ventilation position.",
     confirm_delete: "Really delete?",
     add: "Add",
     edit: "Edit",
@@ -58,27 +207,79 @@ const I18N = {
     cover_status: "Status",
     cover_pause_duration: "Pause duration (min)",
     cover_pause_duration_hint: "How long automation pauses after manual operation. Empty = use global default.",
-    cover_indoor_temp: "Indoor temperature sensor",
-    cover_indoor_temp_hint: "Per-cover sensor for comfort mode. Overrides global sensor.",
-    cover_lock_sensor: "Lock sensor",
+    cover_indoor_temp: "Indoor temperature sensor (°C)",
+    cover_indoor_temp_hint: "Sensor of this cover's room, for the setpoints and “Sun on facade”. Replaces the global sensor.",
+    cover_lock_sensor: "Open window sensor",
     cover_lock_sensor_hint: "Window contact sensor. When open, cover moves to lock position (safety).",
+    cover_lock_hold: "Keep current position when the window opens",
+    cover_lock_hold_hint: "On: the cover stays where it is while the window is open (locked, no command). Off: it moves to the lock position below (only upwards, never closer).",
     cover_lock_position: "Lock position",
     cover_lock_position_hint: "Target position when window is open. Empty = use global default.",
-    cover_vent_sensor: "Vent sensor",
+    cover_vent_sensor: "Tilted window sensor",
     cover_vent_sensor_hint: "Tilt contact sensor. When tilted, cover moves to vent position.",
     cover_vent_position: "Vent position",
     cover_vent_position_hint: "Target position when window is tilted. Empty = use global default.",
-    cover_comfort_min: "Comfort temp min",
-    cover_comfort_max: "Comfort temp max",
-    cover_comfort_hint: "Per-room comfort range. Empty = use global values from settings.",
-    cover_preemptive_shading: "Preemptive shading enabled",
-    cover_preemptive_shading_hint: "When enabled, the global solar sensor can trigger shading inside the comfort zone. Disable for rooms where fast warm-up is desired (e.g. bathroom).",
-    cover_inverted: "Inverted",
+    cover_comfort_min: "Cold temperature setpoint (°C)",
+    cover_comfort_max: "Hot temperature setpoint (°C)",
+    cover_comfort_hint: "Setpoints for this room. Empty = global values from settings.",
+    cover_comfort_global: "Empty = global value: {v} °C ({src})",
+    cover_default_note: "Empty = default value: {v} (Settings)",
+    unit_sensor: "sensor unit",
+    cover_comfort_src_settings: "Settings",
+    cover_sun_switches_hint: "Settings for this cover only; “Global” = value from Settings › Sun exposure.",
+    tristate_global: "Global ({value})",
+    settings_sun_facade_hint: "These settings only change the answer of the “Sun on facade” condition, for covers with an indoor temperature sensor (own or global). They are meant for rules that close when the sun is out: close only when it helps. Leave everything off if a rule opens the covers when the sun is out.",
+    sun_heating_label: "Action at the cold setpoint: let the sun warm the room",
+    sun_heating_hint: "The condition answers “no sun”: rules that close in the sun don't close and the sun warms the room. Avoid it if a rule opens the covers when the sun is out (it would no longer apply).",
+    sun_below: "≤ {t} °C",
+    sun_above: "≥ {t} °C",
+    sun_between: "between {min} and {max} °C",
+    settings_comfort_range_title: "Indoor temperature setpoints",
+    settings_indoor_reminder: "Applies according to each room's indoor temperature (Sensors tab: global sensor {name}, setpoints {min} and {max} °C). A cover can have its own sensor and setpoints.",
+    settings_indoor_none: "not set",
+    sun_explain_title: "How does it work?",
+    sun_explain_intro: "Example: a “close if sun” rule with the sun on the facade. Highlighted rows match your settings.",
+    sun_explain_col_room: "Room",
+    sun_explain_col_answer: "“Sun on facade” answers",
+    sun_explain_col_effect: "Effect",
+    sun_explain_room_cold_on: "Cold, “let the sun warm it” checked",
+    sun_explain_room_cold_off: "Cold, box unchecked",
+    sun_explain_room_position: "Comfortable, “As soon as the sun is on the facade”",
+    sun_explain_room_ignore: "Comfortable, “Never”",
+    sun_explain_room_preemptive: "Comfortable, “Only with strong sunshine”",
+    sun_explain_room_hot: "Too hot",
+    sun_explain_sun: "“sun”",
+    sun_explain_no_sun: "“no sun”",
+    sun_explain_sun_always: "always “sun”",
+    sun_explain_sun_if_strong: "“sun” if the sensor exceeds the threshold, otherwise “no sun”",
+    sun_explain_eff_warm: "Does not close: the cover stays open and the room warms up.",
+    sun_explain_eff_close: "Closes.",
+    sun_explain_eff_close_as_hot: "Closes, as if the room were hot.",
+    sun_explain_eff_wait: "Does not close; will close once the room gets too hot.",
+    sun_explain_eff_strong: "Only closes in bright sunshine, before the room heats up.",
+    sun_explain_so: "So",
+    sun_explain_cold: "Cold room: the box does not open the cover, it prevents closing because of the sun. If the cover is already open (by a daytime opening rule, for example), it stays open.",
+    sun_explain_hot: "Room too hot: the cover only closes if a “close if sun” rule applies to this cover and to the active scenario.",
+    sun_explain_comfort: "Comfortable room: the in-between, where you choose when the sun should count.",
+    sun_comfort_label: "Action between the setpoints: behaviour depending on the sun",
+    sun_comfort_position: "As soon as the sun is on the facade",
+    sun_comfort_position_hint: "The condition is true as soon as the sun is on the facade.",
+    sun_comfort_ignore: "Never (wait until the room gets too hot)",
+    sun_comfort_ignore_hint: "Answers “no sun”: the cover only closes once the room gets too hot.",
+    sun_comfort_preemptive: "Only with strong sunshine",
+    sun_comfort_preemptive_hint: "Answers “sun” as soon as the sunshine sensor exceeds its threshold: the cover closes before the room heats up.",
+    sun_comfort_hint: "Behaviour of “Sun on facade” while the room is between the setpoints. Global = value set in Settings › Sun exposure.",
+    sun_hot_note: "Room too hot (≥ {t} °C): the sun always counts as soon as it is on the facade.",
+    solar_used_by: "Used by the option “Only with strong sunshine”: {n} cover(s).",
+    solar_unused: "Only used by the option “Only with strong sunshine” (no cover uses it at the moment).",
+    tristate_on: "Enabled",
+    tristate_off: "Disabled",
+    cover_inverted: "Reverse open/close direction",
     cover_inverted_hint: "Enable if 100% means closed (reversed motor direction).",
     cover_lock_tilt: "Lock tilt position",
     cover_vent_tilt: "Vent tilt position",
     cover_inverted_tilt: "Inverted tilt",
-    cover_min_pos_change: "Min. position change",
+    cover_min_pos_change: "Min. position change (%)",
     cover_min_pos_change_hint: "Minimum position difference to trigger a move. Empty = use global default.",
     cover_min_time: "Min. time between changes (s)",
     cover_min_time_hint: "Minimum seconds between position changes. Empty = use global default.",
@@ -86,12 +287,55 @@ const I18N = {
     cover_section_sensors: "Sensors",
     cover_section_advanced: "Advanced",
     cover_section_tilt: "Tilt",
+    cover_section_window: "Window",
+    cover_section_automation: "Automation",
+    cover_section_room: "Room",
+    cover_inverted_short: "Reversed",
+    cover_lock_hold_short: "Keep position",
+    sun_heating_label_short: "Cold: let it warm",
+    sun_comfort_label_short: "Between setpoints",
+    settings_comfort_min_short: "Cold setpoint (°C)",
+    settings_comfort_max_short: "Hot setpoint (°C)",
+    cover_comfort_min_short: "Cold setpoint (°C)",
+    cover_comfort_max_short: "Hot setpoint (°C)",
+    settings_indoor_temp_short: "Indoor sensor (°C)",
+    cover_indoor_temp_short: "Indoor sensor (°C)",
+    settings_comfort_hysteresis_short: "Setpoint hysteresis (°C)",
+    settings_threshold_hysteresis_short: "Outdoor hysteresis (°C)",
+    settings_solar_hysteresis_short: "Sunshine hysteresis",
+    settings_wind_hysteresis_short: "Wind hysteresis",
+    settings_solar_threshold_short: "Strong sunshine threshold",
+    settings_sun_facade_title_short: "Sun on facade",
+    cover_min_time_short: "Min. delay (s)",
+    cover_min_pos_change_short: "Min. change (%)",
+    cover_expand_all: "Expand all",
+    cover_collapse_all: "Collapse all",
+    cover_sum_auto_on: "Automatic",
+    cover_sum_auto_off: "Automation disabled",
+    cover_sum_no_facade: "no facade",
+    cover_sum_open: "Open: {v}",
+    cover_sum_hold: "keep position",
+    cover_sum_tilted: "Tilted: {v}",
+    cover_sum_no_window: "No window sensor",
+    cover_sum_pause: "Pause {n} min",
+    cover_sum_travel: "Travel {n} s",
+    cover_sum_own: "{n} own setting(s)",
+    cover_sum_all_global: "default values",
+    cover_sum_global: "global",
+    cover_sum_no_indoor: "No indoor sensor",
+    cover_sum_sun_heat_on: "Cold: let the sun warm",
+    cover_sum_sun_heat_off: "Cold: sun counts",
+    cover_sum_sun_between: "Between: {v}",
+    cover_sum_mode_position: "as soon as the sun is there",
+    cover_sum_mode_ignore: "never",
+    cover_sum_mode_preemptive: "strong sunshine",
     cover_auto_enabled: "Automation enabled",
     cover_temp: "Temp",
     cover_current_pos: "Current",
     cover_target_pos: "Target",
     cover_position: "Position",
     cover_position_target_label: "Target",
+    cover_position_inverted_tip: "Inverted cover: HA reports {raw}% (shown here on the rules' scale)",
     cover_hysteresis_position: "Position change too small",
     cover_hysteresis_time: "Too soon since last change",
     cover_rule: "Rule",
@@ -105,18 +349,23 @@ const I18N = {
     time_ago_h: "{n} h ago",
     time_ago_h_m: "{h} h {m} min ago",
     show_hint: "Show hint",
-    comfort_cooling: "Cooling",
-    comfort_heating: "Heating",
-    comfort_neutral: "Neutral",
+    settings_temp_color: "Room temperature colours (cover list)",
+    settings_temp_color_action: "By action needed",
+    settings_temp_color_action_hint: "Cold room in red (to heat), hot room in blue (to cool).",
+    settings_temp_color_thermometer: "By temperature",
+    settings_temp_color_thermometer_hint: "Cold room in blue, hot room in red, like a thermometer.",
+    comfort_cooling: "Hot – to cool",
+    comfort_heating: "Cold – to heat",
+    comfort_neutral: "Comfort",
     cover_add: "Add covers",
     // Facades
     facade_direction: "Direction",
     facade_direction_hint: "Presets azimuth values with house rotation applied.",
     facade_azimuth_start: "Azimuth start",
     facade_azimuth_end: "Azimuth end",
-    facade_azimuth_hint: "Real compass bearings where sun enters/exits this facade.",
+    facade_azimuth_hint: "Real compass bearings where sun enters/exits this facade. Start = end: full circle.",
     facade_min_elevation: "Min. elevation",
-    facade_min_elevation_hint: "Minimum sun elevation for this facade to count as sun-exposed.",
+    facade_min_elevation_hint: "Minimum sun elevation for this facade to count as sun-exposed. Values below 0 are treated as 0.",
     facade_covers: "Assigned covers",
     facade_add: "Add facade",
     facade_no_covers: "No covers assigned",
@@ -135,6 +384,38 @@ const I18N = {
     rule_operator_and: "AND (all must match)",
     rule_operator_or: "OR (any must match)",
     rule_conditions: "Conditions",
+    rule_scenarios: "Scenarios",
+    rule_scenarios_hint: "Scenarios in which this rule applies. In each scenario it can still be switched off temporarily from the Scenarios tab.",
+    rule_safety: "Safety rule",
+    rule_safety_hint: "Acts even when the cover is paused after a manual move, in manual mode, wind-protected or with automation disabled. Does not override the lock (window open). Between rules, priority decides: put it at the top of the list. Reserve it for emergencies, e.g. the fire alarm.",
+    rule_safety_badge: "Safety",
+    scenario_no_member_rules: "No rule belongs to this scenario (select it in the rule editor).",
+    rule_groups_operator: "Groups are joined by",
+    rule_groups_hint: "AND = every group must match. OR = one group is enough. Inside a group, its own operator applies.",
+    rule_group: "Group",
+    rule_group_joined_by: "conditions joined by",
+    rule_group_add: "Add a group",
+    rule_group_add_hint: "Groups allow e.g. (A OR B) AND (C OR D), or (A AND B) OR (C AND D).",
+    rule_group_delete: "Delete the group and its conditions",
+    rule_group_delete_confirm: "Delete this group and its conditions?",
+    rule_unsaved_confirm: "Discard unsaved changes to this rule?",
+    discard: "Discard",
+    input_invalid_range: "Enter a whole number between {min} and {max}",
+    input_not_integer: "Enter a whole number",
+    input_invalid_number: "Enter a valid number",
+    rule_group_empty: "No condition in this group yet (empty groups are ignored).",
+    rule_cond_move: "Move to another group",
+    rule_cond_up: "Move up",
+    rule_cond_down: "Move down",
+    rule_group_up: "Move group up",
+    rule_group_down: "Move group down",
+    rule_cond_not: "NOT",
+    rule_cond_not_hint: "Invert this condition (NOT). If its sensor is unavailable, the condition is not met.",
+    rule_groups_count: "{n} groups",
+    cond_collapse: "Collapse",
+    cond_expand: "Expand",
+    cond_collapse_all: "Collapse all",
+    cond_expand_all: "Expand all",
     rule_facades: "Facades",
     rule_covers: "Covers",
     rule_assignment_hint: "Limit this rule to specific facades/covers. Empty = applies to all covers.",
@@ -143,14 +424,29 @@ const I18N = {
     rule_copy_suffix: "(copy)",
     rule_add_condition: "Add condition",
     rule_no_conditions: "No conditions",
-    rule_reorder_hint: "Drag to reorder. Top rule wins when multiple rules match.",
+    rule_reorder_hint: "Drag or use ▲▼ to reorder. Top rule wins when multiple rules match.",
     // Condition types
     cond_sun_on_facade: "Sun on facade",
     cond_sun_elevation_above: "Sun elevation above",
     cond_sun_elevation_below: "Sun elevation below",
     cond_temperature_above: "Outdoor temperature above",
     cond_temperature_below: "Outdoor temperature below",
-    cond_temperature_comfort: "Temperature comfort",
+    cond_temperature_comfort: "Room temperature",
+    cond_outdoor_vs_indoor: "Outdoor air compared to the room",
+    cond_room_occupied: "Room occupied",
+    cond_group_presence: "Presence",
+    opt_cooler: "cooler than the room",
+    opt_warmer: "warmer than the room",
+    param_delta: "Minimum difference (°C)",
+    cover_occupancy_box_title: "Room occupancy",
+    cover_occupancy_sensor: "Occupancy sensor",
+    cover_occupancy_sensor_hint: "Used by the “Room occupied” rule condition. With NOT it lets a rule, for example, only open when the room is free. Unavailable sensor: neither “occupied” nor “free” is met.",
+    cover_occupancy_off_note: "Choose a sensor to tell when the room is occupied.",
+    cover_occupancy_states: "States = room occupied",
+    cover_occupancy_states_placeholder: "Present, on, home…",
+    cover_occupancy_states_hint: "Click the states that mean “room occupied” (several allowed). A state missing from the list can be added.",
+    cover_occupancy_default_note: "No state chosen: default states apply (on, home, Présent, occupied, detected).",
+    cover_occupancy_reset: "Back to the default states",
     cond_time_between: "Time between",
     cond_time_after_sunrise: "Time after sunrise",
     cond_time_after_sunset: "Time after sunset",
@@ -172,7 +468,7 @@ const I18N = {
     param_state: "State",
     param_operator: "Comparison",
     param_value: "Value",
-    param_hysteresis: "Buffer",
+    param_hysteresis: "Hysteresis",
     opt_above: "above",
     opt_below: "below",
     param_weather: "Weather condition",
@@ -184,7 +480,7 @@ const I18N = {
     cond_preview_context: "context-dependent",
     day_mon: "Mon", day_tue: "Tue", day_wed: "Wed", day_thu: "Thu", day_fri: "Fri", day_sat: "Sat", day_sun: "Sun",
     opt_on: "On (workday)", opt_off: "Off (non-workday)",
-    opt_cooling: "Cooling", opt_heating: "Heating",
+    opt_cooling: "Hot (≥ hot setpoint)", opt_heating: "Cold (≤ cold setpoint)", opt_neutral: "Between the setpoints",
     // Scenarios
     scenario_add: "Add scenario",
     scenario_icon: "Icon",
@@ -195,25 +491,34 @@ const I18N = {
     settings_outdoor_temp: "Outdoor temperature sensor",
     settings_outdoor_temp_short: "Outdoor:",
     settings_outdoor_temp_hint: "Used for temperature-based rule conditions (temperature above/below).",
-    settings_indoor_temp: "Indoor temperature sensor (global)",
-    settings_indoor_temp_hint: "Fallback for covers without their own indoor sensor. Used for comfort mode and shading decisions.",
+    settings_indoor_temp: "Indoor temperature sensor (global) (°C)",
+    settings_indoor_temp_hint: "Used for covers without their own indoor sensor. Used by the setpoints and by “Sun on facade”.",
     settings_weather: "Weather entity",
     settings_weather_hint: "Used for weather-based rule conditions (e.g. only shade when sunny).",
-    settings_comfort_min: "Comfort temp min",
-    settings_comfort_max: "Comfort temp max",
-    settings_comfort_hint: "Defines the comfort range. Below min = heating mode (shading off, use solar heat). Above max = cooling mode (shading active). Between = neutral (keep current position).",
-    settings_comfort_hysteresis: "Hysteresis",
-    settings_comfort_hysteresis_hint: "Temperature buffer at comfort boundaries to prevent oscillation between modes (e.g. 1.0 = mode only changes 1 degree past threshold).",
-    settings_threshold_hysteresis: "Threshold buffer",
-    settings_threshold_hysteresis_hint: "Deadband for the rule conditions \"temperature above/below\". A condition turns true only above threshold + buffer and false only below threshold - buffer, so an outdoor sensor lingering at the threshold no longer flips the rule with every reading. 0 disables the buffer.",
+    settings_comfort_min: "Cold temperature setpoint (°C)",
+    settings_comfort_max: "Hot temperature setpoint (°C)",
+    settings_comfort_hint: "Temperature range in which a room is considered comfortable. At or below the cold setpoint: cold room; at or above the hot setpoint: room too hot. Used by the “Room temperature” condition and by “Sun on facade” (Sun exposure tab).",
+    settings_comfort_hysteresis: "Hysteresis – between the setpoints (°C)",
+    settings_comfort_hysteresis_hint: "Prevents a room close to a setpoint from changing state with every reading: it only becomes comfortable again once it has moved away from the setpoint by this value.",
+    settings_threshold_hysteresis: "Hysteresis – on outdoor temperature in rules (°C)",
+    settings_threshold_hysteresis_hint: "Prevents an “outdoor temperature above/below” or “Outdoor air compared to the room” condition from flipping with every reading while the temperature stays close to the threshold. 0 = no hysteresis.",
     settings_house_rotation: "House rotation (degrees)",
-    settings_house_rotation_hint: "Offset from true north (-180 to 180, positive = clockwise). Applied automatically when selecting a facade direction. Drag the house in the compass, hold Shift to snap to 45°.",
+    settings_house_rotation_hint: "Offset from true north (-180 to 180, positive = clockwise). Applied when selecting a facade direction; changing it rotates existing facades too. Drag the house in the compass, hold Shift to snap to 45°.",
     settings_house_rotation_reset: "Reset",
     settings_section_house: "House",
     settings_section_sensors: "Sensors",
-    settings_section_comfort: "Comfort",
+    settings_outdoor_box_title: "Outdoor temperature",
+    settings_outdoor_off_note: "Choose an outdoor temperature sensor to set the hysteresis.",
+    settings_other_sensors_title: "Other sensors",
+    settings_section_comfort: "Sun exposure",
     settings_section_automation: "Automation",
+    settings_auto_box_pause: "Pause after a manual command",
+    settings_auto_box_window: "Window positions",
+    settings_auto_box_moves: "Movements",
+    settings_auto_box_misc: "Logbook and updates",
     settings_pause_duration: "Default pause duration (min)",
+    pause_resume_on_match: "Resume when the position matches the rule",
+    pause_resume_on_match_hint: "Ends the pause after a manual move as soon as the cover is back at the position its rule asks for: put back by hand, or the rule changed and now wants the position it was left at. Checked once the cover is still, at least 1 min after the pause started. The pause duration stays the maximum.",
     settings_pause_duration_hint: "How long automation pauses after manual cover operation. Can be overridden per cover.",
     settings_lock_position: "Default lock position",
     settings_lock_position_hint: "Target position when window is open (100 = fully open). Can be overridden per cover.",
@@ -238,18 +543,80 @@ const I18N = {
     settings_workday_sensor: "Workday sensor",
     settings_workday_hint: "Binary sensor for workday detection (e.g. HA Workday integration). Used by the 'workday' condition type in rules.",
     settings_section_wind: "Wind protection",
-    settings_wind_hint: "Safety feature: raises all covers when wind speed exceeds the threshold. Deactivates when speed drops below threshold minus hysteresis.",
+    settings_wind_hint: "Safety feature: when the wind speed exceeds the threshold, all covers move to the wind protection position (100 = open, e.g. to protect awnings and slats; 0 = closed, e.g. to protect the windows). Deactivates when the speed drops below the threshold minus the hysteresis.",
     settings_wind_sensor: "Wind speed sensor",
-    settings_wind_threshold: "Threshold (activation)",
-    settings_wind_hysteresis: "Hysteresis (deactivation difference)",
-    settings_section_solar: "Preemptive shading",
-    settings_solar_hint: "Sensor for solar radiation (e.g. PV power in W, solar irradiance in W/m\u00B2, or illuminance in lux). When the threshold is exceeded, shading starts within the comfort zone.",
-    settings_solar_sensor: "Solar intensity sensor",
-    settings_solar_threshold: "Solar intensity threshold",
-    settings_solar_threshold_hint: "Shading starts within the comfort zone when this value is exceeded.",
-    settings_solar_hysteresis: "Threshold buffer",
-    settings_solar_hysteresis_hint: "Deadband in the sensor's own unit. Shading starts above threshold + buffer and stops only below threshold - buffer, so a sensor drifting around the threshold does not toggle shading on every reading. 0 disables the buffer.",
+    settings_wind_threshold: "Activation threshold",
+    settings_wind_hysteresis: "Hysteresis – protection release",
+    settings_wind_hysteresis_hint: "Protection is only released once the wind has dropped this much below the threshold.",
+    hyst_title_comfort: "How does it work? – hysteresis between the setpoints",
+    hyst_title_rules: "How does it work? – outdoor temperature hysteresis",
+    hyst_title_solar: "How does it work? – sunshine hysteresis",
+    hyst_title_wind: "How does it work? – wind hysteresis",
+    hyst_with_values: "With your values",
+    hyst_example: "Example",
+    hyst_between: "between {a} and {b}",
+    hyst_above: "above {a}",
+    hyst_below: "below {a}",
+    hyst_keep: "Keeps its previous state",
+    hyst_comfort_intro: "{w}: setpoints {a} and {b} °C, hysteresis {h} °C.",
+    hyst_col_room_temp: "Room temperature",
+    hyst_col_state: "State",
+    hyst_cold: "Cold",
+    hyst_hot: "Hot",
+    hyst_comfortable: "Comfortable",
+    hyst_stay_cold: "Stays cold if it was, otherwise comfortable",
+    hyst_stay_hot: "Stays hot if it was, otherwise comfortable",
+    hyst_comfort_so1: "Hysteresis does not move the setpoints: the room becomes cold at {a} °C and hot at {b} °C.",
+    hyst_comfort_so2: "It only acts on the way back: a cold room must warm up to {ah} °C to be comfortable again, a hot room must cool down to {bh} °C.",
+    hyst_comfort_so3: "Example: the room drops to {a} °C → cold. It rises to {mid} °C → still cold. At {ah} °C → comfortable. If it drops back to {mid} °C → it stays comfortable (it only becomes cold again at {a} °C).",
+    hyst_comfort_so4: "Without hysteresis, a room hovering around a setpoint would change state with every reading, and the covers with it.",
+    hyst_rules_intro: "Example (none of your rules has this condition yet): a condition “outdoor temperature above {t} °C”, hysteresis {h} °C.",
+    hyst_rules_scope: "This hysteresis only applies to the “Outdoor temperature above / below” conditions (each with its own threshold) and “Outdoor air compared to the room” (on the outdoor – room difference) of your rules. It has no effect on the indoor temperature setpoints.",
+    hyst_rules_intro_real: "Example from your rules: “{rule}” has the condition “outdoor temperature {op} {t} °C”, hysteresis {h} °C.",
+    hyst_op_above: "above",
+    hyst_op_below: "below",
+    hyst_rules_so1_below: "The threshold entered in the rule is the middle of the band: the condition becomes true below {tl} °C and only becomes false again above {th} °C.",
+    hyst_rules_so2_below: "For “above” it is the other way round: true above {th} °C, false again below {tl} °C.",
+    hyst_rules_so3_below: "For it to become true below {t} °C, enter {th} °C in the rule.",
+    hyst_col_temp: "Temperature",
+    hyst_col_condition: "Condition",
+    hyst_true: "True",
+    hyst_false: "False",
+    hyst_rules_so1: "The threshold entered in the rule is the middle of the band: the condition becomes true above {th} °C and only becomes false again below {tl} °C.",
+    hyst_rules_so2: "For “below” it is the other way round: true below {tl} °C, false again above {th} °C.",
+    hyst_rules_so3: "For it to become true above {t} °C, enter {tl} °C in the rule.",
+    hyst_zero: "With 0 there is no hysteresis: the state changes exactly at the threshold, every time.",
+    hyst_solar_intro: "{w}: threshold {t}, hysteresis {h}.",
+    hyst_col_sensor: "Sunshine sensor",
+    hyst_col_strong: "Strong sunshine",
+    hyst_strong_yes: "Yes: the condition answers “sun”",
+    hyst_strong_no: "No",
+    hyst_solar_so1: "The threshold is the middle of the band: strong sunshine starts above {th} and only stops below {tl}. A passing cloud therefore does not reopen the covers.",
+    hyst_solar_so2: "Only concerns covers set to “Only with strong sunshine”.",
+    hyst_wind_intro: "{w}: threshold {t}, hysteresis {h}.",
+    hyst_col_wind: "Wind",
+    hyst_col_protection: "Protection",
+    hyst_wind_on: "Active",
+    hyst_wind_stay: "Stays active if it was, otherwise inactive",
+    hyst_wind_off: "Released",
+    hyst_wind_so1: "As for comfort, hysteresis only acts on the way back: protection activates at {t} and is only released once the wind has dropped to {tl}.",
+    hyst_wind_so2: "A gust falling just below the threshold therefore does not move the covers back. A hysteresis greater than or equal to the threshold is ignored.",
+    settings_wind_position: "Wind protection position",
+    settings_wind_position_hint: "Position all covers move to while wind protection is active (0-100). 100 = open (protects awnings and slats), 0 = closed (protects the windows).",
+    settings_section_solar: "Sunshine",
+    settings_solar_hint: "Sensor measuring sunshine (light in lux, solar production in W, irradiance in W/m²). Above its threshold, the option “Only with strong sunshine” closes the covers.",
+    settings_solar_sensor: "Sunshine sensor",
+    settings_solar_threshold: "Strong sunshine above",
+    settings_solar_threshold_hint: "Above this threshold, the option “Only with strong sunshine” answers “sun”.",
+    threshold_entity: "or entity",
+    threshold_entity_hint: "If an entity is selected, its value is used; the number entered serves as a fallback if the entity is unavailable.",
+    threshold_entity_current: "Current",
+    threshold_entity_unavailable: "unavailable, the number entered is used",
+    threshold_fallback: "Entity value. If it is unavailable: {v}",
+    settings_solar_hysteresis: "Hysteresis – sunshine threshold",
+    settings_solar_hysteresis_hint: "Prevents strong sunshine from flipping with every reading while the sensor stays close to the threshold. 0 = no hysteresis.",
     settings_solar_short: "Solar:",
+    settings_sun_facade_title: "Sun on facade – depending on indoor temperature",
     status_auto: "Auto",
     status_paused: "Paused",
     status_manual: "Manual",
@@ -275,15 +642,16 @@ const I18N = {
     info_sun_title: "Sun position (azimuth / elevation)",
     info_outdoor_title: "Outdoor temperature",
     info_solar_title: "Solar intensity",
-    info_solar_exceeded_title: "Solar above threshold - preemptive shading active",
+    info_solar_exceeded_title: "Strong sunshine: threshold exceeded",
     rule_active_for: "Active for",
     rule_covers_count: "cover(s)",
     rule_inactive: "Not matching",
     master_enabled: "Automation",
-    master_enabled_hint: "Lock and vent protection remain active even when automation is disabled.",
+    master_enabled_hint: "Lock and vent protection as well as safety rules remain active even when automation is disabled.",
     log_time: "Time",
     log_event: "Event",
     log_cover: "Cover",
+    cover_show_log: "Show this cover's log",
     log_message: "Details",
     log_type_position: "Position",
     log_type_status: "Status",
@@ -292,8 +660,12 @@ const I18N = {
     log_loading: "Loading log...",
     log_empty: "No log entries in the last 3 days.",
     log_filter_all: "All",
+    log_filter_cover: "Cover:",
+    log_filter_all_covers: "All covers",
+    log_filter_cover_note: "Global events (wind) are also shown.",
     log_clear: "Clear log",
     log_clear_confirm: "Delete all log entries?",
+    log_clear_confirm_all: "Clear the whole log (all covers)?",
     settings_section_backup: "Backup",
     settings_backup_hint: "Export the complete configuration as a JSON file. Import replaces all settings, covers, facades, rules, and scenarios.",
     settings_export: "Export configuration",
@@ -302,6 +674,10 @@ const I18N = {
     settings_import_success: "Configuration imported successfully.",
     settings_import_error: "Import failed",
     settings_export_error: "Export failed",
+    settings_unsaved_confirm: "Discard unsaved settings changes?",
+    settings_unsaved_warning: "Some settings were changed but not saved: they are not in the export.",
+    settings_export_unsaved_confirm: "Some settings were changed but not saved. Save them before exporting?",
+    settings_save_and_export: "Save and export",
   },
   de: {
     title: "CoverAutomatic",
@@ -313,9 +689,155 @@ const I18N = {
     error_load: "Konfiguration konnte nicht geladen werden.",
     retry: "Erneut versuchen",
     saved: "Gespeichert",
+    cond_time_after_dawn: "Zeit nach Morgendämmerung",
+    cond_time_before_dawn: "Zeit vor Morgendämmerung",
+    cond_time_after_dusk: "Zeit nach Abenddämmerung",
+    cond_time_before_dusk: "Zeit vor Abenddämmerung",
+    cond_time_after_dawn_hint: "Von der Morgendämmerung (+ Offset) bis zur Abenddämmerung. Gegenstück: „{other}“.",
+    cond_time_before_dawn_hint: "Von der Abenddämmerung bis zur nächsten Morgendämmerung (+ Offset). Gegenstück: „{other}“.",
+    cond_time_after_dusk_hint: "Von der Abenddämmerung (+ Offset) bis zur nächsten Morgendämmerung. Gegenstück: „{other}“.",
+    cond_time_before_dusk_hint: "Von der Morgendämmerung bis zur Abenddämmerung (+ Offset). Gegenstück: „{other}“.",
+    cond_time_after_sunrise_hint: "Vom Sonnenaufgang (+ Offset) bis zum Sonnenuntergang. Gegenstück: „{other}“.",
+    cond_time_before_sunrise_hint: "Vom Sonnenuntergang bis zum nächsten Sonnenaufgang (+ Offset). Gegenstück: „{other}“.",
+    cond_time_after_sunset_hint: "Vom Sonnenuntergang (+ Offset) bis zum nächsten Sonnenaufgang. Gegenstück: „{other}“.",
+    cond_time_before_sunset_hint: "Vom Sonnenaufgang bis zum Sonnenuntergang (+ Offset). Gegenstück: „{other}“.",
+    cover_travel_auto_default: "Standard: {s} s",
+    cover_travel_not_measured: "Gemessen: noch nicht (bei der nächsten Fahrt von mindestens 20 %).",
+    cover_travel_used: "Verwendet: {s} s ({src}) · Wartezeit vor Erkennung manueller Bedienung: {wait} s",
+    cover_travel_used_none: "Verwendet: keine · Wartezeit vor Erkennung manueller Bedienung: {wait} s",
+    cover_travel_src_manual: "eingegeben",
+    cover_travel_src_measured: "gemessen",
+    cover_travel_src_default: "globaler Standard",
+    cover_travel_src_none: "keine",
+    settings_default_travel_time: "Standard-Laufzeit (s)",
+    settings_default_travel_time_placeholder: "keine (30 s Wartezeit)",
+    settings_default_travel_time_hint: "Laufzeit für Behänge ohne eingegebenen und noch ohne gemessenen Wert. Reihenfolge: Wert am Behang, dann gemessener Wert, dann dieser Standard. Leer = 30 s Wartezeit.",
+    cover_travel_time: "Laufzeit (s)",
+    cover_travel_auto: "automatisch (wird bei den ersten Fahrten gemessen)",
+    cover_travel_auto_measured: "automatisch: {s} s gemessen",
+    cover_travel_measured: "Gemessen: {s} s für eine volle Fahrt.",
+    cover_travel_reset: "Zurücksetzen",
+    cover_travel_time_hint: "Dauer einer vollen Fahrt von 0 bis 100 %. Nach einem eigenen Befehl wartet die Integration so lange (plus 5 s, mindestens 30 s), bevor sie eine Positionsänderung als manuelle Bedienung wertet. Leer lassen, um den gemessenen Wert bzw. sonst die Standard-Laufzeit aus den Einstellungen zu verwenden.",
+    scenario_rule_off: "in Regeln deaktiviert",
+    scenario_rule_off_hint: "Diese Regel ist im Tab „Regeln“ ausgeschaltet und wird daher nie ausgeführt. Die Einstellung hier gilt wieder, sobald die Regel aktiviert ist.",
+    ha_ctype_and: "und",
+    ha_ctype_or: "oder",
+    ha_ctype_not: "nicht",
+    ha_ctype_template: "Template",
+    ha_ctype_state: "Zustand",
+    ha_ctype_numeric_state: "Zahlenwert",
+    ha_ctype_zone: "Zone",
+    ha_ctype_time: "Zeit",
+    ha_ctype_sun: "Sonne",
+    ha_ctype_device: "Gerät",
+    ha_ctype_trigger: "Auslöser",
+    cond_group_sun: "Sonne",
+    cond_group_temperature: "Temperatur",
+    cond_group_time: "Zeit",
+    cond_group_weather: "Wetter",
+    cond_group_entities: "Entitäten",
+    cond_menu_ha_state: "Zustand einer Entität",
+    cond_menu_ha_numeric: "Zahlenwert einer Entität",
+    cond_menu_ha_yaml: "Home-Assistant-Bedingung (YAML)",
+    cond_ha_condition: "Home-Assistant-Bedingung",
+    cond_ha_state: "Zustand einer Entität",
+    cond_ha_numeric: "Zahlenwert einer Entität",
+    ha_tab_form: "Formular",
+    ha_tab_yaml: "YAML",
+    ha_kind: "Typ",
+    ha_kind_state: "Zustand",
+    ha_kind_numeric: "Zahlenwert",
+    ha_entity: "Entität",
+    ha_current: "aktuell",
+    ha_attribute: "Attribut",
+    ha_attribute_none: "— Zustand der Entität —",
+    ha_compare: "Vergleich",
+    ha_is: "ist",
+    ha_is_not: "ist nicht",
+    ha_for: "Seit mindestens (min)",
+    ha_for_negate_hint: "Mit „ist nicht“ nicht verfügbar.",
+    ha_states: "Zustände",
+    ha_state_other: "Anderer Wert…",
+    ha_state_add: "Hinzufügen",
+    ha_operator: "Operator",
+    ha_op_above: "über",
+    ha_op_below: "unter",
+    ha_op_between: "zwischen",
+    ha_value: "Wert",
+    ha_min: "Minimum",
+    ha_max: "Maximum",
+    ha_form_unsupported: "Diese Bedingung kann nicht als Formular angezeigt werden (Template, Zone, verschachtelte Bedingungen…). Sie bleibt in YAML bearbeitbar.",
+    ha_yaml_label: "Bedingung",
+    ha_yaml_placeholder: "condition: state\nentity_id: person.ich\nstate: not_home\nfor: \"00:15:00\"",
+    ha_yaml_help: "Gleiches Format wie der Abschnitt „condition“ einer Home-Assistant-Automatisierung. Eine Liste von Bedingungen wird mit UND verknüpft.",
+    ha_valid: "Bedingung gültig",
+    ha_entities: "Überwachte Entitäten",
+    ha_unknown_entities: "Entitäten nicht gefunden (ID prüfen)",
+    ha_err_yaml: "YAML-Syntaxfehler in Zeile {line}, Spalte {column}",
+    ha_err_not_mapping: "Das YAML muss eine Bedingung beschreiben (z. B. „condition: state“).",
+    ha_err_invalid: "Ungültige Bedingung",
+    ha_err_empty: "Leere Bedingung",
+    ha_checking: "Wird geprüft…",
+    ha_incomplete_entity: "Wähle eine Entität.",
+    ha_incomplete_states: "Wähle mindestens einen Zustand.",
+    ha_incomplete_value: "Gib einen Wert ein.",
+    cond_convert: "In erweiterte Bedingung umwandeln",
+    cond_convert_hint: "Ergänzt Attribut, „ist nicht“, Dauer und Zustandsauswahl. Wird beim Speichern der Regel übernommen.",
+    ha_chip_is: "{entity} ist {states}",
+    ha_chip_is_not: "{entity} ist nicht {states}",
+    ha_chip_for: " seit {min} min",
+    ha_chip_or: " oder ",
+    ha_chip_above: "{entity} > {value}",
+    ha_chip_below: "{entity} < {value}",
+    ha_chip_between: "{entity} zwischen {min} und {max}",
+    ha_chip_other: "HA-Bedingung: {type}",
+    rule_op_short_and: "UND", rule_op_short_or: "ODER",
+    compass_n: "N", compass_e: "O", compass_s: "S", compass_w: "W",
+    error_generic: "Die Änderung konnte nicht gespeichert werden",
+    error_not_found: "Element nicht gefunden (evtl. zwischenzeitlich gelöscht)",
+    error_invalid_format: "Ungültiger Wert",
+    error_invalid_conditions: "Ungültige Regelbedingung",
+    error_invalid_data: "Ungültige Konfigurationsdaten",
+    error_too_large: "Importdatei ist zu groß",
+    error_unauthorized: "Administratorrechte erforderlich",
+    error_invalid_comfort_range: "Der Kalt-Sollwert muss unter dem Warm-Sollwert liegen",
+    error_invalid_wind_hysteresis: "Die Wind-Hysterese muss kleiner als der Windschwellwert sein",
+    rule_priority_up: "Priorität erhöhen",
+    rule_priority_down: "Priorität senken",
+    rule_enabled_aria: "Regel {name} aktiv",
+    rule_invalid_fields: "Rot markierte Felder korrigieren (leerer oder ungültiger Wert), dann speichern",
+    ha_err_request: "Prüfung fehlgeschlagen",
+    error_not_loaded: "CoverAutomatic ist nicht geladen (Integration neu laden oder Home Assistant neu starten)",
+    error_invalid_solar_hysteresis: "Die Sonnenschein-Hysterese muss kleiner als die Sonnenscheinschwelle sein",
+    error_invalid_value: "Ungültige Zahl",
+    drag_handle: "Zum Sortieren ziehen",
+    settings_nav_label: "Einstellungen",
+    import_invalid_json: "Ungültiges JSON",
+    status_unlocked: "Entsperrt",
+    log_msg_wind_activated: "Aktiviert ({speed} ≥ {threshold})",
+    log_msg_wind_deactivated: "Deaktiviert ({speed} ≤ {threshold})",
+    log_msg_wind_disabled: "Deaktiviert (in den Einstellungen ausgeschaltet)",
+    log_msg_status_change: "{from} → {to}",
+    log_msg_rule: "{rule} → {position} %",
+    log_msg_position: "{from} % → {to} %",
+    log_msg_safety_takeover: "Sicherheitsregel {rule} übernimmt ({status}) → {position} %",
+    log_msg_safety_release: "Sicherheitsregel {rule} beendet ({status})",
+    log_msg_sensor_unavailable: "{status} beibehalten: Sensor {sensor} nicht verfügbar",
+    log_msg_lock_sensor_missing: "Fenstersensor {sensor} nicht gefunden: ignoriert",
+    log_msg_move_blocked_window_unknown: "Fahrt auf {position} % zurückgehalten: Fensterzustand unbekannt ({sensor})",
+    log_msg_wind_restore_dropped: "Wiederherstellung des Windschutzes verworfen: Sensor {sensor} fehlt oder ohne Wert",
     save: "Speichern",
     cancel: "Abbrechen",
     delete: "Löschen",
+    rule_duplicate: "Duplizieren (die Kopie wird direkt darunter erstellt)",
+    rule_copy_suffix: "Kopie",
+    settings_wind_off_note: "Wählen Sie einen Windsensor, um den Windschutz zu aktivieren.",
+    settings_solar_off_note: "Wählen Sie einen Sensor, um Schwelle und Hysterese einzustellen.",
+    settings_solar_nested_off: "Nur von der Option „Nur bei starkem Sonnenschein“ verwendet (hier oder bei einem Behang).",
+    cover_lock_box_title: "Fenster offen",
+    cover_lock_off_note: "Wählen Sie einen Fenstersensor, um diese Einstellungen zu aktivieren.",
+    cover_vent_box_title: "Fenster gekippt (Lüftung)",
+    cover_vent_off_note: "Wählen Sie einen Kippsensor, um die Lüftungsposition einzustellen.",
     confirm_delete: "Wirklich löschen?",
     add: "Hinzufügen",
     edit: "Bearbeiten",
@@ -330,40 +852,135 @@ const I18N = {
     cover_status: "Status",
     cover_pause_duration: "Pausendauer (Min.)",
     cover_pause_duration_hint: "Wie lange die Automatik nach manueller Bedienung pausiert. Leer = globaler Standard.",
-    cover_indoor_temp: "Innentemperatur-Sensor",
-    cover_indoor_temp_hint: "Sensor für den Komfortmodus dieses Behangs. Überschreibt den globalen Sensor.",
-    cover_lock_sensor: "Sperr-Sensor",
+    cover_indoor_temp: "Innentemperatur-Sensor (°C)",
+    cover_indoor_temp_hint: "Sensor des Raums dieses Behangs, für die Sollwerte und „Sonne auf Fassade“. Ersetzt den globalen Sensor.",
+    cover_lock_sensor: "Sensor Fenster offen",
     cover_lock_sensor_hint: "Fensterkontakt. Bei geöffnetem Fenster fährt der Behang auf Sperrposition (Sicherheit).",
+    cover_lock_hold: "Aktuelle Position beim Öffnen des Fensters halten",
+    cover_lock_hold_hint: "Ein: Der Behang bleibt bei geöffnetem Fenster, wo er ist (gesperrt, kein Befehl). Aus: Er fährt auf die Sperrposition unten (nur nach oben, nie weiter zu).",
     cover_lock_position: "Sperrposition",
     cover_lock_position_hint: "Zielposition bei geöffnetem Fenster. Leer = globaler Standard.",
-    cover_vent_sensor: "Lüftungssensor",
+    cover_vent_sensor: "Sensor Fenster gekippt",
     cover_vent_sensor_hint: "Kippkontakt. Bei gekipptem Fenster fährt der Behang auf Lüftungsposition.",
     cover_vent_position: "Lüftungsposition",
     cover_vent_position_hint: "Zielposition bei gekipptem Fenster. Leer = globaler Standard.",
-    cover_comfort_min: "Komfort-Temp. min",
-    cover_comfort_max: "Komfort-Temp. max",
-    cover_comfort_hint: "Komfortbereich pro Raum. Leer = globale Werte aus Einstellungen.",
-    cover_preemptive_shading: "Präventive Beschattung aktiv",
-    cover_preemptive_shading_hint: "Wenn aktiv, kann der globale Solarsensor innerhalb der Komfortzone beschatten. Für Räume deaktivieren, in denen die Komforttemperatur schnell erreicht werden soll (z. B. Bad).",
-    cover_inverted: "Invertiert",
+    cover_comfort_min: "Temperatursollwert kalt (°C)",
+    cover_comfort_max: "Temperatursollwert warm (°C)",
+    cover_comfort_hint: "Sollwerte für diesen Raum. Leer = globale Werte aus den Einstellungen.",
+    cover_comfort_global: "Leer = globaler Wert: {v} °C ({src})",
+    cover_default_note: "Leer = Standardwert: {v} (Einstellungen)",
+    unit_sensor: "Sensoreinheit",
+    cover_comfort_src_settings: "Einstellungen",
+    cover_sun_switches_hint: "Einstellungen nur für diesen Behang; „Global“ = Wert aus Einstellungen › Sonnenexposition.",
+    tristate_global: "Global ({value})",
+    settings_sun_facade_hint: "Diese Einstellungen ändern nur die Antwort der Bedingung „Sonne auf Fassade“, für Behänge mit Innentemperatursensor (eigener oder globaler). Sie dienen Regeln, die bei Sonne schließen: nur schließen, wenn es nützt. Alles aus lassen, wenn eine Regel die Behänge bei Sonne öffnet.",
+    sun_heating_label: "Aktion beim Kalt-Sollwert: Sonne wärmen lassen",
+    sun_heating_hint: "Die Bedingung meldet „keine Sonne“: Regeln, die bei Sonne schließen, schließen nicht und die Sonne wärmt den Raum. Vermeiden, wenn eine Regel die Behänge bei Sonne öffnet (sie würde nicht mehr greifen).",
+    sun_below: "≤ {t} °C",
+    sun_above: "≥ {t} °C",
+    sun_between: "zwischen {min} und {max} °C",
+    settings_comfort_range_title: "Innentemperatur-Sollwerte",
+    settings_indoor_reminder: "Gilt je nach Innentemperatur jedes Raums (Reiter Sensoren: globaler Sensor {name}, Sollwerte {min} und {max} °C). Ein Behang kann eigenen Sensor und eigene Sollwerte haben.",
+    settings_indoor_none: "nicht festgelegt",
+    sun_explain_title: "Wie funktioniert das?",
+    sun_explain_intro: "Beispiel: eine Regel „schließen bei Sonne“ und Sonne auf der Fassade. Hervorgehobene Zeilen entsprechen Ihren Einstellungen.",
+    sun_explain_col_room: "Raum",
+    sun_explain_col_answer: "Antwort von „Sonne auf Fassade“",
+    sun_explain_col_effect: "Wirkung",
+    sun_explain_room_cold_on: "Kalt, „Sonne wärmen lassen“ aktiviert",
+    sun_explain_room_cold_off: "Kalt, Kästchen deaktiviert",
+    sun_explain_room_position: "Angenehm, „Sobald die Sonne auf der Fassade steht“",
+    sun_explain_room_ignore: "Angenehm, „Nie“",
+    sun_explain_room_preemptive: "Angenehm, „Nur bei starkem Sonnenschein“",
+    sun_explain_room_hot: "Zu warm",
+    sun_explain_sun: "„Sonne“",
+    sun_explain_no_sun: "„keine Sonne“",
+    sun_explain_sun_always: "immer „Sonne“",
+    sun_explain_sun_if_strong: "„Sonne“, wenn der Sensor die Schwelle überschreitet, sonst „keine Sonne“",
+    sun_explain_eff_warm: "Schließt nicht: der Behang bleibt offen und der Raum erwärmt sich.",
+    sun_explain_eff_close: "Schließt.",
+    sun_explain_eff_close_as_hot: "Schließt, als wäre der Raum warm.",
+    sun_explain_eff_wait: "Schließt nicht; schließt, sobald der Raum zu warm wird.",
+    sun_explain_eff_strong: "Schließt nur bei starkem Sonnenschein, bevor der Raum warm wird.",
+    sun_explain_so: "Also",
+    sun_explain_cold: "Kalter Raum: das Kästchen öffnet den Behang nicht, es verhindert das Schließen wegen der Sonne. Ist der Behang bereits offen (z. B. durch eine Öffnungsregel am Tag), bleibt er offen.",
+    sun_explain_hot: "Zu warmer Raum: der Behang schließt nur, wenn eine Regel „schließen bei Sonne“ für diesen Behang und das aktive Szenario gilt.",
+    sun_explain_comfort: "Angenehmer Raum: der Zwischenbereich, in dem Sie wählen, wann die Sonne zählt.",
+    sun_comfort_label: "Aktion zwischen den Sollwerten: Verhalten je nach Sonne",
+    sun_comfort_position: "Sobald die Sonne auf der Fassade steht",
+    sun_comfort_position_hint: "Die Bedingung ist wahr, sobald die Sonne auf der Fassade steht.",
+    sun_comfort_ignore: "Nie (warten, bis der Raum zu warm wird)",
+    sun_comfort_ignore_hint: "Meldet „keine Sonne“: der Behang schließt erst, wenn der Raum zu warm wird.",
+    sun_comfort_preemptive: "Nur bei starkem Sonnenschein",
+    sun_comfort_preemptive_hint: "Meldet „Sonne“, sobald der Sonnenscheinsensor seine Schwelle überschreitet: der Behang schließt, bevor der Raum warm wird.",
+    sun_comfort_hint: "Verhalten von „Sonne auf Fassade“, solange der Raum zwischen den Sollwerten liegt. Global = Wert aus Einstellungen › Sonnenexposition.",
+    sun_hot_note: "Raum zu warm (≥ {t} °C): die Sonne zählt immer, sobald sie auf der Fassade steht.",
+    solar_used_by: "Verwendet von der Option „Nur bei starkem Sonnenschein“: {n} Behang/Behänge.",
+    solar_unused: "Nur von der Option „Nur bei starkem Sonnenschein“ verwendet (derzeit kein Behang).",
+    tristate_on: "Aktiviert",
+    tristate_off: "Deaktiviert",
+    cover_inverted: "Öffnungs-/Schließrichtung umkehren",
     cover_inverted_hint: "Aktivieren, wenn 100 % geschlossen bedeutet (umgekehrte Motorrichtung).",
-    cover_lock_tilt: "Sperr-Tiltposition",
-    cover_vent_tilt: "Lüftungs-Tiltposition",
-    cover_inverted_tilt: "Invertierter Tilt",
-    cover_min_pos_change: "Min. Positionsänderung",
+    cover_lock_tilt: "Sperr-Neigung",
+    cover_vent_tilt: "Lüftungs-Neigung",
+    cover_inverted_tilt: "Umgekehrte Neigung",
+    cover_min_pos_change: "Min. Positionsänderung (%)",
     cover_min_pos_change_hint: "Mindestabweichung für eine Fahrt. Leer = globaler Standard.",
     cover_min_time: "Min. Zeit zwischen Änderungen (s)",
     cover_min_time_hint: "Mindestabstand in Sekunden zwischen Positionsänderungen. Leer = globaler Standard.",
     cover_section_base: "Allgemein",
     cover_section_sensors: "Sensoren",
     cover_section_advanced: "Erweitert",
-    cover_section_tilt: "Tilt",
+    cover_section_tilt: "Neigung",
+    cover_section_window: "Fenster",
+    cover_section_automation: "Automatisierung",
+    cover_section_room: "Raum",
+    cover_inverted_short: "Umgekehrt",
+    cover_lock_hold_short: "Position halten",
+    sun_heating_label_short: "Kalt: wärmen lassen",
+    sun_comfort_label_short: "Zwischen den Sollwerten",
+    settings_comfort_min_short: "Sollwert kalt (°C)",
+    settings_comfort_max_short: "Sollwert warm (°C)",
+    cover_comfort_min_short: "Sollwert kalt (°C)",
+    cover_comfort_max_short: "Sollwert warm (°C)",
+    settings_indoor_temp_short: "Innensensor (°C)",
+    cover_indoor_temp_short: "Innensensor (°C)",
+    settings_comfort_hysteresis_short: "Hysterese Sollwerte (°C)",
+    settings_threshold_hysteresis_short: "Hysterese außen (°C)",
+    settings_solar_hysteresis_short: "Hysterese Sonnenschein",
+    settings_wind_hysteresis_short: "Hysterese Wind",
+    settings_solar_threshold_short: "Schwelle starker Sonnenschein",
+    settings_sun_facade_title_short: "Sonne auf Fassade",
+    cover_min_time_short: "Min. Verzögerung (s)",
+    cover_min_pos_change_short: "Min. Änderung (%)",
+    cover_expand_all: "Alle aufklappen",
+    cover_collapse_all: "Alle zuklappen",
+    cover_sum_auto_on: "Automatisch",
+    cover_sum_auto_off: "Automatisierung aus",
+    cover_sum_no_facade: "keine Fassade",
+    cover_sum_open: "Offen: {v}",
+    cover_sum_hold: "Position halten",
+    cover_sum_tilted: "Gekippt: {v}",
+    cover_sum_no_window: "Kein Fenstersensor",
+    cover_sum_pause: "Pause {n} min",
+    cover_sum_travel: "Laufzeit {n} s",
+    cover_sum_own: "{n} eigene Einstellung(en)",
+    cover_sum_all_global: "Standardwerte",
+    cover_sum_global: "global",
+    cover_sum_no_indoor: "Kein Innensensor",
+    cover_sum_sun_heat_on: "Kalt: Sonne wärmen lassen",
+    cover_sum_sun_heat_off: "Kalt: Sonne zählt",
+    cover_sum_sun_between: "Dazwischen: {v}",
+    cover_sum_mode_position: "sobald die Sonne da ist",
+    cover_sum_mode_ignore: "nie",
+    cover_sum_mode_preemptive: "starker Sonnenschein",
     cover_auto_enabled: "Automatik aktiviert",
     cover_temp: "Temp",
     cover_current_pos: "Ist",
     cover_target_pos: "Soll",
     cover_position: "Position",
     cover_position_target_label: "Soll",
+    cover_position_inverted_tip: "Invertierter Behang: HA meldet {raw} % (hier in der Skala der Regeln angezeigt)",
     cover_hysteresis_position: "Positionsänderung zu gering",
     cover_hysteresis_time: "Zu kurz seit letzter Änderung",
     cover_rule: "Regel",
@@ -377,17 +994,22 @@ const I18N = {
     time_ago_h: "vor {n} Std.",
     time_ago_h_m: "vor {h} Std. {m} Min.",
     show_hint: "Hilfe anzeigen",
-    comfort_cooling: "Kühlen",
-    comfort_heating: "Heizen",
-    comfort_neutral: "Neutral",
+    settings_temp_color: "Farben der Raumtemperatur (Behangliste)",
+    settings_temp_color_action: "Nach nötiger Aktion",
+    settings_temp_color_action_hint: "Kalter Raum rot (heizen), warmer Raum blau (kühlen).",
+    settings_temp_color_thermometer: "Nach Temperatur",
+    settings_temp_color_thermometer_hint: "Kalter Raum blau, warmer Raum rot, wie ein Thermometer.",
+    comfort_cooling: "Warm – kühlen",
+    comfort_heating: "Kalt – heizen",
+    comfort_neutral: "Komfort",
     cover_add: "Behänge hinzufügen",
     facade_direction: "Richtung",
     facade_direction_hint: "Setzt Azimutwerte mit Hausrotation automatisch.",
     facade_azimuth_start: "Azimut Start",
     facade_azimuth_end: "Azimut Ende",
-    facade_azimuth_hint: "Echte Kompasspeilungen, an denen die Sonne die Fassade erreicht/verlässt.",
+    facade_azimuth_hint: "Echte Kompasspeilungen, an denen die Sonne die Fassade erreicht/verlässt. Start = Ende: voller Kreis.",
     facade_min_elevation: "Min. Elevation",
-    facade_min_elevation_hint: "Minimale Sonnenhöhe, damit diese Fassade als besonnt gilt.",
+    facade_min_elevation_hint: "Minimale Sonnenhöhe, damit diese Fassade als besonnt gilt. Werte unter 0 gelten als 0.",
     facade_covers: "Zugewiesene Behänge",
     facade_add: "Fassade hinzufügen",
     facade_no_covers: "Keine Behänge zugewiesen",
@@ -399,12 +1021,44 @@ const I18N = {
     rule_priority: "Priorität",
     rule_target_pos: "Zielposition",
     rule_target_pos_hint: "Position bei Regelübereinstimmung (0 = geschlossen, 100 = offen).",
-    rule_target_tilt: "Ziel-Tiltposition",
+    rule_target_tilt: "Ziel-Neigung",
     rule_operator: "Bedingungsoperator",
     rule_operator_hint: "UND = alle Bedingungen müssen zutreffen. ODER = eine reicht.",
     rule_operator_and: "UND (alle müssen zutreffen)",
     rule_operator_or: "ODER (eine muss zutreffen)",
     rule_conditions: "Bedingungen",
+    rule_scenarios: "Szenarien",
+    rule_scenarios_hint: "Szenarien, in denen diese Regel gilt. In jedem Szenario kann sie im Tab „Szenarien“ weiterhin vorübergehend ausgeschaltet werden.",
+    rule_safety: "Sicherheitsregel",
+    rule_safety_hint: "Wirkt auch während der Pause nach manueller Bedienung, im manuellen Modus des Behangs, bei Windschutz und bei deaktivierter Automatik. Setzt die Sperre (Fenster offen) nicht außer Kraft. Zwischen Regeln entscheidet die Priorität: oben in der Liste platzieren. Nur für Notfälle verwenden, z. B. den Feueralarm.",
+    rule_safety_badge: "Sicherheit",
+    scenario_no_member_rules: "Diesem Szenario ist keine Regel zugeordnet (im Regeleditor auswählen).",
+    rule_groups_operator: "Gruppen verknüpft mit",
+    rule_groups_hint: "UND = alle Gruppen müssen zutreffen. ODER = eine Gruppe reicht. Innerhalb einer Gruppe gilt ihr eigener Operator.",
+    rule_group: "Gruppe",
+    rule_group_joined_by: "Bedingungen verknüpft mit",
+    rule_group_add: "Gruppe hinzufügen",
+    rule_group_add_hint: "Gruppen erlauben z. B. (A ODER B) UND (C ODER D) oder (A UND B) ODER (C UND D).",
+    rule_group_delete: "Gruppe und ihre Bedingungen löschen",
+    rule_group_delete_confirm: "Diese Gruppe und ihre Bedingungen löschen?",
+    rule_unsaved_confirm: "Ungespeicherte Änderungen an dieser Regel verwerfen?",
+    discard: "Verwerfen",
+    input_invalid_range: "Ganze Zahl zwischen {min} und {max} eingeben",
+    input_not_integer: "Ganze Zahl eingeben",
+    input_invalid_number: "Gültige Zahl eingeben",
+    rule_group_empty: "Noch keine Bedingung in dieser Gruppe (leere Gruppen werden ignoriert).",
+    rule_cond_move: "In andere Gruppe verschieben",
+    rule_cond_up: "Nach oben",
+    rule_cond_down: "Nach unten",
+    rule_group_up: "Gruppe nach oben",
+    rule_group_down: "Gruppe nach unten",
+    rule_cond_not: "NICHT",
+    rule_cond_not_hint: "Bedingung umkehren (NICHT). Ist ihr Sensor nicht verfügbar, gilt sie als nicht erfüllt.",
+    rule_groups_count: "{n} Gruppen",
+    cond_collapse: "Einklappen",
+    cond_expand: "Ausklappen",
+    cond_collapse_all: "Alle einklappen",
+    cond_expand_all: "Alle ausklappen",
     rule_facades: "Fassaden",
     rule_covers: "Behänge",
     rule_assignment_hint: "Regel auf bestimmte Fassaden/Behänge beschränken. Leer = gilt für alle.",
@@ -413,13 +1067,28 @@ const I18N = {
     rule_copy_suffix: "(Kopie)",
     rule_add_condition: "Bedingung hinzufügen",
     rule_no_conditions: "Keine Bedingungen",
-    rule_reorder_hint: "Ziehen zum Sortieren. Obere Regel gewinnt bei Überschneidung.",
+    rule_reorder_hint: "Ziehen oder ▲▼ zum Sortieren. Obere Regel gewinnt bei Überschneidung.",
     cond_sun_on_facade: "Sonne auf Fassade",
     cond_sun_elevation_above: "Sonnenhöhe über",
     cond_sun_elevation_below: "Sonnenhöhe unter",
     cond_temperature_above: "Außentemperatur über",
     cond_temperature_below: "Außentemperatur unter",
-    cond_temperature_comfort: "Temperatur Komfort",
+    cond_temperature_comfort: "Raumtemperatur",
+    cond_outdoor_vs_indoor: "Außenluft im Vergleich zum Raum",
+    cond_room_occupied: "Raum belegt",
+    cond_group_presence: "Anwesenheit",
+    opt_cooler: "kühler als der Raum",
+    opt_warmer: "wärmer als der Raum",
+    param_delta: "Mindestdifferenz (°C)",
+    cover_occupancy_box_title: "Raumbelegung",
+    cover_occupancy_sensor: "Belegungssensor",
+    cover_occupancy_sensor_hint: "Wird von der Regelbedingung „Raum belegt“ verwendet. Mit NICHT kann eine Regel z. B. nur öffnen, wenn der Raum frei ist. Sensor nicht verfügbar: weder „belegt“ noch „frei“ ist erfüllt.",
+    cover_occupancy_off_note: "Wählen Sie einen Sensor, der angibt, wann der Raum belegt ist.",
+    cover_occupancy_states: "Zustände = Raum belegt",
+    cover_occupancy_states_placeholder: "Präsent, on, home…",
+    cover_occupancy_states_hint: "Klicken Sie auf die Zustände, die „Raum belegt“ bedeuten (mehrere möglich). Ein fehlender Zustand kann hinzugefügt werden.",
+    cover_occupancy_default_note: "Kein Zustand gewählt: Standardzustände gelten (on, home, Présent, occupied, detected).",
+    cover_occupancy_reset: "Zurück zu den Standardzuständen",
     cond_time_between: "Zeit zwischen",
     cond_time_after_sunrise: "Zeit nach Sonnenaufgang",
     cond_time_after_sunset: "Zeit nach Sonnenuntergang",
@@ -430,7 +1099,7 @@ const I18N = {
     cond_weather_is: "Wetter ist",
     cond_day_of_week: "Wochentag",
     cond_workday: "Arbeitstag-Sensor",
-    param_elevation: "Elevation",
+    param_elevation: "Sonnenhöhe",
     param_temperature: "Temperatur",
     param_start_time: "Startzeit",
     param_end_time: "Endzeit",
@@ -440,7 +1109,7 @@ const I18N = {
     param_state: "Status",
     param_operator: "Vergleich",
     param_value: "Wert",
-    param_hysteresis: "Puffer",
+    param_hysteresis: "Hysterese",
     opt_above: "über",
     opt_below: "unter",
     param_weather: "Wetterbedingung",
@@ -452,34 +1121,43 @@ const I18N = {
     cond_preview_context: "kontextabhängig",
     day_mon: "Mo", day_tue: "Di", day_wed: "Mi", day_thu: "Do", day_fri: "Fr", day_sat: "Sa", day_sun: "So",
     opt_on: "An (Arbeitstag)", opt_off: "Aus (kein Arbeitstag)",
-    opt_cooling: "Kühlung", opt_heating: "Heizung",
+    opt_cooling: "Warm (≥ Warm-Sollwert)", opt_heating: "Kalt (≤ Kalt-Sollwert)", opt_neutral: "Zwischen den Sollwerten",
     scenario_add: "Szenario hinzufügen",
-    scenario_icon: "Icon",
+    scenario_icon: "Symbol",
     scenario_icon_custom: "Eigenes MDI-Icon",
     scenario_icon_custom_hint: "Beliebigen Material-Design-Icon-Namen eingeben (z. B. mdi:lightbulb). Vollständige Liste auf materialdesignicons.com.",
     scenario_no_rules: "Keine Regeln konfiguriert",
     settings_outdoor_temp: "Außentemperatur-Sensor",
     settings_outdoor_temp_short: "Außen:",
     settings_outdoor_temp_hint: "Wird für temperaturbasierte Regelbedingungen verwendet (Außentemperatur über/unter).",
-    settings_indoor_temp: "Innentemperatur-Sensor (global)",
-    settings_indoor_temp_hint: "Fallback für Behänge ohne eigenen Innensensor. Wird für Komfortmodus und Beschattungsentscheidungen verwendet.",
+    settings_indoor_temp: "Innentemperatur-Sensor (global) (°C)",
+    settings_indoor_temp_hint: "Für Behänge ohne eigenen Innensensor. Wird von den Sollwerten und von „Sonne auf Fassade“ verwendet.",
     settings_weather: "Wetter-Entität",
     settings_weather_hint: "Wird für wetterbasierte Regelbedingungen verwendet (z. B. nur beschatten bei Sonne).",
-    settings_comfort_min: "Komfort-Temp. min",
-    settings_comfort_max: "Komfort-Temp. max",
-    settings_comfort_hint: "Definiert den Komfortbereich. Unter min = Heizmodus (keine Beschattung, Sonnenwärme nutzen). Über max = Kühlmodus (Beschattung aktiv). Dazwischen = Neutral (Position beibehalten).",
-    settings_comfort_hysteresis: "Hysterese",
-    settings_comfort_hysteresis_hint: "Temperaturpuffer an Komfortgrenzen, um Pendeln zwischen Modi zu verhindern (z. B. 1,0 = Moduswechsel erst 1 Grad jenseits des Schwellwerts).",
-    settings_threshold_hysteresis: "Schwellwert-Puffer",
-    settings_threshold_hysteresis_hint: "Totband für die Regelbedingungen \"Temperatur über/unter\". Eine Bedingung wird erst oberhalb von Schwelle + Puffer wahr und erst unterhalb von Schwelle - Puffer falsch. So kippt eine Regel nicht mehr bei jedem Messwert, wenn der Außensensor an der Schwelle verweilt. 0 schaltet den Puffer ab.",
+    settings_comfort_min: "Temperatursollwert kalt (°C)",
+    settings_comfort_max: "Temperatursollwert warm (°C)",
+    settings_comfort_hint: "Temperaturbereich, in dem ein Raum als angenehm gilt. Bis zum Kalt-Sollwert: kalter Raum; ab dem Warm-Sollwert: zu warmer Raum. Verwendet von der Bedingung „Raumtemperatur“ und von „Sonne auf Fassade“ (Reiter Sonnenexposition).",
+    settings_comfort_hysteresis: "Hysterese – zwischen den Sollwerten (°C)",
+    settings_comfort_hysteresis_hint: "Verhindert, dass ein Raum nahe einem Sollwert bei jedem Messwert den Zustand wechselt: er wird erst wieder angenehm, wenn er sich um diesen Wert vom Sollwert entfernt hat.",
+    settings_threshold_hysteresis: "Hysterese – Außentemperatur in Regeln (°C)",
+    settings_threshold_hysteresis_hint: "Verhindert, dass eine Bedingung „Außentemperatur über/unter“ oder „Außenluft im Vergleich zum Raum“ bei jedem Messwert kippt, solange die Temperatur nahe der Schwelle bleibt. 0 = keine Hysterese.",
     settings_house_rotation: "Hausrotation (Grad)",
-    settings_house_rotation_hint: "Abweichung von exakt Nord (-180 bis 180, positiv = im Uhrzeigersinn). Wird automatisch bei der Fassaden-Richtungswahl angewendet. Haus im Kompass ziehen, mit Shift auf 45° einrasten.",
+    settings_house_rotation_hint: "Abweichung von exakt Nord (-180 bis 180, positiv = im Uhrzeigersinn). Wird bei der Fassaden-Richtungswahl angewendet; eine Änderung dreht bestehende Fassaden mit. Haus im Kompass ziehen, mit Shift auf 45° einrasten.",
     settings_house_rotation_reset: "Zurücksetzen",
     settings_section_house: "Haus",
     settings_section_sensors: "Sensoren",
-    settings_section_comfort: "Komfort",
+    settings_outdoor_box_title: "Außentemperatur",
+    settings_outdoor_off_note: "Wählen Sie einen Außentemperatursensor, um die Hysterese einzustellen.",
+    settings_other_sensors_title: "Weitere Sensoren",
+    settings_section_comfort: "Sonnenexposition",
     settings_section_automation: "Automatik",
+    settings_auto_box_pause: "Pause nach manuellem Befehl",
+    settings_auto_box_window: "Fensterpositionen",
+    settings_auto_box_moves: "Bewegungen",
+    settings_auto_box_misc: "Logbuch und Updates",
     settings_pause_duration: "Standard-Pausendauer (Min.)",
+    pause_resume_on_match: "Fortsetzen, wenn die Position der Regel entspricht",
+    pause_resume_on_match_hint: "Beendet die Pause nach manueller Bedienung, sobald der Behang wieder an der Position steht, die seine Regel verlangt: von Hand zurückgestellt oder die Regel hat gewechselt und verlangt nun diese Position. Geprüft, wenn der Behang stillsteht, frühestens 1 Min. nach Beginn der Pause. Die Pausendauer bleibt das Maximum.",
     settings_pause_duration_hint: "Wie lange die Automatik nach manueller Bedienung pausiert. Kann pro Behang überschrieben werden.",
     settings_lock_position: "Standard-Sperrposition",
     settings_lock_position_hint: "Zielposition bei geöffnetem Fenster (100 = offen). Kann pro Behang überschrieben werden.",
@@ -504,18 +1182,80 @@ const I18N = {
     settings_workday_sensor: "Arbeitstag-Sensor",
     settings_workday_hint: "Binärsensor zur Arbeitstag-Erkennung (z. B. HA Workday-Integration). Wird vom Bedingungstyp 'Arbeitstag-Sensor' in Regeln verwendet.",
     settings_section_wind: "Windschutz",
-    settings_wind_hint: "Sicherheitsfeature: Fährt alle Behänge hoch, wenn die Windgeschwindigkeit den Schwellwert überschreitet. Deaktiviert sich, wenn die Geschwindigkeit unter Schwellwert minus Hysterese fällt.",
+    settings_wind_hint: "Sicherheitsfunktion: Überschreitet die Windgeschwindigkeit den Schwellwert, fahren alle Behänge auf die Windschutz-Position (100 = offen, z. B. zum Schutz von Markisen und Lamellen; 0 = geschlossen, z. B. zum Schutz der Scheiben). Deaktiviert sich, wenn die Geschwindigkeit unter Schwellwert minus Hysterese fällt.",
     settings_wind_sensor: "Windgeschwindigkeits-Sensor",
-    settings_wind_threshold: "Schwellwert (Aktivierung)",
-    settings_wind_hysteresis: "Hysterese (Deaktivierungsdifferenz)",
-    settings_section_solar: "Pr\u00E4ventive Beschattung",
-    settings_solar_hint: "Sensor f\u00FCr Sonneneinstrahlung (z.\u00A0B. PV-Leistung in W, Solarstrahlung in W/m\u00B2 oder Helligkeit in Lux). Bei \u00DCberschreitung des Schwellwerts wird bereits innerhalb der Komfortzone beschattet.",
-    settings_solar_sensor: "Solarintensit\u00E4ts-Sensor",
-    settings_solar_threshold: "Solarintensit\u00E4ts-Schwellwert",
-    settings_solar_threshold_hint: "Beschattung beginnt innerhalb der Komfortzone, wenn dieser Wert \u00FCberschritten wird.",
-    settings_solar_hysteresis: "Schwellwert-Puffer",
-    settings_solar_hysteresis_hint: "Totband in der Einheit des Sensors. Die Beschattung startet erst oberhalb von Schwelle + Puffer und endet erst unterhalb von Schwelle - Puffer. So schaltet ein um die Schwelle schwankender Sensor die Beschattung nicht bei jedem Messwert um. 0 schaltet den Puffer ab.",
-    settings_solar_short: "Solar:",
+    settings_wind_threshold: "Aktivierungsschwelle",
+    settings_wind_hysteresis: "Hysterese – Aufhebung des Schutzes",
+    settings_wind_hysteresis_hint: "Der Schutz wird erst aufgehoben, wenn der Wind um diesen Wert unter die Schwelle gefallen ist.",
+    hyst_title_comfort: "Wie funktioniert das? – Hysterese zwischen den Sollwerten",
+    hyst_title_rules: "Wie funktioniert das? – Außentemperatur-Hysterese",
+    hyst_title_solar: "Wie funktioniert das? – Sonnenschein-Hysterese",
+    hyst_title_wind: "Wie funktioniert das? – Wind-Hysterese",
+    hyst_with_values: "Mit Ihren Werten",
+    hyst_example: "Beispiel",
+    hyst_between: "zwischen {a} und {b}",
+    hyst_above: "über {a}",
+    hyst_below: "unter {a}",
+    hyst_keep: "Behält den vorherigen Zustand",
+    hyst_comfort_intro: "{w}: Sollwerte {a} und {b} °C, Hysterese {h} °C.",
+    hyst_col_room_temp: "Raumtemperatur",
+    hyst_col_state: "Zustand",
+    hyst_cold: "Kalt",
+    hyst_hot: "Warm",
+    hyst_comfortable: "Angenehm",
+    hyst_stay_cold: "Bleibt kalt, wenn er es war, sonst angenehm",
+    hyst_stay_hot: "Bleibt warm, wenn er es war, sonst angenehm",
+    hyst_comfort_so1: "Die Hysterese verschiebt die Sollwerte nicht: der Raum wird ab {a} °C kalt und ab {b} °C warm.",
+    hyst_comfort_so2: "Sie wirkt nur auf dem Rückweg: ein kalter Raum muss auf {ah} °C steigen, um wieder angenehm zu sein, ein warmer Raum auf {bh} °C fallen.",
+    hyst_comfort_so3: "Beispiel: der Raum fällt auf {a} °C → kalt. Er steigt auf {mid} °C → noch kalt. Bei {ah} °C → angenehm. Fällt er wieder auf {mid} °C → bleibt angenehm (kalt erst wieder bei {a} °C).",
+    hyst_comfort_so4: "Ohne Hysterese würde ein Raum nahe einem Sollwert bei jedem Messwert den Zustand wechseln, und die Behänge mit ihm.",
+    hyst_rules_intro: "Beispiel (noch keine Ihrer Regeln hat diese Bedingung): eine Bedingung „Außentemperatur über {t} °C“, Hysterese {h} °C.",
+    hyst_rules_scope: "Diese Hysterese gilt nur für die Bedingungen „Außentemperatur über / unter“ (jeweils mit eigener Schwelle) und „Außenluft im Vergleich zum Raum“ (auf die Differenz außen – Raum) Ihrer Regeln. Sie wirkt sich nicht auf die Innentemperatur-Sollwerte aus.",
+    hyst_rules_intro_real: "Beispiel aus Ihren Regeln: „{rule}“ enthält die Bedingung „Außentemperatur {op} {t} °C“, Hysterese {h} °C.",
+    hyst_op_above: "über",
+    hyst_op_below: "unter",
+    hyst_rules_so1_below: "Die in der Regel eingegebene Schwelle ist die Mitte des Bereichs: die Bedingung wird unter {tl} °C wahr und erst über {th} °C wieder falsch.",
+    hyst_rules_so2_below: "Bei „über“ umgekehrt: wahr über {th} °C, wieder falsch unter {tl} °C.",
+    hyst_rules_so3_below: "Damit sie unter {t} °C wahr wird, geben Sie {th} °C in der Regel ein.",
+    hyst_col_temp: "Temperatur",
+    hyst_col_condition: "Bedingung",
+    hyst_true: "Wahr",
+    hyst_false: "Falsch",
+    hyst_rules_so1: "Die in der Regel eingegebene Schwelle ist die Mitte des Bereichs: die Bedingung wird über {th} °C wahr und erst unter {tl} °C wieder falsch.",
+    hyst_rules_so2: "Bei „unter“ umgekehrt: wahr unter {tl} °C, wieder falsch über {th} °C.",
+    hyst_rules_so3: "Damit sie über {t} °C wahr wird, geben Sie {tl} °C in der Regel ein.",
+    hyst_zero: "Mit 0 keine Hysterese: der Zustand wechselt genau an der Schwelle, jedes Mal.",
+    hyst_solar_intro: "{w}: Schwelle {t}, Hysterese {h}.",
+    hyst_col_sensor: "Sonnenscheinsensor",
+    hyst_col_strong: "Starker Sonnenschein",
+    hyst_strong_yes: "Ja: die Bedingung meldet „Sonne“",
+    hyst_strong_no: "Nein",
+    hyst_solar_so1: "Die Schwelle ist die Mitte des Bereichs: starker Sonnenschein beginnt über {th} und endet erst unter {tl}. Eine vorbeiziehende Wolke öffnet die Behänge also nicht wieder.",
+    hyst_solar_so2: "Betrifft nur Behänge mit „Nur bei starkem Sonnenschein“.",
+    hyst_wind_intro: "{w}: Schwelle {t}, Hysterese {h}.",
+    hyst_col_wind: "Wind",
+    hyst_col_protection: "Schutz",
+    hyst_wind_on: "Aktiv",
+    hyst_wind_stay: "Bleibt aktiv, wenn er es war, sonst inaktiv",
+    hyst_wind_off: "Aufgehoben",
+    hyst_wind_so1: "Wie beim Komfort wirkt die Hysterese nur auf dem Rückweg: der Schutz aktiviert sich ab {t} und wird erst aufgehoben, wenn der Wind auf {tl} gefallen ist.",
+    hyst_wind_so2: "Eine Böe, die knapp unter die Schwelle fällt, bewegt die Behänge also nicht zurück. Eine Hysterese größer oder gleich der Schwelle wird ignoriert.",
+    settings_wind_position: "Windschutz-Position",
+    settings_wind_position_hint: "Position, auf die alle Behänge bei aktivem Windschutz fahren (0-100). 100 = offen (schützt Markisen und Lamellen), 0 = geschlossen (schützt die Scheiben).",
+    settings_section_solar: "Sonnenschein",
+    settings_solar_hint: "Sensor für die Sonneneinstrahlung (Helligkeit in lx, Solarproduktion in W, Einstrahlung in W/m²). Über seiner Schwelle schließt die Option „Nur bei starkem Sonnenschein“ die Behänge.",
+    settings_solar_sensor: "Sonnenscheinsensor",
+    settings_solar_threshold: "Starker Sonnenschein über",
+    settings_solar_threshold_hint: "Über dieser Schwelle meldet die Option „Nur bei starkem Sonnenschein“ „Sonne“.",
+    threshold_entity: "oder Entität",
+    threshold_entity_hint: "Ist eine Entität gewählt, wird ihr Wert verwendet; die eingegebene Zahl dient als Rückfallwert, wenn die Entität nicht verfügbar ist.",
+    threshold_entity_current: "Aktuell",
+    threshold_entity_unavailable: "nicht verfügbar, die eingegebene Zahl wird verwendet",
+    threshold_fallback: "Wert der Entität. Falls nicht verfügbar: {v}",
+    settings_solar_hysteresis: "Hysterese – Sonnenscheinschwelle",
+    settings_solar_hysteresis_hint: "Verhindert, dass starker Sonnenschein bei jedem Messwert kippt, solange der Sensor nahe der Schwelle bleibt. 0 = keine Hysterese.",
+    settings_solar_short: "Sonne:",
+    settings_sun_facade_title: "Sonne auf Fassade – je nach Innentemperatur",
     status_auto: "Auto",
     status_paused: "Pausiert",
     status_manual: "Manuell",
@@ -541,15 +1281,16 @@ const I18N = {
     info_sun_title: "Sonnenposition (Azimut / Elevation)",
     info_outdoor_title: "Außentemperatur",
     info_solar_title: "Solarintensität",
-    info_solar_exceeded_title: "Solar über Schwellwert – präventive Beschattung aktiv",
+    info_solar_exceeded_title: "Starker Sonnenschein: Schwelle überschritten",
     rule_active_for: "Aktiv für",
     rule_covers_count: "Behang/Behänge",
     rule_inactive: "Nicht aktiv",
     master_enabled: "Automatik",
-    master_enabled_hint: "Sperr- und Lüftungsschutz bleiben auch bei deaktivierter Automatik aktiv.",
+    master_enabled_hint: "Sperr- und Lüftungsschutz sowie Sicherheitsregeln bleiben auch bei deaktivierter Automatik aktiv.",
     log_time: "Zeit",
     log_event: "Ereignis",
     log_cover: "Behang",
+    cover_show_log: "Protokoll dieses Behangs",
     log_message: "Details",
     log_type_position: "Position",
     log_type_status: "Status",
@@ -558,9 +1299,13 @@ const I18N = {
     log_loading: "Protokoll wird geladen...",
     log_empty: "Keine Einträge in den letzten 3 Tagen.",
     log_filter_all: "Alle",
+    log_filter_cover: "Behang:",
+    log_filter_all_covers: "Alle Behänge",
+    log_filter_cover_note: "Globale Ereignisse (Wind) werden ebenfalls angezeigt.",
     log_clear: "Protokoll leeren",
     log_clear_confirm: "Alle Protokolleinträge löschen?",
-    settings_section_backup: "Backup",
+    log_clear_confirm_all: "Gesamtes Protokoll löschen (alle Behänge)?",
+    settings_section_backup: "Sicherung",
     settings_backup_hint: "Exportiere die gesamte Konfiguration als JSON-Datei. Der Import ersetzt alle Einstellungen, Behänge, Fassaden, Regeln und Szenarien.",
     settings_export: "Konfiguration exportieren",
     settings_import: "Konfiguration importieren",
@@ -568,6 +1313,654 @@ const I18N = {
     settings_import_success: "Konfiguration erfolgreich importiert.",
     settings_import_error: "Import fehlgeschlagen",
     settings_export_error: "Export fehlgeschlagen",
+    settings_unsaved_confirm: "Ungespeicherte Einstellungen verwerfen?",
+    settings_unsaved_warning: "Einige Einstellungen wurden geändert, aber nicht gespeichert: Sie fehlen im Export.",
+    settings_export_unsaved_confirm: "Einige Einstellungen wurden geändert, aber nicht gespeichert. Vor dem Export speichern?",
+    settings_save_and_export: "Speichern und exportieren",
+  },
+  fr: {
+    title: "CoverAutomatic",
+    version_link_title: "Ouvrir les notes de version sur GitHub",
+    update_badge_title: "Mise à jour disponible - ouvrir les notes de version sur GitHub",
+    tabs: { covers: "Volets", facades: "Façades", rules: "Règles", scenarios: "Scénarios", settings: "Paramètres", log: "Journal" },
+    nav_label: "Sections",
+    loading: "Chargement de la configuration...",
+    error_load: "Échec du chargement de la configuration.",
+    retry: "Réessayer",
+    saved: "Enregistré",
+    cond_time_after_dawn: "Après l'aube",
+    cond_time_before_dawn: "Avant l'aube",
+    cond_time_after_dusk: "Après le crépuscule",
+    cond_time_before_dusk: "Avant le crépuscule",
+    cond_time_after_dawn_hint: "De l'aube (+ décalage) jusqu'au crépuscule. Complément : « {other} ».",
+    cond_time_before_dawn_hint: "Du crépuscule jusqu'à l'aube suivante (+ décalage). Complément : « {other} ».",
+    cond_time_after_dusk_hint: "Du crépuscule (+ décalage) jusqu'à l'aube suivante. Complément : « {other} ».",
+    cond_time_before_dusk_hint: "De l'aube jusqu'au crépuscule (+ décalage). Complément : « {other} ».",
+    cond_time_after_sunrise_hint: "Du lever du soleil (+ décalage) jusqu'au coucher. Complément : « {other} ».",
+    cond_time_before_sunrise_hint: "Du coucher du soleil jusqu'au lever suivant (+ décalage). Complément : « {other} ».",
+    cond_time_after_sunset_hint: "Du coucher du soleil (+ décalage) jusqu'au lever suivant. Complément : « {other} ».",
+    cond_time_before_sunset_hint: "Du lever du soleil jusqu'au coucher (+ décalage). Complément : « {other} ».",
+    cover_travel_auto_default: "défaut : {s} s",
+    cover_travel_not_measured: "Mesurée : pas encore (au prochain déplacement d'au moins 20 %).",
+    cover_travel_used: "Utilisée : {s} s ({src}) · attente avant détection d'une commande manuelle : {wait} s",
+    cover_travel_used_none: "Utilisée : aucune · attente avant détection d'une commande manuelle : {wait} s",
+    cover_travel_src_manual: "saisie",
+    cover_travel_src_measured: "mesurée",
+    cover_travel_src_default: "défaut global",
+    cover_travel_src_none: "aucune",
+    settings_default_travel_time: "Durée de course par défaut (s)",
+    settings_default_travel_time_placeholder: "aucune (attente de 30 s)",
+    settings_default_travel_time_hint: "Durée de course utilisée pour les volets sans valeur saisie et pas encore mesurés. Ordre : valeur saisie sur le volet, puis valeur mesurée, puis ce défaut. Vide = attente de 30 s.",
+    cover_travel_time: "Durée de course (s)",
+    cover_travel_auto: "auto (mesurée aux premiers déplacements)",
+    cover_travel_auto_measured: "auto : {s} s mesurées",
+    cover_travel_measured: "Mesurée : {s} s pour une course complète.",
+    cover_travel_reset: "Réinitialiser",
+    cover_travel_time_hint: "Temps d'une course complète de 0 à 100 %. Après avoir envoyé une commande, l'intégration attend cette durée (plus 5 s, au moins 30 s) avant de considérer un changement de position comme une commande manuelle. Laissez vide pour utiliser la valeur mesurée, ou à défaut la durée de course par défaut des Paramètres.",
+    scenario_rule_off: "désactivée dans Règles",
+    scenario_rule_off_hint: "Cette règle est désactivée dans l'onglet Règles : elle ne s'applique jamais. Le réglage ci-contre reprendra effet dès qu'elle sera réactivée.",
+    ha_ctype_and: "et",
+    ha_ctype_or: "ou",
+    ha_ctype_not: "non",
+    ha_ctype_template: "modèle",
+    ha_ctype_state: "état",
+    ha_ctype_numeric_state: "valeur numérique",
+    ha_ctype_zone: "zone",
+    ha_ctype_time: "heure",
+    ha_ctype_sun: "soleil",
+    ha_ctype_device: "appareil",
+    ha_ctype_trigger: "déclencheur",
+    cond_group_sun: "Soleil",
+    cond_group_temperature: "Température",
+    cond_group_time: "Horaires",
+    cond_group_weather: "Météo",
+    cond_group_entities: "Entités",
+    cond_menu_ha_state: "État d'une entité",
+    cond_menu_ha_numeric: "Valeur numérique d'une entité",
+    cond_menu_ha_yaml: "Condition Home Assistant (YAML)",
+    cond_ha_condition: "Condition Home Assistant",
+    cond_ha_state: "État d'une entité",
+    cond_ha_numeric: "Valeur numérique d'une entité",
+    ha_tab_form: "Formulaire",
+    ha_tab_yaml: "YAML",
+    ha_kind: "Type",
+    ha_kind_state: "État",
+    ha_kind_numeric: "Valeur numérique",
+    ha_entity: "Entité",
+    ha_current: "actuellement",
+    ha_attribute: "Attribut",
+    ha_attribute_none: "— état de l'entité —",
+    ha_compare: "Comparaison",
+    ha_is: "est",
+    ha_is_not: "n'est pas",
+    ha_for: "Depuis au moins (min)",
+    ha_for_negate_hint: "Non disponible avec « n'est pas ».",
+    ha_states: "États",
+    ha_state_other: "Autre valeur…",
+    ha_state_add: "Ajouter",
+    ha_operator: "Opérateur",
+    ha_op_above: "au-dessus de",
+    ha_op_below: "en dessous de",
+    ha_op_between: "entre",
+    ha_value: "Valeur",
+    ha_min: "Minimum",
+    ha_max: "Maximum",
+    ha_form_unsupported: "Cette condition ne peut pas être affichée sous forme de formulaire (modèle, zone, conditions imbriquées…). Elle reste modifiable en YAML.",
+    ha_yaml_label: "Condition",
+    ha_yaml_placeholder: "condition: state\nentity_id: person.moi\nstate: not_home\nfor: \"00:15:00\"",
+    ha_yaml_help: "Même format que la section « condition » d'une automatisation Home Assistant. Une liste de conditions est combinée avec ET.",
+    ha_valid: "Condition valide",
+    ha_entities: "Entités surveillées",
+    ha_unknown_entities: "Entités introuvables (vérifiez l'identifiant)",
+    ha_err_yaml: "Erreur de syntaxe YAML ligne {line}, colonne {column}",
+    ha_err_not_mapping: "Le YAML doit décrire une condition (ex. « condition: state »).",
+    ha_err_invalid: "Condition invalide",
+    ha_err_empty: "Condition vide",
+    ha_checking: "Vérification…",
+    ha_incomplete_entity: "Choisissez une entité.",
+    ha_incomplete_states: "Choisissez au moins un état.",
+    ha_incomplete_value: "Indiquez une valeur.",
+    cond_convert: "Convertir en condition enrichie",
+    cond_convert_hint: "Ajoute attribut, « n'est pas », durée et choix des états. Appliqué à l'enregistrement de la règle.",
+    ha_chip_is: "{entity} est {states}",
+    ha_chip_is_not: "{entity} n'est pas {states}",
+    ha_chip_for: " depuis {min} min",
+    ha_chip_or: " ou ",
+    ha_chip_above: "{entity} > {value}",
+    ha_chip_below: "{entity} < {value}",
+    ha_chip_between: "{entity} entre {min} et {max}",
+    ha_chip_other: "Condition HA : {type}",
+    rule_op_short_and: "ET", rule_op_short_or: "OU",
+    compass_n: "N", compass_e: "E", compass_s: "S", compass_w: "O",
+    error_generic: "Impossible d'enregistrer la modification",
+    error_not_found: "Élément introuvable (il a peut-être été supprimé entre-temps)",
+    error_invalid_format: "Valeur invalide",
+    error_invalid_conditions: "Condition de règle invalide",
+    error_invalid_data: "Données de configuration invalides",
+    error_too_large: "Le fichier d'import est trop volumineux",
+    error_unauthorized: "Droits administrateur requis",
+    error_invalid_comfort_range: "La consigne froide doit être inférieure à la consigne chaude",
+    error_invalid_wind_hysteresis: "L'hystérésis du vent doit être inférieure au seuil de vent",
+    rule_priority_up: "Monter la priorité",
+    rule_priority_down: "Baisser la priorité",
+    rule_enabled_aria: "Règle {name} active",
+    rule_invalid_fields: "Corrigez les champs en rouge (valeur vide ou invalide) avant d'enregistrer",
+    ha_err_request: "Vérification impossible",
+    error_not_loaded: "CoverAutomatic n'est pas chargé (rechargez l'intégration ou redémarrez Home Assistant)",
+    error_invalid_solar_hysteresis: "L'hystérésis d'ensoleillement doit être inférieure au seuil d'ensoleillement",
+    error_invalid_value: "Nombre invalide",
+    drag_handle: "Glisser pour réordonner",
+    settings_nav_label: "Réglages",
+    import_invalid_json: "JSON invalide",
+    status_unlocked: "Déverrouillé",
+    log_msg_wind_activated: "Activée ({speed} ≥ {threshold})",
+    log_msg_wind_deactivated: "Désactivée ({speed} ≤ {threshold})",
+    log_msg_wind_disabled: "Désactivée (désactivée dans les réglages)",
+    log_msg_status_change: "{from} → {to}",
+    log_msg_rule: "{rule} → {position} %",
+    log_msg_position: "{from} % → {to} %",
+    log_msg_safety_takeover: "Règle de sécurité {rule} prend la main ({status}) → {position} %",
+    log_msg_safety_release: "Règle de sécurité {rule} terminée ({status})",
+    log_msg_sensor_unavailable: "{status} conservé : capteur {sensor} indisponible",
+    log_msg_lock_sensor_missing: "Capteur de fenêtre {sensor} introuvable : ignoré",
+    log_msg_move_blocked_window_unknown: "Mouvement vers {position} % retenu : état de la fenêtre inconnu ({sensor})",
+    log_msg_wind_restore_dropped: "Protection vent restaurée abandonnée : capteur {sensor} introuvable ou sans valeur",
+    save: "Enregistrer",
+    cancel: "Annuler",
+    delete: "Supprimer",
+    rule_duplicate: "Dupliquer (la copie est créée juste en dessous)",
+    rule_copy_suffix: "copie",
+    settings_wind_off_note: "Choisissez un capteur de vent pour activer la protection.",
+    settings_solar_off_note: "Choisissez un capteur pour régler le seuil et l'hystérésis.",
+    settings_solar_nested_off: "Utilisé seulement par l'option « Seulement en cas de fort ensoleillement » (ici ou sur un volet).",
+    cover_lock_box_title: "Fenêtre ouverte",
+    cover_lock_off_note: "Choisissez un capteur d'ouverture pour activer ces réglages.",
+    cover_vent_box_title: "Fenêtre basculée (aération)",
+    cover_vent_off_note: "Choisissez un capteur d'oscillo-battant pour régler la position d'aération.",
+    confirm_delete: "Vraiment supprimer ?",
+    add: "Ajouter",
+    edit: "Modifier",
+    close: "Fermer",
+    none: "Aucun",
+    enabled: "Activé",
+    active: "Actif",
+    activate: "Activer",
+    name: "Nom",
+    // Covers
+    cover_facade: "Façade",
+    cover_facade_hint: "Détermine quelles règles de façade s'appliquent à ce volet.",
+    cover_status: "Statut",
+    cover_pause_duration: "Durée de pause (min)",
+    cover_pause_duration_hint: "Durée de mise en pause de l'automatisation après une commande manuelle. Vide = valeur globale par défaut.",
+    cover_indoor_temp: "Capteur de température intérieure (°C)",
+    cover_indoor_temp_hint: "Capteur de la pièce de ce volet, pour les consignes et « Soleil sur la façade ». Remplace le capteur global.",
+    cover_lock_sensor: "Capteur de fenêtre ouverte",
+    cover_lock_sensor_hint: "Capteur d'ouverture de fenêtre. Fenêtre ouverte : le volet se place en position de verrouillage (sécurité).",
+    cover_lock_hold: "Garder la position actuelle à l'ouverture de la fenêtre",
+    cover_lock_hold_hint: "Activé : le volet reste où il est tant que la fenêtre est ouverte (verrouillé, aucune commande). Désactivé : il se place sur la position de verrouillage ci-dessous (uniquement vers le haut, jamais plus fermé).",
+    cover_lock_position: "Position de verrouillage",
+    cover_lock_position_hint: "Position cible lorsque la fenêtre est ouverte. Vide = valeur globale par défaut.",
+    cover_vent_sensor: "Capteur de fenêtre basculée",
+    cover_vent_sensor_hint: "Capteur de fenêtre en oscillo-battant. Fenêtre basculée : le volet se place en position d'aération.",
+    cover_vent_position: "Position d'aération",
+    cover_vent_position_hint: "Position cible lorsque la fenêtre est basculée. Vide = valeur globale par défaut.",
+    cover_comfort_min: "Consigne de température froide (°C)",
+    cover_comfort_max: "Consigne de température chaude (°C)",
+    cover_comfort_hint: "Consignes propres à la pièce. Vide = valeurs globales des paramètres.",
+    cover_comfort_global: "Vide = valeur globale : {v} °C ({src})",
+    cover_default_note: "Vide = valeur par défaut : {v} (Paramètres)",
+    unit_sensor: "unité du capteur",
+    cover_comfort_src_settings: "Paramètres",
+    cover_sun_switches_hint: "Réglages propres à ce volet ; « Global » = valeur de Paramètres › Exposition au soleil.",
+    tristate_global: "Global ({value})",
+    settings_sun_facade_hint: "Ces réglages ne changent que la réponse de la condition « Soleil sur la façade », pour les volets ayant un capteur de température intérieure (propre ou global). Ils servent aux règles de fermeture au soleil : ne fermer que lorsque c'est utile. Laissez tout désactivé si une règle ouvre les volets quand il y a du soleil.",
+    sun_heating_label: "Action sur consigne de température froide : laisser le soleil chauffer",
+    sun_heating_hint: "La condition répond « pas de soleil » : les règles de fermeture au soleil ne ferment pas et le soleil chauffe la pièce. À éviter si une règle ouvre les volets quand il y a du soleil (elle ne s'appliquerait plus).",
+    sun_below: "≤ {t} °C",
+    sun_above: "≥ {t} °C",
+    sun_between: "entre {min} et {max} °C",
+    settings_comfort_range_title: "Consignes de température intérieure",
+    settings_indoor_reminder: "S'applique selon la température intérieure de chaque pièce (onglet Capteurs : capteur global {name}, consignes {min} et {max} °C). Un volet peut avoir son propre capteur et ses propres consignes.",
+    settings_indoor_none: "non défini",
+    sun_explain_title: "Comment ça marche ?",
+    sun_explain_intro: "Exemple : une règle « fermer si soleil » et le soleil sur la façade. Les lignes surlignées correspondent à vos réglages.",
+    sun_explain_col_room: "Pièce",
+    sun_explain_col_answer: "Réponse de « Soleil sur la façade »",
+    sun_explain_col_effect: "Effet",
+    sun_explain_room_cold_on: "Froide, « laisser le soleil chauffer » coché",
+    sun_explain_room_cold_off: "Froide, case décochée",
+    sun_explain_room_position: "Confortable, « Dès que le soleil est sur la façade »",
+    sun_explain_room_ignore: "Confortable, « Jamais »",
+    sun_explain_room_preemptive: "Confortable, « Seulement en cas de fort ensoleillement »",
+    sun_explain_room_hot: "Trop chaude",
+    sun_explain_sun: "« soleil »",
+    sun_explain_no_sun: "« pas de soleil »",
+    sun_explain_sun_always: "toujours « soleil »",
+    sun_explain_sun_if_strong: "« soleil » si le capteur dépasse le seuil, sinon « pas de soleil »",
+    sun_explain_eff_warm: "Ne ferme pas : le volet reste ouvert et la pièce se réchauffe.",
+    sun_explain_eff_close: "Ferme.",
+    sun_explain_eff_close_as_hot: "Ferme, comme si la pièce était chaude.",
+    sun_explain_eff_wait: "Ne ferme pas ; fermera quand la pièce deviendra trop chaude.",
+    sun_explain_eff_strong: "Ne ferme que par grand soleil, avant que la pièce chauffe.",
+    sun_explain_so: "Donc",
+    sun_explain_cold: "Pièce froide : la case n'ouvre pas le volet, elle empêche la fermeture au soleil. Si le volet est déjà ouvert (par une règle d'ouverture le jour, par exemple), il le reste.",
+    sun_explain_hot: "Pièce trop chaude : le volet ne ferme que si une règle « fermer si soleil » s'applique à ce volet et au scénario actif.",
+    sun_explain_comfort: "Pièce confortable : c'est l'entre-deux, où vous choisissez quand le soleil doit compter.",
+    sun_comfort_label: "Action entre les consignes : comportement suivant le soleil",
+    sun_comfort_position: "Dès que le soleil est sur la façade",
+    sun_comfort_position_hint: "La condition est vraie dès que le soleil est sur la façade.",
+    sun_comfort_ignore: "Jamais (attendre que la pièce devienne trop chaude)",
+    sun_comfort_ignore_hint: "Répond « pas de soleil » : le volet ne ferme que lorsque la pièce devient trop chaude.",
+    sun_comfort_preemptive: "Seulement en cas de fort ensoleillement",
+    sun_comfort_preemptive_hint: "Répond « soleil » dès que le capteur d'ensoleillement dépasse son seuil : le volet ferme avant que la pièce ne chauffe.",
+    sun_comfort_hint: "Comportement de « Soleil sur la façade » quand la pièce est entre les consignes. Global = valeur de Paramètres › Exposition au soleil.",
+    sun_hot_note: "Pièce trop chaude (≥ {t} °C) : le soleil est toujours pris en compte dès qu'il est sur la façade.",
+    solar_used_by: "Utilisé par l'option « Seulement en cas de fort ensoleillement » : {n} volet(s).",
+    solar_unused: "Utilisé uniquement par l'option « Seulement en cas de fort ensoleillement » (aucun volet ne l'utilise actuellement).",
+    tristate_on: "Activé",
+    tristate_off: "Désactivé",
+    cover_inverted: "Inverser le sens ouverture/fermeture",
+    cover_inverted_hint: "À activer si 100 % signifie fermé (sens moteur inversé).",
+    cover_lock_tilt: "Inclinaison de verrouillage",
+    cover_vent_tilt: "Inclinaison d'aération",
+    cover_inverted_tilt: "Inclinaison inversée",
+    cover_min_pos_change: "Variation de position min. (%)",
+    cover_min_pos_change_hint: "Écart de position minimal pour déclencher un mouvement. Vide = valeur globale par défaut.",
+    cover_min_time: "Délai min. entre changements (s)",
+    cover_min_time_hint: "Nombre minimal de secondes entre deux changements de position. Vide = valeur globale par défaut.",
+    cover_section_base: "Général",
+    cover_section_sensors: "Capteurs",
+    cover_section_advanced: "Avancé",
+    cover_section_tilt: "Inclinaison",
+    cover_section_window: "Fenêtre",
+    cover_section_automation: "Automatisation",
+    cover_section_room: "Pièce",
+    cover_inverted_short: "Sens inversé",
+    cover_lock_hold_short: "Garder la position",
+    sun_heating_label_short: "Froide : laisser chauffer",
+    sun_comfort_label_short: "Entre les consignes",
+    settings_comfort_min_short: "Consigne froide (°C)",
+    settings_comfort_max_short: "Consigne chaude (°C)",
+    cover_comfort_min_short: "Consigne froide (°C)",
+    cover_comfort_max_short: "Consigne chaude (°C)",
+    settings_indoor_temp_short: "Capteur intérieur (°C)",
+    cover_indoor_temp_short: "Capteur intérieur (°C)",
+    settings_comfort_hysteresis_short: "Hystérésis consignes (°C)",
+    settings_threshold_hysteresis_short: "Hystérésis extérieure (°C)",
+    settings_solar_hysteresis_short: "Hystérésis ensoleillement",
+    settings_wind_hysteresis_short: "Hystérésis vent",
+    settings_solar_threshold_short: "Seuil fort ensoleillement",
+    settings_sun_facade_title_short: "Soleil sur la façade",
+    cover_min_time_short: "Délai min. (s)",
+    cover_min_pos_change_short: "Variation min. (%)",
+    cover_expand_all: "Tout déplier",
+    cover_collapse_all: "Tout replier",
+    cover_sum_auto_on: "Automatique",
+    cover_sum_auto_off: "Automatisation désactivée",
+    cover_sum_no_facade: "sans façade",
+    cover_sum_open: "Ouverte : {v}",
+    cover_sum_hold: "garder la position",
+    cover_sum_tilted: "Basculée : {v}",
+    cover_sum_no_window: "Aucun capteur de fenêtre",
+    cover_sum_pause: "Pause {n} min",
+    cover_sum_travel: "Course {n} s",
+    cover_sum_own: "{n} réglage(s) propre(s)",
+    cover_sum_all_global: "valeurs par défaut",
+    cover_sum_global: "global",
+    cover_sum_no_indoor: "Aucun capteur intérieur",
+    cover_sum_sun_heat_on: "Froide : laisser chauffer",
+    cover_sum_sun_heat_off: "Froide : soleil pris en compte",
+    cover_sum_sun_between: "Entre : {v}",
+    cover_sum_mode_position: "dès que le soleil est là",
+    cover_sum_mode_ignore: "jamais",
+    cover_sum_mode_preemptive: "fort ensoleillement",
+    cover_auto_enabled: "Automatisation activée",
+    cover_temp: "Temp.",
+    cover_current_pos: "Actuelle",
+    cover_target_pos: "Cible",
+    cover_position: "Position",
+    cover_position_target_label: "Cible",
+    cover_position_inverted_tip: "Volet inversé : HA indique {raw} % (affiché ici dans l'échelle des règles)",
+    cover_hysteresis_position: "Changement de position trop faible",
+    cover_hysteresis_time: "Trop tôt depuis le dernier changement",
+    cover_rule: "Règle",
+    cover_no_rule: "–",
+    cover_resume: "Reprendre",
+    cover_goto_rule: "Ouvrir la règle",
+    cover_remove: "Retirer le volet",
+    cover_last_change: "Dernier changement",
+    cover_just_now: "à l'instant",
+    time_ago_min: "il y a {n} min",
+    time_ago_h: "il y a {n} h",
+    time_ago_h_m: "il y a {h} h {m} min",
+    show_hint: "Afficher l'aide",
+    settings_temp_color: "Couleurs de la température (liste des volets)",
+    settings_temp_color_action: "Selon l'action à faire",
+    settings_temp_color_action_hint: "Pièce froide en rouge (à chauffer), pièce chaude en bleu (à refroidir).",
+    settings_temp_color_thermometer: "Selon la température",
+    settings_temp_color_thermometer_hint: "Pièce froide en bleu, pièce chaude en rouge, comme un thermomètre.",
+    comfort_cooling: "Chaud – à refroidir",
+    comfort_heating: "Froid – à chauffer",
+    comfort_neutral: "Confort",
+    cover_add: "Ajouter des volets",
+    // Facades
+    facade_direction: "Orientation",
+    facade_direction_hint: "Préremplit les valeurs d'azimut en tenant compte de la rotation de la maison.",
+    facade_azimuth_start: "Azimut début",
+    facade_azimuth_end: "Azimut fin",
+    facade_azimuth_hint: "Relèvements réels (boussole) où le soleil arrive sur cette façade et la quitte. Début = fin : cercle complet.",
+    facade_min_elevation: "Élévation min.",
+    facade_min_elevation_hint: "Élévation solaire minimale pour que cette façade soit considérée comme ensoleillée. Une valeur inférieure à 0 compte comme 0.",
+    facade_covers: "Volets associés",
+    facade_add: "Ajouter une façade",
+    facade_no_covers: "Aucun volet associé",
+    facade_sun_active: "Soleil sur la façade",
+    facade_dir_north: "Nord",
+    facade_dir_east: "Est",
+    facade_dir_south: "Sud",
+    facade_dir_west: "Ouest",
+    // Rules
+    rule_priority: "Priorité",
+    rule_target_pos: "Position cible",
+    rule_target_pos_hint: "Position du volet lorsque cette règle s'applique (0 = fermé, 100 = entièrement ouvert).",
+    rule_target_tilt: "Inclinaison cible",
+    rule_operator: "Opérateur des conditions",
+    rule_operator_hint: "ET = toutes les conditions doivent être remplies. OU = une seule condition suffit.",
+    rule_operator_and: "ET (toutes requises)",
+    rule_operator_or: "OU (une seule suffit)",
+    rule_conditions: "Conditions",
+    rule_scenarios: "Scénarios",
+    rule_scenarios_hint: "Scénarios dans lesquels cette règle s'applique. Dans chaque scénario, elle peut encore être désactivée temporairement depuis l'onglet Scénarios.",
+    rule_safety: "Règle de sécurité",
+    rule_safety_hint: "Agit même si le volet est en pause après un mouvement manuel, en mode manuel, en protection vent ou avec l'automatisation désactivée. Ne passe pas outre le verrouillage (fenêtre ouverte). Entre règles, c'est la priorité qui décide : placez-la en haut de la liste. À réserver aux urgences, par exemple l'alarme incendie.",
+    rule_safety_badge: "Sécurité",
+    scenario_no_member_rules: "Aucune règle n'appartient à ce scénario (à cocher dans l'éditeur de règle).",
+    rule_groups_operator: "Les groupes sont reliés par",
+    rule_groups_hint: "ET = tous les groupes doivent être remplis. OU = un seul groupe suffit. À l'intérieur d'un groupe, c'est son propre opérateur qui s'applique.",
+    rule_group: "Groupe",
+    rule_group_joined_by: "conditions reliées par",
+    rule_group_add: "Ajouter un groupe",
+    rule_group_add_hint: "Les groupes permettent par exemple (A OU B) ET (C OU D), ou (A ET B) OU (C ET D).",
+    rule_group_delete: "Supprimer le groupe et ses conditions",
+    rule_group_delete_confirm: "Supprimer ce groupe et ses conditions ?",
+    rule_unsaved_confirm: "Abandonner les modifications non enregistrées de cette règle ?",
+    discard: "Abandonner",
+    input_invalid_range: "Saisissez un nombre entier entre {min} et {max}",
+    input_not_integer: "Saisissez un nombre entier",
+    input_invalid_number: "Saisissez un nombre valide",
+    rule_group_empty: "Aucune condition dans ce groupe pour le moment (un groupe vide est ignoré).",
+    rule_cond_move: "Déplacer vers un autre groupe",
+    rule_cond_up: "Monter",
+    rule_cond_down: "Descendre",
+    rule_group_up: "Monter le groupe",
+    rule_group_down: "Descendre le groupe",
+    rule_cond_not: "NON",
+    rule_cond_not_hint: "Inverser cette condition (NON). Si son capteur est indisponible, la condition n'est pas remplie.",
+    rule_groups_count: "{n} groupes",
+    cond_collapse: "Replier",
+    cond_expand: "Développer",
+    cond_collapse_all: "Tout replier",
+    cond_expand_all: "Tout développer",
+    rule_facades: "Façades",
+    rule_covers: "Volets",
+    rule_assignment_hint: "Limite cette règle à certaines façades/volets. Vide = s'applique à tous les volets.",
+    rule_add: "Ajouter une règle",
+    rule_add_condition: "Ajouter une condition",
+    rule_no_conditions: "Aucune condition",
+    rule_reorder_hint: "Glisser ou utiliser ▲▼ pour réordonner. La règle la plus haute l'emporte si plusieurs règles s'appliquent.",
+    // Condition types
+    cond_sun_on_facade: "Soleil sur la façade",
+    cond_sun_elevation_above: "Élévation solaire supérieure à",
+    cond_sun_elevation_below: "Élévation solaire inférieure à",
+    cond_temperature_above: "Température extérieure supérieure à",
+    cond_temperature_below: "Température extérieure inférieure à",
+    cond_temperature_comfort: "Température de la pièce",
+    cond_outdoor_vs_indoor: "Air extérieur comparé à la pièce",
+    cond_room_occupied: "Pièce occupée",
+    cond_group_presence: "Présence",
+    opt_cooler: "plus frais que la pièce",
+    opt_warmer: "plus chaud que la pièce",
+    param_delta: "Écart minimum (°C)",
+    cover_occupancy_box_title: "Occupation de la pièce",
+    cover_occupancy_sensor: "Capteur d'occupation",
+    cover_occupancy_sensor_hint: "Utilisé par la condition « Pièce occupée » des règles. Avec NON, elle permet par exemple de n'ouvrir que si la pièce est libre. Capteur indisponible : ni « occupée » ni « libre » n'est rempli.",
+    cover_occupancy_off_note: "Choisissez un capteur pour indiquer quand la pièce est occupée.",
+    cover_occupancy_states: "États = pièce occupée",
+    cover_occupancy_states_placeholder: "Présent, on, home…",
+    cover_occupancy_states_hint: "Cliquez sur les états qui veulent dire « pièce occupée » (plusieurs possibles). Un état absent de la liste peut être ajouté.",
+    cover_occupancy_default_note: "Aucun état choisi : états reconnus par défaut (on, home, Présent, occupied, detected).",
+    cover_occupancy_reset: "Revenir aux états par défaut",
+    cond_time_between: "Heure comprise entre",
+    cond_time_after_sunrise: "Après le lever du soleil",
+    cond_time_after_sunset: "Après le coucher du soleil",
+    cond_time_before_sunrise: "Avant le lever du soleil",
+    cond_time_before_sunset: "Avant le coucher du soleil",
+    cond_state_is: "L'état est",
+    cond_numeric_state: "Valeur numérique",
+    cond_weather_is: "La météo est",
+    cond_day_of_week: "Jour de la semaine",
+    cond_workday: "Capteur jour ouvré",
+    // Condition params
+    param_elevation: "Élévation",
+    param_temperature: "Température",
+    param_start_time: "Heure de début",
+    param_end_time: "Heure de fin",
+    param_offset: "Décalage (min)",
+    param_entity_id: "ID d'entité",
+    param_entity_search: "Rechercher un nom ou un ID d'entité…",
+    param_state: "État",
+    param_operator: "Comparaison",
+    param_value: "Valeur",
+    param_hysteresis: "Hystérésis",
+    opt_above: "supérieur à",
+    opt_below: "inférieur à",
+    param_weather: "Condition météo",
+    param_mode: "Mode",
+    param_days: "Jours",
+    param_select_type: "Choisir le type de condition",
+    cond_preview_active: "remplie",
+    cond_preview_inactive: "non remplie",
+    cond_preview_context: "dépend du contexte",
+    day_mon: "Lun", day_tue: "Mar", day_wed: "Mer", day_thu: "Jeu", day_fri: "Ven", day_sat: "Sam", day_sun: "Dim",
+    opt_on: "Activé (jour ouvré)", opt_off: "Désactivé (jour non ouvré)",
+    opt_cooling: "Chaude (≥ consigne chaude)", opt_heating: "Froide (≤ consigne froide)", opt_neutral: "Entre les consignes",
+    // Scenarios
+    scenario_add: "Ajouter un scénario",
+    scenario_icon: "Icône",
+    scenario_icon_custom: "Icône MDI personnalisée",
+    scenario_icon_custom_hint: "Saisissez un nom d'icône Material Design (ex. mdi:lightbulb). Liste complète sur materialdesignicons.com.",
+    scenario_no_rules: "Aucune règle configurée",
+    // Settings
+    settings_outdoor_temp: "Capteur de température extérieure",
+    settings_outdoor_temp_short: "Ext. :",
+    settings_outdoor_temp_hint: "Utilisé pour les conditions de règle basées sur la température (supérieure/inférieure à).",
+    settings_indoor_temp: "Capteur de température intérieure (global) (°C)",
+    settings_indoor_temp_hint: "Utilisé pour les volets sans capteur intérieur propre. Sert aux consignes et à « Soleil sur la façade ».",
+    settings_weather: "Entité météo",
+    settings_weather_hint: "Utilisée pour les conditions de règle basées sur la météo (ex. n'ombrer que par temps ensoleillé).",
+    settings_comfort_min: "Consigne de température froide (°C)",
+    settings_comfort_max: "Consigne de température chaude (°C)",
+    settings_comfort_hint: "Plage de température où la pièce est jugée confortable. Jusqu'à la consigne froide : pièce froide ; à partir de la consigne chaude : pièce trop chaude. Utilisée par la condition « Température de la pièce » et par « Soleil sur la façade » (onglet Exposition au soleil).",
+    settings_comfort_hysteresis: "Hystérésis – entre les consignes (°C)",
+    settings_comfort_hysteresis_hint: "Évite qu'une pièce proche d'une consigne change d'état à chaque mesure : elle ne redevient confortable qu'après s'être éloignée de la consigne de cette valeur.",
+    settings_threshold_hysteresis: "Hystérésis – sur température extérieure dans les règles (°C)",
+    settings_threshold_hysteresis_hint: "Évite qu'une condition « température extérieure supérieure/inférieure à » ou « Air extérieur comparé à la pièce » bascule à chaque mesure quand la température reste proche du seuil. 0 = pas d'hystérésis.",
+    settings_house_rotation: "Rotation de la maison (degrés)",
+    settings_house_rotation_hint: "Décalage par rapport au nord géographique (-180 à 180, positif = sens horaire). Appliqué lors du choix d'une orientation de façade ; une modification fait aussi pivoter les façades existantes. Faites glisser la maison sur la boussole, maintenez Maj pour aligner par pas de 45°.",
+    settings_house_rotation_reset: "Réinitialiser",
+    settings_section_house: "Maison",
+    settings_section_sensors: "Capteurs",
+    settings_outdoor_box_title: "Température extérieure",
+    settings_outdoor_off_note: "Choisissez un capteur de température extérieure pour régler l'hystérésis.",
+    settings_other_sensors_title: "Autres capteurs",
+    settings_section_comfort: "Exposition au soleil",
+    settings_section_automation: "Automatisation",
+    settings_auto_box_pause: "Pause après une commande manuelle",
+    settings_auto_box_window: "Positions de fenêtre",
+    settings_auto_box_moves: "Mouvements",
+    settings_auto_box_misc: "Journal et mises à jour",
+    settings_pause_duration: "Durée de pause par défaut (min)",
+    pause_resume_on_match: "Reprendre quand la position correspond à la règle",
+    pause_resume_on_match_hint: "Termine la pause après une commande manuelle dès que le volet est revenu à la position demandée par sa règle : remis en place à la main, ou la règle a changé et demande la position où il a été laissé. Vérifié une fois le volet immobile, au moins 1 min après le début de la pause. La durée de pause reste le maximum.",
+    settings_pause_duration_hint: "Durée de mise en pause de l'automatisation après une commande manuelle d'un volet. Modifiable par volet.",
+    settings_lock_position: "Position de verrouillage par défaut",
+    settings_lock_position_hint: "Position cible lorsque la fenêtre est ouverte (100 = entièrement ouvert). Modifiable par volet.",
+    settings_lock_tilt_position: "Inclinaison de verrouillage par défaut",
+    settings_lock_tilt_position_hint: "Inclinaison lorsque la fenêtre est ouverte. Laisser vide pour ne pas piloter l'inclinaison.",
+    settings_vent_position: "Position d'aération par défaut",
+    settings_vent_position_hint: "Position cible lorsque la fenêtre est basculée (ex. 30 pour un espace d'aération). Modifiable par volet.",
+    settings_vent_tilt_position: "Inclinaison d'aération par défaut",
+    settings_vent_tilt_position_hint: "Inclinaison lorsque la fenêtre est basculée. Laisser vide pour ne pas piloter l'inclinaison.",
+    settings_min_position_change: "Variation de position min. par défaut (%)",
+    settings_min_position_change_hint: "Écart de position minimal en pourcentage pour déclencher un mouvement. Modifiable par volet.",
+    settings_min_time: "Délai min. entre changements par défaut (s)",
+    settings_min_time_hint: "Nombre minimal de secondes entre deux changements de position (protection moteur). Modifiable par volet.",
+    settings_command_stagger: "Délai entre commandes (s)",
+    settings_command_stagger_hint: "Délai en secondes entre les commandes lorsque plusieurs volets bougent en même temps. Recommandé : 0,3-0,5 pour les systèmes radio (Z-Wave, Zigbee). 0 = aucun délai.",
+    settings_logbook_enabled: "Écrire dans le journal de bord",
+    settings_logbook_enabled_hint: "Enregistre les mouvements des volets, verrouillages/déverrouillages, pauses/reprises et la protection contre le vent dans le journal de bord de Home Assistant.",
+    settings_update_check_enabled: "Vérifier les mises à jour",
+    settings_update_check_enabled_hint: "À l'ouverture du panneau, interroge une fois l'API publique GitHub pour connaître la dernière version et afficher un avis de mise à jour. Désactiver pour empêcher toute requête sortante vers GitHub.",
+    settings_current_value: "Actuel",
+    settings_validation_min_max: "Le min. doit être inférieur au max.",
+    settings_workday_sensor: "Capteur jour ouvré",
+    settings_workday_hint: "Capteur binaire de détection des jours ouvrés (ex. intégration Workday de HA). Utilisé par le type de condition « jour ouvré » dans les règles.",
+    settings_section_wind: "Protection contre le vent",
+    settings_wind_hint: "Fonction de sécurité : quand la vitesse du vent dépasse le seuil, tous les volets se placent sur la position de protection vent (100 = ouverts, par exemple pour protéger stores et lames ; 0 = fermés, par exemple pour protéger les vitres). Se désactive lorsque la vitesse repasse sous le seuil moins l'hystérésis.",
+    settings_wind_sensor: "Capteur de vitesse du vent",
+    settings_wind_threshold: "Seuil d'activation",
+    settings_wind_hysteresis: "Hystérésis – levée de la protection",
+    settings_wind_hysteresis_hint: "La protection n'est levée qu'une fois le vent redescendu de cette valeur sous le seuil.",
+    hyst_title_comfort: "Comment ça marche ? – hystérésis entre les consignes",
+    hyst_title_rules: "Comment ça marche ? – hystérésis sur température extérieure",
+    hyst_title_solar: "Comment ça marche ? – hystérésis d'ensoleillement",
+    hyst_title_wind: "Comment ça marche ? – hystérésis du vent",
+    hyst_with_values: "Avec vos valeurs",
+    hyst_example: "Exemple",
+    hyst_between: "entre {a} et {b}",
+    hyst_above: "au-dessus de {a}",
+    hyst_below: "en dessous de {a}",
+    hyst_keep: "Garde son état précédent",
+    hyst_comfort_intro: "{w} : consignes {a} et {b} °C, hystérésis {h} °C.",
+    hyst_col_room_temp: "Température de la pièce",
+    hyst_col_state: "État",
+    hyst_cold: "Froide",
+    hyst_hot: "Chaude",
+    hyst_comfortable: "Confortable",
+    hyst_stay_cold: "Reste froide si elle l'était, sinon confortable",
+    hyst_stay_hot: "Reste chaude si elle l'était, sinon confortable",
+    hyst_comfort_so1: "L'hystérésis ne déplace pas les consignes : la pièce devient froide dès {a} °C et chaude dès {b} °C.",
+    hyst_comfort_so2: "Elle n'agit qu'au retour : une pièce froide doit remonter à {ah} °C pour redevenir confortable, une pièce chaude doit redescendre à {bh} °C.",
+    hyst_comfort_so3: "Exemple : la pièce descend à {a} °C → froide. Elle remonte à {mid} °C → toujours froide. À {ah} °C → confortable. Si elle redescend à {mid} °C → elle reste confortable (elle ne redevient froide qu'à {a} °C).",
+    hyst_comfort_so4: "Sans hystérésis, une pièce qui hésite autour d'une consigne changerait d'état à chaque mesure, et les volets avec elle.",
+    hyst_rules_intro: "Exemple (aucune de vos règles n'a encore cette condition) : une condition « température extérieure supérieure à {t} °C », hystérésis {h} °C.",
+    hyst_rules_scope: "Cette hystérésis s'applique uniquement aux conditions « Température extérieure supérieure à / inférieure à » (chacune avec son propre seuil) et « Air extérieur comparé à la pièce » (sur l'écart extérieur – pièce) de vos règles. Elle n'a aucun effet sur les consignes de température intérieure.",
+    hyst_rules_intro_real: "Exemple tiré de vos règles : « {rule} » contient la condition « température extérieure {op} {t} °C », hystérésis {h} °C.",
+    hyst_op_above: "supérieure à",
+    hyst_op_below: "inférieure à",
+    hyst_rules_so1_below: "Le seuil saisi dans la règle est le milieu de la zone : la condition devient vraie en dessous de {tl} °C et ne redevient fausse qu'au-dessus de {th} °C.",
+    hyst_rules_so2_below: "Pour « supérieure à », c'est l'inverse : vraie au-dessus de {th} °C, fausse à nouveau en dessous de {tl} °C.",
+    hyst_rules_so3_below: "Pour qu'elle devienne vraie en dessous de {t} °C, saisissez {th} °C dans la règle.",
+    hyst_col_temp: "Température",
+    hyst_col_condition: "Condition",
+    hyst_true: "Vraie",
+    hyst_false: "Fausse",
+    hyst_rules_so1: "Le seuil saisi dans la règle est le milieu de la zone : la condition devient vraie au-dessus de {th} °C et ne redevient fausse qu'en dessous de {tl} °C.",
+    hyst_rules_so2: "Pour « inférieure à », c'est l'inverse : vraie en dessous de {tl} °C, fausse à nouveau au-dessus de {th} °C.",
+    hyst_rules_so3: "Pour qu'elle devienne vraie au-dessus de {t} °C, saisissez {tl} °C dans la règle.",
+    hyst_zero: "Avec 0, pas d'hystérésis : l'état change exactement au seuil, à chaque passage.",
+    hyst_solar_intro: "{w} : seuil {t}, hystérésis {h}.",
+    hyst_col_sensor: "Capteur d'ensoleillement",
+    hyst_col_strong: "Fort ensoleillement",
+    hyst_strong_yes: "Oui : la condition répond « soleil »",
+    hyst_strong_no: "Non",
+    hyst_solar_so1: "Le seuil est le milieu de la zone : le fort ensoleillement commence au-dessus de {th} et ne s'arrête qu'en dessous de {tl}. Un nuage passager ne rouvre donc pas les volets.",
+    hyst_solar_so2: "Ne concerne que les volets réglés sur « Seulement en cas de fort ensoleillement ».",
+    hyst_wind_intro: "{w} : seuil {t}, hystérésis {h}.",
+    hyst_col_wind: "Vent",
+    hyst_col_protection: "Protection",
+    hyst_wind_on: "Activée",
+    hyst_wind_stay: "Reste activée si elle l'était, sinon non activée",
+    hyst_wind_off: "Levée",
+    hyst_wind_so1: "Comme pour le confort, l'hystérésis n'agit qu'au retour : la protection s'active dès {t} et n'est levée qu'une fois le vent redescendu à {tl}.",
+    hyst_wind_so2: "Une rafale qui retombe juste sous le seuil ne relance donc pas les volets. Une hystérésis supérieure ou égale au seuil est ignorée.",
+    settings_wind_position: "Position de protection vent",
+    settings_wind_position_hint: "Position prise par tous les volets pendant la protection vent (0-100). 100 = ouverts (protège stores et lames), 0 = fermés (protège les vitres).",
+    settings_section_solar: "Ensoleillement",
+    settings_solar_hint: "Capteur mesurant l'ensoleillement (luminosité en lux, production solaire en W, irradiance en W/m²). Au-dessus de son seuil, l'option « Seulement en cas de fort ensoleillement » ferme les volets.",
+    settings_solar_sensor: "Capteur d'ensoleillement",
+    settings_solar_threshold: "Fort ensoleillement au-dessus de",
+    settings_solar_threshold_hint: "Au-dessus de ce seuil, l'option « Seulement en cas de fort ensoleillement » répond « soleil ».",
+    threshold_entity: "ou entité",
+    threshold_entity_hint: "Si une entité est choisie, sa valeur est utilisée ; le nombre saisi sert de secours si l'entité est indisponible.",
+    threshold_entity_current: "Actuel",
+    threshold_entity_unavailable: "indisponible, le nombre saisi est utilisé",
+    threshold_fallback: "Valeur de l'entité. Si elle est indisponible : {v}",
+    settings_solar_hysteresis: "Hystérésis – seuil d'ensoleillement",
+    settings_solar_hysteresis_hint: "Évite que le fort ensoleillement bascule à chaque mesure quand le capteur reste proche du seuil. 0 = pas d'hystérésis.",
+    settings_solar_short: "Soleil :",
+    settings_sun_facade_title: "Soleil sur la façade – selon la température intérieure",
+    status_auto: "Auto",
+    status_paused: "En pause",
+    status_manual: "Manuel",
+    status_locked: "Verrouillé",
+    status_venting: "Aération",
+    status_wind_protected: "Protection vent",
+    weather_sunny: "Ensoleillé",
+    weather_cloudy: "Nuageux",
+    weather_partlycloudy: "Partiellement nuageux",
+    weather_rainy: "Pluvieux",
+    weather_pouring: "Forte pluie",
+    weather_snowy: "Neigeux",
+    weather_snowy_rainy: "Neige fondue",
+    weather_windy: "Venteux",
+    weather_windy_variant: "Venteux et nuageux",
+    weather_fog: "Brouillard",
+    weather_hail: "Grêle",
+    weather_lightning: "Éclairs",
+    weather_lightning_rainy: "Orage",
+    weather_exceptional: "Temps exceptionnel",
+    weather_clear_night: "Nuit claire",
+    weather_unknown: "Inconnu",
+    info_sun_title: "Position du soleil (azimut / élévation)",
+    info_outdoor_title: "Température extérieure",
+    info_solar_title: "Intensité solaire",
+    info_solar_exceeded_title: "Fort ensoleillement : seuil dépassé",
+    rule_active_for: "Active pour",
+    rule_covers_count: "volet(s)",
+    rule_inactive: "Non remplie",
+    master_enabled: "Automatisation",
+    master_enabled_hint: "Les protections de verrouillage et d'aération ainsi que les règles de sécurité restent actives même lorsque l'automatisation est désactivée.",
+    log_time: "Heure",
+    log_event: "Événement",
+    log_cover: "Volet",
+    cover_show_log: "Voir le journal de ce volet",
+    log_message: "Détails",
+    log_type_position: "Position",
+    log_type_status: "Statut",
+    log_type_rule: "Règle",
+    log_type_wind: "Vent",
+    log_loading: "Chargement du journal...",
+    log_empty: "Aucune entrée de journal sur les 3 derniers jours.",
+    log_filter_all: "Tout",
+    log_filter_cover: "Volet :",
+    log_filter_all_covers: "Tous les volets",
+    log_filter_cover_note: "Les événements globaux (vent) sont aussi affichés.",
+    log_clear: "Vider le journal",
+    log_clear_confirm: "Supprimer toutes les entrées du journal ?",
+    log_clear_confirm_all: "Vider tout le journal (tous les volets) ?",
+    settings_section_backup: "Sauvegarde",
+    settings_backup_hint: "Exporte l'ensemble de la configuration dans un fichier JSON. L'import remplace tous les paramètres, volets, façades, règles et scénarios.",
+    settings_export: "Exporter la configuration",
+    settings_import: "Importer la configuration",
+    settings_import_confirm: "La configuration entière va être remplacée. Continuer ?",
+    settings_import_success: "Configuration importée avec succès.",
+    settings_import_error: "Échec de l'import",
+    settings_export_error: "Échec de l'export",
+    settings_unsaved_confirm: "Abandonner les réglages non enregistrés ?",
+    settings_unsaved_warning: "Des réglages ont été modifiés sans être enregistrés : ils ne sont pas dans l'export.",
+    settings_export_unsaved_confirm: "Des réglages ont été modifiés sans être enregistrés. Les enregistrer avant l'export ?",
+    settings_save_and_export: "Enregistrer et exporter",
   }
 };
 
@@ -576,9 +1969,11 @@ const I18N = {
  * ============================================================ */
 const CONDITION_TYPES = [
   "sun_on_facade", "sun_elevation_above", "sun_elevation_below",
-  "temperature_above", "temperature_below", "temperature_comfort",
+  "temperature_above", "temperature_below", "temperature_comfort", "outdoor_vs_indoor",
+  "room_occupied",
   "time_between", "time_after_sunrise", "time_after_sunset",
   "time_before_sunrise", "time_before_sunset",
+  "time_after_dawn", "time_before_dawn", "time_after_dusk", "time_before_dusk",
   "state_is", "numeric_state", "weather_is", "day_of_week", "workday"
 ];
 
@@ -588,7 +1983,12 @@ const CONDITION_PARAMS = {
   sun_elevation_below: [{ key: "elevation", type: "number", default: 60, step: 0.5 }],
   temperature_above: [{ key: "temperature", type: "number", default: 25 }],
   temperature_below: [{ key: "temperature", type: "number", default: 15 }],
-  temperature_comfort: [{ key: "mode", type: "select", options: ["cooling", "heating"], default: "cooling" }],
+  temperature_comfort: [{ key: "mode", type: "select", options: ["heating", "neutral", "cooling"], default: "cooling" }],
+  outdoor_vs_indoor: [
+    { key: "operator", type: "select", options: ["cooler", "warmer"], default: "cooler" },
+    { key: "delta", type: "number", default: 0, step: 0.5 }
+  ],
+  room_occupied: [],
   time_between: [
     { key: "start_time", type: "time", default: "08:00" },
     { key: "end_time", type: "time", default: "20:00" }
@@ -597,6 +1997,10 @@ const CONDITION_PARAMS = {
   time_after_sunset: [{ key: "offset", type: "number", default: 0 }],
   time_before_sunrise: [{ key: "offset", type: "number", default: 0 }],
   time_before_sunset: [{ key: "offset", type: "number", default: -60 }],
+  time_after_dawn: [{ key: "offset", type: "number", default: 0 }],
+  time_before_dawn: [{ key: "offset", type: "number", default: 0 }],
+  time_after_dusk: [{ key: "offset", type: "number", default: 0 }],
+  time_before_dusk: [{ key: "offset", type: "number", default: 0 }],
   state_is: [
     { key: "entity_id", type: "entity", default: "" },
     { key: "state", type: "text", default: "on" }
@@ -607,14 +2011,30 @@ const CONDITION_PARAMS = {
     { key: "value", type: "number", default: 0 },
     { key: "hysteresis", type: "number", default: 0, step: 0.1 }
   ],
-  weather_is: [{ key: "weather", type: "multiselect", options: ["sunny", "cloudy", "partlycloudy", "rainy", "snowy", "windy", "fog", "clear-night"], default: ["sunny"] }],
+  weather_is: [{ key: "weather", type: "multiselect", options: ["sunny", "clear-night", "partlycloudy", "cloudy", "fog", "rainy", "pouring", "lightning", "lightning-rainy", "hail", "snowy", "snowy-rainy", "windy", "windy-variant", "exceptional"], default: ["sunny"] }],
   day_of_week: [{ key: "days", type: "dayselect", default: ["mon","tue","wed","thu","fri"] }],
   workday: [{ key: "state", type: "select", options: ["on", "off"], default: "on" }]
 };
 
+// "Add condition" menu, grouped by theme. The legacy "state_is" and
+// "numeric_state" types are no longer offered (existing ones keep working and
+// can be converted): the "Entités" group creates native HA conditions.
+const CONDITION_MENU = [
+  { label: "cond_group_sun", items: ["sun_on_facade", "sun_elevation_above", "sun_elevation_below"].map(t => ({ value: t, label: "cond_" + t })) },
+  { label: "cond_group_temperature", items: ["temperature_above", "temperature_below", "temperature_comfort", "outdoor_vs_indoor"].map(t => ({ value: t, label: "cond_" + t })) },
+  { label: "cond_group_presence", items: [{ value: "room_occupied", label: "cond_room_occupied" }] },
+  { label: "cond_group_time", items: ["time_between", "time_after_dawn", "time_before_dawn", "time_after_sunrise", "time_before_sunrise", "time_after_sunset", "time_before_sunset", "time_after_dusk", "time_before_dusk", "day_of_week", "workday"].map(t => ({ value: t, label: "cond_" + t })) },
+  { label: "cond_group_weather", items: [{ value: "weather_is", label: "cond_weather_is" }] },
+  { label: "cond_group_entities", items: [
+    { value: "ha:state", label: "cond_menu_ha_state" },
+    { value: "ha:numeric", label: "cond_menu_ha_numeric" },
+    { value: "ha:yaml", label: "cond_menu_ha_yaml" },
+  ] },
+];
+
 // Condition types that depend on a cover/facade context and cannot be
 // evaluated in the editor preview (mirrors engine _CONTEXT_DEPENDENT_TYPES).
-const CONTEXT_DEPENDENT_TYPES = ["sun_on_facade", "temperature_comfort"];
+const CONTEXT_DEPENDENT_TYPES = ["sun_on_facade", "temperature_comfort", "outdoor_vs_indoor", "room_occupied"];
 
 const FACADE_PRESETS = {
   north: { start: 315, end: 45 },
@@ -650,6 +2070,8 @@ const PANEL_STYLES = `
     --ca-active: var(--ca-success-strong, #4caf50);
     --ca-card-bg: var(--ha-card-background, var(--card-background-color, #fff));
     --ca-border: var(--divider-color, #e0e0e0);
+    --ca-box-border: color-mix(in srgb, var(--primary-text-color, #212121) 25%, transparent);
+    --ca-sep: color-mix(in srgb, var(--primary-text-color, #212121) 45%, transparent);
     --ca-secondary-text: var(--secondary-text-color, #727272);
     --ca-error: var(--error-color, #db4437);
     --ca-success: var(--success-color, #43a047);
@@ -709,6 +2131,7 @@ const PANEL_STYLES = `
     align-items: center;
     flex: 0 0 auto;
   }
+  .info-bar-slot { display: contents; }
   .header-right {
     display: flex;
     align-items: center;
@@ -1047,7 +2470,33 @@ const PANEL_STYLES = `
     border-bottom: 1px solid var(--ca-border);
     flex-shrink: 0;
   }
+  .slide-header .slide-back { display: none; }
+  /* Cover sheet: the help icon sits on the label line instead of its own line */
+  .slide-body .form-group { position: relative; }
+  .slide-body .form-group > .field-hint > summary { position: absolute; top: 0; right: 0; }
+  .slide-body .form-group:has(> .field-hint) > label { padding-right: 24px; }
+  .slide-body .sep-item, .slide-body .threshold-entity, .slide-body .opt-box { position: relative; }
+  .slide-body .sep-item > .field-hint > summary,
+  .slide-body .threshold-entity > .field-hint > summary { position: absolute; top: 0; right: 0; }
+  .slide-body .opt-box-body > .field-hint > summary { position: absolute; top: 12px; right: 14px; }
+  .toggle-row .toggle-label { display: block; flex: 1; min-width: 0; }
+  .toggle-row .toggle-label .field-hint { display: inline; margin: 0 0 0 2px; }
+  .toggle-row .toggle-label .field-hint > summary { display: inline-flex; vertical-align: middle; padding: 0 4px; }
+  .toggle-row .toggle-label .field-hint[open] .hint-body { display: block; }
+  .lbl-short { display: none; }
+  @media (max-width: 600px) {
+    .lbl-long { display: none; }
+    .lbl-short { display: inline; }
+  }
+  .slide-expand-bar { display: flex; justify-content: flex-end; margin: -8px 0 4px; }
+  .slide-header .btn-icon:focus:not(:focus-visible) { outline: none; }
+  .slide-close-bottom { display: none; }
   .slide-header h2 {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
     margin: 0;
     font-size: 18px;
     font-weight: 500;
@@ -1064,12 +2513,10 @@ const PANEL_STYLES = `
   }
   .form-group label {
     display: block;
-    font-size: 12px;
+    font-size: 13px;
     font-weight: 500;
     color: var(--ca-secondary-text);
     margin-bottom: 4px;
-    text-transform: uppercase;
-    letter-spacing: 0.3px;
   }
   .form-group input[type="text"],
   .form-group input[type="number"],
@@ -1092,6 +2539,11 @@ const PANEL_STYLES = `
   .form-group textarea:focus {
     border-color: var(--ca-primary);
   }
+  .form-group input.input-invalid,
+  input.input-invalid {
+    border-color: var(--ca-danger);
+    box-shadow: 0 0 0 1px var(--ca-danger);
+  }
   .form-row {
     display: grid;
     grid-template-columns: 1fr 1fr;
@@ -1243,6 +2695,122 @@ const PANEL_STYLES = `
     color: var(--ca-primary);
     margin-top: 3px;
   }
+  /* Optional entity providing a threshold (number = fallback) */
+  input.entity-driven { display: none; }
+  .entity-shadow-value {
+    padding: 10px 12px; border-radius: 8px; font-size: 14px;
+    border: 1px solid var(--ca-border);
+    background: color-mix(in srgb, var(--primary-text-color, #212121) 6%, transparent);
+    color: var(--ca-secondary-text);
+    max-width: 200px;
+  }
+  .entity-shadow-note { font-size: 12px; color: var(--ca-secondary-text); margin-top: 4px; }
+  .threshold-entity {
+    margin-top: 10px;
+    padding-left: 10px;
+    border-left: 2px solid var(--ca-border);
+  }
+  .threshold-entity-label {
+    font-size: 12px;
+    color: var(--ca-secondary-text);
+    margin-bottom: 4px;
+  }
+  .threshold-entity-value {
+    font-size: 12px;
+    color: var(--ca-primary);
+    margin-top: 4px;
+    min-height: 0;
+  }
+  .threshold-entity-value:empty { display: none; }
+  .threshold-entity-unavail { color: var(--ca-warning, var(--ca-secondary-text)); }
+
+  /* Settings page: roomier layout (settings tab only) */
+  .settings-stack { gap: 20px; }
+  .settings-stack .card-header {
+    font-size: 15px;
+    font-weight: 600;
+    color: var(--primary-text-color);
+    text-transform: none;
+    letter-spacing: 0;
+    padding: 16px 24px 14px;
+    margin-bottom: 0;
+  }
+  .settings-stack .card-header svg { color: var(--ca-primary); opacity: 1; }
+  .settings-stack .card-body { padding: 20px 24px 24px; }
+  .settings-stack .form-group { margin-bottom: 24px; }
+  .settings-stack .card-body > .form-group:last-child,
+  .settings-stack .card-body > .form-row:last-child { margin-bottom: 0; }
+  .settings-stack .form-row > .form-group { margin-bottom: 0; }
+  .settings-stack .form-group > label:not(.checkbox-row) { margin-bottom: 6px; }
+  .settings-stack .form-row {
+    grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+    gap: 24px 28px;
+    margin-bottom: 24px;
+  }
+  .settings-stack .form-group input[type="number"] { max-width: 220px; }
+  .settings-stack .form-group select,
+  .settings-stack .form-group input[type="text"] { max-width: 480px; }
+  .settings-stack .settings-hint { margin-top: 6px; line-height: 1.5; }
+  .settings-stack .field-hint { margin-top: 6px; }
+  .settings-stack .settings-hint-intro {
+    font-size: 13px;
+    line-height: 1.55;
+    margin-bottom: 24px;
+    padding: 10px 14px;
+    border-radius: 8px;
+    border-left: 3px solid color-mix(in srgb, var(--ca-primary) 55%, transparent);
+    background: color-mix(in srgb, var(--ca-primary) 6%, transparent);
+  }
+  .settings-stack .sensor-current-value { margin-top: 6px; }
+  .settings-stack .checkbox-row {
+    font-size: 14px;
+    text-transform: none;
+    letter-spacing: 0;
+    color: var(--primary-text-color);
+    margin-bottom: 0;
+  }
+  .settings-stack .checkbox-row input { width: 18px; height: 18px; margin: 0; }
+  .settings-save-bar { padding-top: 4px; }
+  .pos-inverted { display: inline-flex; align-items: center; gap: 4px; }
+  .pos-inverted-mark { font-size: 12px; color: var(--secondary-text-color, #727272); cursor: help; }
+  .radio-group { display: flex; flex-direction: column; gap: 10px; margin-top: 6px; }
+  .form-group .radio-row, .form-group .radio-row * { text-transform: none; letter-spacing: normal; }
+  .form-group .radio-row { display: flex; align-items: flex-start; gap: 10px; cursor: pointer; font-weight: normal; font-size: 14px; color: var(--primary-text-color); margin: 0; }
+  .form-group .radio-row b { font-weight: 500; }
+  .radio-row input { margin-top: 3px; width: 16px; height: 16px; flex: none; }
+  .sun-explain { margin-top: 12px; border: 1px solid var(--ca-box-border); border-radius: 8px; }
+  .sun-explain summary { cursor: pointer; padding: 8px 12px; font-size: 13px; font-weight: 500; color: var(--primary-color); }
+  .sun-explain-body { padding: 0 12px 12px; }
+  .sun-explain-table { width: 100%; border-collapse: collapse; margin-top: 8px; font-size: 13px; }
+  .sun-explain-table th { text-align: left; font-weight: 500; font-size: 12px; color: var(--secondary-text-color, #727272); padding: 6px 8px; border-bottom: 1px solid var(--divider-color, #e0e0e0); }
+  .sun-explain-table td { padding: 6px 8px; vertical-align: top; border-bottom: 1px solid var(--divider-color, #e0e0e0); color: var(--primary-text-color); }
+  .sun-explain-table tr.current td { background: rgba(var(--rgb-primary-color, 3, 169, 244), 0.12); }
+  .sun-explain-table tr.current td:first-child { box-shadow: inset 3px 0 0 var(--primary-color); font-weight: 500; }
+  .sun-explain-so { margin-top: 10px; font-size: 13px; color: var(--primary-text-color); }
+  .sun-explain-so ul { margin: 4px 0 0; padding-left: 20px; }
+  .sun-explain-so li { margin: 3px 0; line-height: 1.45; }
+  .radio-hint { font-size: 12px; color: var(--secondary-text-color, #727272); font-weight: normal; text-transform: none; letter-spacing: normal; }
+  .opt-box { border: 1px solid var(--ca-box-border); border-radius: 10px; padding: 12px 14px; margin: 0 0 14px;
+    background: color-mix(in srgb, var(--primary-text-color, #212121) 2%, transparent); }
+  .opt-box > .opt-box-title { padding-bottom: 8px; border-bottom: 1px solid var(--ca-box-border); }
+  .sep-list > * + * { border-top: 1px solid var(--ca-sep); margin-top: 12px; padding-top: 12px; }
+  .opt-box > .form-group:last-child, .opt-box > .form-row:last-child .form-group { margin-bottom: 0; }
+  .sep-list > .form-group:last-child, .sep-list > .sep-item > .form-group:last-child { margin-bottom: 0; }
+  .opt-box .opt-box { margin: 10px 0 0; }
+  .opt-box.opt-box-flat { border: 0; padding: 0; margin: 0; background: none; }
+  .opt-box.opt-box-nested { margin: 8px 0 4px 26px; background: var(--ca-card-bg); }
+  .opt-box-body > .form-group:last-child, .opt-box-body > .form-row:last-child .form-group { margin-bottom: 0; }
+  .opt-box-title { font-weight: 600; margin-bottom: 10px; }
+  .opt-box-offnote { display: none; font-size: 12px; color: var(--secondary-text-color, #727272); margin: 2px 0 8px; font-style: italic; }
+  .opt-box.opt-off > .opt-box-offnote { display: block; }
+  .opt-box.opt-off > .opt-box-body { opacity: 0.45; }
+  /* Only the outermost disabled box fades and explains why */
+  .opt-box.opt-off .opt-box.opt-off > .opt-box-body { opacity: 1; }
+  .opt-box.opt-off .opt-box .opt-box-offnote { display: none; }
+  .opt-box.opt-off > .opt-box-body * { cursor: not-allowed; }
+  .settings-unsaved-warning { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin-bottom: 12px; padding: 8px 12px; border-radius: 8px; background: rgba(255, 152, 0, 0.12); color: var(--warning-color, #ff9800); }
+  .settings-unsaved-warning .btn { margin-left: auto; }
+
   /* House card: rotation input + compass side by side */
   .settings-house-layout {
     display: flex;
@@ -1536,7 +3104,7 @@ const PANEL_STYLES = `
   /* Section */
   .section {
     margin-bottom: 8px;
-    border-top: 1px solid var(--ca-border);
+    border-top: 1px solid var(--ca-sep);
   }
   .section:first-child {
     border-top: none;
@@ -1569,6 +3137,18 @@ const PANEL_STYLES = `
   }
   .section-header .section-title {
     flex: 1;
+    min-width: 0;
+  }
+  .section-header .section-summary {
+    display: block;
+    margin-top: 2px;
+    font-size: 12px;
+    font-weight: normal;
+    letter-spacing: normal;
+    color: var(--ca-secondary-text);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
   }
   .section-header .arrow {
     font-size: 10px;
@@ -1582,7 +3162,15 @@ const PANEL_STYLES = `
     max-height: 0;
     transition: max-height 0.35s ease;
   }
-  .section-body.expanded { max-height: 800px; }
+  .section-body.expanded { max-height: 6000px; padding-bottom: 8px; }
+  /* Cover sheet: the slide background is the page grey, so framed boxes
+     take the card colour and a stronger border to stand out */
+  .slide-body .opt-box:not(.opt-box-flat) {
+    background: var(--ca-card-bg);
+    border-color: color-mix(in srgb, var(--primary-text-color, #212121) 35%, transparent);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.06);
+  }
+  .slide-body .opt-box .opt-box:not(.opt-box-flat) { box-shadow: none; }
 
   /* Buttons */
   .btn {
@@ -1708,6 +3296,22 @@ const PANEL_STYLES = `
     gap: 8px;
     align-items: center;
   }
+  .rule-safety-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 3px;
+    padding: 1px 7px 1px 5px;
+    border-radius: 999px;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.2px;
+    color: var(--ca-danger);
+    background: color-mix(in srgb, var(--ca-danger) 12%, transparent);
+    border: 1px solid color-mix(in srgb, var(--ca-danger) 30%, transparent);
+    white-space: nowrap;
+  }
+  .rule-safety-badge svg { flex-shrink: 0; }
+  .rule-safety-group .toggle-row { margin-bottom: 0; }
   .priority-badge {
     display: inline-flex;
     align-items: center;
@@ -1773,6 +3377,29 @@ const PANEL_STYLES = `
   .cond-preview-on .cond-preview-dot { background: var(--ca-active, var(--ca-success-strong)); }
   .cond-preview-context { font-style: italic; opacity: 0.65; }
   .day-select { display: flex; gap: 4px; flex-wrap: wrap; }
+  /* Native Home Assistant condition card */
+  .ha-seg { display: inline-flex; border: 1px solid var(--ca-border); border-radius: 8px; overflow: hidden; margin: 8px 0 4px; }
+  .ha-seg button { border: 0; background: var(--ca-card-bg); color: var(--ca-secondary-text); padding: 6px 14px; font: inherit; font-size: 13px; cursor: pointer; }
+  .ha-seg button + button { border-left: 1px solid var(--ca-border); }
+  .ha-seg button.on { background: var(--ca-primary); color: #fff; }
+  .condition-card .cond-params.ha-params { grid-template-columns: 1fr; }
+  .ha-params .form-row { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+  textarea.ha-yaml { width: 100%; box-sizing: border-box; font: 13px/1.5 ui-monospace, Menlo, Consolas, monospace; padding: 10px 12px; border-radius: 8px; border: 1px solid var(--ca-border); background: var(--code-editor-background-color, #1e1e1e); color: var(--code-editor-color, #d4d4d4); resize: vertical; tab-size: 2; }
+  .btn-link { background: none; border: 0; padding: 0 0 0 6px; color: var(--ca-primary); font: inherit; cursor: pointer; text-decoration: underline; }
+  .ha-help { font-size: 12px; color: var(--ca-secondary-text); margin-top: 4px; }
+  .ha-current { font-size: 12px; color: var(--ca-secondary-text); margin-top: 4px; }
+  .ha-add-state { display: flex; gap: 8px; margin-top: 8px; max-width: 420px; }
+  .ha-add-state input { flex: 1; }
+  .ha-status { display: grid; gap: 6px; margin-top: 10px; }
+  .ha-status:empty { display: none; }
+  .ha-msg { font-size: 13px; padding: 6px 10px; border-radius: 6px; overflow-wrap: anywhere; }
+  .ha-msg-ok { color: var(--ca-success); background: color-mix(in srgb, var(--ca-success) 12%, transparent); }
+  .ha-msg-err { color: var(--ca-error); background: color-mix(in srgb, var(--ca-error) 12%, transparent); }
+  .ha-msg-warn { color: var(--ca-warning); background: color-mix(in srgb, var(--ca-warning) 12%, transparent); }
+  .ha-msg-info { color: var(--ca-secondary-text); background: color-mix(in srgb, var(--ca-secondary-text) 10%, transparent); }
+  .ha-convert { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin: 8px 0 10px; }
+  .chip.chip-error { color: var(--ca-error); background: color-mix(in srgb, var(--ca-error) 12%, transparent); }
+  @media (max-width: 600px) { .ha-params .form-row { grid-template-columns: 1fr; } }
   .day-btn {
     padding: 4px 8px; border: 1px solid var(--ca-border); border-radius: 4px;
     background: var(--ca-card-bg); color: var(--ca-text); cursor: pointer;
@@ -1823,6 +3450,11 @@ const PANEL_STYLES = `
     font-size: 14px;
   }
   .scenario-card .sc-rule-row:last-child { border-bottom: none; }
+  .scenario-card .sc-rule-label { display: inline-flex; align-items: center; gap: 8px; min-width: 0; }
+  .scenario-card .sc-rule-off .sc-rule-label > span:not(.sc-rule-off-badge),
+  .scenario-card .sc-rule-off .priority-badge { opacity: 0.45; }
+  .scenario-card .sc-rule-off .toggle { opacity: 0.55; }
+  .sc-rule-off-badge { font-size: 11px; padding: 1px 8px; border-radius: 10px; color: var(--ca-secondary-text); border: 1px dashed var(--ca-border); white-space: nowrap; }
 
   /* Toast */
   .toast {
@@ -1861,6 +3493,12 @@ const PANEL_STYLES = `
   .toast.show .toast-progress {
     animation: ca-toast-countdown 2s linear forwards;
   }
+  .toast.toast-error {
+    background: var(--error-color, #db4437);
+  }
+  .toast.toast-error.show .toast-progress {
+    animation-duration: 5s;
+  }
   @keyframes ca-toast-countdown {
     from { transform: scaleX(1); }
     to { transform: scaleX(0); }
@@ -2062,6 +3700,45 @@ const PANEL_STYLES = `
     font-size: 12px;
     color: var(--ca-secondary-text);
   }
+  .slide-out input:disabled, .form-group input:disabled { opacity: .5; cursor: not-allowed; }
+  .cond-group { border: 1px solid var(--ca-border); border-left: 3px solid var(--ca-primary, #03a9f4); border-radius: 8px; padding: 10px 10px 2px; margin-bottom: 4px; }
+  .cond-group-head { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin-bottom: 8px; }
+  .cond-group-title { font-weight: 600; font-size: 13px; }
+  .cond-group-op { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--ca-secondary-text); }
+  .cond-group-op select { width: auto; padding: 4px 8px; font-size: 12px; }
+  .cond-group-head > .btn-icon { margin-left: auto; }
+  .cond-group-head > .move-btns { margin-left: auto; }
+  .cond-group-head > .move-btns + .btn-icon { margin-left: 0; }
+  .move-btns { display: inline-flex; align-items: center; flex: none; }
+  .move-btns.move-btns-v { flex-direction: column; gap: 2px; margin: -4px 0; }
+  .move-btns.move-btns-v .btn-move { padding: 3px 6px; }
+  /* Touch screens cannot drag rows: the arrows replace the handle */
+  @media (max-width: 600px) {
+    .rule-row > .drag-handle { display: none; }
+    .rule-row { gap: 8px; padding-left: 8px; }
+  }
+  .btn-icon.btn-move { font-size: 11px; padding: 5px 6px; border-radius: 6px; }
+  .btn-icon.btn-move:disabled { opacity: .3; cursor: default; background: none; color: var(--ca-secondary-text); }
+  .cond-group-sep { text-align: center; font-weight: 700; font-size: 12px; letter-spacing: .05em; color: var(--ca-primary, #03a9f4); margin: 6px 0; }
+  .cond-group-add { margin: 6px 0 4px; }
+  .cond-head-right { display: inline-flex; align-items: center; gap: 6px; }
+  .cond-chevron { border: none; background: transparent; color: var(--ca-secondary-text); cursor: pointer; font-size: 12px; padding: 0 6px 0 0; transition: transform .15s; }
+  .condition-card.collapsed .cond-chevron { transform: rotate(-90deg); }
+  .condition-card .cond-type[data-action] { cursor: pointer; }
+  .condition-card.collapsed > :not(.cond-header) { display: none; }
+  .condition-card.collapsed .cond-header { margin-bottom: 0; }
+  .cond-summary { display: none; font-size: 12px; color: var(--primary-text-color); margin-left: 8px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 45ch; }
+  .condition-card.collapsed .cond-summary:not(:empty) { display: inline; }
+  .rule-conditions-label { display: flex; align-items: center; justify-content: space-between; }
+  .cond-collapse-all { border: none; background: transparent; color: var(--ca-primary); cursor: pointer; font-size: 12px; text-transform: none; font-weight: 500; letter-spacing: normal; padding: 0; }
+  .cond-group-move { width: auto; padding: 2px 6px; font-size: 12px; }
+  .cond-not { border: 1px solid var(--ca-border); background: transparent; color: var(--ca-secondary-text); border-radius: 10px; padding: 1px 8px; font-size: 11px; font-weight: 600; cursor: pointer; margin-right: 6px; }
+  .cond-not.active { background: var(--error-color, #db4437); border-color: var(--error-color, #db4437); color: #fff; }
+  .condition-card.negated { border-left: 3px solid var(--error-color, #db4437); }
+  .chip-block { display: inline-flex; flex-wrap: wrap; align-items: center; gap: 4px; padding: 2px 6px; border: 1px dashed var(--ca-border); border-radius: 12px; }
+  .chip-op { font-size: 11px; color: var(--ca-secondary-text); }
+  .chip-op-between { font-weight: 700; color: var(--ca-primary, #03a9f4); margin: 0 4px; }
+  .chip-not { color: var(--error-color, #db4437); font-size: 11px; }
   .rule-conditions-label {
     font-size: 13px;
     font-weight: 600;
@@ -2189,6 +3866,27 @@ const PANEL_STYLES = `
     gap: 6px;
     flex-wrap: wrap;
   }
+  .log-cover-filter {
+    margin-bottom: 12px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+  }
+  .log-cover-filter label { font-size: 13px; color: var(--ca-secondary-text); }
+  .log-cover-filter select {
+    min-width: 220px; max-width: 100%;
+    padding: 8px 12px;
+    border: 1px solid var(--ca-border);
+    border-radius: 8px;
+    background: var(--primary-background-color, #fafafa);
+    color: var(--primary-text-color);
+    font-size: 14px;
+    font-family: inherit;
+  }
+  .log-cover-filter select:focus { border-color: var(--ca-primary); outline: none; }
+  .log-cover-note { font-size: 12px; color: var(--ca-secondary-text); }
+  .slide-log-link { margin: 16px 0 4px; }
 
   /* Compass */
   .compass-svg-root {
@@ -2199,12 +3897,24 @@ const PANEL_STYLES = `
   .data-table td.temp-mode {
     font-weight: 600;
   }
+  .temp-icon { display: inline-flex; vertical-align: -2px; margin-right: 3px; }
 
   /* Responsive */
   @media (max-width: 768px) {
     .panel-container { padding: 8px; }
     .card-grid { grid-template-columns: 1fr; }
     .slide-panel { width: 100vw; }
+    /* Full-screen sheet on phones: room for the status bar / notch, big
+       close targets on both sides and a close button at the bottom */
+    .slide-header {
+      padding-top: calc(12px + env(safe-area-inset-top, 0px));
+      gap: 8px;
+    }
+    .slide-header .slide-back { display: inline-flex; }
+    .slide-header .btn-icon { min-width: 44px; min-height: 44px; font-size: 22px; align-items: center; justify-content: center; }
+    .slide-body { padding-bottom: calc(20px + env(safe-area-inset-bottom, 0px)); }
+    .slide-close-bottom { display: flex; justify-content: center; margin: 16px 0 8px; }
+    .slide-close-bottom .btn { min-width: 160px; justify-content: center; }
     .form-row { grid-template-columns: 1fr; }
     .tab-bar button { padding: 10px 14px; font-size: 13px; }
     .data-table th, .data-table td { padding: 10px 12px; font-size: 13px; }
@@ -2213,6 +3923,7 @@ const PANEL_STYLES = `
     /* Settings: sidebar collapses to horizontal scrollable pill strip */
     .settings-shell {
       flex-direction: column;
+      align-items: stretch;
       gap: 12px;
     }
     .settings-nav {
@@ -2242,6 +3953,14 @@ const PANEL_STYLES = `
       scroll-snap-type: x proximity;
     }
     .settings-nav::-webkit-scrollbar { display: none; }
+    .settings-stack { gap: 16px; }
+    .settings-stack .card-header { padding: 14px 16px 12px; }
+    .settings-stack .card-body { padding: 16px 16px 20px; }
+    .settings-stack .form-group { margin-bottom: 20px; }
+    .settings-stack .form-row { grid-template-columns: 1fr; gap: 20px; margin-bottom: 20px; }
+    .settings-stack .form-group input[type="number"],
+    .settings-stack .form-group select,
+    .settings-stack .form-group input[type="text"] { max-width: none; }
     .settings-nav-btn {
       flex: 0 0 auto;
       padding: 8px 12px;
@@ -2292,6 +4011,18 @@ const PANEL_STYLES = `
   }
 `;
 
+// Integer cover settings and their range (cover/update schema: plain int).
+const COVER_INT_LIMITS = {
+  pause_duration: [1, 480],
+  lock_position: [0, 100],
+  vent_position: [0, 100],
+  lock_tilt_position: [0, 100],
+  vent_tilt_position: [0, 100],
+  min_position_change: [1, 50],
+  min_time_between_changes: [60, 3600],
+  travel_time: [1, 300],
+};
+
 /* ============================================================
  * Main panel component
  * ============================================================ */
@@ -2323,21 +4054,47 @@ class CoverAutomaticPanel extends HTMLElement {
     this._latestVersion = null;
     this._logEntries = null;
     this._logFilter = null;
+    this._logCover = null;
     this._coverSort = { key: "name", dir: "asc" };
     this._liveRefreshTimer = null;
     this._condPreviewTimer = null;
     this._eventUnsub = null;
     this._eventDebounce = null;
-    this._expandedSections = { base: true, sensors: true, advanced: false, tilt: false };
+    this._expandedSections = { base: true };
     this._activeSettingsSection = "house";
     this._keydownListener = (e) => this._handleKeyDown(e);
+    // Warn before closing/reloading the page with unsaved rule or settings edits
+    this._beforeUnloadListener = (e) => {
+      let dirty = false;
+      try { dirty = this._ruleDraftDirty() || this._settingsDirty(); } catch (err) { dirty = false; }
+      // Debounced cover edits not sent yet: send them now and warn
+      // (the page may still close before they reach the server).
+      if (this._saveTimers && Object.keys(this._saveTimers).length) {
+        dirty = true;
+        try { this._flushCoverSaves(); } catch (err) { /* ignore */ }
+      }
+      if (!dirty) return;
+      e.preventDefault();
+      e.returnValue = "";
+    };
+    // Working copy of the rule open in the editor ({ id, rule }); every editor
+    // change goes here and only reaches _config once saved.
+    this._ruleDraft = null;
+    // Unsaved settings inputs (field -> { kind, value }), kept across sections.
+    this._settingsDraft = null;
+    this._haTimers = {};
+    this._haInflight = {};
+    this._previewSeq = 0;
+    this._subscribing = null;
+    this._confirmOkLabel = null;
 
 
     this.attachShadow({ mode: "open" });
   }
 
   set hass(hass) {
-    const prevLang = this._hass?.language;
+    const prevHass = this._hass;
+    const prevLang = prevHass?.language;
     this._hass = hass;
     if (!this._initialized) {
       this._initialize();
@@ -2347,13 +4104,44 @@ class CoverAutomaticPanel extends HTMLElement {
       this._render();
       return;
     }
+    // HA assigns a new hass object on every state change anywhere in the
+    // system. Only re-render when an entity this panel displays changed.
+    if (!this._relevantStatesChanged(prevHass, hass)) return;
     if (this._config) {
       const shell = this.shadowRoot ? this.shadowRoot.querySelector(".panel-container") : null;
-      if (shell) this._updateRegion(shell, "header", this._renderHeaderContent());
+      // Only the info bar depends on HA states: patch it alone so the rest
+      // of the header (master switch, focus) is not rebuilt.
+      if (shell) this._patchInfoBar(shell);
       if (this._activeTab === "covers") this._updateLiveCells();
     }
   }
 
+  _relevantEntityIds() {
+    const ids = new Set(["sun.sun"]);
+    const cfg = this._config;
+    if (!cfg) return ids;
+    const s = cfg.settings || {};
+    for (const key of ["outdoor_temp_sensor", "indoor_temp_sensor", "weather_entity", "solar_sensor", "wind_sensor", "workday_sensor",
+      "comfort_temp_min_entity", "comfort_temp_max_entity", "solar_threshold_entity"]) {
+      if (s[key]) ids.add(s[key]);
+    }
+    for (const [eid, c] of Object.entries(cfg.covers || {})) {
+      ids.add(eid);
+      for (const key of ["lock_sensor", "vent_sensor", "indoor_temp_sensor", "comfort_temp_min_entity", "comfort_temp_max_entity", "occupancy_sensor"]) {
+        if (c && c[key]) ids.add(c[key]);
+      }
+    }
+    return ids;
+  }
+
+  _relevantStatesChanged(prevHass, hass) {
+    if (!prevHass || !hass || !prevHass.states || !hass.states) return true;
+    for (const id of this._relevantEntityIds()) {
+      if (prevHass.states[id] !== hass.states[id]) return true;
+    }
+    return false;
+  }
+
   set panel(panel) {
     this._panel = panel;
   }
@@ -2361,6 +4149,7 @@ class CoverAutomaticPanel extends HTMLElement {
   connectedCallback() {
     // Window-level so Escape works regardless of where focus sits
     window.addEventListener("keydown", this._keydownListener);
+    window.addEventListener("beforeunload", this._beforeUnloadListener);
     // Re-attach subscriptions when the element is re-inserted (HA caches
     // custom panels and detaches/re-attaches them on navigation). _initialize
     // only runs once, so without this the real-time event push and the live
@@ -2374,14 +4163,17 @@ class CoverAutomaticPanel extends HTMLElement {
 
   disconnectedCallback() {
     window.removeEventListener("keydown", this._keydownListener);
+    window.removeEventListener("beforeunload", this._beforeUnloadListener);
     this._stopLiveRefresh();
     this._stopCondPreview();
     this._unsubscribeUpdates();
     this._removeHouseDragListeners();
-    if (this._saveTimers) {
-      Object.values(this._saveTimers).forEach(t => clearTimeout(t));
-      this._saveTimers = {};
-    }
+    // Send pending debounced cover edits now instead of dropping them.
+    this._flushCoverSaves();
+    // Pending HA-condition validations only refresh the (now hidden) editor.
+    for (const t of Object.values(this._haTimers || {})) clearTimeout(t);
+    this._haTimers = {};
+    if (this._toastTimer) { clearTimeout(this._toastTimer); this._toastTimer = null; }
   }
 
   /* ---------- i18n helper ---------- */
@@ -2391,6 +4183,12 @@ class CoverAutomaticPanel extends HTMLElement {
     return dict[key] !== undefined ? dict[key] : (I18N.en[key] !== undefined ? I18N.en[key] : key);
   }
 
+  // Label separator: French typography puts a (narrow no-break) space before ":"
+  _colon() {
+    const lang = (this._hass?.language) || "en";
+    return lang.startsWith("fr") ? "\u202F: " : ": ";
+  }
+
   _tt(section, key) {
     const lang = (this._hass?.language) || "en";
     const dict = I18N[lang] || I18N.en;
@@ -2412,17 +4210,36 @@ class CoverAutomaticPanel extends HTMLElement {
   }
 
   _subscribeUpdates() {
-    if (this._eventUnsub || !this._hass) return;
-    this._hass.connection.subscribeEvents(() => {
-      if (this._activeTab !== "covers" || !this._config) return;
+    // _subscribing: a subscription request is in flight (a quick
+    // disconnect/reconnect must not open a second one).
+    if (this._eventUnsub || this._subscribing || !this._hass) return;
+    // Dedicated WebSocket subscription (no bus event, so nothing is written
+    // to the recorder database on every update cycle).
+    const pending = this._hass.connection.subscribeMessage(() => {
+      if (!this.isConnected || this._activeTab !== "covers" || !this._config) return;
+      // Debounce 500 ms, but refresh at least every 3 s while events keep coming
+      const now = Date.now();
+      if (!this._eventDebounceStart) this._eventDebounceStart = now;
       if (this._eventDebounce) clearTimeout(this._eventDebounce);
+      const wait = Math.max(0, Math.min(500, this._eventDebounceStart + 3000 - now));
       this._eventDebounce = setTimeout(() => {
         this._eventDebounce = null;
+        this._eventDebounceStart = null;
         this._refreshLiveCovers();
-      }, 500);
-    }, "cover_automatic_updated").then((unsub) => {
+      }, wait);
+    }, { type: "cover_automatic/subscribe" });
+    this._subscribing = pending;
+    Promise.resolve(pending).then((unsub) => {
+      if (this._subscribing === pending) this._subscribing = null;
+      // Disconnected while the request was pending (or already subscribed):
+      // release it right away instead of leaking it.
+      if (!this.isConnected || this._eventUnsub) {
+        try { const r = unsub(); if (r && r.catch) r.catch(() => {}); } catch (e) { /* ignore */ }
+        return;
+      }
       this._eventUnsub = unsub;
     }).catch((err) => {
+      if (this._subscribing === pending) this._subscribing = null;
       console.warn("CoverAutomatic: failed to subscribe to update events", err);
     });
   }
@@ -2436,6 +4253,7 @@ class CoverAutomaticPanel extends HTMLElement {
       clearTimeout(this._eventDebounce);
       this._eventDebounce = null;
     }
+    this._eventDebounceStart = null;
   }
 
   /* ---------- WebSocket calls ---------- */
@@ -2456,6 +4274,7 @@ class CoverAutomaticPanel extends HTMLElement {
     this._render();
     try {
       this._config = await this._ws("cover_automatic/config");
+      this._cfgEpoch = (this._cfgEpoch || 0) + 1;
       if (this._activeTab === "covers") this._startLiveRefresh();
       this._render();
       this._checkForUpdate();
@@ -2473,59 +4292,256 @@ class CoverAutomaticPanel extends HTMLElement {
       if (!resp.ok) return;
       const data = await resp.json();
       const latest = (data.tag_name || "").replace(/^v/, "");
-      if (latest && latest !== this._config.version) {
+      if (latest && this._compareVersions(latest, this._config.version) > 0) {
         this._latestVersion = latest;
         this._updateRegion(this.shadowRoot.querySelector(".panel-container"), "header", this._renderHeaderContent());
       }
     } catch (e) { /* silent */ }
   }
 
-  _updateConfigFromResult(result) {
-    if (result) {
-      this._config = result;
-      this._showToast();
-      this._render();
+  // Compare dotted numeric versions: >0 if a is newer than b, <0 if older.
+  _compareVersions(a, b) {
+    const pa = String(a).split(/[.-]/).map(x => parseInt(x, 10));
+    const pb = String(b).split(/[.-]/).map(x => parseInt(x, 10));
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+      const x = Number.isFinite(pa[i]) ? pa[i] : 0;
+      const y = Number.isFinite(pb[i]) ? pb[i] : 0;
+      if (x !== y) return x > y ? 1 : -1;
+    }
+    return 0;
+  }
+
+  // Apply a configuration returned by a WebSocket call.
+  //   opts.resetDraft: the open rule was just saved -> restart its draft from
+  //                    the saved version.
+  //   opts.render:     false = update the data only (caller patches the DOM).
+  //   opts.haLive:     with resetDraft, live HA validation results to keep for
+  //                    the open rule, keyed by condition index.
+  _updateConfigFromResult(result, opts = {}) {
+    if (!result) return;
+    // Capture unsaved DOM-only editor fields before the editor is rebuilt.
+    if (!opts.resetDraft) this._syncRuleDraftFromDom();
+    // The backend renamed the rule id after a name change: the open editor
+    // and its per-rule state follow the new id.
+    const renamed = result.renamed_rule;
+    if (renamed && renamed.from && renamed.to && renamed.from !== renamed.to
+      && (result.rules || {})[renamed.to]) {
+      this._followRuleRename(renamed.from, renamed.to);
+    }
+    this._config = result;
+    // Live refreshes started before this config are outdated (see _refreshLiveCovers)
+    this._cfgEpoch = (this._cfgEpoch || 0) + 1;
+    // Settings changed on the server (import, other window): keep only the
+    // inputs really edited here, the others show the new stored values.
+    this._captureSettingsDraft();
+    if (this._settingsDraft) {
+      // The settings inputs still show the old values until the next render:
+      // do not capture them again (they would overwrite the new ones).
+      this._settingsDomStale = true;
+      for (const [field, d] of Object.entries(this._settingsDraft)) {
+        if (this._draftSame(d)) delete this._settingsDraft[field];
+        else d.initial = undefined; // re-read from the next render
+      }
+    }
+    // The open rule no longer exists (deleted or renamed elsewhere)
+    if (this._expandedRule && !(result.rules || {})[this._expandedRule]) this._expandedRule = null;
+    const d = this._ruleDraft;
+    let keepLive = false;
+    if (d) {
+      const saved = (result.rules || {})[d.id];
+      if (!saved || this._expandedRule !== d.id) {
+        this._discardRuleDraft();
+      } else if (opts.resetDraft) {
+        this._ruleDraft = { id: d.id, rule: this._clone(saved) };
+      } else {
+        keepLive = true; // unrelated change: the open rule keeps its draft
+      }
+    }
+    // Live validation results belong to the draft's conditions; keep them
+    // only while that draft is kept as is.
+    const live = {};
+    if (keepLive && this._haLive) {
+      const pre = d.id + ":";
+      for (const [k, v] of Object.entries(this._haLive)) if (k.startsWith(pre)) live[k] = v;
+    }
+    if (opts.haLive && this._ruleDraft) {
+      for (const [i, v] of Object.entries(opts.haLive)) live[this._ruleDraft.id + ":" + i] = v;
+    }
+    this._haLive = live;
+    this._showToast();
+    if (opts.render === false) return;
+    this._noDomSync = !!opts.resetDraft;
+    try { this._render(); } finally { this._noDomSync = false; }
+  }
+
+  // Move every piece of per-rule editor state from one rule id to another.
+  _followRuleRename(from, to) {
+    const moveKey = (k) => (k.startsWith(from + ":") ? to + k.slice(from.length) : k);
+    if (this._expandedRule === from) this._expandedRule = to;
+    if (this._ruleDraft && this._ruleDraft.id === from) {
+      this._ruleDraft.id = to;
+      if (this._ruleDraft.rule) this._ruleDraft.rule.id = to;
+    }
+    if (this._collapsedConds) this._collapsedConds = new Set([...this._collapsedConds].map(moveKey));
+    if (this._haLive) {
+      const next = {};
+      for (const [k, v] of Object.entries(this._haLive)) next[moveKey(k)] = v;
+      this._haLive = next;
+    }
+    const restart = [];
+    // Running validations were started for the old id: their results are
+    // dropped (see _runHaValidate), so they run again for the new id.
+    for (const k of Object.keys(this._haInflight || {})) {
+      if (k.startsWith(from + ":")) restart.push(parseInt(k.slice(from.length + 1), 10));
     }
+    for (const [k, t] of Object.entries(this._haTimers || {})) {
+      if (!k.startsWith(from + ":")) continue;
+      clearTimeout(t);
+      delete this._haTimers[k];
+      restart.push(parseInt(k.slice(from.length + 1), 10));
+    }
+    // Scheduled (not run yet): they run once the new config is in place.
+    for (const idx of new Set(restart)) if (Number.isFinite(idx)) this._scheduleHaValidate(to, idx);
+    if (this._dragRuleId === from) this._dragRuleId = to;
+    if (this._dragOverId === from) this._dragOverId = to;
+  }
+
+  _clone(o) {
+    return o == null ? o : JSON.parse(JSON.stringify(o));
   }
 
   /* ---------- Debounced save for covers ---------- */
-  _debouncedCoverSave(entityId, field, value) {
-    const key = `${entityId}.${field}`;
-    if (this._saveTimers[key]) clearTimeout(this._saveTimers[key]);
-    this._saveTimers[key] = setTimeout(async () => {
+  // field may be an object { field: value, ... } to save several at once
+  //   hooks.onSettled(ok): called once the save finished (not when a newer
+  //   edit of the same fields replaced it).
+  _debouncedCoverSave(entityId, field, value, hooks = null) {
+    const fields = typeof field === "object" && field !== null ? field : { [field]: value };
+    const key = `${entityId}.${Object.keys(fields).join("+")}`;
+    this._cancelCoverSave(key);
+    const fn = async () => {
       try {
-        const data = { entity_id: entityId };
-        data[field] = value;
+        const data = { entity_id: entityId, ...fields };
         const result = await this._ws("cover_automatic/cover/update", data);
-        this._updateConfigFromResult(result);
+        if (this._slideHasFocus()) {
+          // The user is still typing in the slide-out: rebuilding it would
+          // drop focus and keystrokes. Update the data, refresh everything
+          // around it and patch the derived texts inside it.
+          this._updateConfigFromResult(result, { render: false });
+          this._refreshAroundSlideOut();
+        } else {
+          this._updateConfigFromResult(result);
+        }
+        if (hooks && hooks.onSettled) hooks.onSettled(true);
       } catch (e) {
         console.error("Save error:", e);
+        this._showError(e);
+        if (hooks && hooks.onSettled) hooks.onSettled(false);
       }
+    };
+    const timer = setTimeout(() => {
+      if (this._saveTimers[key] && this._saveTimers[key].timer === timer) delete this._saveTimers[key];
+      fn();
     }, 500);
+    this._saveTimers[key] = { timer, fn };
+  }
+
+  _cancelCoverSave(key) {
+    const pending = this._saveTimers[key];
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    delete this._saveTimers[key];
+  }
+
+  // Send every pending debounced cover edit right away.
+  _flushCoverSaves() {
+    const pending = Object.values(this._saveTimers || {});
+    this._saveTimers = {};
+    for (const p of pending) {
+      clearTimeout(p.timer);
+      p.fn();
+    }
+  }
+
+  _slideHasFocus() {
+    const a = this.shadowRoot && this.shadowRoot.activeElement;
+    return !!(this._slideOpen && a && a.closest && a.closest(".slide-panel"));
+  }
+
+  // Re-render everything except the slide-out, then update the texts inside
+  // the slide-out that derive from the saved values (focus stays intact).
+  _refreshAroundSlideOut() {
+    const shell = this.shadowRoot.querySelector(".panel-container");
+    if (!shell || !shell.querySelector("[data-region]")) return;
+    this._updateRegion(shell, "header", this._renderHeaderContent());
+    this._updateRegion(shell, "content", this._renderContent());
+    const cover = (this._config.covers || {})[this._selectedCover];
+    if (!cover) { this._render(); return; }
+    const info = this._travelInfo(cover);
+    const id = CSS.escape(cover.entity_id);
+    const input = shell.querySelector(`[data-action="cover-input"][data-id="${id}"][data-field="travel_time"]`);
+    if (input) input.placeholder = info.placeholder;
+    const used = shell.querySelector(`[data-travel-used="${id}"]`);
+    if (used) used.textContent = info.usedTxt;
+  }
+
+  // Travel-time texts of a cover: placeholder, measured value, effective value.
+  _travelInfo(cover) {
+    const num = (v) => (typeof v === "number" && v > 0 ? v : null);
+    const measured = num(cover.measured_travel_time);
+    const manual = num(cover.travel_time);
+    const globalTravel = num(this._config.settings?.default_travel_time);
+    const fmtS = (v) => String(Math.round(v));
+    const placeholder = measured != null
+      ? this._t("cover_travel_auto_measured").replace("{s}", fmtS(measured))
+      : (globalTravel != null ? this._t("cover_travel_auto_default").replace("{s}", fmtS(globalTravel)) : this._t("cover_travel_auto"));
+    // Effective value, same order as the integration: entered > measured > default
+    let used = null, usedSrc = "none";
+    if (manual != null) { used = manual; usedSrc = "manual"; }
+    else if (measured != null) { used = measured; usedSrc = "measured"; }
+    else if (globalTravel != null) { used = globalTravel; usedSrc = "default"; }
+    const settle = used != null ? Math.max(30, used + 5) : 30;
+    const usedTxt = (used != null
+      ? this._t("cover_travel_used").replace("{s}", fmtS(used)).replace("{src}", this._t("cover_travel_src_" + usedSrc))
+      : this._t("cover_travel_used_none")).replace("{wait}", fmtS(settle));
+    return { measured, placeholder, usedTxt, fmtS };
   }
 
   /* ---------- Toast ---------- */
-  _showToast() {
+  _showToast(message, isError = false) {
     if (this._toastTimer) clearTimeout(this._toastTimer);
     const toast = this.shadowRoot.querySelector(".toast");
     if (!toast) return;
     const msg = toast.querySelector(".toast-msg");
     // Setting the text on show (not statically) makes role="status" announce it
-    if (msg) msg.textContent = this._t("saved");
+    if (msg) msg.textContent = message || this._t("saved");
     // Force reflow so the countdown animation restarts on rapid re-shows
     toast.classList.remove("show");
+    toast.classList.toggle("toast-error", !!isError);
     void toast.offsetWidth;
     toast.classList.add("show");
     this._toastTimer = setTimeout(() => {
       toast.classList.remove("show");
       if (msg) msg.textContent = "";
-    }, 2000);
+    }, isError ? 5000 : 2000);
+  }
+
+  // Show a localized error toast for a failed WebSocket call. The backend
+  // sends a stable error code; its message text is English-only.
+  _showError(err) {
+    const code = err && err.code ? String(err.code) : "";
+    const key = "error_" + code;
+    const text = code ? this._t(key) : key;
+    let msg = text !== key ? text : this._t("error_generic");
+    // Which condition is wrong is only in the backend message: show it too
+    if (code === "invalid_conditions" && err.message) msg += " — " + String(err.message);
+    this._showToast(msg, true);
   }
 
   /* ---------- Confirm dialog ---------- */
-  _showConfirm(message, callback) {
+  _showConfirm(message, callback, okLabel = null) {
     this._confirmMessage = message;
     this._confirmCallback = callback;
+    this._confirmOkLabel = okLabel;
     this._render();
     // Move focus into the dialog so keyboard users can act on it
     setTimeout(() => this.shadowRoot.querySelector(".confirm-dialog .btn-secondary")?.focus(), 0);
@@ -2534,31 +4550,185 @@ class CoverAutomaticPanel extends HTMLElement {
   _hideConfirm() {
     this._confirmMessage = "";
     this._confirmCallback = null;
+    this._confirmOkLabel = null;
     this._render();
   }
 
   /* ---------- Main render ---------- */
   _render() {
     const root = this.shadowRoot;
+    // Unsaved inputs that live only in the DOM survive the rebuild.
+    this._syncRuleDraftFromDom();
+    this._captureSettingsDraft();
 
     // Full render when no shell exists, loading/error, or shell has no regions yet
     const shell = root.querySelector(".panel-container");
     if (!shell || !this._config || this._error || !shell.querySelector("[data-region]")) {
       this._fullRender();
-      return;
+    } else {
+      // Partial render: update regions individually
+      this._updateRegion(shell, "header", this._renderHeaderContent());
+      this._updateRegion(shell, "tabs", this._renderTabsContent());
+      this._updateRegion(shell, "content", this._renderContent());
+      this._updateRegion(shell, "slideout", this._renderSlideOut());
+      this._updateRegion(shell, "confirm", this._renderConfirmDialog());
     }
+    this._applySettingsDraft();
+    this._syncSettingsRadios();
+    this._settingsDomStale = false;
+    this._refreshDeps();
+  }
 
-    // Partial render: update regions individually
-    this._updateRegion(shell, "header", this._renderHeaderContent());
-    this._updateRegion(shell, "tabs", this._renderTabsContent());
-    this._updateRegion(shell, "content", this._renderContent());
-    this._updateRegion(shell, "slideout", this._renderSlideOut());
-    this._updateRegion(shell, "confirm", this._renderConfirmDialog());
+  _patchInfoBar(shell) {
+    const slot = shell.querySelector('[data-region="header"] .info-bar-slot');
+    if (!slot) { this._updateRegion(shell, "header", this._renderHeaderContent()); return; }
+    const html = this._renderInfoBarInline();
+    // Compare with the last generated HTML (innerHTML serialization, SVG
+    // included, never matches it exactly and would rewrite every time).
+    if (slot._caHtml === html) return;
+    slot._caHtml = html;
+    slot.innerHTML = html;
   }
 
   _updateRegion(shell, name, html) {
     const el = shell.querySelector(`[data-region="${name}"]`);
-    if (el) el.innerHTML = html;
+    if (!el) return;
+    if (name === "slideout") { this._updateSlideOutRegion(el, html); return; }
+    el.innerHTML = html;
+  }
+
+  /* ---------- Slide-out: keep scroll position and focus ---------- */
+  // Structure of the slide-out HTML without the parts that are patched in
+  // place (control values, placeholders, section summaries, travel text).
+  _slideSig(html) {
+    return String(html)
+      .replace(/\s(?:value|placeholder)="[^"]*"/g, "")
+      .replace(/\s(?:checked|selected|disabled)(?=[\s>])/g, "")
+      .replace(/(<span class="section-summary">)[^<]*(<\/span>)/g, "$1$2")
+      .replace(/(data-travel-used="[^"]*">)[^<]*(<\/div>)/g, "$1$2");
+  }
+
+  // Selector finding "the same" element again after a rebuild.
+  _slideElKey(el) {
+    if (!el || !el.tagName) return null;
+    const attrs = ["data-action", "data-id", "data-field", "data-section", "data-val", "data-occ-other", "data-ids", "id", "name"];
+    let sel = el.tagName.toLowerCase();
+    let any = false;
+    for (const a of attrs) {
+      const v = el.getAttribute(a);
+      if (v != null) { sel += `[${a}="${CSS.escape(v)}"]`; any = true; }
+    }
+    if (el.type === "radio" && el.value) sel += `[value="${CSS.escape(el.value)}"]`;
+    return any ? sel : null;
+  }
+
+  _updateSlideOutRegion(el, html) {
+    const prevHtml = this._slideHtml;
+    this._slideHtml = html;
+    const oldPanel = el.querySelector(".slide-panel");
+    const oldCover = oldPanel && oldPanel.classList.contains("open") ? oldPanel.dataset.cover : null;
+    const sameCover = !!(oldCover && this._slideOpen && this._selectedCover === oldCover);
+    if (!sameCover) { el.innerHTML = html; return; }
+    if (prevHtml === html) return; // nothing changed: keep the DOM as is
+    if (prevHtml != null && this._slideSig(prevHtml) === this._slideSig(html)) {
+      this._patchSlideOut(el, prevHtml, html);
+      return;
+    }
+    // Structural change: rebuild, then restore scroll and focus.
+    const body = el.querySelector(".slide-body");
+    const scroll = body ? body.scrollTop : 0;
+    const active = this.shadowRoot.activeElement;
+    let key = null, selStart = null, selEnd = null;
+    if (active && el.contains(active)) {
+      key = this._slideElKey(active);
+      try { selStart = active.selectionStart; selEnd = active.selectionEnd; } catch (e) { /* not a text field */ }
+    } else if (this._slideClick && Date.now() - this._slideClick.t < 2000) {
+      // iOS Safari does not focus clicked buttons: use the last click instead
+      key = this._slideClick.key;
+    }
+    el.innerHTML = html;
+    const nbody = el.querySelector(".slide-body");
+    if (nbody) nbody.scrollTop = scroll;
+    if (key) {
+      let target = null;
+      try { target = el.querySelector(key); } catch (e) { target = null; }
+      if (target) {
+        try { target.focus({ preventScroll: true }); } catch (e) { target.focus(); }
+        if (selStart != null) { try { target.setSelectionRange(selStart, selEnd); } catch (e) { /* ignore */ } }
+        if (nbody) nbody.scrollTop = scroll;
+      }
+    }
+  }
+
+  // Same structure: update only what differs between the previous and the
+  // new HTML. Controls the user is editing (focused, pending save, invalid)
+  // keep their value.
+  _patchSlideOut(el, prevHtml, html) {
+    const parse = (h) => { const t = document.createElement("template"); t.innerHTML = h; return t.content; };
+    const oldT = parse(prevHtml), newT = parse(html);
+    const active = this.shadowRoot.activeElement;
+    const pendingKeys = Object.keys(this._saveTimers || {});
+    const pending = (id, field) => pendingKeys.some(k => k.startsWith(id + ".") && k.slice(id.length + 1).split("+").includes(field));
+    const ctrlState = (c) => {
+      if (!c) return null;
+      if (c.tagName === "SELECT") {
+        const o = c.querySelector("option[selected]") || c.querySelector("option");
+        return o ? (o.getAttribute("value") ?? o.textContent) : "";
+      }
+      if (c.type === "checkbox" || c.type === "radio") return c.hasAttribute("checked");
+      return c.getAttribute("value") ?? "";
+    };
+    for (const nc of newT.querySelectorAll("input, select, textarea")) {
+      const key = this._slideElKey(nc);
+      if (!key) continue;
+      const oc = oldT.querySelector(key);
+      const live = el.querySelector(key);
+      if (!oc || !live) continue;
+      const ph = nc.getAttribute("placeholder");
+      if (ph !== oc.getAttribute("placeholder")) { if (ph == null) live.removeAttribute("placeholder"); else live.setAttribute("placeholder", ph); }
+      const nv = ctrlState(nc);
+      if (nv === ctrlState(oc)) continue;
+      if (live === active) {
+        // Focused control keeps what it shows; the new server value is
+        // applied on blur if the user did not change it (_onSlideFocusOut).
+        const dom = typeof nv === "boolean" ? live.checked : live.value;
+        live._caStale = { value: nv, dom: live._caStale ? live._caStale.dom : dom };
+        continue;
+      }
+      if (live.classList.contains("input-invalid")) continue;
+      if (live.dataset.id && live.dataset.field && pending(live.dataset.id, live.dataset.field)) continue;
+      delete live._caStale;
+      if (typeof nv === "boolean") live.checked = nv; else live.value = nv;
+    }
+    for (const ns of newT.querySelectorAll(".section-header[data-section]")) {
+      const sel = `.section-header[data-section="${CSS.escape(ns.dataset.section)}"] .section-summary`;
+      const n = ns.querySelector(".section-summary");
+      const live = el.querySelector(sel);
+      if (n && live && live.textContent !== n.textContent) live.textContent = n.textContent;
+    }
+    for (const nt of newT.querySelectorAll("[data-travel-used]")) {
+      const live = el.querySelector(`[data-travel-used="${CSS.escape(nt.dataset.travelUsed)}"]`);
+      if (live && live.textContent !== nt.textContent) live.textContent = nt.textContent;
+    }
+  }
+
+  // A slide-out control skipped by _patchSlideOut while focused: once blurred,
+  // show the server value unless the user changed it meanwhile.
+  _onSlideFocusOut(e) {
+    const el = e.target;
+    if (!el || !el._caStale) return;
+    const stale = el._caStale;
+    delete el._caStale;
+    if (!el.isConnected || !el.closest || !el.closest(".slide-panel")) return;
+    if (el.classList.contains("input-invalid")) return;
+    const pendingKeys = Object.keys(this._saveTimers || {});
+    const id = el.dataset.id, field = el.dataset.field;
+    if (id && field && pendingKeys.some(k => k.startsWith(id + ".") && k.slice(id.length + 1).split("+").includes(field))) return;
+    if (typeof stale.value === "boolean") {
+      if (el.checked === stale.dom) el.checked = stale.value;
+    } else if (el.value === stale.dom) {
+      el.value = stale.value;
+    }
   }
 
   _fullRender() {
@@ -2589,7 +4759,8 @@ class CoverAutomaticPanel extends HTMLElement {
     html += `<div class="panel-header" data-region="header" role="banner">${this._renderHeaderContent()}</div>`;
     html += `<div class="tab-bar" data-region="tabs" role="navigation" aria-label="${this._t("nav_label")}">${this._renderTabsContent()}</div>`;
     html += `<div class="tab-content" data-region="content" role="main">${this._renderContent()}</div>`;
-    html += `<div data-region="slideout">${this._renderSlideOut()}</div>`;
+    this._slideHtml = this._renderSlideOut();
+    html += `<div data-region="slideout">${this._slideHtml}</div>`;
     html += `<div data-region="confirm">${this._renderConfirmDialog()}</div>`;
     html += '</div>';
     html += `<div class="toast" role="status"><span class="toast-msg"></span><span class="toast-progress"></span></div>`;
@@ -2614,14 +4785,14 @@ class CoverAutomaticPanel extends HTMLElement {
       html += ' <a class="version-info" href="https://github.com/crandler/CoverAutomatic/releases/tag/v' + v + '" target="_blank" rel="noopener noreferrer" title="' + this._t("version_link_title") + '">v' + v + '</a>';
     }
     html += '</div><div class="header-right">';
-    html += this._renderInfoBarInline();
+    html += '<span class="info-bar-slot">' + this._renderInfoBarInline() + '</span>';
     if (activeScenario) {
       html += '<span class="scenario-badge">' + (activeScenario.icon ? '<ha-icon icon="' + this._esc(activeScenario.icon) + '" class="scenario-badge-icon"></ha-icon>' : '') + this._esc(activeScenario.name) + '</span>';
     }
     html += '<div class="master-switch" title="' + this._t("master_enabled_hint") + '">';
     html += '<span class="master-label">' + this._t("master_enabled") + '</span>';
     html += '<label class="master-toggle">';
-    html += '<input type="checkbox" ' + (enabled ? 'checked ' : '') + 'data-action="master-toggle">';
+    html += '<input type="checkbox" ' + (enabled ? 'checked ' : '') + 'data-action="master-toggle" aria-label="' + this._esc(this._t("master_enabled")) + '">';
     html += '<span class="toggle-slider"></span>';
     html += '</label>';
     html += '</div>';
@@ -2660,11 +4831,11 @@ class CoverAutomaticPanel extends HTMLElement {
       : this._sunIconSvg(14);
     let widgets = [];
     if (az != null && el != null) {
-      const sunTitle = this._t("info_sun_title") || "Sonnenposition";
+      const sunTitle = this._t("info_sun_title");
       widgets.push('<span class="info-widget" title="' + this._esc(sunTitle) + '">' + sunIcon + '<span class="info-widget-value">' + Number(az).toFixed(1) + '\u00B0 / ' + Number(el).toFixed(1) + '\u00B0</span></span>');
     }
     if (tempVal != null) {
-      const tempTitle = this._t("info_outdoor_title") || "Au\u00DFentemperatur";
+      const tempTitle = this._t("info_outdoor_title");
       const thermoIcon = '<svg class="info-bar-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"/></svg>';
       widgets.push('<span class="info-widget" title="' + this._esc(tempTitle) + '">' + thermoIcon + '<span class="info-widget-value">' + tempVal.toFixed(1) + ' \u00B0C</span></span>');
     }
@@ -2678,7 +4849,7 @@ class CoverAutomaticPanel extends HTMLElement {
       const threshold = settings.solar_threshold ?? 0;
       const exceeded = threshold > 0 && solarVal > threshold;
       const unit = solarState.attributes && solarState.attributes.unit_of_measurement ? ' ' + solarState.attributes.unit_of_measurement : '';
-      const solarTitle = exceeded ? (this._t("info_solar_exceeded_title") || "Solar \u00FCber Schwellwert \u2013 Beschattung aktiv") : (this._t("info_solar_title") || "Solarintensit\u00E4t");
+      const solarTitle = exceeded ? this._t("info_solar_exceeded_title") : this._t("info_solar_title");
       const activityIcon = '<svg class="info-bar-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.5.5 0 0 1-.96 0L9.24 2.18a.5.5 0 0 0-.96 0l-2.35 8.36A2 2 0 0 1 4 12H2"/></svg>';
       const cls = exceeded ? 'info-widget info-widget-highlight' : 'info-widget';
       widgets.push('<span class="' + cls + '" title="' + this._esc(solarTitle) + '">' + activityIcon + '<span class="info-widget-value">' + solarVal.toFixed(0) + this._esc(unit) + (exceeded ? ' \u25B2' : '') + '</span></span>');
@@ -2693,6 +4864,30 @@ class CoverAutomaticPanel extends HTMLElement {
     return '<span class="pos-bar' + cls + '"><span class="pos-bar-track"><span class="pos-bar-fill" style="width:' + p + '%"></span></span><span class="pos-bar-label">' + pos + '%</span></span>';
   }
 
+  // Current position in the rules' (logical) frame: inverted covers are
+  // mirrored like the coordinator does. Returns { pos, raw } (raw = HA value).
+  _coverCurrentPos(cover, haState) {
+    let v = haState && haState.attributes ? haState.attributes.current_position : null;
+    // Open/close-only covers: read the position from the state
+    if (v == null && haState) v = { open: 100, closed: 0 }[haState.state] ?? null;
+    const raw = v == null || v === "" || isNaN(Number(v)) ? null : Number(v);
+    if (raw == null) return { pos: null, raw: null };
+    return { pos: cover && cover.inverted ? 100 - raw : raw, raw };
+  }
+
+  // Position cell: current (logical) vs target, with the raw HA value in a
+  // tooltip for inverted covers.
+  _posCellHtml(cover, haState, target) {
+    const { pos, raw } = this._coverCurrentPos(cover, haState);
+    // Unknown current position (cover unavailable): don't draw the target
+    // as if it were the current position.
+    if (pos == null) return '\u2013';
+    const bar = this._posBarCombined(pos, target);
+    if (!(cover && cover.inverted) || raw == null) return bar;
+    const tip = this._t("cover_position_inverted_tip").replace("{raw}", raw);
+    return `<span class="pos-inverted" title="${this._esc(tip)}">${bar}<span class="pos-inverted-mark" aria-label="${this._esc(tip)}">\u21C5</span></span>`;
+  }
+
   // Combined position bar: single column shows current + target with a marker when they differ
   _posBarCombined(current, target) {
     if (current == null && target == null) return '\u2013';
@@ -2708,7 +4903,7 @@ class CoverAutomaticPanel extends HTMLElement {
     const lo = Math.min(c, t);
     const hi = Math.max(c, t);
     const rangeWidth = hi - lo;
-    const title = this._t("cover_position_target_label") + ": " + target + "%";
+    const title = this._t("cover_position_target_label") + this._colon() + target + "%";
     return '<span class="pos-bar pos-bar-diverges" title="' + this._esc(title) + '">'
       + '<span class="pos-bar-track">'
         + '<span class="pos-bar-fill" style="width:' + lo + '%"></span>'
@@ -2768,15 +4963,37 @@ class CoverAutomaticPanel extends HTMLElement {
       archive: '<rect width="20" height="5" x="2" y="3" rx="1"/><path d="M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8"/><path d="M10 12h4"/>',
       menu: '<line x1="4" x2="20" y1="12" y2="12"/><line x1="4" x2="20" y1="6" y2="6"/><line x1="4" x2="20" y1="18" y2="18"/>',
       info: '<circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/>',
+      app_window: '<rect x="2" y="4" width="20" height="16" rx="2"/><path d="M10 4v4"/><path d="M2 8h20"/><path d="M6 4v4"/>',
       sliders: '<line x1="21" x2="14" y1="4" y2="4"/><line x1="10" x2="3" y1="4" y2="4"/><line x1="21" x2="12" y1="12" y2="12"/><line x1="8" x2="3" y1="12" y2="12"/><line x1="21" x2="16" y1="20" y2="20"/><line x1="12" x2="3" y1="20" y2="20"/><line x1="14" x2="14" y1="2" y2="6"/><line x1="8" x2="8" y1="10" y2="14"/><line x1="16" x2="16" y1="18" y2="22"/>',
       copy: '<rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>',
       move_vertical: '<polyline points="8 18 12 22 16 18"/><polyline points="8 6 12 2 16 6"/><line x1="12" x2="12" y1="2" y2="22"/>',
       activity: '<path d="M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.5.5 0 0 1-.96 0L9.24 2.18a.5.5 0 0 0-.96 0l-2.35 8.36A2 2 0 0 1 4 12H2"/>',
+      copy: '<rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>',
+      shield: '<path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/>',
+      thermometer_snowflake: '<path d="m10 20-1.25-2.5L6 18"/><path d="M10 4 8.75 6.5 6 6"/><path d="M10.585 15H10"/><path d="M2 12h6.5L10 9"/><path d="M20 14.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0z"/><path d="m4 10 1.5 2L4 14"/><path d="m7 21 3-6-1.5-3"/><path d="m7 3 3 6h2"/>',
+      thermometer_sun: '<path d="M12 2v2"/><path d="M12 8a4 4 0 0 0-1.645 7.647"/><path d="M2 12h2"/><path d="M20 14.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0z"/><path d="m4.93 4.93 1.41 1.41"/><path d="m6.34 17.66-1.41 1.41"/>',
       sun: '<circle cx="12" cy="12" r="4"/><path d="M12 2v2"/><path d="M12 20v2"/><path d="m4.93 4.93 1.41 1.41"/><path d="m17.66 17.66 1.41 1.41"/><path d="M2 12h2"/><path d="M20 12h2"/><path d="m6.34 17.66-1.41 1.41"/><path d="m19.07 4.93-1.41 1.41"/>'
     };
     return '<svg width="' + size + '" height="' + size + '" viewBox="0 0 24 24" fill="' + a + '">' + (paths[name] || '') + '</svg>';
   }
 
+  // Room temperature cell of the cover list: text colour, icon and tooltip
+  // for the comfort mode. The icon (snowflake / sun thermometer) carries the
+  // meaning; the colours follow the chosen convention: "action" (default:
+  // cold room red = to heat, hot room blue = to cool) or thermometer (cold
+  // blue, hot red).
+  _tempCellParts(cm, tempVal) {
+    const cold = cm === "heating", hot = cm === "cooling";
+    const thermo = (this._config?.settings || {}).temp_color_thermometer === true;
+    const red = "var(--ca-danger)", blue = "var(--ca-info)";
+    const color = cold ? (thermo ? blue : red) : hot ? (thermo ? red : blue) : "";
+    const icon = cold || hot
+      ? '<span class="temp-icon" aria-hidden="true">' + this._lucideIcon(cold ? "thermometer_snowflake" : "thermometer_sun", 14) + '</span>'
+      : "";
+    const text = tempVal != null ? tempVal.toFixed(1) + " \u00B0C" : "\u2013";
+    return { color, html: icon + this._esc(text), title: cm ? this._t("comfort_" + cm) : "" };
+  }
+
   _renderContent() {
     switch (this._activeTab) {
       case "covers": return this._renderCovers();
@@ -2796,7 +5013,7 @@ class CoverAutomaticPanel extends HTMLElement {
       + '<p>' + this._esc(this._confirmMessage) + '</p>'
       + '<div class="actions">'
       + '<button class="btn btn-secondary" data-action="confirm-cancel">' + this._t("cancel") + '</button>'
-      + '<button class="btn btn-danger" data-action="confirm-ok">' + this._t("delete") + '</button>'
+      + '<button class="btn btn-danger" data-action="confirm-ok">' + this._esc(this._confirmOkLabel || this._t("delete")) + '</button>'
       + '</div></div></div>';
   }
 
@@ -2879,7 +5096,6 @@ class CoverAutomaticPanel extends HTMLElement {
       const selected = this._selectedCover === c.entity_id ? " selected" : "";
       const statusClass = "status-" + (c.status || "auto");
       const haState = this._hass?.states ? this._hass.states[c.entity_id] : null;
-      const currentPos = haState && haState.attributes ? haState.attributes.current_position : null;
       const live = (this._config.live_covers || {})[c.entity_id] || {};
       const targetPos = live.target_position;
       const hysteresis = live.hysteresis;
@@ -2907,10 +5123,9 @@ class CoverAutomaticPanel extends HTMLElement {
       const tempSensor = c.indoor_temp_sensor || (this._config.settings || {}).indoor_temp_sensor;
       const tempState = tempSensor && this._hass?.states ? this._hass.states[tempSensor] : null;
       const tempVal = tempState && tempState.state !== "unavailable" && tempState.state !== "unknown" ? parseFloat(tempState.state) : null;
-      const tempColor = cm === "cooling" ? "var(--ca-info)" : cm === "heating" ? "var(--ca-danger)" : "";
-      const tempTitle = cm ? this._t("comfort_" + cm) : "";
-      html += `<td class="nowrap${tempColor ? ' temp-mode' : ''}" data-live-temp="${this._esc(c.entity_id)}"${tempColor ? ' style="color:' + tempColor + '"' : ''}${tempTitle ? ' title="' + this._esc(tempTitle) + '"' : ''}>${tempVal != null ? tempVal.toFixed(1) + " °C" : "–"}</td>`;
-      html += `<td class="pos-cell" data-live-position="${this._esc(c.entity_id)}">${this._posBarCombined(currentPos, targetPos)}${infoIcon}</td>`;
+      const tp = this._tempCellParts(cm, tempVal);
+      html += `<td class="nowrap${tp.color ? ' temp-mode' : ''}" data-live-temp="${this._esc(c.entity_id)}"${tp.color ? ' style="color:' + tp.color + '"' : ''}${tp.title ? ' title="' + this._esc(tp.title) + '"' : ''}>${tp.html}</td>`;
+      html += `<td class="pos-cell" data-live-position="${this._esc(c.entity_id)}">${this._posCellHtml(c, haState, targetPos)}${infoIcon}</td>`;
       html += `<td data-live-rule="${this._esc(c.entity_id)}">${ruleCellHtml}</td>`;
       html += `<td class="last-change" data-live-lastchange="${this._esc(c.entity_id)}">${lastChange}</td>`;
       html += '<td class="row-chevron" aria-hidden="true"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m9 18 6-6-6-6"/></svg></td>';
@@ -2927,120 +5142,193 @@ class CoverAutomaticPanel extends HTMLElement {
     const cover = open ? (this._config.covers || {})[this._selectedCover] : null;
 
     let html = `<div class="slide-overlay${open ? " open" : ""}" data-action="close-slide" aria-hidden="true"></div>`;
-    html += `<div class="slide-panel${open ? " open" : ""}"${cover ? ` role="dialog" aria-modal="true" aria-label="${this._esc(cover.name)}"` : ' aria-hidden="true"'}>`;
+    html += `<div class="slide-panel${open ? " open" : ""}"${cover ? ` data-cover="${this._esc(cover.entity_id)}"` : ""}${cover ? ` role="dialog" aria-modal="true" aria-label="${this._esc(cover.name)}"` : ' aria-hidden="true"'}>`;
 
     if (cover) {
       html += `<div class="slide-header">
+        <button class="btn-icon slide-back" data-action="close-slide" title="${this._t("close")}" aria-label="${this._t("close")}">&#8592;</button>
         <h2>${this._esc(cover.name)}</h2>
-        <button class="btn-icon" data-action="close-slide" title="${this._t("close")}">&#10005;</button>
+        <button class="btn-icon slide-close" data-action="close-slide" title="${this._t("close")}" aria-label="${this._t("close")}">&#10005;</button>
       </div>`;
       html += '<div class="slide-body">';
 
-      // Section: Base
+      const cid = this._esc(cover.entity_id);
+      const cs = this._config.settings || {};
+      const ctl = (field) => `[data-field="${field}"][data-id="${cover.entity_id.replace(/["\\]/g, "\\$&")}"]`;
+      const sum = this._coverSectionSummaries(cover);
+      const allIds = ["base", "window", "room", "sun", "automation"];
+      const allOpen = allIds.every(id => this._expandedSections[id]);
+      html += `<div class="slide-expand-bar"><button type="button" class="btn-link" data-action="sections-toggle-all" data-ids="${allIds.join(",")}">${
+        this._t(allOpen ? "cover_collapse_all" : "cover_expand_all")}</button></div>`;
+
+      // Section: General
       html += this._renderSection("base", this._t("cover_section_base"), () => {
+        const items = [
+          this._renderToggle("cover_auto_enabled", cover.auto_enabled, "cover-toggle", cover.entity_id, "auto_enabled"),
+          this._renderFacadeDropdown(cover) + this._hint("cover_facade_hint"),
+          this._renderToggle("cover_inverted", cover.inverted, "cover-toggle", cover.entity_id, "inverted", "cover_inverted_hint"),
+        ];
+        if (cover.supports_tilt) {
+          items.push(this._renderToggle("cover_inverted_tilt", cover.inverted_tilt, "cover-toggle", cover.entity_id, "inverted_tilt"));
+        }
+        return this._sepList(items);
+      }, sum.base);
+
+      // Section: Window (open = lock, tilted = ventilation)
+      html += this._renderSection("window", this._t("cover_section_window"), () => {
         let s = '';
-        // Auto enabled
-        s += this._renderToggle("cover_auto_enabled", cover.auto_enabled, "cover-toggle", cover.entity_id, "auto_enabled");
-        // Facade
-        s += this._renderFacadeDropdown(cover);
-        s += this._hint("cover_facade_hint");
-        // Pause duration
-        const globalPause = this._config.settings?.pause_duration ?? 10;
-        const coverPause = this._num(cover.pause_duration);
-        s += `<div class="form-group">
-          <label>${this._t("cover_pause_duration")}</label>
-          <input type="number" min="0" max="480" value="${coverPause}" placeholder="${globalPause}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="pause_duration">
-          ${this._hint("cover_pause_duration_hint")}
-        </div>`;
+        const globalLockPos = cs.lock_position ?? 100;
+        const lockTilt = cover.supports_tilt ? `<div class="form-group">
+                <label>${this._t("cover_lock_tilt")}</label>
+                <input type="number" min="0" max="100" value="${this._num(cover.lock_tilt_position, "")}" placeholder="${this._t("none")}" data-action="cover-input" data-id="${cid}" data-field="lock_tilt_position">
+              </div>` : "";
+        s += this._optBox({
+          title: this._t("cover_lock_box_title"),
+          dep: ctl("lock_sensor"), mode: "value",
+          head: `<div class="form-group">
+            <label>${this._t("cover_lock_sensor")}</label>
+            ${this._renderCoverEntitySelect("lock_sensor", cover.lock_sensor, cover.entity_id, "binary_sensor", null)}
+            ${this._renderSensorValue(cover.lock_sensor)}
+            ${this._hint("cover_lock_sensor_hint")}
+          </div>`,
+          offNote: this._t("cover_lock_off_note"),
+          body: `${this._renderToggle("cover_lock_hold", !!cover.lock_hold_position, "cover-toggle", cover.entity_id, "lock_hold_position", "cover_lock_hold_hint")}
+            ${this._optBox({
+              cls: "opt-box-flat",
+              dep: ctl("lock_hold_position"), mode: "unchecked",
+              body: `<div class="form-group">
+                <label>${this._t("cover_lock_position")}</label>
+                <input type="number" min="0" max="100" value="${this._num(cover.lock_position, "")}" placeholder="${globalLockPos}" data-action="cover-input" data-id="${cid}" data-field="lock_position">
+                ${this._hint("cover_lock_position_hint")}
+              </div>${lockTilt}`,
+            })}`,
+        });
+        const globalVentPos = cs.vent_position ?? 30;
+        const ventTilt = cover.supports_tilt ? `<div class="form-group">
+            <label>${this._t("cover_vent_tilt")}</label>
+            <input type="number" min="0" max="100" value="${this._num(cover.vent_tilt_position, "")}" placeholder="${this._t("none")}" data-action="cover-input" data-id="${cid}" data-field="vent_tilt_position">
+          </div>` : "";
+        s += this._optBox({
+          title: this._t("cover_vent_box_title"),
+          dep: ctl("vent_sensor"), mode: "value",
+          head: `<div class="form-group">
+            <label>${this._t("cover_vent_sensor")}</label>
+            ${this._renderCoverEntitySelect("vent_sensor", cover.vent_sensor, cover.entity_id, "binary_sensor", null)}
+            ${this._renderSensorValue(cover.vent_sensor)}
+            ${this._hint("cover_vent_sensor_hint")}
+          </div>`,
+          offNote: this._t("cover_vent_off_note"),
+          body: `<div class="form-group">
+            <label>${this._t("cover_vent_position")}</label>
+            <input type="number" min="0" max="100" value="${this._num(cover.vent_position, "")}" placeholder="${globalVentPos}" data-action="cover-input" data-id="${cid}" data-field="vent_position">
+            ${this._hint("cover_vent_position_hint")}
+          </div>${ventTilt}`,
+        });
         return s;
-      });
+      }, sum.window);
 
-      // Section: Sensors
-      html += this._renderSection("sensors", this._t("cover_section_sensors"), () => {
+      // Section: Room (indoor temperature setpoints + occupancy)
+      html += this._renderSection("room", this._t("cover_section_room"), () => {
         let s = '';
-        s += `<div class="form-group">
-          <label>${this._t("cover_indoor_temp")}</label>
-          ${this._renderCoverEntitySelect("indoor_temp_sensor", cover.indoor_temp_sensor, cover.entity_id, "sensor", "temperature")}
-          ${this._hint("cover_indoor_temp_hint")}
-        </div>`;
-        const globalMin = this._config.settings?.comfort_temp_min ?? 22;
-        const globalMax = this._config.settings?.comfort_temp_max ?? 24;
-        s += '<div class="form-row">';
-        s += `<div class="form-group">
-          <label>${this._t("cover_comfort_min")}</label>
-          <input type="number" step="0.5" value="${this._num(cover.comfort_temp_min, "")}" placeholder="${globalMin}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="comfort_temp_min">
-        </div>`;
-        s += `<div class="form-group">
-          <label>${this._t("cover_comfort_max")}</label>
-          <input type="number" step="0.5" value="${this._num(cover.comfort_temp_max, "")}" placeholder="${globalMax}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="comfort_temp_max">
-        </div>`;
-        s += '</div>';
-        s += this._hint("cover_comfort_hint");
-        const preemptiveOn = cover.preemptive_shading !== false;
-        s += this._renderToggle("cover_preemptive_shading", preemptiveOn, "cover-toggle", cover.entity_id, "preemptive_shading");
-        s += this._hint("cover_preemptive_shading_hint");
-        s += `<div class="form-group">
-          <label>${this._t("cover_lock_sensor")}</label>
-          ${this._renderCoverEntitySelect("lock_sensor", cover.lock_sensor, cover.entity_id, "binary_sensor", null)}
-          ${this._hint("cover_lock_sensor_hint")}
-        </div>`;
-        const globalLockPos = this._config.settings?.lock_position ?? 100;
-        s += `<div class="form-group">
-          <label>${this._t("cover_lock_position")}</label>
-          <input type="number" min="0" max="100" value="${this._num(cover.lock_position, "")}" placeholder="${globalLockPos}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="lock_position">
-          ${this._hint("cover_lock_position_hint")}
-        </div>`;
-        s += `<div class="form-group">
-          <label>${this._t("cover_vent_sensor")}</label>
-          ${this._renderCoverEntitySelect("vent_sensor", cover.vent_sensor, cover.entity_id, "binary_sensor", null)}
-          ${this._hint("cover_vent_sensor_hint")}
-        </div>`;
-        const globalVentPos = this._config.settings?.vent_position ?? 30;
-        s += `<div class="form-group">
-          <label>${this._t("cover_vent_position")}</label>
-          <input type="number" min="0" max="100" value="${this._num(cover.vent_position, "")}" placeholder="${globalVentPos}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="vent_position">
-          ${this._hint("cover_vent_position_hint")}
-        </div>`;
+        // Global setpoints actually used (entity from Settings when readable)
+        const globalMin = this._effectiveThreshold(cs.comfort_temp_min_entity, cs.comfort_temp_min ?? 21);
+        const globalMax = this._effectiveThreshold(cs.comfort_temp_max_entity, cs.comfort_temp_max ?? 25);
+        const globalNote = (entity, value) => `<div class="ha-help global-note">${this._esc(this._t("cover_comfort_global")
+          .replace("{v}", value).replace("{src}", entity ? this._haEntityName(entity) : this._t("cover_comfort_src_settings")))}</div>`;
+        s += this._optBox({
+          title: this._t("settings_comfort_range_title"),
+          body: `<div class="form-group">
+            <label>${this._L("cover_indoor_temp")}</label>
+            ${this._renderCoverEntitySelect("indoor_temp_sensor", cover.indoor_temp_sensor, cover.entity_id, "sensor", "temperature")}
+            ${this._renderSensorValue(cover.indoor_temp_sensor)}
+            ${this._hint("cover_indoor_temp_hint")}
+          </div>
+          <div class="form-row">
+            <div class="form-group">
+              <label>${this._L("cover_comfort_min")}</label>
+              <input type="number" step="0.5" value="${this._num(cover.comfort_temp_min, "")}" placeholder="${globalMin}" data-action="cover-input" data-id="${cid}" data-field="comfort_temp_min">
+              ${globalNote(cs.comfort_temp_min_entity, globalMin)}
+              ${this._renderThresholdEntity(`data-action="cover-input" data-id="${cid}" data-field="comfort_temp_min_entity"`, cover.comfort_temp_min_entity, "temperature")}
+            </div>
+            <div class="form-group">
+              <label>${this._L("cover_comfort_max")}</label>
+              <input type="number" step="0.5" value="${this._num(cover.comfort_temp_max, "")}" placeholder="${globalMax}" data-action="cover-input" data-id="${cid}" data-field="comfort_temp_max">
+              ${globalNote(cs.comfort_temp_max_entity, globalMax)}
+              ${this._renderThresholdEntity(`data-action="cover-input" data-id="${cid}" data-field="comfort_temp_max_entity"`, cover.comfort_temp_max_entity, "temperature")}
+            </div>
+          </div>
+          ${this._hint("cover_comfort_hint")}`,
+        });
+        s += this._optBox({
+          title: this._t("cover_occupancy_box_title"),
+          dep: ctl("occupancy_sensor"), mode: "value",
+          head: `<div class="form-group">
+            <label>${this._t("cover_occupancy_sensor")}</label>
+            ${this._renderCoverEntitySelect("occupancy_sensor", cover.occupancy_sensor, cover.entity_id,
+              ["binary_sensor", "input_boolean", "input_select", "person", "device_tracker"], null)}
+            ${this._renderSensorValue(cover.occupancy_sensor)}
+            ${this._hint("cover_occupancy_sensor_hint")}
+          </div>`,
+          offNote: this._t("cover_occupancy_off_note"),
+          body: this._renderOccupancyStates(cover),
+        });
         return s;
-      });
-
-      // Section: Advanced
-      html += this._renderSection("advanced", this._t("cover_section_advanced"), () => {
+      }, sum.room);
+
+      // Section: Sun exposure (null = follow the global setting)
+      html += this._renderSection("sun", this._t("settings_section_comfort"), () => {
+        return `<div class="settings-hint-intro">${this._esc(this._t("cover_sun_switches_hint"))}</div>`
+          + this._sepList([
+            this._renderCoverTristate(cover, "sun_heating_ignore", "sun_heating_label", "sun_heating_hint"),
+            this._renderCoverSunComfort(cover),
+          ]);
+      }, sum.sun);
+
+      // Section: Automation (per-cover overrides of Settings › Automation)
+      html += this._renderSection("automation", this._t("cover_section_automation"), () => {
         let s = '';
-        s += this._renderToggle("cover_inverted", cover.inverted, "cover-toggle", cover.entity_id, "inverted");
-        s += this._hint("cover_inverted_hint");
-        const globalMinChange = this._config.settings?.min_position_change ?? 5;
+        const globalPause = cs.pause_duration ?? 10;
+        s += `<div class="form-group">
+          <label>${this._t("cover_pause_duration")}</label>
+          <input type="number" min="1" max="480" value="${this._num(cover.pause_duration)}" placeholder="${globalPause}" data-action="cover-input" data-id="${cid}" data-field="pause_duration">
+          <div class="ha-help">${this._esc(this._t("cover_default_note").replace("{v}", globalPause + " min"))}</div>
+          ${this._hint("cover_pause_duration_hint")}
+        </div>`;
+        s += this._renderCoverTristate(cover, "pause_resume_on_match", "pause_resume_on_match", "pause_resume_on_match_hint");
+        const globalMinChange = cs.min_position_change ?? 5;
         s += `<div class="form-group">
-          <label>${this._t("cover_min_pos_change")}</label>
-          <input type="number" min="1" max="50" value="${this._num(cover.min_position_change, "")}" placeholder="${globalMinChange}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="min_position_change">
+          <label>${this._L("cover_min_pos_change")}</label>
+          <input type="number" min="1" max="50" value="${this._num(cover.min_position_change, "")}" placeholder="${globalMinChange}" data-action="cover-input" data-id="${cid}" data-field="min_position_change">
+          <div class="ha-help">${this._esc(this._t("cover_default_note").replace("{v}", globalMinChange + " %"))}</div>
           ${this._hint("cover_min_pos_change_hint")}
         </div>`;
-        const globalMinTime = this._config.settings?.min_time_between_changes ?? 300;
+        const globalMinTime = cs.min_time_between_changes ?? 300;
         s += `<div class="form-group">
-          <label>${this._t("cover_min_time")}</label>
-          <input type="number" min="60" max="3600" value="${this._num(cover.min_time_between_changes, "")}" placeholder="${globalMinTime}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="min_time_between_changes">
+          <label>${this._L("cover_min_time")}</label>
+          <input type="number" min="60" max="3600" value="${this._num(cover.min_time_between_changes, "")}" placeholder="${globalMinTime}" data-action="cover-input" data-id="${cid}" data-field="min_time_between_changes">
+          <div class="ha-help">${this._esc(this._t("cover_default_note").replace("{v}", globalMinTime + " s"))}</div>
           ${this._hint("cover_min_time_hint")}
         </div>`;
-        return s;
-      });
-
-      // Section: Tilt (only if supports_tilt)
-      if (cover.supports_tilt) {
-        html += this._renderSection("tilt", this._t("cover_section_tilt"), () => {
-          let s = '';
-          s += this._renderToggle("cover_inverted_tilt", cover.inverted_tilt, "cover-toggle", cover.entity_id, "inverted_tilt");
-          s += `<div class="form-group">
-            <label>${this._t("cover_lock_tilt")}</label>
-            <input type="number" min="0" max="100" value="${this._num(cover.lock_tilt_position, "")}" placeholder="${this._t("none")}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="lock_tilt_position">
-          </div>`;
-          s += `<div class="form-group">
-            <label>${this._t("cover_vent_tilt")}</label>
-            <input type="number" min="0" max="100" value="${this._num(cover.vent_tilt_position, "")}" placeholder="${this._t("none")}" data-action="cover-input" data-id="${this._esc(cover.entity_id)}" data-field="vent_tilt_position">
-          </div>`;
-          return s;
-        });
-      }
+        const { measured, placeholder: travelPlaceholder, usedTxt, fmtS } = this._travelInfo(cover);
+        s += `<div class="form-group">
+          <label>${this._t("cover_travel_time")}</label>
+          <input type="number" min="1" max="300" value="${this._num(cover.travel_time, "")}" placeholder="${this._esc(travelPlaceholder)}" data-action="cover-input" data-id="${cid}" data-field="travel_time">
+          <div class="ha-help">${measured != null
+            ? `${this._esc(this._t("cover_travel_measured").replace("{s}", fmtS(measured)))}
+               <button type="button" class="btn-link" data-action="cover-travel-reset" data-id="${cid}">${this._t("cover_travel_reset")}</button>`
+            : this._esc(this._t("cover_travel_not_measured"))}</div>
+          <div class="ha-help" data-travel-used="${cid}">${this._esc(usedTxt)}</div>
+          ${this._hint("cover_travel_time_hint")}
+        </div>`;
+        return `<div class="sep-list">${s}</div>`;
+      }, sum.automation);
 
+      html += `<div class="slide-log-link">
+        <button class="btn btn-secondary btn-sm" data-action="cover-show-log" data-id="${this._esc(cover.entity_id)}">${this._t("cover_show_log")}</button>
+      </div>`;
+      html += `<div class="slide-close-bottom">
+        <button class="btn btn-secondary" data-action="close-slide">${this._t("close")}</button>
+      </div>`;
       html += `<div class="slide-delete-wrap">
         <button class="btn btn-danger" data-action="cover-delete" data-id="${this._esc(cover.entity_id)}">${this._t("cover_remove")}</button>
       </div>`;
@@ -3051,15 +5339,17 @@ class CoverAutomaticPanel extends HTMLElement {
     return html;
   }
 
-  _renderSection(id, title, contentFn) {
+  _renderSection(id, title, contentFn, summary = "") {
     const expanded = this._expandedSections[id];
     const arrowClass = expanded ? "arrow expanded" : "arrow";
-    const iconMap = { base: "info", sensors: "gauge", advanced: "sliders", tilt: "move_vertical" };
+    const iconMap = { base: "info", window: "app_window", automation: "cog", room: "house", sun: "sun",
+      sensors: "gauge", advanced: "sliders", tilt: "move_vertical" };
     const iconName = iconMap[id];
     const icon = iconName ? `<span class="section-icon">${this._lucideIcon(iconName, 16)}</span>` : "";
     return `<div class="section">
-      <div class="section-header" data-action="toggle-section" data-section="${id}">
-        ${icon}<span class="section-title">${this._esc(title)}</span>
+      <div class="section-header" data-action="toggle-section" data-section="${id}" tabindex="0" role="button" aria-expanded="${expanded ? "true" : "false"}">
+        ${icon}<span class="section-title">${this._esc(title)}${summary && !expanded
+          ? `<span class="section-summary">${this._esc(summary)}</span>` : ""}</span>
         <span class="${arrowClass}">&#9654;</span>
       </div>
       <div class="section-body${expanded ? " expanded" : ""}">
@@ -3068,33 +5358,498 @@ class CoverAutomaticPanel extends HTMLElement {
     </div>`;
   }
 
-  _renderToggle(labelKey, checked, action, id, field) {
-    return `<div class="toggle-row">
-      <span>${this._t(labelKey)}</span>
-      <label class="toggle">
-        <input type="checkbox" ${checked ? "checked" : ""} data-action="${action}" data-id="${this._esc(id)}" data-field="${field}">
-        <span class="toggle-slider"></span>
-      </label>
+  // Framed group of options. With `dep` (CSS selector of the controlling
+  // input) the body is greyed out and its inputs disabled while the control
+  // is off; values are kept and still saved. Modes: "checked", "unchecked",
+  // "value" (non-empty), "tristate" ("" = follow `global`).
+  _optBox({ dep = null, mode = "checked", global = null, title = "", head = "", body = "", offNote = "", cls = "", value = null, force = false } = {}) {
+    const depAttrs = dep
+      ? ` data-dep="${this._esc(dep)}" data-dep-mode="${mode}"${global == null ? "" : ` data-dep-global="${global ? "1" : "0"}"`}`
+        + (value == null ? "" : ` data-dep-value="${this._esc(value)}"`) + (force ? ` data-dep-force="1"` : "")
+      : "";
+    return `<div class="opt-box${cls ? " " + cls : ""}"${depAttrs}>
+      ${title ? `<div class="opt-box-title">${this._esc(title)}</div>` : ""}
+      ${head}
+      ${offNote ? `<div class="opt-box-offnote">${this._esc(offNote)}</div>` : ""}
+      <div class="opt-box-body">${body}</div>
     </div>`;
   }
 
-  _renderFacadeDropdown(cover) {
-    const facades = this._config.facades || {};
-    let html = `<div class="form-group"><label>${this._t("cover_facade")}</label><select data-action="cover-select" data-id="${this._esc(cover.entity_id)}" data-field="facade_id">`;
-    html += `<option value="">${this._t("none")}</option>`;
-    for (const f of Object.values(facades)) {
-      const sel = cover.facade_id === f.id ? " selected" : "";
-      html += `<option value="${this._esc(f.id)}"${sel}>${this._esc(f.name)}</option>`;
-    }
-    html += '</select></div>';
-    return html;
+  // Apply the enabled/greyed state of every dependent option box.
+  _refreshDeps() {
+    const root = this.shadowRoot;
+    if (!root) return;
+    this._refreshSunExplain();
+    this._refreshHystExplains();
+    this._refreshEntityDriven();
+    root.querySelectorAll(".opt-box[data-dep]").forEach(box => {
+      let ctl = null;
+      try { ctl = root.querySelector(box.dataset.dep); } catch (e) { ctl = null; }
+      let on = !!ctl && !ctl.disabled;
+      if (on) {
+        const mode = box.dataset.depMode || "checked";
+        if (mode === "checked") on = !!ctl.checked;
+        else if (mode === "unchecked") on = !ctl.checked;
+        else if (mode === "value") on = String(ctl.value || "").trim() !== "";
+        else if (mode === "tristate") on = ctl.value === "" ? box.dataset.depGlobal === "1" : ctl.value === "true";
+        else if (mode === "equals") on = ctl.value === box.dataset.depValue;
+      }
+      if (box.dataset.depForce === "1") on = true;
+      box.classList.toggle("opt-off", !on);
+      const body = box.querySelector(":scope > .opt-box-body");
+      if (!body) return;
+      body.querySelectorAll("input, select, textarea, button").forEach(el => {
+        if (!on) {
+          if (!el.disabled) { el.disabled = true; el.dataset.depDisabled = "1"; }
+        } else if (el.dataset.depDisabled) {
+          el.disabled = false;
+          delete el.dataset.depDisabled;
+        }
+      });
+    });
   }
 
-  /* ============================================================
-   * TAB: Facades
-   * ============================================================ */
-  _renderFacades() {
-    const facades = this._config.facades || {};
+  // "How does it work?" table of the Sun on facade card. Rows matching the
+  // current (draft) choices are highlighted by _refreshSunExplain.
+  // A threshold driven by an entity: the number field is replaced by a greyed
+  // box with the entity's value; the number stays stored as the fallback used
+  // while the entity is unavailable.
+  _refreshEntityDriven() {
+    const root = this.shadowRoot;
+    if (!root) return;
+    root.querySelectorAll("[data-threshold-entity]").forEach(sel => {
+      const group = sel.closest(".form-group");
+      const num = group ? group.querySelector(':scope > input[type="number"]') : null;
+      if (!num) return;
+      let shadow = num.nextElementSibling;
+      if (!shadow || !shadow.classList.contains("entity-shadow")) {
+        shadow = document.createElement("div");
+        shadow.className = "entity-shadow";
+        num.insertAdjacentElement("afterend", shadow);
+      }
+      const entity = sel.value;
+      num.classList.toggle("entity-driven", !!entity);
+      shadow.hidden = !entity;
+      group.querySelectorAll(":scope > .global-note").forEach(n => { n.hidden = !!entity; });
+      if (!entity) return;
+      const st = this._hass && this._hass.states ? this._hass.states[entity] : null;
+      const v = st ? parseFloat(st.state) : NaN;
+      const unit = st && st.attributes.unit_of_measurement ? " " + st.attributes.unit_of_measurement : "";
+      const fallback = num.value !== "" ? num.value : num.placeholder;
+      const html = `<div class="entity-shadow-value">${this._esc(Number.isFinite(v) ? String(v) + unit : "—")}</div>`
+        + (fallback !== "" && fallback != null
+          ? `<div class="entity-shadow-note">${this._esc(this._t("threshold_fallback").replace("{v}", fallback))}</div>` : "");
+      if (shadow.dataset.sig !== html) { shadow.innerHTML = html; shadow.dataset.sig = html; }
+    });
+  }
+
+  // "How does it work?" blocks of the hysteresis settings. The table is
+  // computed from the values currently in the form (draft included) and
+  // refreshed on every input by _refreshHystExplains.
+  _renderHystExplain(kind) {
+    const open = this._explainOpen && this._explainOpen[kind];
+    const body = this._hystBody(kind, this._hystValues(kind));
+    return `<details class="sun-explain" data-hyst="${kind}"${open ? " open" : ""}>
+      <summary data-action="explain-toggle" data-key="${kind}">${this._esc(this._t("hyst_title_" + kind))}</summary>
+      <div class="sun-explain-body" data-hyst-body>${body}</div>
+    </details>`;
+  }
+
+  _refreshHystExplains() {
+    const root = this.shadowRoot;
+    if (!root) return;
+    root.querySelectorAll("details[data-hyst]").forEach(d => {
+      const body = d.querySelector("[data-hyst-body]");
+      if (!body) return;
+      const html = this._hystBody(d.dataset.hyst, this._hystValues(d.dataset.hyst));
+      if (body.dataset.sig !== html) { body.innerHTML = html; body.dataset.sig = html; }
+    });
+  }
+
+  _hystValues(kind) {
+    const s = (this._config && this._config.settings) || {};
+    const root = this.shadowRoot;
+    const field = (name) => root ? root.querySelector(`[data-settings-field="${name}"]`) : null;
+    const str = (name) => { const el = field(name); return el ? el.value : (s[name] || ""); };
+    const num = (name, def) => { const v = parseFloat(str(name)); return Number.isFinite(v) ? v : def; };
+    const unitOf = (id) => {
+      const st = id && this._hass && this._hass.states ? this._hass.states[id] : null;
+      return (st && st.attributes.unit_of_measurement) || "";
+    };
+    if (kind === "comfort") {
+      return {
+        a: this._effectiveThreshold(str("comfort_temp_min_entity"), num("comfort_temp_min", 21)),
+        b: this._effectiveThreshold(str("comfort_temp_max_entity"), num("comfort_temp_max", 25)),
+        h: num("comfort_hysteresis", 1),
+      };
+    }
+    if (kind === "rules") {
+      // Real example taken from the rules when one uses the condition
+      const h = num("threshold_hysteresis", 0.5);
+      const rules = Object.values((this._config && this._config.rules) || {})
+        .sort((x, y) => (y.enabled !== false) - (x.enabled !== false));
+      for (const r of rules) {
+        for (const c of r.conditions || []) {
+          if (c.type !== "temperature_above" && c.type !== "temperature_below") continue;
+          const p = c.params || {};
+          const t = parseFloat(p.temperature != null ? p.temperature : p.value);
+          if (Number.isFinite(t)) return { t, h, above: c.type === "temperature_above", rule: r.name || r.id };
+        }
+      }
+      return { t: 18, h, above: true, rule: null };
+    }
+    if (kind === "solar") {
+      const t = this._effectiveThreshold(str("solar_threshold_entity"), num("solar_threshold", 0));
+      const h = num("solar_hysteresis", 0), u = unitOf(str("solar_sensor"));
+      return t > 0 ? { t, h, u, ex: false } : { t: 30000, h: h || 5000, u: u || "lx", ex: true };
+    }
+    const t = num("wind_speed_threshold", 0), u = unitOf(str("wind_sensor"));
+    let h = num("wind_speed_hysteresis", 0);
+    if (t > 0) { if (h >= t) h = 0; return { t, h, u, ex: false }; }
+    return { t: 50, h: h > 0 && h < 50 ? h : 10, u: u || "km/h", ex: true };
+  }
+
+  _hystBody(kind, v) {
+    const lang = (this._hass && this._hass.language) || "en";
+    const fmt = (x) => {
+      const r = String(Math.round(x * 100) / 100);
+      return /^(fr|de)/.test(lang) ? r.replace(".", ",") : r;
+    };
+    const fu = (x, u) => fmt(x) + (u ? " " + u : "");
+    const tr = (key, map) => {
+      let out = this._t(key);
+      for (const [k, val] of Object.entries(map || {})) out = out.split("{" + k + "}").join(val);
+      return out;
+    };
+    const between = (a, b, u) => tr("hyst_between", { a: fmt(a), b: fmt(b) }) + (u ? " " + u : "");
+    const table = (cols, rows) => `<table class="sun-explain-table">
+        <thead><tr>${cols.map(c => `<th>${this._esc(this._t(c))}</th>`).join("")}</tr></thead>
+        <tbody>${rows.map(r => `<tr><td>${this._esc(r[0])}</td><td>${this._esc(r[1])}</td></tr>`).join("")}</tbody>
+      </table>`;
+    const so = (lines) => `<div class="sun-explain-so"><b>${this._esc(this._t("sun_explain_so"))}</b>
+        <ul>${lines.map(l => `<li>${this._esc(l)}</li>`).join("")}</ul></div>`;
+    const intro = (key, map) => `<div class="settings-hint">${this._esc(tr(key, map))}</div>`;
+    const w = this._t("hyst_with_values");
+    if (kind === "comfort") {
+      const { a, b, h } = v, ah = a + h, bh = b - h, deg = "°C";
+      const rows = [[this._t("sun_below").replace("{t}", fmt(a)), this._t("hyst_cold")]];
+      if (h > 0) rows.push([between(a, ah, deg), this._t("hyst_stay_cold")]);
+      if (ah < bh) rows.push([between(ah, bh, deg), this._t("hyst_comfortable")]);
+      if (h > 0) rows.push([between(bh, b, deg), this._t("hyst_stay_hot")]);
+      rows.push([this._t("sun_above").replace("{t}", fmt(b)), this._t("hyst_hot")]);
+      const m = { a: fmt(a), b: fmt(b), ah: fmt(ah), bh: fmt(bh), mid: fmt(a + h / 2), h: fmt(h), w };
+      return intro("hyst_comfort_intro", m) + table(["hyst_col_room_temp", "hyst_col_state"], rows)
+        + so([tr("hyst_comfort_so1", m), tr("hyst_comfort_so2", m), tr("hyst_comfort_so3", m), tr("hyst_comfort_so4", m)]);
+    }
+    if (kind === "rules" || kind === "solar") {
+      const { t, h } = v, u = kind === "rules" ? "°C" : v.u;
+      const yes = this._t(kind === "rules" ? "hyst_true" : "hyst_strong_yes");
+      const no = this._t(kind === "rules" ? "hyst_false" : "hyst_strong_no");
+      const rows = h > 0
+        ? [[tr("hyst_above", { a: fu(t + h, u) }), yes], [between(t - h, t + h, u), this._t("hyst_keep")], [tr("hyst_below", { a: fu(t - h, u) }), no]]
+        : [[tr("hyst_above", { a: fu(t, u) }), yes], [tr("hyst_below", { a: fu(t, u) }), no]];
+      const m = { t: kind === "rules" ? fmt(t) : fu(t, u), h: kind === "rules" ? fmt(h) : fu(h, u),
+        th: kind === "rules" ? fmt(t + h) : fu(t + h, u), tl: kind === "rules" ? fmt(t - h) : fu(t - h, u),
+        w: v.ex ? this._t("hyst_example") : w };
+      if (kind === "rules") {
+        const sfx = v.above ? "" : "_below";
+        const rrows = v.above ? rows : rows.slice().reverse().map((r, i, arr) => [r[0], arr[arr.length - 1 - i][1]]);
+        m.rule = v.rule || "";
+        m.op = this._t(v.above ? "hyst_op_above" : "hyst_op_below");
+        const lines = h > 0
+          ? [tr("hyst_rules_so1" + sfx, m), tr("hyst_rules_so2" + sfx, m), tr("hyst_rules_so3" + sfx, m)]
+          : [this._t("hyst_zero")];
+        return `<div class="settings-hint" style="margin-bottom:6px"><b>${this._esc(this._t("hyst_rules_scope"))}</b></div>`
+          + intro(v.rule ? "hyst_rules_intro_real" : "hyst_rules_intro", m)
+          + table(["hyst_col_temp", "hyst_col_condition"], rrows) + so(lines);
+      }
+      const lines = h > 0 ? [tr("hyst_solar_so1", m), tr("hyst_solar_so2", m)] : [this._t("hyst_zero"), tr("hyst_solar_so2", m)];
+      return intro("hyst_solar_intro", m) + table(["hyst_col_sensor", "hyst_col_strong"], rows) + so(lines);
+    }
+    // wind
+    const { t, h, u } = v, tl = t - h;
+    const rows = [["≥ " + fu(t, u), this._t("hyst_wind_on")]];
+    if (h > 0) rows.push([between(tl, t, u), this._t("hyst_wind_stay")]);
+    rows.push([(h > 0 ? "≤ " + fu(tl, u) : "< " + fu(t, u)), this._t("hyst_wind_off")]);
+    const m = { t: fu(t, u), h: fu(h, u), tl: fu(tl, u), w: v.ex ? this._t("hyst_example") : w };
+    const lines = h > 0 ? [tr("hyst_wind_so1", m), tr("hyst_wind_so2", m)] : [this._t("hyst_zero")];
+    return intro("hyst_wind_intro", m) + table(["hyst_col_wind", "hyst_col_protection"], rows) + so(lines);
+  }
+
+  // Numeric state of a threshold entity when readable, else the static value
+  _effectiveThreshold(entityId, fallback) {
+    const st = entityId && this._hass?.states ? this._hass.states[entityId] : null;
+    const v = st ? parseFloat(st.state) : NaN;
+    return Number.isFinite(v) ? Math.round(v * 10) / 10 : fallback;
+  }
+
+  _renderSunExplain(cmin, cmax) {
+    const t = (k) => this._esc(this._t(k));
+    const sun = t("sun_explain_sun"), noSun = t("sun_explain_no_sun");
+    const rows = [
+      ["cold-on", "sun_explain_room_cold_on", noSun, "sun_explain_eff_warm", this._t("sun_below").replace("{t}", cmin)],
+      ["cold-off", "sun_explain_room_cold_off", sun, "sun_explain_eff_close", this._t("sun_below").replace("{t}", cmin)],
+      ["position", "sun_explain_room_position", sun, "sun_explain_eff_close_as_hot", this._t("sun_between").replace("{min}", cmin).replace("{max}", cmax)],
+      ["ignore", "sun_explain_room_ignore", noSun, "sun_explain_eff_wait", this._t("sun_between").replace("{min}", cmin).replace("{max}", cmax)],
+      ["preemptive", "sun_explain_room_preemptive", t("sun_explain_sun_if_strong"), "sun_explain_eff_strong", this._t("sun_between").replace("{min}", cmin).replace("{max}", cmax)],
+      ["hot", "sun_explain_room_hot", t("sun_explain_sun_always"), "sun_explain_eff_close", this._t("sun_above").replace("{t}", cmax)],
+    ];
+    return `<details class="sun-explain"${this._sunExplainOpen ? " open" : ""}>
+      <summary data-action="sun-explain-toggle">${t("sun_explain_title")}</summary>
+      <div class="sun-explain-body">
+        <div class="settings-hint">${t("sun_explain_intro")}</div>
+        <table class="sun-explain-table">
+          <thead><tr><th>${t("sun_explain_col_room")}</th><th>${t("sun_explain_col_answer")}</th><th>${t("sun_explain_col_effect")}</th></tr></thead>
+          <tbody>${rows.map(([id, room, answer, eff, range]) => `<tr data-sun-row="${id}">
+            <td>${t(room)}<br><span class="radio-hint">${this._esc(range)}</span></td><td>${answer}</td><td>${t(eff)}</td></tr>`).join("")}</tbody>
+        </table>
+        <div class="sun-explain-so"><b>${t("sun_explain_so")}</b>
+          <ul><li>${t("sun_explain_cold")}</li><li>${t("sun_explain_hot")}</li><li>${t("sun_explain_comfort")}</li></ul>
+        </div>
+      </div>
+    </details>`;
+  }
+
+  _refreshSunExplain() {
+    const root = this.shadowRoot;
+    const table = root && root.querySelector(".sun-explain-table");
+    if (!table) return;
+    const heat = root.querySelector('[data-settings-field="sun_heating_ignore"]');
+    const mode = root.querySelector('[data-settings-field="sun_comfort_mode"]');
+    const on = new Set(["hot", heat && heat.checked ? "cold-on" : "cold-off", mode ? mode.value : ""]);
+    table.querySelectorAll("tr[data-sun-row]").forEach(tr => tr.classList.toggle("current", on.has(tr.dataset.sunRow)));
+  }
+
+  // Behaviour of "Sun on facade" while the room is in its comfort range,
+  // stored as two flags: position (no ignore) / ignore / ignore unless
+  // strong solar radiation (preemptive shading).
+  _sunComfortMode(neutralIgnore, preemptive) {
+    if (!neutralIgnore) return "position";
+    return preemptive ? "preemptive" : "ignore";
+  }
+
+  _sunComfortFlags(mode) {
+    return {
+      sun_neutral_ignore: mode !== "position",
+      preemptive_shading: mode === "preemptive",
+    };
+  }
+
+  // Covers whose effective setting uses the sunshine sensor
+  _coversUsingRadiation() {
+    const s = this._config.settings || {};
+    const gNeutral = s.sun_neutral_ignore !== false, gPre = s.preemptive_shading !== false;
+    return Object.values(this._config.covers || {}).filter(c => {
+      if (!(c.indoor_temp_sensor || s.indoor_temp_sensor)) return false;
+      const n = c.sun_neutral_ignore ?? gNeutral, p = c.preemptive_shading ?? gPre;
+      return n && p;
+    }).length;
+  }
+
+  // Per-cover select: Global (follow settings) or one of the three modes
+  // States meaning "occupied" when the cover sets none (mirror of the engine)
+  static get OCCUPIED_DEFAULTS() {
+    return ["on", "home", "present", "présent", "occupied", "occupé", "detected", "true", "1"];
+  }
+
+  // Occupied states of a cover: its own list, else the defaults (null)
+  _occupancyOwnStates(cover) {
+    // An edit not confirmed by the server yet is shown over the stored value
+    const pend = this._occPending;
+    const raw = pend && cover.entity_id in pend ? pend[cover.entity_id] : cover.occupancy_states;
+    return raw && String(raw).trim() ? String(raw).split(",").map(x => x.trim()).filter(Boolean) : null;
+  }
+
+  // State buttons like the rule editor: the sensor's possible states, the
+  // selected ones meaning "occupied".
+  _renderOccupancyStates(cover) {
+    const cid = this._esc(cover.entity_id);
+    const stateObj = cover.occupancy_sensor && this._hass?.states ? this._hass.states[cover.occupancy_sensor] : null;
+    const own = this._occupancyOwnStates(cover);
+    const defaults = CoverAutomaticPanel.OCCUPIED_DEFAULTS;
+    const known = this._haKnownStates(stateObj, null);
+    (own || []).forEach(v => { if (!known.some(k => k.toLowerCase() === v.toLowerCase())) known.push(v); });
+    const isSel = (v) => own
+      ? own.some(o => o.toLowerCase() === v.toLowerCase())
+      : defaults.includes(v.toLowerCase());
+    let html = `<div class="form-group"><label>${this._t("cover_occupancy_states")}</label><div class="day-select">`;
+    for (const v of known) {
+      html += `<button type="button" class="day-btn${isSel(v) ? " selected" : ""}" data-action="cover-occ-toggle" data-id="${cid}" data-val="${this._esc(v)}" title="${this._esc(v)}">${this._esc(this._haStateLabel(stateObj, null, v))}</button>`;
+    }
+    html += `</div>`;
+    if (!own) html += `<div class="ha-help">${this._esc(this._t("cover_occupancy_default_note"))}</div>`;
+    html += `<div class="ha-add-state"><input type="text" placeholder="${this._esc(this._t("ha_state_other"))}" data-occ-other="${cid}">
+        <button type="button" class="btn btn-secondary" data-action="cover-occ-add" data-id="${cid}">${this._t("ha_state_add")}</button></div>
+      ${own ? `<div class="ha-help"><button type="button" class="btn-link" data-action="cover-occ-reset" data-id="${cid}">${this._t("cover_occupancy_reset")}</button></div>` : ""}
+      ${this._hint("cover_occupancy_states_hint")}</div>`;
+    return html;
+  }
+
+  _onOccupancyStates(entityId, update) {
+    const cover = (this._config.covers || {})[entityId];
+    if (!cover) return;
+    const stateObj = cover.occupancy_sensor && this._hass?.states ? this._hass.states[cover.occupancy_sensor] : null;
+    // Start from what is shown selected (explicit list, else the matching defaults)
+    let list = this._occupancyOwnStates(cover)
+      || this._haKnownStates(stateObj, null).filter(v => CoverAutomaticPanel.OCCUPIED_DEFAULTS.includes(v.toLowerCase()));
+    list = update(list);
+    const value = list && list.length ? list.join(", ") : null;
+    // Not written into the config before the server confirms: shown through
+    // _occPending, dropped (stored value shown again) if the save fails.
+    if (!this._occPending) this._occPending = {};
+    this._occPending[entityId] = value;
+    this._render();
+    this._debouncedCoverSave(entityId, "occupancy_states", value, {
+      onSettled: (ok) => {
+        if (!this._occPending || this._occPending[entityId] !== value) return; // newer edit pending
+        delete this._occPending[entityId];
+        if (!ok) this._render();
+      },
+    });
+  }
+
+  // Items separated by a thin line (content without framed boxes)
+  _sepList(items) {
+    return `<div class="sep-list">${items.filter(Boolean).map(h => `<div class="sep-item">${h}</div>`).join("")}</div>`;
+  }
+
+  // One-line summaries shown under collapsed section titles of the cover sheet
+  _coverSectionSummaries(cover) {
+    const s = this._config.settings || {};
+    const sep = " · ";
+    const facade = cover.facade_id && this._config.facades ? this._config.facades[cover.facade_id] : null;
+    const base = [
+      this._t(cover.auto_enabled === false ? "cover_sum_auto_off" : "cover_sum_auto_on"),
+      facade ? facade.name : this._t("cover_sum_no_facade"),
+    ];
+    if (cover.inverted) base.push(this._t("cover_inverted"));
+
+    const win = [];
+    if (cover.lock_sensor) {
+      win.push(this._t("cover_sum_open").replace("{v}", cover.lock_hold_position
+        ? this._t("cover_sum_hold")
+        : (cover.lock_position ?? s.lock_position ?? 100) + " %"));
+    }
+    if (cover.vent_sensor) {
+      win.push(this._t("cover_sum_tilted").replace("{v}", (cover.vent_position ?? s.vent_position ?? 30) + " %"));
+    }
+
+    const auto = [this._t("cover_sum_pause").replace("{n}", cover.pause_duration ?? s.pause_duration ?? 10)];
+    const travel = [cover.travel_time, cover.measured_travel_time, s.default_travel_time]
+      .find(v => typeof v === "number" && v > 0);
+    if (travel) auto.push(this._t("cover_sum_travel").replace("{n}", Math.round(travel)));
+    const own = ["pause_duration", "min_position_change", "min_time_between_changes", "travel_time"]
+      .filter(k => cover[k] != null).length;
+    auto.push(own ? this._t("cover_sum_own").replace("{n}", own) : this._t("cover_sum_all_global"));
+
+    const room = [];
+    const indoor = cover.indoor_temp_sensor || s.indoor_temp_sensor;
+    room.push(indoor
+      ? this._haEntityName(indoor) + (cover.indoor_temp_sensor ? "" : " (" + this._t("cover_sum_global") + ")")
+      : this._t("cover_sum_no_indoor"));
+    const cmin = this._effectiveThreshold(cover.comfort_temp_min_entity || s.comfort_temp_min_entity,
+      cover.comfort_temp_min ?? s.comfort_temp_min ?? 21);
+    const cmax = this._effectiveThreshold(cover.comfort_temp_max_entity || s.comfort_temp_max_entity,
+      cover.comfort_temp_max ?? s.comfort_temp_max ?? 25);
+    room.push(cmin + " / " + cmax + " °C");
+    if (cover.occupancy_sensor) room.push(this._haEntityName(cover.occupancy_sensor));
+
+    const heat = cover.sun_heating_ignore ?? (s.sun_heating_ignore !== false);
+    const mode = this._sunComfortMode(
+      cover.sun_neutral_ignore ?? (s.sun_neutral_ignore !== false),
+      cover.preemptive_shading ?? (s.preemptive_shading !== false));
+    const followsGlobal = cover.sun_heating_ignore == null && cover.sun_neutral_ignore == null && cover.preemptive_shading == null;
+    const sun = [
+      this._t(heat ? "cover_sum_sun_heat_on" : "cover_sum_sun_heat_off"),
+      this._t("cover_sum_sun_between").replace("{v}", this._t("cover_sum_mode_" + mode)),
+    ];
+    if (followsGlobal) sun.push(this._t("cover_sum_global"));
+
+    return {
+      base: base.join(sep),
+      window: win.length ? win.join(sep) : this._t("cover_sum_no_window"),
+      automation: auto.join(sep),
+      room: room.join(sep),
+      sun: sun.join(sep),
+    };
+  }
+
+  _renderCoverSunComfort(cover) {
+    const s = this._config.settings || {};
+    const gMode = this._sunComfortMode(s.sun_neutral_ignore !== false, s.preemptive_shading !== false);
+    const own = (cover.sun_neutral_ignore == null && cover.preemptive_shading == null)
+      ? ""
+      : this._sunComfortMode(
+        cover.sun_neutral_ignore ?? (s.sun_neutral_ignore !== false),
+        cover.preemptive_shading ?? (s.preemptive_shading !== false));
+    const opt = (value, label) => `<option value="${value}"${own === value ? " selected" : ""}>${this._esc(label)}</option>`;
+    return `<div class="form-group">
+      <label>${this._L("sun_comfort_label")}</label>
+      <select data-action="cover-sun-comfort" data-id="${this._esc(cover.entity_id)}" data-field="sun_comfort_mode">
+        ${opt("", this._t("tristate_global").replace("{value}", this._t("sun_comfort_" + gMode)))}
+        ${opt("position", this._t("sun_comfort_position"))}
+        ${opt("ignore", this._t("sun_comfort_ignore"))}
+        ${opt("preemptive", this._t("sun_comfort_preemptive"))}
+      </select>
+      ${this._hint("sun_comfort_hint")}
+    </div>`;
+  }
+
+  // Select "Global (value) / On / Off" for a nullable per-cover flag
+  _renderCoverTristate(cover, field, labelKey, hintKey) {
+    const own = cover[field];
+    const globalOn = (this._config.settings || {})[field] !== false;
+    const onOff = (on) => this._t(on ? "tristate_on" : "tristate_off");
+    const opt = (value, label, selected) =>
+      `<option value="${value}"${selected ? " selected" : ""}>${this._esc(label)}</option>`;
+    return `<div class="form-group">
+      <label>${this._L(labelKey)}</label>
+      <select data-action="cover-tristate" data-id="${this._esc(cover.entity_id)}" data-field="${field}">
+        ${opt("", this._t("tristate_global").replace("{value}", onOff(globalOn)), own == null)}
+        ${opt("true", onOff(true), own === true)}
+        ${opt("false", onOff(false), own === false)}
+      </select>
+      ${this._hint(hintKey)}
+    </div>`;
+  }
+
+  // Label with a shorter variant shown on narrow screens (key + "_short")
+  _L(key) {
+    const lang = (this._hass?.language) || "en";
+    const dict = I18N[lang] || I18N.en;
+    const sk = key + "_short";
+    const long = this._esc(this._t(key));
+    if (dict[sk] === undefined && I18N.en[sk] === undefined) return long;
+    return `<span class="lbl-long">${long}</span><span class="lbl-short">${this._esc(this._t(sk))}</span>`;
+  }
+
+  _renderToggle(labelKey, checked, action, id, field, hintKey = null) {
+    return `<div class="toggle-row">
+      <span class="toggle-label">${this._L(labelKey)}${hintKey ? this._hint(hintKey) : ""}</span>
+      <label class="toggle">
+        <input type="checkbox" ${checked ? "checked" : ""} data-action="${action}" data-id="${this._esc(id)}" data-field="${field}">
+        <span class="toggle-slider"></span>
+      </label>
+    </div>`;
+  }
+
+  _renderFacadeDropdown(cover) {
+    const facades = this._config.facades || {};
+    let html = `<div class="form-group"><label>${this._t("cover_facade")}</label><select data-action="cover-select" data-id="${this._esc(cover.entity_id)}" data-field="facade_id">`;
+    html += `<option value="">${this._t("none")}</option>`;
+    for (const f of Object.values(facades)) {
+      const sel = cover.facade_id === f.id ? " selected" : "";
+      html += `<option value="${this._esc(f.id)}"${sel}>${this._esc(f.name)}</option>`;
+    }
+    html += '</select></div>';
+    return html;
+  }
+
+  /* ============================================================
+   * TAB: Facades
+   * ============================================================ */
+  _renderFacades() {
+    const facades = this._config.facades || {};
     const entries = Object.values(facades).sort((a, b) => (a.azimuth_start ?? 0) - (b.azimuth_start ?? 0));
 
     let html = '<div class="card-grid">';
@@ -3134,11 +5889,11 @@ class CoverAutomaticPanel extends HTMLElement {
       </div>
       <div class="card-body">
         <div class="facade-meta-row">
-          <span>${this._t("facade_azimuth_start")}: ${f.azimuth_start}&#176;</span>
-          <span>${this._t("facade_azimuth_end")}: ${f.azimuth_end}&#176;</span>
+          <span>${this._t("facade_azimuth_start")}${this._colon()}${f.azimuth_start}&#176;</span>
+          <span>${this._t("facade_azimuth_end")}${this._colon()}${f.azimuth_end}&#176;</span>
         </div>
         <div class="facade-covers-intro">
-          ${this._t("facade_min_elevation")}: ${f.min_elevation}&#176;
+          ${this._t("facade_min_elevation")}${this._colon()}${f.min_elevation}&#176;
         </div>
         <div class="facade-covers-list-wrap">
           <div class="facade-covers-label">${this._t("facade_covers")}</div>
@@ -3178,11 +5933,11 @@ class CoverAutomaticPanel extends HTMLElement {
       <div class="form-row">
         <div class="form-group">
           <label>${this._t("facade_azimuth_start")}</label>
-          <input type="number" min="0" max="360" step="0.1" value="${this._num(f.azimuth_start)}" data-facade-field="azimuth_start">
+          <input type="number" step="any" value="${this._num(f.azimuth_start)}" data-facade-field="azimuth_start">
         </div>
         <div class="form-group">
           <label>${this._t("facade_azimuth_end")}</label>
-          <input type="number" min="0" max="360" step="0.1" value="${this._num(f.azimuth_end)}" data-facade-field="azimuth_end">
+          <input type="number" step="any" value="${this._num(f.azimuth_end)}" data-facade-field="azimuth_end">
         </div>
       </div>
       ${this._hint("facade_azimuth_hint")}
@@ -3227,11 +5982,11 @@ class CoverAutomaticPanel extends HTMLElement {
       <div class="form-row">
         <div class="form-group">
           <label>${this._t("facade_azimuth_start")}</label>
-          <input type="number" min="0" max="360" step="0.1" value="135" data-facade-field="azimuth_start">
+          <input type="number" step="any" value="135" data-facade-field="azimuth_start">
         </div>
         <div class="form-group">
           <label>${this._t("facade_azimuth_end")}</label>
-          <input type="number" min="0" max="360" step="0.1" value="225" data-facade-field="azimuth_end">
+          <input type="number" step="any" value="225" data-facade-field="azimuth_end">
         </div>
       </div>
       ${this._hint("facade_azimuth_hint")}
@@ -3262,7 +6017,7 @@ class CoverAutomaticPanel extends HTMLElement {
    * ============================================================ */
   _renderRules() {
     const rules = this._config.rules || {};
-    const sorted = Object.values(rules).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    const sorted = this._rulesByPriority(rules);
 
     let html = `<div class="rule-reorder-hint">${this._t("rule_reorder_hint")}</div>`;
 
@@ -3282,24 +6037,49 @@ class CoverAutomaticPanel extends HTMLElement {
 
       const activeClass = isActive ? " rule-active" : "";
       html += `<div class="rule-row${activeClass}${dragging}${dragOver}" draggable="true" data-rule-id="${this._esc(r.id)}" data-action="rule-drag">`;
-      html += `<span class="drag-handle" title="Drag">&#9783;</span>`;
-      html += `<div class="rule-info" data-action="rule-expand" data-id="${this._esc(r.id)}">`;
+      html += `<span class="drag-handle" title="${this._esc(this._t("drag_handle"))}">&#9783;</span>`;
+      // Keyboard/touch alternative to drag & drop
+      html += this._moveBtns(`data-id="${this._esc(r.id)}"`, "rule-prio-up", "rule-prio-down", "rule_priority_up", "rule_priority_down", idx === 0, idx === sorted.length - 1)
+        .replace('class="move-btns"', 'class="move-btns move-btns-v"');
+      html += `<div class="rule-info" data-action="rule-expand" data-id="${this._esc(r.id)}" tabindex="0" role="button" aria-expanded="${isExpanded ? "true" : "false"}">`;
       html += `<div class="rule-name">`;
       html += `<span class="rule-active-dot ${isActive ? "active" : ""}" title="${isActive ? this._t("rule_active_for") + " " + matchedCovers.length + " " + this._t("rule_covers_count") : this._t("rule_inactive")}"></span>`;
-      html += `${this._esc(r.name)}</div>`;
+      html += `${this._esc(r.name)}`;
+      if (r.safety) {
+        html += `<span class="rule-safety-badge" title="${this._esc(this._t("rule_safety"))}">${this._lucideIcon("shield", 12)}${this._esc(this._t("rule_safety_badge"))}</span>`;
+      }
+      html += '</div>';
       html += '<div class="rule-meta">';
       html += `<span class="priority-badge">#${idx + 1}</span>`;
-      html += `<span>${r.condition_operator === "or" ? "OR" : "AND"}</span>`;
-      html += `<span class="rule-target">${this._t("rule_target_pos")}:${this._posBar(r.target_position, "compact")}</span>`;
+      const rg = this._ruleGroups(r);
+      html += rg.n > 1
+        ? `<span>${this._t("rule_groups_count").replace("{n}", rg.n)}</span>`
+        : `<span>${this._t(rg.ops[0] === "or" ? "rule_op_short_or" : "rule_op_short_and")}</span>`;
+      html += `<span class="rule-target">${this._t("rule_target_pos")}${this._colon()}${this._posBar(r.target_position, "compact")}</span>`;
       if (r.target_tilt_position != null) {
-        html += `<span class="rule-target">${this._t("rule_target_tilt")}:${this._posBar(r.target_tilt_position, "compact")}</span>`;
+        html += `<span class="rule-target">${this._t("rule_target_tilt")}${this._colon()}${this._posBar(r.target_tilt_position, "compact")}</span>`;
       }
       html += '</div>';
       // Condition chips
       if (r.conditions && r.conditions.length > 0) {
         html += '<div class="chip-group mt-6">';
-        for (const c of r.conditions) {
-          html += `<span class="chip">${this._t("cond_" + c.type)}</span>`;
+        const chip = (c, ci) => {
+          const invalid = c.type === "ha_condition" && this._config.condition_status?.[r.id]?.[String(ci)]?.valid === false;
+          const not = c.negate ? `<b class="chip-not">${this._t("rule_cond_not")}</b> ` : "";
+          return `<span class="chip${invalid ? " chip-error" : ""}">${not}${this._esc(this._condChipLabel(c))}</span>`;
+        };
+        if (rg.n > 1) {
+          // One bracketed block per group, joined by the between-groups operator
+          const parts = [];
+          for (let g = 0; g < rg.n; g++) {
+            const members = [...r.conditions.entries()].filter(([, c]) => (parseInt(c.group, 10) || 0) === g);
+            if (!members.length) continue;
+            const inner = this._t(rg.ops[g] === "or" ? "rule_op_short_or" : "rule_op_short_and");
+            parts.push(`<span class="chip-block">${members.map(([ci, c]) => chip(c, ci)).join(`<span class="chip-op">${inner}</span>`)}</span>`);
+          }
+          html += parts.join(`<span class="chip-op chip-op-between">${this._t(rg.between === "or" ? "rule_op_short_or" : "rule_op_short_and")}</span>`);
+        } else {
+          for (const [ci, c] of r.conditions.entries()) html += chip(c, ci);
         }
         html += '</div>';
       }
@@ -3307,18 +6087,23 @@ class CoverAutomaticPanel extends HTMLElement {
 
       // Enable toggle
       html += `<label class="toggle">
-        <input type="checkbox" ${r.enabled ? "checked" : ""} data-action="rule-toggle-enabled" data-id="${this._esc(r.id)}">
+        <input type="checkbox" ${r.enabled ? "checked" : ""} data-action="rule-toggle-enabled" data-id="${this._esc(r.id)}" aria-label="${this._esc(this._t("rule_enabled_aria").replace("{name}", r.name || r.id))}">
         <span class="toggle-slider"></span>
       </label>`;
 
+<<<<<<< Updated upstream
       html += `<button class="btn-icon" data-action="rule-duplicate" data-id="${this._esc(r.id)}" title="${this._t("rule_duplicate")}" aria-label="${this._t("rule_duplicate")}">${this._lucideIcon("copy", 16)}</button>`;
+=======
+      html += `<button class="btn-icon" data-action="rule-duplicate" data-id="${this._esc(r.id)}" title="${this._esc(this._t("rule_duplicate"))}" aria-label="${this._esc(this._t("rule_duplicate"))}">${this._lucideIcon("copy", 16)}</button>`;
+>>>>>>> Stashed changes
       html += `<button class="btn-icon" data-action="rule-delete" data-id="${this._esc(r.id)}" title="${this._t("delete")}">&#10005;</button>`;
       html += '</div>'; // rule-row
 
       // Expanded editor
       html += `<div class="rule-editor${isExpanded ? " expanded" : ""}">`;
       if (isExpanded) {
-        html += this._renderRuleEditor(r);
+        // The editor works on the draft; the row above shows the saved rule.
+        html += this._renderRuleEditor(this._edRule(r.id) || r);
       }
       html += '</div>';
     }
@@ -3339,10 +6124,29 @@ class CoverAutomaticPanel extends HTMLElement {
 
     let html = '';
 
+    // Scenarios this rule belongs to (null = all scenarios)
+    const scenarios = Object.values(this._config.scenarios || {});
+    html += `<div class="form-group">
+      <label>${this._t("rule_scenarios")}</label>
+      <div class="multi-select">`;
+    for (const sc of scenarios) {
+      const member = !Array.isArray(rule.scenario_ids) || rule.scenario_ids.includes(sc.id);
+      html += `<button class="ms-item${member ? " selected" : ""}" data-action="rule-scenario-toggle" data-rule="${this._esc(rule.id)}" data-scenario="${this._esc(sc.id)}">${this._esc(sc.name)}</button>`;
+    }
+    html += `</div>
+      ${this._hint("rule_scenarios_hint")}
+    </div>`;
+
+    // Safety rule (overrides pause, manual mode, wind protection, master switch)
+    html += `<div class="form-group rule-safety-group">
+      ${this._renderToggle("rule_safety", !!rule.safety, "rule-field", rule.id, "safety")}
+      ${this._hint("rule_safety_hint")}
+    </div>`;
+
     // Name
     html += `<div class="form-group">
       <label>${this._t("name")}</label>
-      <input type="text" value="${this._esc(rule.name)}" data-action="rule-field" data-id="${this._esc(rule.id)}" data-field="name">
+      <input type="text" value="${this._esc(rule.name)}" data-action="rule-field" data-id="${this._esc(rule.id)}" data-field="name" maxlength="100">
     </div>`;
 
     // Target position + tilt
@@ -3358,15 +6162,6 @@ class CoverAutomaticPanel extends HTMLElement {
     </div>`;
     html += '</div>';
 
-    html += `<div class="form-group">
-      <label>${this._t("rule_operator")}</label>
-      <select data-action="rule-field" data-id="${this._esc(rule.id)}" data-field="condition_operator">
-        <option value="and"${rule.condition_operator==="and"?" selected":""}>${this._t("rule_operator_and")}</option>
-        <option value="or"${rule.condition_operator==="or"?" selected":""}>${this._t("rule_operator_or")}</option>
-      </select>
-      ${this._hint("rule_operator_hint")}
-    </div>`;
-
     // Facades multi-select
     html += `<div class="form-group">
       <label>${this._t("rule_facades")}</label>
@@ -3388,50 +6183,241 @@ class CoverAutomaticPanel extends HTMLElement {
     html += '</div></div>';
     html += this._hint("rule_assignment_hint");
 
-    // Conditions
-    html += `<div class="rule-conditions-label">${this._t("rule_conditions")}</div>`;
+    // Conditions, organised in groups
+    const condCount = (rule.conditions || []).length;
+    const allCollapsed = condCount > 0 && rule.conditions.every((_, i) => this._isCondCollapsed(rule.id, i));
+    html += `<div class="rule-conditions-label"><span>${this._t("rule_conditions")}</span>${condCount > 1
+      ? `<button class="cond-collapse-all" data-action="rule-cond-collapse-all" data-rule="${this._esc(rule.id)}">${this._t(allCollapsed ? "cond_expand_all" : "cond_collapse_all")}</button>` : ""}</div>`;
+    html += this._renderConditionGroups(rule);
 
-    if (rule.conditions && rule.conditions.length > 0) {
-      for (const [i] of rule.conditions.entries()) {
-        html += this._renderConditionCard(rule, i);
-      }
-    } else {
-      html += `<div class="rule-no-conditions">${this._t("rule_no_conditions")}</div>`;
-    }
+    // Save button
+    html += `<div class="rule-editor-actions">
+      <button class="btn btn-primary" data-action="rule-save" data-id="${this._esc(rule.id)}">${this._t("save")}</button>
+    </div>`;
 
-    // Add condition
-    html += `<div class="rule-condition-add">
-      <select class="rule-condition-type-select" data-action="rule-add-condition-type" data-rule="${this._esc(rule.id)}">
+    return html;
+  }
+
+  // Operators per condition group and number of groups of a rule.
+  _ruleGroups(rule) {
+    const ops = Array.isArray(rule.group_operators) && rule.group_operators.length
+      ? [...rule.group_operators] : [rule.condition_operator === "or" ? "or" : "and"];
+    let n = ops.length;
+    for (const c of rule.conditions || []) n = Math.max(n, (parseInt(c.group, 10) || 0) + 1);
+    while (ops.length < n) ops.push("and");
+    return { ops, n, between: rule.condition_operator === "or" ? "or" : "and" };
+  }
+
+  _opSelect(attrs, value) {
+    return `<select ${attrs}>
+        <option value="and"${value === "and" ? " selected" : ""}>${this._t("rule_operator_and")}</option>
+        <option value="or"${value === "or" ? " selected" : ""}>${this._t("rule_operator_or")}</option>
+      </select>`;
+  }
+
+  _renderConditionAdd(rule, group) {
+    return `<div class="rule-condition-add">
+      <select class="rule-condition-type-select" data-action="rule-add-condition-type" data-rule="${this._esc(rule.id)}" data-group="${group}">
         <option value="">${this._t("rule_add_condition")}...</option>
-        ${CONDITION_TYPES.map(t => `<option value="${t}">${this._t("cond_" + t)}</option>`).join("")}
+        ${CONDITION_MENU.map(g => `<optgroup label="${this._esc(this._t(g.label))}">${g.items.map(it => `<option value="${it.value}">${this._esc(this._t(it.label))}</option>`).join("")}</optgroup>`).join("")}
       </select>
     </div>`;
+  }
 
-    // Save button
-    html += `<div class="rule-editor-actions">
-      <button class="btn btn-primary" data-action="rule-save" data-id="${this._esc(rule.id)}">${this._t("save")}</button>
-    </div>`;
+  // Compact up/down buttons (reordering conditions and groups).
+  _moveBtns(attrs, actUp, actDown, tipUp, tipDown, firstPos, lastPos) {
+    return `<span class="move-btns">
+      <button class="btn-icon btn-move" data-action="${actUp}" ${attrs} title="${this._esc(this._t(tipUp))}" aria-label="${this._esc(this._t(tipUp))}"${firstPos ? " disabled" : ""}>&#9650;</button>
+      <button class="btn-icon btn-move" data-action="${actDown}" ${attrs} title="${this._esc(this._t(tipDown))}" aria-label="${this._esc(this._t(tipDown))}"${lastPos ? " disabled" : ""}>&#9660;</button>
+    </span>`;
+  }
+
+  // Indices (in rule.conditions) of the conditions of one group, in order.
+  _groupCondIndices(conditions, group) {
+    const out = [];
+    (conditions || []).forEach((c, i) => { if ((parseInt(c.group, 10) || 0) === group) out.push(i); });
+    return out;
+  }
 
+  _renderConditionGroups(rule) {
+    const rid = this._esc(rule.id);
+    const { ops, n, between } = this._ruleGroups(rule);
+    const conds = rule.conditions || [];
+    let html = "";
+    if (n === 1) {
+      html += `<div class="form-group">
+        <label>${this._t("rule_operator")}</label>
+        ${this._opSelect(`data-action="rule-group-op" data-rule="${rid}" data-group="0"`, ops[0])}
+        ${this._hint("rule_operator_hint")}
+      </div>`;
+      if (conds.length > 0) {
+        for (const [i] of conds.entries()) html += this._renderConditionCard(rule, i, 1);
+      } else {
+        html += `<div class="rule-no-conditions">${this._t("rule_no_conditions")}</div>`;
+      }
+      html += this._renderConditionAdd(rule, 0);
+    } else {
+      html += `<div class="form-group">
+        <label>${this._t("rule_groups_operator")}</label>
+        ${this._opSelect(`data-action="rule-field" data-id="${rid}" data-field="condition_operator"`, between)}
+        ${this._hint("rule_groups_hint")}
+      </div>`;
+      for (let g = 0; g < n; g++) {
+        if (g > 0) html += `<div class="cond-group-sep" data-group-sep="${rid}">${this._t(between === "or" ? "rule_op_short_or" : "rule_op_short_and")}</div>`;
+        html += `<div class="cond-group">
+          <div class="cond-group-head">
+            <span class="cond-group-title">${this._t("rule_group")} ${g + 1}</span>
+            <span class="cond-group-op"><span>${this._t("rule_group_joined_by")}</span>
+              ${this._opSelect(`data-action="rule-group-op" data-rule="${rid}" data-group="${g}"`, ops[g])}</span>
+            <span class="cond-preview cond-group-preview" data-group-preview="${g}"></span>
+            ${this._moveBtns(`data-rule="${rid}" data-group="${g}"`, "rule-group-up", "rule-group-down", "rule_group_up", "rule_group_down", g === 0, g === n - 1)}
+            <button class="btn-icon" data-action="rule-group-delete" data-rule="${rid}" data-group="${g}" title="${this._esc(this._t("rule_group_delete"))}">&#10005;</button>
+          </div>`;
+        let count = 0;
+        for (const [i, c] of conds.entries()) {
+          if ((parseInt(c.group, 10) || 0) !== g) continue;
+          html += this._renderConditionCard(rule, i, n);
+          count++;
+        }
+        if (!count) html += `<div class="rule-no-conditions">${this._t("rule_group_empty")}</div>`;
+        html += this._renderConditionAdd(rule, g);
+        html += '</div>';
+      }
+    }
+    if (n < MAX_CONDITION_GROUPS) {
+      html += `<button class="btn btn-secondary btn-sm cond-group-add" data-action="rule-group-add" data-rule="${rid}">+ ${this._t("rule_group_add")}</button>
+        ${n === 1 ? this._hint("rule_group_add_hint") : ""}`;
+    }
     return html;
   }
 
-  _renderConditionCard(rule, idx) {
+  // Collapsed condition cards (per rule and condition index, kept while the panel is open).
+  _isCondCollapsed(ruleId, idx) {
+    return !!(this._collapsedConds && this._collapsedConds.has(ruleId + ":" + idx));
+  }
+
+  _setCondCollapsed(ruleId, idx, collapsed) {
+    if (!this._collapsedConds) this._collapsedConds = new Set();
+    const key = ruleId + ":" + idx;
+    if (collapsed) this._collapsedConds.add(key); else this._collapsedConds.delete(key);
+    const root = this.shadowRoot;
+    const card = root && root.querySelector(`.condition-card[data-cond-card="${CSS.escape(key)}"]`);
+    if (!card) return;
+    card.classList.toggle("collapsed", collapsed);
+    const chev = card.querySelector(".cond-chevron");
+    if (chev) {
+      chev.setAttribute("aria-expanded", collapsed ? "false" : "true");
+      chev.title = this._t(collapsed ? "cond_expand" : "cond_collapse");
+    }
+    // Refresh the one-line summary with the values edited meanwhile.
+    const rule = this._edRule(ruleId);
+    const sum = card.querySelector(".cond-summary");
+    if (sum && rule && rule.conditions && rule.conditions[idx]) sum.textContent = this._condSummary(rule.conditions[idx]);
+  }
+
+  _onCondCollapseAll(ruleId) {
+    const rule = this._edRule(ruleId);
+    if (!rule || !rule.conditions) return;
+    const anyOpen = rule.conditions.some((_, i) => !this._isCondCollapsed(ruleId, i));
+    rule.conditions.forEach((_, i) => this._setCondCollapsed(ruleId, i, anyOpen));
+    const btn = this.shadowRoot && this.shadowRoot.querySelector(`[data-action="rule-cond-collapse-all"][data-rule="${CSS.escape(ruleId)}"]`);
+    if (btn) btn.textContent = this._t(anyOpen ? "cond_expand_all" : "cond_collapse_all");
+  }
+
+  // Index shift after a condition is deleted (collapsed state follows its card).
+  _shiftCollapsedConds(ruleId, removedIdx) {
+    if (!this._collapsedConds) return;
+    const next = new Set();
+    for (const key of this._collapsedConds) {
+      const sep = key.lastIndexOf(":");
+      const rid = key.slice(0, sep);
+      const i = parseInt(key.slice(sep + 1), 10);
+      if (rid !== ruleId) { next.add(key); continue; }
+      if (i === removedIdx) continue;
+      next.add(rid + ":" + (i > removedIdx ? i - 1 : i));
+    }
+    this._collapsedConds = next;
+  }
+
+  // One-line summary of a condition's settings, shown when it is collapsed.
+  _condSummary(c) {
+    const p = c.params || {};
+    const off = v => { const n = Number(v) || 0; return n === 0 ? "" : (n > 0 ? "+" : "−") + Math.abs(n) + " min"; };
+    switch (c.type) {
+      case "ha_condition": return this._condChipLabel(c);
+      case "sun_elevation_above": return "> " + (p.elevation ?? p.value ?? "") + "°";
+      case "sun_elevation_below": return "< " + (p.elevation ?? p.value ?? "") + "°";
+      case "temperature_above": return "> " + (p.temperature ?? p.value ?? "") + " °C";
+      case "temperature_below": return "< " + (p.temperature ?? p.value ?? "") + " °C";
+      case "temperature_comfort": return this._optionLabel("mode", p.mode || "cooling");
+      case "outdoor_vs_indoor": {
+        const d = Math.abs(Number(p.delta) || 0);
+        return this._optionLabel("operator", p.operator === "warmer" ? "warmer" : "cooler") + (d ? " (≥ " + d + " °C)" : "");
+      }
+      case "time_between": return (p.start_time || "") + " – " + (p.end_time || "");
+      case "state_is": return (p.entity_id ? this._haEntityName(p.entity_id) : "?") + " = " + (p.state ?? "");
+      case "numeric_state": return (p.entity_id ? this._haEntityName(p.entity_id) : "?") + (p.operator === "below" ? " < " : " > ") + (p.value ?? "");
+      case "weather_is": {
+        const w = Array.isArray(p.weather) ? p.weather : (p.weather ? [p.weather] : (p.states || []));
+        return w.map(v => this._optionLabel("weather", v)).join(", ");
+      }
+      case "day_of_week": return (p.days || []).map(d => this._i18nOr("day_" + d, d)).join(" ");
+      case "workday": return this._optionLabel("state", p.state || "on");
+      default:
+        return c.type && c.type.startsWith("time_") ? off(p.offset) : "";
+    }
+  }
+
+  _renderConditionCard(rule, idx, groupCount = null) {
     const cond = rule.conditions[idx];
+    const nGroups = groupCount ?? this._ruleGroups(rule).n;
+    const negated = !!cond.negate;
+    const cGroup = parseInt(cond.group, 10) || 0;
+    const groupMove = nGroups > 1
+      ? `<select class="cond-group-move" data-action="rule-cond-group" data-rule="${this._esc(rule.id)}" data-idx="${idx}" title="${this._esc(this._t("rule_cond_move"))}">${Array.from({ length: nGroups }, (_, g) => `<option value="${g}"${g === cGroup ? " selected" : ""}>${this._t("rule_group")} ${g + 1}</option>`).join("")}</select>`
+      : "";
+    const siblings = this._groupCondIndices(rule.conditions, cGroup);
+    const pos = siblings.indexOf(idx);
+    const moveBtns = this._moveBtns(`data-rule="${this._esc(rule.id)}" data-idx="${idx}"`, "rule-cond-up", "rule-cond-down",
+      "rule_cond_up", "rule_cond_down", pos <= 0, pos === siblings.length - 1);
+    const notBtn = `<button class="cond-not${negated ? " active" : ""}" data-action="rule-cond-negate" data-rule="${this._esc(rule.id)}" data-idx="${idx}" title="${this._esc(this._t("rule_cond_not_hint"))}">${this._t("rule_cond_not")}</button>`;
     const paramDefs = CONDITION_PARAMS[cond.type] || [];
 
     const isContextCond = CONTEXT_DEPENDENT_TYPES.includes(cond.type);
     const previewCell = isContextCond
       ? `<span class="cond-preview cond-preview-context">${this._t("cond_preview_context")}</span>`
       : `<span class="cond-preview" data-cond-preview="${idx}"></span>`;
-    let html = `<div class="condition-card">
+    const isHa = cond.type === "ha_condition";
+    const title = isHa ? this._haCondTitle(cond) : this._t("cond_" + cond.type);
+    const collapsed = this._isCondCollapsed(rule.id, idx);
+    let html = `<div class="condition-card${isHa ? " ha-card" : ""}${negated ? " negated" : ""}${collapsed ? " collapsed" : ""}" data-cond-card="${this._esc(rule.id)}:${idx}">
       <div class="cond-header">
         <span class="cond-head-left">
-          <span class="cond-type">${this._t("cond_" + cond.type)}</span>
+          <button class="cond-chevron" data-action="rule-cond-collapse" data-rule="${this._esc(rule.id)}" data-idx="${idx}" title="${this._esc(this._t(collapsed ? "cond_expand" : "cond_collapse"))}" aria-expanded="${collapsed ? "false" : "true"}">&#9662;</button>
+          ${notBtn}
+          <span class="cond-type" data-action="rule-cond-collapse" data-rule="${this._esc(rule.id)}" data-idx="${idx}">${this._esc(title)}</span>
+          <span class="cond-summary" data-cond-summary="${idx}">${this._esc(this._condSummary(cond))}</span>
           ${previewCell}
         </span>
-        <button class="btn-icon" data-action="rule-delete-condition" data-rule="${this._esc(rule.id)}" data-idx="${idx}" title="${this._t("delete")}">&#10005;</button>
+        <span class="cond-head-right">
+          ${groupMove}
+          ${moveBtns}
+          <button class="btn-icon" data-action="rule-delete-condition" data-rule="${this._esc(rule.id)}" data-idx="${idx}" title="${this._t("delete")}">&#10005;</button>
+        </span>
       </div>`;
 
+    if (isHa) {
+      html += this._renderHaConditionBody(rule, idx, cond);
+      return html + '</div>';
+    }
+
+    // Legacy entity conditions can be converted to the richer HA condition
+    const legacyHyst = cond.type === "numeric_state" && Number((cond.params || {}).hysteresis) > 0;
+    if ((cond.type === "state_is" || cond.type === "numeric_state") && !legacyHyst) {
+      html += `<div class="ha-convert"><button type="button" class="btn btn-secondary btn-small" data-action="cond-convert" data-rule="${this._esc(rule.id)}" data-idx="${idx}">${this._t("cond_convert")}</button>
+        <span class="ha-help">${this._esc(this._t("cond_convert_hint"))}</span></div>`;
+    }
+
     if (paramDefs.length > 0) {
       html += '<div class="cond-params">';
       for (const p of paramDefs) {
@@ -3450,7 +6436,7 @@ class CoverAutomaticPanel extends HTMLElement {
           html += `<div class="day-select" data-rule="${this._esc(rule.id)}" data-idx="${idx}" data-key="${p.key}">`;
           for (const opt of p.options) {
             const active = selected.includes(opt);
-            html += `<button type="button" class="day-btn${active ? " selected" : ""}" data-action="multiselect-toggle" data-rule="${this._esc(rule.id)}" data-idx="${idx}" data-key="${p.key}" data-val="${opt}">${opt}</button>`;
+            html += `<button type="button" class="day-btn${active ? " selected" : ""}" data-action="multiselect-toggle" data-rule="${this._esc(rule.id)}" data-idx="${idx}" data-key="${p.key}" data-val="${this._esc(opt)}">${this._esc(this._optionLabel(p.key, opt))}</button>`;
           }
           html += '</div>';
         } else if (p.type === "time") {
@@ -3465,7 +6451,7 @@ class CoverAutomaticPanel extends HTMLElement {
           }
           html += '</div>';
         } else if (p.type === "number") {
-          html += `<input type="number" value="${this._num(val)}"${p.step ? ' step="' + p.step + '"' : ""} data-action="cond-param" data-rule="${this._esc(rule.id)}" data-idx="${idx}" data-key="${p.key}">`;
+          html += `<input type="number" value="${this._num(val)}" step="${p.step ? p.step : "any"}" data-action="cond-param" data-rule="${this._esc(rule.id)}" data-idx="${idx}" data-key="${p.key}">`;
         } else if (p.type === "entity") {
           html += this._renderCondEntitySelect(rule, idx, p.key, val);
         } else {
@@ -3476,15 +6462,658 @@ class CoverAutomaticPanel extends HTMLElement {
       html += '</div>';
     }
 
+    // Sun time conditions: window covered and complementary condition
+    if (/^time_(after|before)_(sunrise|sunset|dawn|dusk)$/.test(cond.type || "")) {
+      const sunHint = this._t("cond_" + cond.type + "_hint");
+      if (sunHint !== "cond_" + cond.type + "_hint") {
+        const other = cond.type.startsWith("time_after_") ? cond.type.replace("time_after_", "time_before_") : cond.type.replace("time_before_", "time_after_");
+        html += `<div class="ha-help cond-type-hint">${this._esc(sunHint.replace("{other}", this._t("cond_" + other)))}</div>`;
+      }
+    }
+
+    html += '</div>';
+    return html;
+  }
+
+  async _onCoverTravelReset(entityId) {
+    try {
+      const result = await this._ws("cover_automatic/cover/update", { entity_id: entityId, measured_travel_time: null });
+      this._updateConfigFromResult(result);
+    } catch (e) { console.error(e); this._showError(e); }
+  }
+
+  /* ---------- Native Home Assistant conditions (type "ha_condition") ---------- */
+
+  // Parse a condition config into the form model, or null when the form
+  // cannot represent it (templates, zones, nested and/or...).
+  _haFormModel(config, opHint = null) {
+    if (!config || typeof config !== "object") return null;
+    let cfg = config;
+    let negate = false;
+    if (cfg.condition === "not") {
+      const subs = Array.isArray(cfg.conditions) ? cfg.conditions : [];
+      if (subs.length !== 1 || !subs[0] || subs[0].condition !== "state") return null;
+      negate = true;
+      cfg = subs[0];
+    }
+    const allowed = new Set(["condition", "entity_id", "attribute", "state", "for", "above", "below"]);
+    if (Object.keys(cfg).some(k => !allowed.has(k))) return null;
+    let entity = cfg.entity_id;
+    if (Array.isArray(entity)) {
+      if (entity.length > 1) return null;
+      entity = entity[0];
+    }
+    if (entity != null && typeof entity !== "string") return null;
+    const model = { kind: null, entity: entity || "", attribute: cfg.attribute || "", negate };
+    if (cfg.condition === "state") {
+      if (cfg.above != null || cfg.below != null) return null;
+      model.kind = "state";
+      const st = cfg.state;
+      model.states = st == null ? [] : (Array.isArray(st) ? st.map(String) : [String(st)]);
+      model.forMinutes = null;
+      if (cfg.for != null) {
+        const f = cfg.for;
+        if (typeof f === "object" && !Array.isArray(f)) {
+          const keys = Object.keys(f);
+          if (keys.some(k => !["hours", "minutes", "seconds"].includes(k))) return null;
+          model.forMinutes = (Number(f.hours) || 0) * 60 + (Number(f.minutes) || 0) + (Number(f.seconds) || 0) / 60;
+        } else if (typeof f === "string" && /^\d{1,2}:\d{2}(:\d{2})?$/.test(f)) {
+          const p = f.split(":").map(Number);
+          model.forMinutes = p[0] * 60 + p[1] + (p[2] || 0) / 60;
+        } else if (typeof f === "number") {
+          model.forMinutes = f / 60;
+        } else {
+          return null;
+        }
+      }
+      return model;
+    }
+    if (cfg.condition === "numeric_state" && !negate) {
+      if (cfg.state != null || cfg.for != null) return null;
+      const num = (v) => (v == null || v === "" ? null : Number(v));
+      if ((cfg.above != null && !Number.isFinite(num(cfg.above))) || (cfg.below != null && !Number.isFinite(num(cfg.below)))) return null;
+      model.kind = "numeric";
+      model.above = num(cfg.above);
+      model.below = num(cfg.below);
+      model.operator = model.above != null && model.below != null ? "between" : (model.below != null ? "below" : "above");
+      // The chosen operator is kept in the params while a value is missing
+      // (e.g. "between" with only the minimum filled in yet).
+      if (["above", "below", "between"].includes(opHint)) model.operator = opHint;
+      return model;
+    }
+    return null;
+  }
+
+  // Build the Home Assistant condition config from the form model.
+  _haFormToConfig(m) {
+    if (m.kind === "numeric") {
+      const cfg = { condition: "numeric_state", entity_id: m.entity || "" };
+      if (m.attribute) cfg.attribute = m.attribute;
+      if (m.operator !== "below" && m.above != null && Number.isFinite(m.above)) cfg.above = m.above;
+      if (m.operator !== "above" && m.below != null && Number.isFinite(m.below)) cfg.below = m.below;
+      return cfg;
+    }
+    const cfg = { condition: "state", entity_id: m.entity || "" };
+    if (m.attribute) cfg.attribute = m.attribute;
+    cfg.state = m.states.length === 1 ? m.states[0] : [...m.states];
+    if (!m.negate && m.forMinutes != null && m.forMinutes > 0) cfg.for = { minutes: m.forMinutes };
+    return m.negate ? { condition: "not", conditions: [cfg] } : cfg;
+  }
+
+  _haDefaultConfig(kind) {
+    return kind === "numeric"
+      ? { condition: "numeric_state", entity_id: "", above: 0 }
+      : { condition: "state", entity_id: "", state: [] };
+  }
+
+  // Missing field in a form-built condition (shown instead of HA's error).
+  _haFormIncomplete(m) {
+    if (!m) return null;
+    if (!m.entity) return "ha_incomplete_entity";
+    if (m.kind === "state" && m.states.length === 0) return "ha_incomplete_states";
+    if (m.kind === "numeric") {
+      if (m.operator === "between" && (m.above == null || m.below == null)) return "ha_incomplete_value";
+      if (m.operator === "above" && m.above == null) return "ha_incomplete_value";
+      if (m.operator === "below" && m.below == null) return "ha_incomplete_value";
+    }
+    return null;
+  }
+
+  // Possible states of an entity, for the state buttons.
+  _haKnownStates(stateObj, attribute) {
+    const out = [];
+    const add = (v) => { if (v != null && v !== "" && !out.includes(String(v))) out.push(String(v)); };
+    if (!stateObj) return out;
+    if (attribute) {
+      add(stateObj.attributes[attribute]);
+      return out;
+    }
+    const domain = stateObj.entity_id.split(".")[0];
+    const a = stateObj.attributes || {};
+    const ONOFF = ["on", "off"];
+    const BY_DOMAIN = {
+      binary_sensor: ONOFF, switch: ONOFF, light: ONOFF, input_boolean: ONOFF, fan: ONOFF,
+      automation: ONOFF, script: ONOFF, remote: ONOFF, siren: ONOFF, humidifier: ONOFF,
+      cover: ["open", "closed", "opening", "closing"],
+      lock: ["locked", "unlocked", "locking", "unlocking", "open", "jammed"],
+      alarm_control_panel: ["disarmed", "armed_home", "armed_away", "armed_night", "armed_vacation", "armed_custom_bypass", "arming", "pending", "triggered"],
+      media_player: ["off", "on", "idle", "playing", "paused", "standby", "buffering"],
+      sun: ["above_horizon", "below_horizon"],
+      vacuum: ["cleaning", "docked", "idle", "paused", "returning", "error"],
+      lawn_mower: ["mowing", "docked", "paused", "returning", "error"],
+      weather: ["sunny", "clear-night", "partlycloudy", "cloudy", "fog", "rainy", "pouring", "lightning", "lightning-rainy", "hail", "snowy", "snowy-rainy", "windy", "windy-variant", "exceptional"],
+    };
+    if (Array.isArray(a.options)) a.options.forEach(add);
+    if (domain === "climate" && Array.isArray(a.hvac_modes)) a.hvac_modes.forEach(add);
+    if (domain === "water_heater" && Array.isArray(a.operation_list)) a.operation_list.forEach(add);
+    if (domain === "person" || domain === "device_tracker") {
+      add("home"); add("not_home");
+      for (const z of Object.values(this._hass.states)) {
+        if (z.entity_id.startsWith("zone.") && z.entity_id !== "zone.home") add(z.attributes.friendly_name);
+      }
+    }
+    (BY_DOMAIN[domain] || []).forEach(add);
+    add(stateObj.state);
+    return out.filter(v => v !== "unavailable" && v !== "unknown");
+  }
+
+  _haStateLabel(stateObj, attribute, value) {
+    try {
+      if (stateObj && attribute && this._hass.formatEntityAttributeValue) {
+        return this._hass.formatEntityAttributeValue(stateObj, attribute, value);
+      }
+      if (stateObj && !attribute && this._hass.formatEntityState) {
+        return this._hass.formatEntityState(stateObj, value);
+      }
+    } catch (e) { /* fall through */ }
+    return String(value);
+  }
+
+  _haAttributeLabel(stateObj, attribute) {
+    try {
+      if (stateObj && this._hass.formatEntityAttributeName) return this._hass.formatEntityAttributeName(stateObj, attribute);
+    } catch (e) { /* fall through */ }
+    return attribute;
+  }
+
+  _haEntityName(entityId) {
+    const s = entityId && this._hass?.states ? this._hass.states[entityId] : null;
+    return s ? (s.attributes.friendly_name || entityId) : (entityId || "?");
+  }
+
+  _haCondTitle(cond) {
+    const p = cond.params || {};
+    if ((p.ui || "form") === "form") {
+      const m = this._haFormModel(p.config);
+      if (m) return this._t(m.kind === "numeric" ? "cond_ha_numeric" : "cond_ha_state");
+    }
+    return this._t("cond_ha_condition");
+  }
+
+  // Current validation status of an ha_condition card (live result from the
+  // validate command, else the status sent with the configuration).
+  _haStatus(ruleId, idx) {
+    const live = this._haLive && this._haLive[ruleId + ":" + idx];
+    if (live) return live;
+    const st = this._config?.condition_status?.[ruleId]?.[String(idx)];
+    return st || null;
+  }
+
+  _renderHaConditionBody(rule, idx, cond) {
+    const p = cond.params || {};
+    const ui = p.ui || "form";
+    const rid = this._esc(rule.id);
+    const base = `data-rule="${rid}" data-idx="${idx}"`;
+    let html = `<div class="ha-seg" role="tablist">
+      <button type="button" class="${ui === "form" ? "on" : ""}" data-action="ha-ui" data-mode="form" ${base} aria-selected="${ui === "form"}">${this._t("ha_tab_form")}</button>
+      <button type="button" class="${ui === "yaml" ? "on" : ""}" data-action="ha-ui" data-mode="yaml" ${base} aria-selected="${ui === "yaml"}">${this._t("ha_tab_yaml")}</button>
+    </div>`;
+    html += '<div class="cond-params ha-params">';
+    if (ui === "yaml") {
+      const text = p.yaml != null ? p.yaml : "";
+      html += `<div class="form-group"><label>${this._t("ha_yaml_label")}</label>
+        <textarea class="ha-yaml" rows="${Math.max(4, text.split("\n").length + 1)}" spellcheck="false" data-action="ha-yaml" ${base} placeholder="${this._esc(this._t("ha_yaml_placeholder"))}">${this._esc(text)}</textarea>
+        <div class="ha-help">${this._esc(this._t("ha_yaml_help"))}</div></div>`;
+    } else {
+      const m = this._haFormModel(p.config, p.op);
+      if (!m) {
+        html += `<div class="ha-msg ha-msg-info">${this._esc(this._t("ha_form_unsupported"))}</div>`;
+        html += '</div>';
+        html += `<div class="ha-status" data-ha-status="${rid}:${idx}">${this._renderHaStatus(rule.id, idx, null)}</div>`;
+        return html;
+      }
+      html += this._renderHaForm(rule, idx, m);
+    }
     html += '</div>';
+    html += `<div class="ha-status" data-ha-status="${rid}:${idx}">${this._renderHaStatus(rule.id, idx, ui === "form" ? this._haFormModel(p.config, p.op) : null)}</div>`;
+    return html;
+  }
+
+  _renderHaForm(rule, idx, m) {
+    const base = `data-rule="${this._esc(rule.id)}" data-idx="${idx}"`;
+    const stateObj = m.entity && this._hass?.states ? this._hass.states[m.entity] : null;
+    let html = '';
+    // Kind + entity
+    html += `<div class="form-row"><div class="form-group"><label>${this._t("ha_kind")}</label>
+      <select data-action="ha-form" data-field="kind" ${base}>
+        <option value="state"${m.kind === "state" ? " selected" : ""}>${this._t("ha_kind_state")}</option>
+        <option value="numeric"${m.kind === "numeric" ? " selected" : ""}>${this._t("ha_kind_numeric")}</option>
+      </select></div>`;
+    html += `<div class="form-group"><label>${this._t("ha_entity")}</label>${this._renderHaEntityInput(rule, idx, m.entity)}`;
+    if (stateObj) {
+      const cur = m.attribute ? stateObj.attributes[m.attribute] : stateObj.state;
+      if (cur != null) {
+        const fname = stateObj.attributes.friendly_name;
+        html += `<div class="ha-current">${fname ? this._esc(fname) + " · " : ""}${this._esc(this._t("ha_current"))}${this._colon()}${this._esc(this._haStateLabel(stateObj, m.attribute, cur))}</div>`;
+      }
+    }
+    html += '</div></div>';
+
+    // Attribute
+    const SKIP = new Set(["friendly_name", "icon", "entity_picture", "supported_features", "device_class", "unit_of_measurement",
+      "attribution", "assumed_state", "restored", "editable", "id", "user_id", "device_trackers", "options", "hvac_modes",
+      "operation_list", "state_class", "entity_id", "source_list", "sound_mode_list", "preset_modes", "fan_modes", "swing_modes"]);
+    const attrs = stateObj ? Object.keys(stateObj.attributes).filter(k => !SKIP.has(k)).filter(k => {
+      const v = stateObj.attributes[k];
+      if (m.kind === "numeric") return typeof v === "number" || (typeof v === "string" && v !== "" && Number.isFinite(Number(v)));
+      return v == null || ["string", "number", "boolean"].includes(typeof v);
+    }) : [];
+    if (m.attribute && !attrs.includes(m.attribute)) attrs.unshift(m.attribute);
+    html += `<div class="form-row"><div class="form-group"><label>${this._t("ha_attribute")}</label>
+      <select data-action="ha-form" data-field="attribute" ${base}>
+        <option value="">${this._t("ha_attribute_none")}</option>
+        ${attrs.map(a => `<option value="${this._esc(a)}"${a === m.attribute ? " selected" : ""}>${this._esc(this._haAttributeLabel(stateObj, a))}</option>`).join("")}
+      </select></div>`;
+
+    if (m.kind === "state") {
+      html += `<div class="form-group"><label>${this._t("ha_compare")}</label>
+        <select data-action="ha-form" data-field="negate" ${base}>
+          <option value="0"${!m.negate ? " selected" : ""}>${this._t("ha_is")}</option>
+          <option value="1"${m.negate ? " selected" : ""}>${this._t("ha_is_not")}</option>
+        </select></div></div>`;
+      html += `<div class="form-row"><div class="form-group"><label>${this._t("ha_for")}</label>
+        <input type="number" min="0" step="any" value="${m.forMinutes != null && !m.negate ? this._esc(String(Math.round(m.forMinutes * 100) / 100)) : ""}" placeholder="0" data-action="ha-form" data-field="for" ${base}${m.negate ? " disabled" : ""}>
+        ${m.negate ? `<div class="ha-help">${this._esc(this._t("ha_for_negate_hint"))}</div>` : ""}</div><div class="form-group"></div></div>`;
+      // States buttons
+      const known = this._haKnownStates(stateObj, m.attribute);
+      m.states.forEach(s => { if (!known.includes(s)) known.push(s); });
+      html += `<div class="form-group"><label>${this._t("ha_states")}</label><div class="day-select">`;
+      for (const s of known) {
+        const sel = m.states.includes(s);
+        html += `<button type="button" class="day-btn${sel ? " selected" : ""}" data-action="ha-state-toggle" data-val="${this._esc(s)}" ${base} title="${this._esc(s)}">${this._esc(this._haStateLabel(stateObj, m.attribute, s))}</button>`;
+      }
+      html += `</div><div class="ha-add-state"><input type="text" placeholder="${this._esc(this._t("ha_state_other"))}" data-ha-other="${this._esc(rule.id)}:${idx}">
+        <button type="button" class="btn btn-secondary" data-action="ha-state-add" ${base}>${this._t("ha_state_add")}</button></div></div>`;
+    } else {
+      html += `<div class="form-group"><label>${this._t("ha_operator")}</label>
+        <select data-action="ha-form" data-field="operator" ${base}>
+          ${["above", "below", "between"].map(o => `<option value="${o}"${m.operator === o ? " selected" : ""}>${this._t("ha_op_" + o)}</option>`).join("")}
+        </select></div></div>`;
+      const num = (v) => (v == null ? "" : this._esc(String(v)));
+      if (m.operator === "between") {
+        html += `<div class="form-row"><div class="form-group"><label>${this._t("ha_min")}</label>
+          <input type="number" step="any" value="${num(m.above)}" data-action="ha-form" data-field="above" ${base}></div>
+          <div class="form-group"><label>${this._t("ha_max")}</label>
+          <input type="number" step="any" value="${num(m.below)}" data-action="ha-form" data-field="below" ${base}></div></div>`;
+      } else {
+        const field = m.operator === "below" ? "below" : "above";
+        html += `<div class="form-row"><div class="form-group"><label>${this._t("ha_value")}</label>
+          <input type="number" step="any" value="${num(m[field])}" data-action="ha-form" data-field="${field}" ${base}></div><div class="form-group"></div></div>`;
+      }
+    }
     return html;
   }
 
+  _renderHaEntityInput(rule, idx, value) {
+    const attrs = `data-action="ha-form" data-field="entity" data-rule="${this._esc(rule.id)}" data-idx="${idx}"`;
+    if (!this._hass || !this._hass.states) {
+      return `<input type="text" value="${this._esc(value || "")}" ${attrs}>`;
+    }
+    const listId = `ca-ha-ent-${this._esc(rule.id)}-${idx}`;
+    const entities = Object.values(this._hass.states)
+      .sort((a, b) => (a.attributes.friendly_name || a.entity_id).localeCompare(b.attributes.friendly_name || b.entity_id));
+    let html = `<input type="text" list="${listId}" value="${this._esc(value || "")}" placeholder="${this._t("param_entity_search")}" autocomplete="off" ${attrs}>`;
+    html += `<datalist id="${listId}">`;
+    for (const e of entities) {
+      html += `<option value="${this._esc(e.entity_id)}">${this._esc(e.attributes.friendly_name || e.entity_id)}</option>`;
+    }
+    return html + "</datalist>";
+  }
+
+  _renderHaStatus(ruleId, idx, formModel) {
+    const incomplete = this._haFormIncomplete(formModel);
+    if (incomplete) return `<div class="ha-msg ha-msg-info">${this._esc(this._t(incomplete))}</div>`;
+    const st = this._haStatus(ruleId, idx);
+    if (!st) return "";
+    if (st.pending) return `<div class="ha-msg ha-msg-info">${this._esc(this._t("ha_checking"))}</div>`;
+    let html = "";
+    if (st.valid) {
+      html += `<div class="ha-msg ha-msg-ok">✓ ${this._esc(this._t("ha_valid"))}</div>`;
+    } else if (st.error_code && st.error_code !== "pending") {
+      html += `<div class="ha-msg ha-msg-err">✕ ${this._esc(this._haErrorText(st))}</div>`;
+    }
+    if (Array.isArray(st.entities) && st.entities.length) {
+      html += `<div class="ha-msg ha-msg-info">${this._esc(this._t("ha_entities"))}${this._colon()}${this._esc(st.entities.join(", "))}</div>`;
+    }
+    if (Array.isArray(st.unknown_entities) && st.unknown_entities.length) {
+      html += `<div class="ha-msg ha-msg-warn">${this._esc(this._t("ha_unknown_entities"))}${this._colon()}${this._esc(st.unknown_entities.join(", "))}</div>`;
+    }
+    return html;
+  }
+
+  _haErrorText(st) {
+    const fill = (tpl, values) => tpl.replace(/\{(\w+)\}/g, (mm, n) => (values[n] != null ? String(values[n]) : mm));
+    switch (st.error_code) {
+      case "yaml":
+        return fill(this._t("ha_err_yaml"), { line: st.error_line ?? "?", column: st.error_column ?? "?" }) + (st.error ? " — " + st.error : "");
+      case "not_mapping": return this._t("ha_err_not_mapping");
+      case "empty": return this._t("ha_err_empty");
+      case "request": return this._t("ha_err_request") + (st.error ? this._colon() + st.error : "");
+      default: return this._t("ha_err_invalid") + (st.error ? this._colon() + st.error : "");
+    }
+  }
+
+  _haCond(ruleId, idx) {
+    const rule = this._edRule(ruleId);
+    const cond = rule && rule.conditions ? rule.conditions[idx] : null;
+    if (!cond || cond.type !== "ha_condition") return null;
+    if (!cond.params) cond.params = {};
+    return cond;
+  }
+
+  // Re-render a single condition card (keeps the rest of the editor intact).
+  _rerenderCondCard(ruleId, idx) {
+    const rule = this._edRule(ruleId);
+    const root = this.shadowRoot;
+    const card = root && root.querySelector(`.condition-card[data-cond-card="${CSS.escape(ruleId)}:${idx}"]`);
+    if (!rule || !card) { this._render(); return; }
+    const tmp = document.createElement("div");
+    tmp.innerHTML = this._renderConditionCard(rule, idx);
+    card.replaceWith(tmp.firstElementChild);
+    this._refreshCondPreview();
+  }
+
+  _refreshHaStatusBox(ruleId, idx) {
+    const cond = this._haCond(ruleId, idx);
+    const box = this.shadowRoot && this.shadowRoot.querySelector(`[data-ha-status="${CSS.escape(ruleId)}:${idx}"]`);
+    if (!cond || !box) return;
+    const model = (cond.params.ui || "form") === "form" ? this._haFormModel(cond.params.config, cond.params.op) : null;
+    box.innerHTML = this._renderHaStatus(ruleId, idx, model);
+  }
+
+  // Validate the condition with Home Assistant (debounced per card).
+  _scheduleHaValidate(ruleId, idx, delay = 400) {
+    const key = ruleId + ":" + idx;
+    this._haTimers = this._haTimers || {};
+    if (this._haTimers[key]) clearTimeout(this._haTimers[key]);
+    this._haTimers[key] = setTimeout(() => {
+      delete this._haTimers[key];
+      this._runHaValidate(ruleId, idx);
+    }, delay);
+  }
+
+  // Validate one card now. The result is dropped when the card no longer
+  // holds the same condition (deleted, moved, draft discarded or reset).
+  _runHaValidate(ruleId, idx) {
+    const key = ruleId + ":" + idx;
+    const cond = this._haCond(ruleId, idx);
+    if (!cond) return Promise.resolve();
+    const p = cond.params;
+    const req = (p.ui || "form") === "yaml" ? { yaml: p.yaml || "" } : { config: p.config || null };
+    const job = (async () => {
+      try {
+        const res = await this._ws("cover_automatic/condition/validate", req);
+        if (!res || this._haCond(ruleId, idx) !== cond) return;
+        (this._haLive = this._haLive || {})[key] = res;
+        // A newer edit is already queued for validation otherwise.
+        if (req.yaml !== undefined && p.yaml === req.yaml) p.config = res.config || null;
+        this._refreshHaStatusBox(ruleId, idx);
+        this._refreshCondPreview();
+      } catch (e) {
+        console.error(e);
+        // Show the failure instead of "Checking…" forever
+        if (this._haCond(ruleId, idx) !== cond) return;
+        (this._haLive = this._haLive || {})[key] = this._haRequestError(e);
+        this._refreshHaStatusBox(ruleId, idx);
+      }
+    })();
+    this._haInflight = this._haInflight || {};
+    this._haInflight[key] = job;
+    job.finally(() => { if (this._haInflight[key] === job) delete this._haInflight[key]; });
+    return job;
+  }
+
+  // Run pending (debounced) validations of a rule right away and wait for
+  // all running ones, so params.config matches params.yaml before a save.
+  async _flushHaValidations(ruleId = null) {
+    const pre = ruleId != null ? ruleId + ":" : "";
+    const jobs = [];
+    for (const [key, t] of Object.entries(this._haTimers || {})) {
+      if (pre && !key.startsWith(pre)) continue;
+      clearTimeout(t);
+      delete this._haTimers[key];
+      const sep = key.lastIndexOf(":");
+      jobs.push(this._runHaValidate(key.slice(0, sep), parseInt(key.slice(sep + 1), 10)));
+    }
+    for (const [key, job] of Object.entries(this._haInflight || {})) {
+      if (!pre || key.startsWith(pre)) jobs.push(job);
+    }
+    await Promise.all(jobs.map(j => Promise.resolve(j).catch(() => {})));
+  }
+
+  // Drop pending validations of a rule (structural change: indices shift).
+  _cancelHaTimers(ruleId) {
+    const pre = ruleId + ":";
+    for (const [key, t] of Object.entries(this._haTimers || {})) {
+      if (!key.startsWith(pre)) continue;
+      clearTimeout(t);
+      delete this._haTimers[key];
+    }
+  }
+
+  // Live status of a validation call that failed (connection, backend error)
+  _haRequestError(e) {
+    return { valid: false, error_code: "request", error: (e && (e.message || e.code)) ? String(e.message || e.code) : "" };
+  }
+
+  async _onHaUi(el) {
+    const ruleId = el.dataset.rule, idx = parseInt(el.dataset.idx, 10);
+    const cond = this._haCond(ruleId, idx);
+    if (!cond) return;
+    const mode = el.dataset.mode;
+    const p = cond.params;
+    if ((p.ui || "form") === mode) return;
+    if (mode === "yaml") {
+      // Render the current config as YAML (server-side dump)
+      try {
+        const res = await this._ws("cover_automatic/condition/validate", { config: p.config || null });
+        if (this._haCond(ruleId, idx) !== cond) return;
+        p.yaml = res && res.yaml ? res.yaml : (p.yaml || "");
+        (this._haLive = this._haLive || {})[ruleId + ":" + idx] = res;
+      } catch (e) {
+        // Stay in the form: an outdated YAML text would replace the condition
+        console.error(e);
+        if (this._haCond(ruleId, idx) !== cond) return;
+        (this._haLive = this._haLive || {})[ruleId + ":" + idx] = this._haRequestError(e);
+        this._refreshHaStatusBox(ruleId, idx);
+        this._showError(e);
+        return;
+      }
+    } else {
+      // Only switch when the form can represent the YAML (else a notice shows)
+      if (p.yaml && p.yaml.trim()) {
+        try {
+          const res = await this._ws("cover_automatic/condition/validate", { yaml: p.yaml });
+          if (this._haCond(ruleId, idx) !== cond) return;
+          if (res && res.config) p.config = res.config;
+          (this._haLive = this._haLive || {})[ruleId + ":" + idx] = res;
+        } catch (e) {
+          // Stay in YAML: the form would show the config of the old text
+          console.error(e);
+          if (this._haCond(ruleId, idx) !== cond) return;
+          (this._haLive = this._haLive || {})[ruleId + ":" + idx] = this._haRequestError(e);
+          this._refreshHaStatusBox(ruleId, idx);
+          this._showError(e);
+          return;
+        }
+      }
+    }
+    p.ui = mode;
+    this._rerenderCondCard(ruleId, idx);
+  }
+
+  _onHaFormChange(el, isInputEvent) {
+    const ruleId = el.dataset.rule, idx = parseInt(el.dataset.idx, 10);
+    const cond = this._haCond(ruleId, idx);
+    if (!cond) return;
+    const p = cond.params;
+    const m = this._haFormModel(p.config, p.op) || this._haFormModel(this._haDefaultConfig("state"));
+    const field = el.dataset.field;
+    let structural = false;
+    const toNum = (v) => (v === "" || v == null ? null : Number(v));
+    switch (field) {
+      case "kind": {
+        const next = this._haFormModel(this._haDefaultConfig(el.value));
+        next.entity = m.entity;
+        m.above = undefined; m.below = undefined;
+        Object.assign(m, next);
+        structural = true;
+        break;
+      }
+      case "entity":
+        if (isInputEvent) return; // wait for the value to be committed (change)
+        m.entity = el.value.trim();
+        m.attribute = "";
+        if (m.kind === "state") m.states = [];
+        structural = true;
+        break;
+      case "attribute":
+        m.attribute = el.value;
+        if (m.kind === "state") m.states = [];
+        structural = true;
+        break;
+      case "negate":
+        m.negate = el.value === "1";
+        structural = true;
+        break;
+      case "for":
+        m.forMinutes = toNum(el.value);
+        break;
+      case "operator":
+        m.operator = el.value;
+        structural = true;
+        break;
+      case "above":
+        m.above = toNum(el.value);
+        break;
+      case "below":
+        m.below = toNum(el.value);
+        break;
+      default:
+        return;
+    }
+    p.config = this._haFormToConfig(m);
+    p.op = m.kind === "numeric" ? m.operator : undefined;
+    p.yaml = ""; // regenerated from config when switching to YAML
+    if (structural) this._rerenderCondCard(ruleId, idx);
+    else this._refreshHaStatusBox(ruleId, idx);
+    this._scheduleHaValidate(ruleId, idx);
+  }
+
+  _onHaStateToggle(el, forceAdd = null) {
+    const ruleId = el.dataset.rule, idx = parseInt(el.dataset.idx, 10);
+    const cond = this._haCond(ruleId, idx);
+    if (!cond) return;
+    const m = this._haFormModel(cond.params.config);
+    if (!m || m.kind !== "state") return;
+    const val = forceAdd != null ? forceAdd : el.dataset.val;
+    if (!val) return;
+    if (m.states.includes(val)) {
+      if (forceAdd == null) m.states = m.states.filter(s => s !== val);
+    } else {
+      m.states.push(val);
+    }
+    cond.params.config = this._haFormToConfig(m);
+    cond.params.yaml = "";
+    this._rerenderCondCard(ruleId, idx);
+    this._scheduleHaValidate(ruleId, idx);
+  }
+
+  _onHaStateAdd(el) {
+    const key = el.dataset.rule + ":" + el.dataset.idx;
+    const input = this.shadowRoot.querySelector(`[data-ha-other="${CSS.escape(key)}"]`);
+    const val = input ? input.value.trim() : "";
+    if (val) this._onHaStateToggle(el, val);
+  }
+
+  _onHaYamlInput(el) {
+    const ruleId = el.dataset.rule, idx = parseInt(el.dataset.idx, 10);
+    const cond = this._haCond(ruleId, idx);
+    if (!cond) return;
+    cond.params.yaml = el.value;
+    (this._haLive = this._haLive || {})[ruleId + ":" + idx] = { pending: true };
+    this._refreshHaStatusBox(ruleId, idx);
+    this._scheduleHaValidate(ruleId, idx, 600);
+  }
+
+  // Convert a legacy state_is / numeric_state condition into an ha_condition.
+  _onCondConvert(el) {
+    const ruleId = el.dataset.rule, idx = parseInt(el.dataset.idx, 10);
+    const rule = this._edRule(ruleId);
+    const cond = rule && rule.conditions ? rule.conditions[idx] : null;
+    if (!cond) return;
+    const p = cond.params || {};
+    const entity = p.entity_id || p.entity || "";
+    let config;
+    if (cond.type === "state_is") {
+      config = { condition: "state", entity_id: entity, state: p.state != null ? String(p.state) : [] };
+    } else if (cond.type === "numeric_state") {
+      config = { condition: "numeric_state", entity_id: entity };
+      const v = Number(p.value);
+      if (Number.isFinite(v)) {
+        if (String(p.operator || "above") === "below") config.below = v; else config.above = v;
+      }
+    } else {
+      return;
+    }
+    const prev = rule.conditions[idx] || {};
+    rule.conditions[idx] = { type: "ha_condition", params: { ui: "form", config, yaml: "" }, group: prev.group || 0, negate: !!prev.negate };
+    this._rerenderCondCard(ruleId, idx);
+    this._scheduleHaValidate(ruleId, idx, 0);
+  }
+
+  // Readable summary of a condition for the collapsed rule chips.
+  _condChipLabel(c) {
+    if (c.type !== "ha_condition") return this._t("cond_" + c.type);
+    const cfg = c.params && c.params.config;
+    const m = this._haFormModel(cfg, c.params && c.params.op);
+    const fill = (tpl, values) => tpl.replace(/\{(\w+)\}/g, (mm, n) => (values[n] != null ? String(values[n]) : mm));
+    if (m && m.entity) {
+      const stateObj = this._hass?.states ? this._hass.states[m.entity] : null;
+      let name = this._haEntityName(m.entity);
+      if (m.attribute) name += " · " + this._haAttributeLabel(stateObj, m.attribute);
+      if (m.kind === "state") {
+        const states = m.states.map(s => "« " + this._haStateLabel(stateObj, m.attribute, s) + " »").join(this._t("ha_chip_or"));
+        let txt = fill(this._t(m.negate ? "ha_chip_is_not" : "ha_chip_is"), { entity: name, states });
+        if (!m.negate && m.forMinutes) txt += fill(this._t("ha_chip_for"), { min: Math.round(m.forMinutes * 100) / 100 });
+        return txt;
+      }
+      if (m.operator === "between") return fill(this._t("ha_chip_between"), { entity: name, min: m.above, max: m.below });
+      return fill(this._t(m.operator === "below" ? "ha_chip_below" : "ha_chip_above"), { entity: name, value: m.operator === "below" ? m.below : m.above });
+    }
+    if (cfg && cfg.condition) {
+      let type = this._i18nOr("ha_ctype_" + cfg.condition, String(cfg.condition));
+      if (Array.isArray(cfg.conditions)) type += " (" + cfg.conditions.length + ")";
+      return fill(this._t("ha_chip_other"), { type });
+    }
+    return this._t("cond_ha_condition");
+  }
+
   _renderRuleAddForm() {
     let html = `<div class="inline-form mt-16">
       <div class="form-group">
         <label>${this._t("name")}</label>
-        <input type="text" value="" data-rule-new-field="name" placeholder="${this._t("name")}">
+        <input type="text" value="" data-rule-new-field="name" maxlength="100" placeholder="${this._t("name")}">
       </div>
       <div class="form-row">
         <div class="form-group">
@@ -3537,8 +7166,21 @@ class CoverAutomaticPanel extends HTMLElement {
     return html;
   }
 
+  // Rules in the order of the Rules tab: highest priority first, ties broken
+  // by rule id -- the same order the engine uses to pick the winning rule.
+  _rulesByPriority(rules) {
+    return Object.values(rules || {}).sort((a, b) =>
+      // Same tie-break as the engine (plain code point order of the ids)
+      ((b.priority ?? 0) - (a.priority ?? 0)) || (String(a.id) < String(b.id) ? -1 : String(a.id) > String(b.id) ? 1 : 0));
+  }
+
+  // Rules that belong to a scenario (scenario_ids null = every scenario).
+  _ruleInScenario(rule, scenarioId) {
+    return !Array.isArray(rule.scenario_ids) || rule.scenario_ids.includes(scenarioId);
+  }
+
   _renderScenarioCard(sc, rules, isActive) {
-    const ruleEntries = Object.values(rules);
+    const ruleEntries = this._rulesByPriority(rules).filter(r => this._ruleInScenario(r, sc.id));
     let html = `<div class="scenario-card${isActive ? " active-scenario" : ""}">
       <div class="sc-header">
         <div class="sc-name">
@@ -3555,12 +7197,16 @@ class CoverAutomaticPanel extends HTMLElement {
     // Rules list with enabled/disabled toggles
     html += '<div class="sc-rules">';
     if (ruleEntries.length === 0) {
-      html += `<div class="scenario-no-rules">${this._t("scenario_no_rules")}</div>`;
+      html += `<div class="scenario-no-rules">${this._t(Object.keys(rules || {}).length ? "scenario_no_member_rules" : "scenario_no_rules")}</div>`;
     } else {
-      for (const r of ruleEntries) {
+      for (const [ri, r] of ruleEntries.entries()) {
         const disabled = (sc.rules_disabled || []).includes(r.id);
-        html += `<div class="sc-rule-row">
-          <span${disabled ? ' class="sc-rule-disabled"' : ""}>${this._esc(r.name)}</span>
+        // A rule switched off in the Rules tab never runs, whatever the
+        // scenario says: show it greyed out. Its scenario toggle stays usable
+        // and takes effect once the rule is enabled again.
+        const ruleOff = r.enabled === false;
+        html += `<div class="sc-rule-row${ruleOff ? " sc-rule-off" : ""}"${ruleOff ? ` title="${this._esc(this._t("scenario_rule_off_hint"))}"` : ""}>
+          <span class="sc-rule-label"><span class="priority-badge">#${ri + 1}</span><span${disabled ? ' class="sc-rule-disabled"' : ""}>${this._esc(r.name)}</span>${r.safety ? `<span class="rule-safety-badge" title="${this._esc(this._t("rule_safety"))}">${this._lucideIcon("shield", 12)}${this._esc(this._t("rule_safety_badge"))}</span>` : ""}${ruleOff ? `<span class="sc-rule-off-badge">${this._esc(this._t("scenario_rule_off"))}</span>` : ""}</span>
           <label class="toggle">
             <input type="checkbox" ${!disabled ? "checked" : ""} data-action="scenario-rule-toggle" data-scenario="${this._esc(sc.id)}" data-rule="${this._esc(r.id)}">
             <span class="toggle-slider"></span>
@@ -3648,6 +7294,11 @@ class CoverAutomaticPanel extends HTMLElement {
       const sel = e.entity_id === currentValue ? " selected" : "";
       html += `<option value="${this._esc(e.entity_id)}"${sel}>${this._esc(name)} (${this._esc(e.entity_id)})</option>`;
     }
+    // A configured entity outside the filter (other device class, not loaded
+    // yet) stays selected instead of being cleared by the next save.
+    if (currentValue && !entities.some(e => e.entity_id === currentValue)) {
+      html += `<option value="${this._esc(currentValue)}" selected>${this._esc(currentValue)}</option>`;
+    }
     html += "</select>";
     return html;
   }
@@ -3656,7 +7307,8 @@ class CoverAutomaticPanel extends HTMLElement {
     if (!this._hass || !this._hass.states) return `<input type="text" value="${this._esc(currentValue || "")}" data-action="cover-input" data-id="${this._esc(coverId)}" data-field="${field}">`;
     const entities = Object.values(this._hass.states)
       .filter(s => {
-        if (!s.entity_id.startsWith(domain + ".")) return false;
+        const domains = Array.isArray(domain) ? domain : [domain];
+        if (!domains.some(d => s.entity_id.startsWith(d + "."))) return false;
         if (deviceClass && s.attributes.device_class !== deviceClass) return false;
         return true;
       })
@@ -3666,7 +7318,12 @@ class CoverAutomaticPanel extends HTMLElement {
     for (const e of entities) {
       const name = e.attributes.friendly_name || e.entity_id;
       const sel = e.entity_id === currentValue ? " selected" : "";
-      html += `<option value="${this._esc(e.entity_id)}"${sel}>${this._esc(name)}</option>`;
+      html += `<option value="${this._esc(e.entity_id)}"${sel}>${this._esc(name)} (${this._esc(e.entity_id)})</option>`;
+    }
+    // A configured entity outside the filter (other device class, not loaded
+    // yet, removed) stays shown and selected instead of reading as "none".
+    if (currentValue && !entities.some(e => e.entity_id === currentValue)) {
+      html += `<option value="${this._esc(currentValue)}" selected>${this._esc(currentValue)}</option>`;
     }
     html += "</select>";
     return html;
@@ -3701,9 +7358,66 @@ class CoverAutomaticPanel extends HTMLElement {
     if (!entityId || !this._hass || !this._hass.states) return "";
     const state = this._hass.states[entityId];
     if (!state || state.state === "unavailable" || state.state === "unknown") return "";
-    const val = state.state;
-    const u = unit || state.attributes.unit_of_measurement || "";
-    return '<div class="sensor-current-value">' + this._t("settings_current_value") + ': ' + this._esc(val) + this._esc(u) + '</div>';
+    let text;
+    if (!unit && typeof this._hass.formatEntityState === "function") {
+      try { text = this._hass.formatEntityState(state); } catch (e) { text = undefined; }
+    }
+    if (!text) text = state.state + (unit || state.attributes.unit_of_measurement || "");
+    return '<div class="sensor-current-value">' + this._t("settings_current_value") + this._colon() + this._esc(text) + '</div>';
+  }
+
+  // Entities that can provide a threshold value (numbers and numeric text).
+  _thresholdEntityOptions(currentValue, kind = null) {
+    const states = (this._hass && this._hass.states) || {};
+    const list = Object.values(states).filter(st => {
+      const dom = st.entity_id.split(".")[0];
+      if (kind === "temperature") {
+        // Setpoints: number helpers, and sensors in degrees only
+        if (dom === "input_number" || dom === "number") return true;
+        const u = st.attributes.unit_of_measurement;
+        return dom === "sensor" && (st.attributes.device_class === "temperature" || u === "°C" || u === "°F");
+      }
+      if (dom === "input_number" || dom === "number" || dom === "input_text") return true;
+      // Sensors: only numeric ones (a text sensor cannot be a threshold)
+      return dom === "sensor" && (st.attributes.unit_of_measurement != null || Number.isFinite(parseFloat(st.state)));
+    }).sort((a, b) => (a.attributes.friendly_name || a.entity_id).localeCompare(b.attributes.friendly_name || b.entity_id));
+    let html = `<option value="">-- ${this._t("none")} --</option>`;
+    let found = false;
+    for (const e of list) {
+      const name = e.attributes.friendly_name || e.entity_id;
+      const sel = e.entity_id === currentValue;
+      if (sel) found = true;
+      html += `<option value="${this._esc(e.entity_id)}"${sel ? " selected" : ""}>${this._esc(name)} (${this._esc(e.entity_id)})</option>`;
+    }
+    // Keep a configured entity selectable even when it is not loaded
+    if (currentValue && !found) html += `<option value="${this._esc(currentValue)}" selected>${this._esc(currentValue)}</option>`;
+    return html;
+  }
+
+  // Current value of a threshold entity, e.g. "currently: 23 °C".
+  _thresholdEntityValue(entityId) {
+    if (!entityId) return "";
+    const st = this._hass && this._hass.states ? this._hass.states[entityId] : null;
+    if (!st || st.state === "unavailable" || st.state === "unknown" || st.state === "") {
+      return `<span class="threshold-entity-unavail">${this._esc(this._t("threshold_entity_unavailable"))}</span>`;
+    }
+    const u = st.attributes.unit_of_measurement;
+    return this._esc(this._t("threshold_entity_current") + this._colon() + st.state + (u ? " " + u : ""));
+  }
+
+  // Optional entity next to a numeric threshold. attrs: the select's
+  // data attributes (settings field or cover-input).
+  _renderThresholdEntity(attrs, currentValue, kind = null) {
+    const cur = currentValue || "";
+    const control = (this._hass && this._hass.states)
+      ? `<select ${attrs} data-threshold-entity>${this._thresholdEntityOptions(cur, kind)}</select>`
+      : `<input type="text" value="${this._esc(cur)}" ${attrs} data-threshold-entity>`;
+    return `<div class="threshold-entity">
+      <div class="threshold-entity-label">${this._esc(this._t("threshold_entity"))}</div>
+      ${control}
+      <div class="threshold-entity-value">${this._thresholdEntityValue(cur)}</div>
+      ${this._hint("threshold_entity_hint")}
+    </div>`;
   }
 
   _renderCompassSVG(rotation) {
@@ -3719,20 +7433,30 @@ class CoverAutomaticPanel extends HTMLElement {
     let facadeArcs = "";
     const facadeColors = ["#7da7c8", "#7fb89e", "#c4a979", "#c98969", "#b878a1", "#8a7eb5"];
     facades.forEach((f, i) => {
-      const startDeg = (f.azimuth_start - 90) * Math.PI / 180;
-      const endDeg = (f.azimuth_end - 90) * Math.PI / 180;
+      const azS = this._facadeAz(f.azimuth_start, 0), azE = this._facadeAz(f.azimuth_end, 0);
+      const startDeg = (azS - 90) * Math.PI / 180;
+      const endDeg = (azE - 90) * Math.PI / 180;
       const arcR = r - 8;
+      const col = facadeColors[i % facadeColors.length];
+      if (azS === azE) {
+        // start == end: full-circle facade (sun-exposed from every direction)
+        facadeArcs += `<circle cx="${cx}" cy="${cy}" r="${arcR}" fill="none" stroke="${col}" stroke-width="9" opacity="0.18"/>`;
+        facadeArcs += `<circle cx="${cx}" cy="${cy}" r="${arcR}" fill="none" stroke="${col}" stroke-width="3.5" opacity="0.9"/>`;
+        const lRad = (azS - 90) * Math.PI / 180;
+        const lx = cx + (arcR - 15) * Math.cos(lRad), ly = cy + (arcR - 15) * Math.sin(lRad);
+        facadeArcs += `<text x="${lx}" y="${ly}" text-anchor="middle" dominant-baseline="central" font-size="9" letter-spacing="0.3" fill="${col}" font-weight="600">${this._esc(String(f.name || "").substring(0, 8))}</text>`;
+        return;
+      }
       const x1 = cx + arcR * Math.cos(startDeg), y1 = cy + arcR * Math.sin(startDeg);
       const x2 = cx + arcR * Math.cos(endDeg), y2 = cy + arcR * Math.sin(endDeg);
-      let sweep = f.azimuth_end - f.azimuth_start;
+      let sweep = azE - azS;
       if (sweep < 0) sweep += 360;
       const large = sweep > 180 ? 1 : 0;
-      const col = facadeColors[i % facadeColors.length];
       const d = `M${x1},${y1} A${arcR},${arcR} 0 ${large},1 ${x2},${y2}`;
       facadeArcs += `<path d="${d}" fill="none" stroke="${col}" stroke-width="9" stroke-linecap="round" opacity="0.18"/>`;
       facadeArcs += `<path d="${d}" fill="none" stroke="${col}" stroke-width="3.5" stroke-linecap="round" opacity="0.9"/>`;
       // Label
-      const midDeg = (f.azimuth_start + sweep / 2 - 90) * Math.PI / 180;
+      const midDeg = (azS + sweep / 2 - 90) * Math.PI / 180;
       const lx = cx + (arcR - 15) * Math.cos(midDeg), ly = cy + (arcR - 15) * Math.sin(midDeg);
       facadeArcs += `<text x="${lx}" y="${ly}" text-anchor="middle" dominant-baseline="central" font-size="9" letter-spacing="0.3" fill="${col}" font-weight="600">${this._esc(f.name.substring(0, 8))}</text>`;
     });
@@ -3805,10 +7529,10 @@ class CoverAutomaticPanel extends HTMLElement {
       <circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="var(--divider-color)" stroke-width="1"/>
       <circle cx="${cx}" cy="${cy}" r="${r - 20}" fill="none" stroke="var(--divider-color)" stroke-width="1" stroke-dasharray="0.5 6" stroke-linecap="round" opacity="0.8"/>
       <!-- Cardinal directions (fixed); N carries the accent as rotation reference -->
-      <text x="${cx}" y="${cy - r - 8}" text-anchor="middle" font-size="12" font-weight="700" letter-spacing="1" fill="var(--ca-primary)">N</text>
-      <text x="${cx}" y="${cy + r + 18}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">S</text>
-      <text x="${cx + r + 11}" y="${cy + 4}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">E</text>
-      <text x="${cx - r - 11}" y="${cy + 4}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">W</text>
+      <text x="${cx}" y="${cy - r - 8}" text-anchor="middle" font-size="12" font-weight="700" letter-spacing="1" fill="var(--ca-primary)">${this._esc(this._t("compass_n"))}</text>
+      <text x="${cx}" y="${cy + r + 18}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">${this._esc(this._t("compass_s"))}</text>
+      <text x="${cx + r + 11}" y="${cy + 4}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">${this._esc(this._t("compass_e"))}</text>
+      <text x="${cx - r - 11}" y="${cy + 4}" text-anchor="middle" font-size="12" font-weight="600" letter-spacing="1" fill="var(--ca-secondary-text)">${this._esc(this._t("compass_w"))}</text>
       <!-- North marker: filled triangle pointing inward from the ring -->
       <polygon points="${cx - 3.5},${cy - r} ${cx + 3.5},${cy - r} ${cx},${cy - r + 8}" fill="var(--ca-primary)"/>
       <!-- Tick marks (north replaced by the triangle marker) -->
@@ -3836,14 +7560,14 @@ class CoverAutomaticPanel extends HTMLElement {
     const s = this._config.settings || {};
     const hint = (text) => `<div class="settings-hint">${text}</div>`;
     const hintIntro = (text) => `<div class="settings-hint-intro">${text}</div>`;
-    const active = this._activeSettingsSection || "house";
+    let active = this._activeSettingsSection || "house";
+    if (active === "solar") active = this._activeSettingsSection = "comfort";
 
     const sections = [
       { id: "house", labelKey: "settings_section_house", icon: this._lucideIcon("house", 16) },
       { id: "sensors", labelKey: "settings_section_sensors", icon: this._lucideIcon("gauge", 16) },
-      { id: "comfort", labelKey: "settings_section_comfort", icon: this._lucideIcon("thermometer", 16) },
+      { id: "comfort", labelKey: "settings_section_comfort", icon: this._lucideIcon("sun", 16) },
       { id: "wind", labelKey: "settings_section_wind", icon: this._lucideIcon("wind", 16) },
-      { id: "solar", labelKey: "settings_section_solar", icon: this._lucideIcon("sun", 16) },
       { id: "automation", labelKey: "settings_section_automation", icon: this._lucideIcon("cog", 16) },
       { id: "backup", labelKey: "settings_section_backup", icon: this._lucideIcon("archive", 16) }
     ];
@@ -3851,7 +7575,7 @@ class CoverAutomaticPanel extends HTMLElement {
     let html = '<div class="settings-shell">';
 
     // Sidebar navigation
-    html += '<aside class="settings-nav" role="tablist" aria-label="Settings">';
+    html += '<aside class="settings-nav" role="tablist" aria-label="' + this._esc(this._t("settings_nav_label")) + '">';
     for (const sec of sections) {
       const isActive = sec.id === active;
       const cls = "settings-nav-btn" + (isActive ? " active" : "");
@@ -3895,118 +7619,194 @@ class CoverAutomaticPanel extends HTMLElement {
       html += `<div class="card">
       <div class="card-header">${this._lucideIcon("gauge")} ${this._t("settings_section_sensors")}</div>
       <div class="card-body">
-        <div class="form-row">
-          <div class="form-group">
-            <label>${this._t("settings_outdoor_temp")}</label>
-            ${this._renderEntitySelect("outdoor_temp_sensor", s.outdoor_temp_sensor, "sensor", "temperature")}
-            ${this._renderSensorValue(s.outdoor_temp_sensor, "\u00B0")}
-            ${hint(this._t("settings_outdoor_temp_hint"))}
-          </div>
-          <div class="form-group">
-            <label>${this._t("settings_indoor_temp")}</label>
+        ${this._optBox({
+          title: this._t("settings_comfort_range_title"),
+          head: `<div class="form-group">
+            <label>${this._L("settings_indoor_temp")}</label>
             ${this._renderEntitySelect("indoor_temp_sensor", s.indoor_temp_sensor, "sensor", "temperature")}
             ${this._renderSensorValue(s.indoor_temp_sensor, "\u00B0")}
             ${hint(this._t("settings_indoor_temp_hint"))}
+          </div>`,
+          body: `${hintIntro(this._t("settings_comfort_hint"))}
+          <div class="form-row">
+            <div class="form-group">
+              <label>${this._L("settings_comfort_min")}</label>
+              <input type="number" step="0.5" value="${this._num(s.comfort_temp_min, 21)}" data-settings-field="comfort_temp_min">
+              ${this._renderThresholdEntity('data-settings-field="comfort_temp_min_entity"', s.comfort_temp_min_entity, "temperature")}
+            </div>
+            <div class="form-group">
+              <label>${this._L("settings_comfort_max")}</label>
+              <input type="number" step="0.5" value="${this._num(s.comfort_temp_max, 25)}" data-settings-field="comfort_temp_max">
+              ${this._renderThresholdEntity('data-settings-field="comfort_temp_max_entity"', s.comfort_temp_max_entity, "temperature")}
+            </div>
           </div>
-        </div>
-        <div class="form-row">
-          <div class="form-group">
-            <label>${this._t("settings_weather")}</label>
-            ${this._renderEntitySelect("weather_entity", s.weather_entity, "weather", null)}
-            ${this._renderSensorValue(s.weather_entity)}
-            ${hint(this._t("settings_weather_hint"))}
-          </div>
-          <div class="form-group">
-            <label>${this._t("settings_workday_sensor")}</label>
-            ${this._renderEntitySelect("workday_sensor", s.workday_sensor, "binary_sensor", null)}
-            ${this._renderSensorValue(s.workday_sensor)}
-            ${hint(this._t("settings_workday_hint"))}
-          </div>
-        </div>
-      </div>
-    </div>`;
-    }
-
-    // Comfort section
-    if (active === "comfort") {
-      html += `<div class="card">
-      <div class="card-header">${this._lucideIcon("thermometer")} ${this._t("settings_section_comfort")}</div>
-      <div class="card-body">
-        ${hintIntro(this._t("settings_comfort_hint"))}
-        <div class="form-row">
-          <div class="form-group">
-            <label>${this._t("settings_comfort_min")}</label>
-            <input type="number" step="0.5" value="${this._num(s.comfort_temp_min, 21)}" data-settings-field="comfort_temp_min">
-          </div>
-          <div class="form-group">
-            <label>${this._t("settings_comfort_max")}</label>
-            <input type="number" step="0.5" value="${this._num(s.comfort_temp_max, 25)}" data-settings-field="comfort_temp_max">
-          </div>
-        </div>
-        <div class="form-row">
           <div class="form-group">
-            <label>${this._t("settings_comfort_hysteresis")}</label>
+            <label>${this._L("settings_comfort_hysteresis")}</label>
             <input type="number" step="0.1" min="0.1" max="5" value="${this._num(s.comfort_hysteresis, 1)}" data-settings-field="comfort_hysteresis">
             ${hint(this._t("settings_comfort_hysteresis_hint"))}
           </div>
-          <div class="form-group">
-            <label>${this._t("settings_threshold_hysteresis")}</label>
+          ${this._renderHystExplain("comfort")}
+          <div class="form-group" style="margin-top:16px">
+            <label>${this._t("settings_temp_color")}</label>
+            <input type="hidden" data-settings-field="temp_color_mode" value="${s.temp_color_thermometer === true ? "thermometer" : "action"}" data-initial="${s.temp_color_thermometer === true ? "thermometer" : "action"}">
+            <div class="radio-group">${["action", "thermometer"].map(v => `<label class="radio-row">
+              <input type="radio" name="temp_color_mode" value="${v}" data-settings-radio="temp_color_mode" ${(s.temp_color_thermometer === true ? "thermometer" : "action") === v ? "checked" : ""}>
+              <span><b>${this._esc(this._t("settings_temp_color_" + v))}</b><br><span class="radio-hint">${this._esc(this._t("settings_temp_color_" + v + "_hint"))}</span></span>
+            </label>`).join("")}</div>
+          </div>`,
+        })}
+        ${this._optBox({
+          title: this._t("settings_outdoor_box_title"),
+          dep: '[data-settings-field="outdoor_temp_sensor"]', mode: "value",
+          head: `<div class="form-group">
+            <label>${this._t("settings_outdoor_temp")}</label>
+            ${this._renderEntitySelect("outdoor_temp_sensor", s.outdoor_temp_sensor, "sensor", "temperature")}
+            ${this._renderSensorValue(s.outdoor_temp_sensor, "\u00B0")}
+            ${hint(this._t("settings_outdoor_temp_hint"))}
+          </div>`,
+          offNote: this._t("settings_outdoor_off_note"),
+          body: `<div class="form-group">
+            <label>${this._L("settings_threshold_hysteresis")}</label>
             <input type="number" step="0.1" min="0" max="5" value="${this._num(s.threshold_hysteresis, 0.5)}" data-settings-field="threshold_hysteresis">
             ${hint(this._t("settings_threshold_hysteresis_hint"))}
           </div>
-        </div>
+          ${this._renderHystExplain("rules")}`,
+        })}
+        ${this._optBox({
+          title: this._t("settings_other_sensors_title"),
+          body: `<div class="form-row">
+            <div class="form-group">
+              <label>${this._t("settings_weather")}</label>
+              ${this._renderEntitySelect("weather_entity", s.weather_entity, "weather", null)}
+              ${this._renderSensorValue(s.weather_entity)}
+              ${hint(this._t("settings_weather_hint"))}
+            </div>
+            <div class="form-group">
+              <label>${this._t("settings_workday_sensor")}</label>
+              ${this._renderEntitySelect("workday_sensor", s.workday_sensor, "binary_sensor", null)}
+              ${this._renderSensorValue(s.workday_sensor)}
+              ${hint(this._t("settings_workday_hint"))}
+            </div>
+          </div>`,
+        })}
       </div>
     </div>`;
     }
 
     // Wind section
     if (active === "wind") {
+      const windSt = s.wind_sensor && this._hass?.states ? this._hass.states[s.wind_sensor] : null;
+      const windUnit = (windSt && windSt.attributes.unit_of_measurement) || "";
       html += `<div class="card">
       <div class="card-header">${this._lucideIcon("wind")} ${this._t("settings_section_wind")}</div>
       <div class="card-body">
         ${hintIntro(this._t("settings_wind_hint"))}
-        <div class="form-group">
+        ${this._optBox({
+          dep: '[data-settings-field="wind_sensor"]', mode: "value",
+          head: `<div class="form-group">
           <label>${this._t("settings_wind_sensor")}</label>
           ${this._renderEntitySelect("wind_sensor", s.wind_sensor, "sensor", "wind_speed")}
-          ${this._renderSensorValue(s.wind_sensor, " km/h")}
-        </div>
-        <div class="form-row">
+          ${this._renderSensorValue(s.wind_sensor)}
+        </div>`,
+          offNote: this._t("settings_wind_off_note"),
+          body: `<div class="form-row">
           <div class="form-group">
-            <label>${this._t("settings_wind_threshold")}</label>
+            <label>${this._t("settings_wind_threshold")}${windUnit ? " (" + this._esc(windUnit) + ")" : ""}</label>
             <input type="number" step="1" min="0" value="${this._num(s.wind_speed_threshold, 0)}" data-settings-field="wind_speed_threshold">
           </div>
           <div class="form-group">
-            <label>${this._t("settings_wind_hysteresis")}</label>
+            <label>${this._L("settings_wind_hysteresis")} (${this._esc(windUnit || this._t("unit_sensor"))})</label>
             <input type="number" step="1" min="0" value="${this._num(s.wind_speed_hysteresis, 0)}" data-settings-field="wind_speed_hysteresis">
+            ${hint(this._t("settings_wind_hysteresis_hint"))}
           </div>
         </div>
+        <div class="form-group">
+          <label>${this._t("settings_wind_position")}</label>
+          <input type="number" step="1" min="0" max="100" value="${this._num(s.wind_position, 100)}" data-settings-field="wind_position">
+          ${hint(this._t("settings_wind_position_hint"))}
+        </div>
+        ${this._renderHystExplain("wind")}`,
+        })}
       </div>
     </div>`;
     }
 
-    // Solar section
-    if (active === "solar") {
+    // Solar cards (shown in the comfort & sun tab)
+    if (active === "comfort") {
+      const mode = this._sunComfortMode(s.sun_neutral_ignore !== false, s.preemptive_shading !== false);
+      // Values actually used by the engine: a readable entity wins over the number
+      const cmin = this._effectiveThreshold(s.comfort_temp_min_entity, this._num(s.comfort_temp_min, 21));
+      const cmax = this._effectiveThreshold(s.comfort_temp_max_entity, this._num(s.comfort_temp_max, 25));
+      const radio = (value) => `<label class="radio-row">
+          <input type="radio" name="sun_comfort_mode" value="${value}" data-settings-radio="sun_comfort_mode" ${mode === value ? "checked" : ""}>
+          <span><b>${this._esc(this._t("sun_comfort_" + value))}</b><br><span class="radio-hint">${this._esc(this._t("sun_comfort_" + value + "_hint"))}</span></span>
+        </label>`;
+      const used = this._coversUsingRadiation();
+      const solarSt = s.solar_sensor && this._hass?.states ? this._hass.states[s.solar_sensor] : null;
+      const solarUnit = (solarSt && solarSt.attributes.unit_of_measurement) || "";
+      // Sunshine sensor, nested under the option that uses it. Enabled when
+      // the global choice is "strong sunshine" or a cover uses it on its own.
+      const solarInner = this._optBox({
+          cls: "opt-box-flat",
+          dep: '[data-settings-field="solar_sensor"]', mode: "value",
+          head: `${hintIntro(this._esc(this._t("settings_solar_hint")))}
+          <div class="settings-hint" style="margin-bottom:12px">${this._esc(used
+            ? this._t("solar_used_by").replace("{n}", used)
+            : this._t("solar_unused"))}</div>
+          <div class="form-group">
+            <label>${this._t("settings_solar_sensor")}</label>
+            ${this._renderEntitySelect("solar_sensor", s.solar_sensor, "sensor")}
+            ${this._renderSensorValue(s.solar_sensor)}
+          </div>`,
+          offNote: this._t("settings_solar_off_note"),
+          body: `<div class="form-row">
+            <div class="form-group">
+              <label>${this._L("settings_solar_threshold")}${solarUnit ? " (" + this._esc(solarUnit) + ")" : ""}</label>
+              <input type="number" step="100" min="0" value="${this._num(s.solar_threshold, 0)}" data-settings-field="solar_threshold">
+              ${hint(this._t("settings_solar_threshold_hint"))}
+              ${this._renderThresholdEntity('data-settings-field="solar_threshold_entity"', s.solar_threshold_entity)}
+            </div>
+            <div class="form-group">
+              <label>${this._L("settings_solar_hysteresis")} (${this._esc(solarUnit || this._t("unit_sensor"))})</label>
+              <input type="number" step="100" min="0" value="${this._num(s.solar_hysteresis, 0)}" data-settings-field="solar_hysteresis">
+              ${hint(this._t("settings_solar_hysteresis_hint"))}
+            </div>
+          </div>
+          ${this._renderHystExplain("solar")}`,
+        });
+      const solarBox = this._optBox({
+        cls: "opt-box-nested",
+        title: this._t("settings_section_solar"),
+        dep: '[data-settings-field="sun_comfort_mode"]', mode: "equals", value: "preemptive", force: used > 0,
+        offNote: this._t("settings_solar_nested_off"),
+        body: solarInner,
+      });
       html += `<div class="card">
-      <div class="card-header">${this._lucideIcon("sun", 18)} ${this._t("settings_section_solar")}</div>
+      <div class="card-header">${this._lucideIcon("sun", 18)} ${this._t("settings_section_comfort")}</div>
       <div class="card-body">
-        ${hintIntro(this._t("settings_solar_hint"))}
+        <div class="opt-box">
+        <div class="opt-box-title">${this._L("settings_sun_facade_title")}</div>
+        <div class="settings-hint" style="margin-bottom:10px"><b>${this._esc(this._t("settings_indoor_reminder")
+          .replace("{name}", s.indoor_temp_sensor ? this._haEntityName(s.indoor_temp_sensor) : this._t("settings_indoor_none"))
+          .replace("{min}", cmin).replace("{max}", cmax))}</b></div>
+        ${hintIntro(this._esc(this._t("settings_sun_facade_hint")))}
         <div class="form-group">
-          <label>${this._t("settings_solar_sensor")}</label>
-          ${this._renderEntitySelect("solar_sensor", s.solar_sensor, "sensor")}
-          ${this._renderSensorValue(s.solar_sensor)}
+          <label class="checkbox-row">
+            <input type="checkbox" data-settings-field="sun_heating_ignore" ${s.sun_heating_ignore !== false ? "checked" : ""}>
+            <span>${this._L("sun_heating_label")} <span class="radio-hint">(${this._esc(this._t("sun_below").replace("{t}", cmin))})</span></span>
+          </label>
+          ${hint(this._esc(this._t("sun_heating_hint")))}
         </div>
-        <div class="form-row">
-          <div class="form-group">
-            <label>${this._t("settings_solar_threshold")}</label>
-            <input type="number" step="100" min="0" value="${this._num(s.solar_threshold, 0)}" data-settings-field="solar_threshold">
-            ${hint(this._t("settings_solar_threshold_hint"))}
-          </div>
-          <div class="form-group">
-            <label>${this._t("settings_solar_hysteresis")}</label>
-            <input type="number" step="100" min="0" value="${this._num(s.solar_hysteresis, 0)}" data-settings-field="solar_hysteresis">
-            ${hint(this._t("settings_solar_hysteresis_hint"))}
-          </div>
+        <div class="form-group">
+          <label>${this._L("sun_comfort_label")} <span class="radio-hint">(${this._esc(this._t("sun_between").replace("{min}", cmin).replace("{max}", cmax))})</span></label>
+          <input type="hidden" data-settings-field="sun_comfort_mode" value="${mode}" data-initial="${mode}">
+          <div class="radio-group">${radio("position")}${radio("ignore")}${radio("preemptive")}</div>
+          ${solarBox}
+        </div>
+        <div class="settings-hint">${this._esc(this._t("sun_hot_note").replace("{t}", cmax))}</div>
+        ${this._renderSunExplain(cmin, cmax)}
         </div>
+
       </div>
     </div>`;
     }
@@ -4016,11 +7816,23 @@ class CoverAutomaticPanel extends HTMLElement {
       html += `<div class="card">
       <div class="card-header">${this._lucideIcon("cog")} ${this._t("settings_section_automation")}</div>
       <div class="card-body">
+        <div class="opt-box">
+        <div class="opt-box-title">${this._esc(this._t("settings_auto_box_pause"))}</div>
         <div class="form-group">
           <label>${this._t("settings_pause_duration")}</label>
           <input type="number" min="1" max="480" value="${this._num(s.pause_duration, 10)}" data-settings-field="pause_duration">
           ${hint(this._t("settings_pause_duration_hint"))}
         </div>
+        <div class="form-group">
+          <label class="checkbox-row">
+            <input type="checkbox" data-settings-field="pause_resume_on_match" ${s.pause_resume_on_match !== false ? "checked" : ""}>
+            <span>${this._t("pause_resume_on_match")}</span>
+          </label>
+          ${hint(this._t("pause_resume_on_match_hint"))}
+        </div>
+        </div>
+        <div class="opt-box">
+        <div class="opt-box-title">${this._esc(this._t("settings_auto_box_window"))}</div>
         <div class="form-row">
           <div class="form-group">
             <label>${this._t("settings_lock_position")}</label>
@@ -4045,6 +7857,9 @@ class CoverAutomaticPanel extends HTMLElement {
             ${hint(this._t("settings_vent_tilt_position_hint"))}
           </div>
         </div>
+        </div>
+        <div class="opt-box">
+        <div class="opt-box-title">${this._esc(this._t("settings_auto_box_moves"))}</div>
         <div class="form-row">
           <div class="form-group">
             <label>${this._t("settings_min_position_change")}</label>
@@ -4062,6 +7877,14 @@ class CoverAutomaticPanel extends HTMLElement {
           <input type="number" step="0.1" min="0" max="2" value="${this._num(s.command_stagger, 0)}" data-settings-field="command_stagger">
           ${hint(this._t("settings_command_stagger_hint"))}
         </div>
+        <div class="form-group">
+          <label>${this._t("settings_default_travel_time")}</label>
+          <input type="number" min="1" max="300" step="1" value="${this._num(s.default_travel_time, "")}" placeholder="${this._esc(this._t("settings_default_travel_time_placeholder"))}" data-settings-field="default_travel_time">
+          ${hint(this._t("settings_default_travel_time_hint"))}
+        </div>
+        </div>
+        <div class="opt-box">
+        <div class="opt-box-title">${this._esc(this._t("settings_auto_box_misc"))}</div>
         <div class="form-group">
           <label class="checkbox-row">
             <input type="checkbox" data-settings-field="logbook_enabled" ${s.logbook_enabled !== false ? "checked" : ""}>
@@ -4076,6 +7899,7 @@ class CoverAutomaticPanel extends HTMLElement {
           </label>
           ${hint(this._t("settings_update_check_enabled_hint"))}
         </div>
+        </div>
       </div>
     </div>`;
     }
@@ -4093,6 +7917,8 @@ class CoverAutomaticPanel extends HTMLElement {
       <div class="card-header">${this._lucideIcon("archive")} ${this._t("settings_section_backup")}</div>
       <div class="card-body">
         ${hintIntro(this._t("settings_backup_hint"))}
+        ${this._settingsDirty() ? `<div class="settings-unsaved-warning">${this._lucideIcon("info", 16)} ${this._esc(this._t("settings_unsaved_warning"))}
+          <button class="btn btn-primary" data-action="settings-save">${this._t("save")}</button></div>` : ""}
         <div class="settings-backup-actions">
           <button class="btn" data-action="backup-export">${this._t("settings_export")}</button>
           <button class="btn" data-action="backup-import">${this._t("settings_import")}</button>
@@ -4107,6 +7933,11 @@ class CoverAutomaticPanel extends HTMLElement {
   }
 
   _renderLog() {
+    // Filter on a cover that no longer exists: back to all covers
+    if (this._logCover && this._config && !(this._config.covers || {})[this._logCover]) {
+      this._logCover = null;
+      this._logEntries = null;
+    }
     if (this._logEntries === null) {
       this._loadLog();
       return '<div class="state-msg"><div class="spinner"></div><div>' + this._t("log_loading") + '</div></div>';
@@ -4125,6 +7956,18 @@ class CoverAutomaticPanel extends HTMLElement {
     html += '<button class="btn btn-sm btn-danger" data-action="log-clear">' + this._t("log_clear") + '</button>';
     html += '</div>';
 
+    // Cover filter: all covers, or one (its entries + global events such as wind)
+    const covers = Object.values(this._config?.covers || {})
+      .sort((a, b) => String(a.name || a.entity_id).localeCompare(String(b.name || b.entity_id), this._hass?.language || undefined));
+    html += '<div class="log-cover-filter"><label for="log-cover-select">' + this._esc(this._t("log_filter_cover")) + '</label>'
+      + '<select id="log-cover-select" data-action="log-cover">'
+      + '<option value=""' + (this._logCover ? '' : ' selected') + '>' + this._esc(this._t("log_filter_all_covers")) + '</option>'
+      + covers.map(c => '<option value="' + this._esc(c.entity_id) + '"' + (this._logCover === c.entity_id ? ' selected' : '') + '>'
+        + this._esc(c.name || c.entity_id) + '</option>').join('')
+      + '</select>'
+      + (this._logCover ? '<span class="log-cover-note">' + this._esc(this._t("log_filter_cover_note")) + '</span>' : '')
+      + '</div>';
+
     let entries = this._logEntries;
     if (this._logFilter) {
       entries = entries.filter(e => e.type === this._logFilter);
@@ -4143,7 +7986,7 @@ class CoverAutomaticPanel extends HTMLElement {
     html += '</tr></thead><tbody>';
 
     for (const e of entries) {
-      const time = new Date(e.ts * 1000).toLocaleString();
+      const time = new Date(e.ts * 1000).toLocaleString(this._hass?.language || undefined);
       const typeLabel = this._t("log_type_" + e.type) || e.type;
       const coverName = e.entity_id ? this._getCoverName(e.entity_id) : "–";
       const typeClass = e.type === "wind" ? "status-wind_protected" : e.type === "status" ? "status-paused" : "";
@@ -4151,20 +7994,64 @@ class CoverAutomaticPanel extends HTMLElement {
       html += '<td class="nowrap">' + this._esc(time) + '</td>';
       html += '<td><span class="status-badge ' + typeClass + '">' + this._esc(typeLabel) + '</span></td>';
       html += '<td>' + this._esc(coverName) + '</td>';
-      html += '<td>' + this._esc(e.message) + '</td>';
+      html += '<td>' + this._esc(this._formatLogMessage(e)) + '</td>';
       html += '</tr>';
     }
     html += '</tbody></table></div></div>';
     return html;
   }
 
+  // Localize an activity log entry from its structured data. Entries written
+  // by versions before 1.63.0 have no data.key and keep their English text.
+  _formatLogMessage(e) {
+    const d = e && e.data;
+    const key = d && d.key;
+    if (!key) return e.message || "";
+    const template = this._t("log_msg_" + key);
+    if (template === "log_msg_" + key) return e.message || "";
+    const status = (v) => {
+      const t = this._t("status_" + v);
+      return t !== "status_" + v ? t : String(v);
+    };
+    const values = { ...d };
+    if (key === "status_change") {
+      values.from = status(d.from);
+      values.to = status(d.to);
+    }
+    if (key === "safety_takeover" || key === "safety_release" || key === "sensor_unavailable") {
+      if (d.status) values.status = status(d.status);
+    }
+    if (Array.isArray(d.sensor)) values.sensor = d.sensor.join(", ");
+    if (key === "rule" || key === "safety_takeover" || key === "safety_release") {
+      const rule = this._config?.rules?.[d.rule_id];
+      values.rule = rule ? rule.name : (d.rule_name || d.rule_id || "");
+    }
+    return template.replace(/\{(\w+)\}/g, (m, name) => (values[name] != null ? String(values[name]) : m));
+  }
+
   async _loadLog() {
+    const cover = this._logCover || null;
+    // Same request already in flight: repeated renders don't refire it
+    if (this._logLoading && this._logLoadingCover === cover) return;
+    const seq = (this._logSeq = (this._logSeq || 0) + 1);
+    this._logLoading = true;
+    this._logLoadingCover = cover;
+    let entries;
     try {
-      const result = await this._ws("cover_automatic/log");
-      this._logEntries = result.entries || [];
+      const msg = cover
+        ? { entity_id: cover, include_global: true, limit: 1000 }
+        : {};
+      const result = await this._ws("cover_automatic/log", msg);
+      entries = result.entries || [];
     } catch (e) {
-      this._logEntries = [];
+      entries = [];
     }
+    // Stale response (filter changed, log cleared or newer request): drop it
+    if (seq !== this._logSeq) return;
+    this._logLoading = false;
+    this._logLoadingCover = undefined;
+    if ((this._logCover || null) !== cover) return;
+    this._logEntries = entries;
     this._render();
   }
 
@@ -4176,13 +8063,12 @@ class CoverAutomaticPanel extends HTMLElement {
     for (const eid of Object.keys(covers)) {
       // Combined position cell: current + target with optional divergence marker, plus hysteresis badge
       const haState = this._hass?.states ? this._hass.states[eid] : null;
-      const curPos = haState && haState.attributes ? haState.attributes.current_position : null;
       const live = liveCvrs[eid] || {};
       const tgtPos = live.target_position;
       const hyst = live.hysteresis;
-      const posCell = root.querySelector('[data-live-position="' + eid + '"]');
+      const posCell = root.querySelector('[data-live-position="' + CSS.escape(eid) + '"]');
       if (posCell) {
-        let barHtml = this._posBarCombined(curPos, tgtPos);
+        let barHtml = this._posCellHtml(covers[eid], haState, tgtPos);
         if (hyst === "position" || hyst === "time") {
           barHtml += ' <span class="status-badge status-paused hysteresis-badge" title="' + this._esc(this._t(hyst === "position" ? "cover_hysteresis_position" : "cover_hysteresis_time")) + '">' + (hyst === "position" ? "\u2195" : "\u23F2") + '</span>';
         }
@@ -4190,7 +8076,7 @@ class CoverAutomaticPanel extends HTMLElement {
       }
       // Status + pause remaining + resume button
       const c = covers[eid];
-      const sCell = root.querySelector('[data-live-status="' + eid + '"]');
+      const sCell = root.querySelector('[data-live-status="' + CSS.escape(eid) + '"]');
       if (sCell && c) {
         const st = c.status || "auto";
         const badge = sCell.querySelector(".status-badge");
@@ -4229,12 +8115,12 @@ class CoverAutomaticPanel extends HTMLElement {
         }
       }
       // Cover name
-      const nCell = root.querySelector('[data-live-name="' + eid + '"]');
+      const nCell = root.querySelector('[data-live-name="' + CSS.escape(eid) + '"]');
       if (nCell && c) {
         nCell.textContent = c.name;
       }
       // Facade name + sun icon
-      const fCell = root.querySelector('[data-live-facade="' + eid + '"]');
+      const fCell = root.querySelector('[data-live-facade="' + CSS.escape(eid) + '"]');
       if (fCell && c) {
         const facadeName = this._getFacadeName(c.facade_id);
         const liveFacade = c.facade_id ? ((this._config.live_facades || {})[c.facade_id] || {}) : {};
@@ -4251,7 +8137,7 @@ class CoverAutomaticPanel extends HTMLElement {
         }
       }
       // Rule name -- preserve clickable rule-link markup via DOM API (avoids innerHTML)
-      const rCell = root.querySelector('[data-live-rule="' + eid + '"]');
+      const rCell = root.querySelector('[data-live-rule="' + CSS.escape(eid) + '"]');
       if (rCell) {
         rCell.textContent = "";
         const ruleId = live.rule_id;
@@ -4269,20 +8155,20 @@ class CoverAutomaticPanel extends HTMLElement {
         }
       }
       // Temperature with comfort color
-      const tempCell = root.querySelector('[data-live-temp="' + eid + '"]');
+      const tempCell = root.querySelector('[data-live-temp="' + CSS.escape(eid) + '"]');
       if (tempCell) {
         const c2 = covers[eid];
         const ts = (c2 && c2.indoor_temp_sensor) || ((this._config.settings || {}).indoor_temp_sensor);
         const tst = ts && this._hass?.states ? this._hass.states[ts] : null;
         const tv = tst && tst.state !== "unavailable" && tst.state !== "unknown" ? parseFloat(tst.state) : null;
-        tempCell.textContent = tv != null ? tv.toFixed(1) + " \u00B0C" : "\u2013";
-        const cm2 = live.comfort_mode;
-        tempCell.style.color = cm2 === "cooling" ? "var(--ca-info)" : cm2 === "heating" ? "var(--ca-danger)" : "";
-        tempCell.style.fontWeight = (cm2 === "cooling" || cm2 === "heating") ? "600" : "";
-        tempCell.title = cm2 ? this._t("comfort_" + cm2) : "";
+        const tp = this._tempCellParts(live.comfort_mode, tv);
+        if (tempCell.innerHTML !== tp.html) tempCell.innerHTML = tp.html;
+        tempCell.style.color = tp.color;
+        tempCell.classList.toggle("temp-mode", !!tp.color);
+        tempCell.title = tp.title;
       }
       // Last change
-      const lcCell = root.querySelector('[data-live-lastchange="' + eid + '"]');
+      const lcCell = root.querySelector('[data-live-lastchange="' + CSS.escape(eid) + '"]');
       if (lcCell) lcCell.textContent = live.last_change ? this._formatTimeAgo(live.last_change) : "";
     }
   }
@@ -4324,8 +8210,13 @@ class CoverAutomaticPanel extends HTMLElement {
       this._stopLiveRefresh();
       return;
     }
+    // Drop stale answers: a newer refresh was started, or the config was
+    // replaced (save, import...) while this request was running.
+    const seq = this._liveSeq = (this._liveSeq || 0) + 1;
+    const epoch = this._cfgEpoch || 0;
     try {
       const result = await this._ws("cover_automatic/config");
+      if (seq !== this._liveSeq || epoch !== (this._cfgEpoch || 0) || !this._config) return;
       if (result) {
         if (result.live_covers) this._config.live_covers = result.live_covers;
         if (result.live_facades) this._config.live_facades = result.live_facades;
@@ -4355,21 +8246,40 @@ class CoverAutomaticPanel extends HTMLElement {
       this._stopCondPreview();
       return;
     }
-    const rule = (this._config.rules || {})[this._expandedRule];
-    if (!rule || !rule.conditions || rule.conditions.length === 0) return;
-    const conditions = rule.conditions.map(c => ({ type: c.type, params: c.params || {} }));
+    const ruleId = this._expandedRule;
+    const rule0 = this._edRule(ruleId);
+    if (!rule0 || !rule0.conditions || rule0.conditions.length === 0) return;
+    const conditions = rule0.conditions.map(c => ({ type: c.type, params: c.params || {}, group: parseInt(c.group, 10) || 0, negate: !!c.negate }));
+    // Only the latest request may paint (responses can arrive out of order,
+    // and structural changes bump the sequence to void older ones).
+    const seq = ++this._previewSeq;
     let result;
     try {
       result = await this._ws("cover_automatic/rule/preview_conditions", { conditions });
     } catch (e) { return; }
+    if (seq !== this._previewSeq) return;
     // The editor may have collapsed or switched tabs during the await.
-    if (!result || !Array.isArray(result.results) || this._activeTab !== "rules" || !this._expandedRule) return;
+    if (!result || !Array.isArray(result.results) || this._activeTab !== "rules" || this._expandedRule !== ruleId) return;
+    // Re-read the rule: its conditions may have changed meanwhile.
+    const rule = this._edRule(ruleId);
+    if (!rule || !rule.conditions || rule.conditions.length !== result.results.length
+      || rule.conditions.some((c, i) => c.type !== conditions[i].type)) return;
     const root = this.shadowRoot;
     if (!root) return;
     result.results.forEach((res, idx) => {
       const el = root.querySelector('.cond-preview[data-cond-preview="' + idx + '"]');
       if (el) this._applyCondPreview(el, res);
     });
+    // Group results (only when every condition of the group is evaluable)
+    const { ops } = this._ruleGroups(rule);
+    root.querySelectorAll(".cond-group-preview[data-group-preview]").forEach(el => {
+      const g = parseInt(el.dataset.groupPreview, 10);
+      const res = result.results.filter((_, i) => (parseInt(rule.conditions[i]?.group, 10) || 0) === g);
+      if (!res.length || res.some(r => !r || r.evaluable === false)) { el.className = "cond-preview cond-group-preview"; el.textContent = ""; return; }
+      const matched = ops[g] === "or" ? res.some(r => r.matched) : res.every(r => r.matched);
+      this._applyCondPreview(el, { evaluable: true, matched, actual: null });
+      el.classList.add("cond-group-preview");
+    });
   }
 
   _applyCondPreview(el, res) {
@@ -4398,13 +8308,25 @@ class CoverAutomaticPanel extends HTMLElement {
     switch (res.kind) {
       case "temp": return v + " °C";
       case "elevation": return v + "°";
-      case "weather": return this._i18nOr("weather_" + v, String(v));
+      case "weather": return this._i18nOr("weather_" + String(v).replace(/-/g, "_"), String(v));
       case "day": return this._i18nOr("day_" + v, String(v));
       case "workday": return this._i18nOr("opt_" + v, String(v));
+      case "ha_reading": {
+        const stateObj = this._hass?.states ? this._hass.states[v.entity_id] : null;
+        return this._haStateLabel(stateObj, v.attribute, v.value);
+      }
       default: return String(v);
     }
   }
 
+  // Display label for a multiselect option; the stored value stays raw.
+  _optionLabel(paramKey, opt) {
+    if (paramKey === "weather") {
+      return this._i18nOr("weather_" + String(opt).replace(/-/g, "_"), String(opt));
+    }
+    return this._i18nOr("opt_" + opt, String(opt));
+  }
+
   _i18nOr(key, fallback) {
     const t = this._t(key);
     return (t && t !== key) ? t : fallback;
@@ -4461,14 +8383,15 @@ class CoverAutomaticPanel extends HTMLElement {
     const root = this.shadowRoot;
 
     root.addEventListener("click", (e) => this._handleClick(e));
-    root.addEventListener("change", (e) => this._handleChange(e));
-    root.addEventListener("input", (e) => this._handleInput(e));
+    root.addEventListener("change", (e) => { this._handleChange(e); this._refreshDeps(); });
+    root.addEventListener("input", (e) => { this._handleInput(e); this._refreshDeps(); });
     root.addEventListener("dragstart", (e) => this._handleDragStart(e));
     root.addEventListener("dragend", (e) => this._handleDragEnd(e));
     root.addEventListener("dragover", (e) => this._handleDragOver(e));
     root.addEventListener("dragleave", (e) => this._handleDragLeave(e));
     root.addEventListener("drop", (e) => this._handleDrop(e));
     root.addEventListener("pointerdown", (e) => this._handleHouseDragStart(e));
+    root.addEventListener("focusout", (e) => this._onSlideFocusOut(e));
     // Enter/Space activate non-native interactive elements (rows, sort headers)
     root.addEventListener("keydown", (e) => {
       if (e.key !== "Enter" && e.key !== " ") return;
@@ -4498,43 +8421,70 @@ class CoverAutomaticPanel extends HTMLElement {
 
   /* ---------- Click delegation ---------- */
   _handleClick(e) {
+    // Remember the last clicked control of the slide-out (focus is restored
+    // to it after a rebuild; iOS does not focus clicked buttons).
+    const clicked = e.target && e.target.closest ? e.target.closest("[data-action], input, select, button") : null;
+    if (clicked && clicked.closest(".slide-panel")) {
+      const key = this._slideElKey(clicked);
+      this._slideClick = key ? { key, t: Date.now() } : null;
+    }
     // Tab clicks
     const tabBtn = e.target.closest("[data-tab]");
     if (tabBtn) {
-      this._activeTab = tabBtn.dataset.tab;
-      this._selectedCover = null;
-      this._slideOpen = false;
-      this._expandedRule = null;
-      this._editingFacade = null;
-      this._addingCover = false;
-      this._addingFacade = false;
-      this._addingRule = false;
-      this._addingScenario = false;
-      this._editingScenario = null;
-      this._logEntries = null;
-      if (this._activeTab === "covers") {
-        this._startLiveRefresh();
-      } else {
-        this._stopLiveRefresh();
-      }
-      this._stopCondPreview();
-      this._render();
+      const tab = tabBtn.dataset.tab;
+      this._confirmLeaveRule(() => this._confirmLeaveSettings(() => this._switchTab(tab)));
       return;
     }
+    this._handleActionClick(e);
+  }
+
+  _switchTab(tab) {
+    this._activeTab = tab;
+    this._selectedCover = null;
+    this._slideOpen = false;
+    this._setExpandedRule(null);
+    this._settingsDraft = null;
+    this._editingFacade = null;
+    this._addingCover = false;
+    this._addingFacade = false;
+    this._addingRule = false;
+    this._addingScenario = false;
+    this._editingScenario = null;
+    this._logEntries = null;
+    if (this._activeTab === "covers") {
+      this._startLiveRefresh();
+    } else {
+      this._stopLiveRefresh();
+    }
+    this._stopCondPreview();
+    this._render();
+  }
 
+  _handleActionClick(e) {
     // Route by data-action
     const actionEl = e.target.closest("[data-action]");
     if (!actionEl) return;
     const action = actionEl.dataset.action;
 
     switch (action) {
-      case "toggle-menu": {
-        const ha = document.querySelector("home-assistant");
-        const drawer = ha?.shadowRoot?.querySelector("home-assistant-main")?.shadowRoot?.querySelector("ha-drawer");
-        if (drawer) { drawer.open = !drawer.open; } else { window.history.back(); }
+      case "toggle-menu":
+        // Standard HA event (like ha-menu-button): opens the sidebar/drawer
+        // without navigating away (unsaved drafts stay).
+        this.dispatchEvent(new CustomEvent("hass-toggle-menu", { bubbles: true, composed: true }));
         break;
-      }
       case "retry": this._loadConfig(); break;
+      case "explain-toggle": {
+        const d = actionEl.closest("details");
+        this._explainOpen = this._explainOpen || {};
+        this._explainOpen[actionEl.dataset.key] = d ? !d.open : false;
+        break;
+      }
+      case "sun-explain-toggle": {
+        // Native <details> toggles after the click: remember the new state
+        const d = actionEl.closest("details");
+        this._sunExplainOpen = d ? !d.open : false;
+        break;
+      }
       case "cover-add-start": this._addingCover = true; this._render(); break;
       case "cover-sort": {
         const key = actionEl.dataset.sort;
@@ -4553,7 +8503,7 @@ class CoverAutomaticPanel extends HTMLElement {
       case "select-cover":
         this._selectedCover = actionEl.dataset.id;
         this._slideOpen = true;
-        this._expandedSections = { base: true, sensors: true, advanced: false, tilt: false };
+        this._expandedSections = { base: true };
         this._render();
         // Move focus into the slide-out so Tab order continues inside the dialog
         setTimeout(() => this.shadowRoot.querySelector(".slide-header .btn-icon")?.focus(), 0);
@@ -4565,7 +8515,7 @@ class CoverAutomaticPanel extends HTMLElement {
         this._activeTab = "rules";
         this._slideOpen = false;
         this._selectedCover = null;
-        this._expandedRule = null;
+        this._setExpandedRule(null);
         this._stopLiveRefresh();
         this._render();
         this._highlightRule(ruleId);
@@ -4578,10 +8528,20 @@ class CoverAutomaticPanel extends HTMLElement {
         }
         break;
       case "toggle-section":
-        this._expandedSections[actionEl.dataset.section] = !this._expandedSections[actionEl.dataset.section];
+        {
+          // Accordion: opening a section closes the others -- unless
+          // several are open ("expand all"): then only this one toggles.
+          const id = actionEl.dataset.section;
+          const open = !this._expandedSections[id];
+          const openCount = Object.values(this._expandedSections).filter(Boolean).length;
+          if (openCount > 1) this._expandedSections = { ...this._expandedSections, [id]: open };
+          else this._expandedSections = { [id]: open };
+        }
         this._render();
         break;
       case "settings-section":
+        // _render() keeps the unsaved inputs of the section left (settings draft)
+        this._captureSettingsDraft();
         this._activeSettingsSection = actionEl.dataset.section;
         this._render();
         break;
@@ -4610,21 +8570,81 @@ class CoverAutomaticPanel extends HTMLElement {
       case "facade-edit-cancel": this._editingFacade = null; this._render(); break;
       case "day-toggle": this._onDayToggle(actionEl); break;
       case "multiselect-toggle": this._onMultiselectToggle(actionEl); break;
+      case "ha-ui": this._onHaUi(actionEl); break;
+      case "ha-state-toggle": this._onHaStateToggle(actionEl); break;
+      case "ha-state-add": this._onHaStateAdd(actionEl); break;
+      case "cond-convert": this._onCondConvert(actionEl); break;
+      case "cover-travel-reset": this._onCoverTravelReset(actionEl.dataset.id); break;
+      case "cover-occ-toggle": {
+        const v = actionEl.dataset.val;
+        this._onOccupancyStates(actionEl.dataset.id, (list) => list.some(x => x.toLowerCase() === v.toLowerCase())
+          ? list.filter(x => x.toLowerCase() !== v.toLowerCase()) : [...list, v]);
+        break;
+      }
+      case "cover-occ-add": {
+        const input = this.shadowRoot.querySelector(`[data-occ-other="${CSS.escape(actionEl.dataset.id)}"]`);
+        const v = input ? input.value.trim() : "";
+        if (v) this._onOccupancyStates(actionEl.dataset.id, (list) => list.some(x => x.toLowerCase() === v.toLowerCase()) ? list : [...list, v]);
+        break;
+      }
+      case "sections-toggle-all": {
+        const ids = (actionEl.dataset.ids || "").split(",").filter(Boolean);
+        const allOpen = ids.every(id => this._expandedSections[id]);
+        this._expandedSections = allOpen ? {} : Object.fromEntries(ids.map(id => [id, true]));
+        this._render();
+        break;
+      }
+      case "cover-occ-reset": this._onOccupancyStates(actionEl.dataset.id, () => null); break;
       case "facade-cover-toggle": actionEl.classList.toggle("selected"); break;
       case "facade-add-save": this._onFacadeAddSave(actionEl); break;
       case "facade-edit-save": this._onFacadeEditSave(actionEl); break;
       case "facade-delete": this._onFacadeDelete(actionEl.dataset.id); break;
-      case "rule-expand":
-        this._expandedRule = this._expandedRule === actionEl.dataset.id ? null : actionEl.dataset.id;
-        this._render();
-        if (this._expandedRule) this._startCondPreview(); else this._stopCondPreview();
+      case "rule-expand": {
+        const next = this._expandedRule === actionEl.dataset.id ? null : actionEl.dataset.id;
+        this._confirmLeaveRule(() => {
+          this._setExpandedRule(next);
+          this._render();
+          if (this._expandedRule) this._startCondPreview(); else this._stopCondPreview();
+        });
         break;
+      }
+      case "rule-prio-up":
+      case "rule-prio-down": this._onRuleMove(actionEl.dataset.id, action === "rule-prio-up" ? -1 : 1); break;
       case "rule-delete": this._onRuleDelete(actionEl.dataset.id); break;
+<<<<<<< Updated upstream
       case "rule-duplicate": this._onRuleDuplicate(actionEl.dataset.id); break;
+=======
+      case "rule-duplicate": {
+        const id = actionEl.dataset.id;
+        this._confirmLeaveRule(() => this._onRuleDuplicate(id));
+        break;
+      }
+>>>>>>> Stashed changes
       case "rule-save": this._onRuleSave(actionEl.dataset.id); break;
       case "rule-delete-condition": this._onRuleDeleteCondition(actionEl.dataset.rule, actionEl.dataset.idx); break;
-      case "rule-facade-toggle": actionEl.classList.toggle("selected"); break;
-      case "rule-cover-toggle": actionEl.classList.toggle("selected"); break;
+      case "rule-cond-negate": this._onRuleCondNegate(actionEl); break;
+      case "rule-cond-collapse": {
+        const idx = parseInt(actionEl.dataset.idx, 10);
+        this._setCondCollapsed(actionEl.dataset.rule, idx, !this._isCondCollapsed(actionEl.dataset.rule, idx));
+        break;
+      }
+      case "rule-cond-collapse-all": this._onCondCollapseAll(actionEl.dataset.rule); break;
+      case "rule-group-add": this._onRuleGroupAdd(actionEl.dataset.rule); break;
+      case "rule-group-delete": this._onRuleGroupDelete(actionEl.dataset.rule, actionEl.dataset.group); break;
+      case "rule-cond-up":
+      case "rule-cond-down":
+        this._onRuleCondReorder(actionEl.dataset.rule, parseInt(actionEl.dataset.idx, 10), action === "rule-cond-up" ? -1 : 1);
+        break;
+      case "rule-group-up":
+      case "rule-group-down":
+        this._onRuleGroupReorder(actionEl.dataset.rule, parseInt(actionEl.dataset.group, 10), action === "rule-group-up" ? -1 : 1);
+        break;
+      case "rule-facade-toggle":
+      case "rule-scenario-toggle":
+      case "rule-cover-toggle":
+        actionEl.classList.toggle("selected");
+        this._syncRuleDraftFromDom();
+        break;
       case "rule-add-start": this._addingRule = true; this._render(); break;
       case "rule-add-cancel": this._addingRule = false; this._render(); break;
       case "rule-add-save": this._onRuleAddSave(actionEl); break;
@@ -4638,24 +8658,40 @@ class CoverAutomaticPanel extends HTMLElement {
       case "scenario-delete": this._onScenarioDelete(actionEl.dataset.id); break;
       case "scenario-icon-pick": this._onScenarioIconPick(actionEl); break;
       case "settings-save": this._onSettingsSave(); break;
-      case "backup-export": this._onBackupExport(); break;
+      case "backup-export": this._onBackupExportClick(); break;
       case "backup-import": { const fi = this.shadowRoot.querySelector('[data-action="backup-file"]'); if (fi) fi.click(); break; }
       case "backup-file": this._onBackupFileSelected(actionEl); break;
+      case "cover-show-log": {
+        const id = actionEl.dataset.id;
+        this._confirmLeaveRule(() => this._confirmLeaveSettings(() => {
+          this._logCover = id || null;
+          this._logFilter = null;
+          this._switchTab("log");
+        }));
+        break;
+      }
       case "log-filter":
         this._logFilter = actionEl.dataset.filter || null;
         this._render();
         break;
       case "log-clear":
-        this._showConfirm(this._t("log_clear_confirm"), async () => {
-          await this._ws("cover_automatic/log/clear");
-          this._logEntries = [];
-          this._render();
+        // The backend clears the whole log, even with a cover filter: say so
+        this._showConfirm(this._t(this._logCover ? "log_clear_confirm_all" : "log_clear_confirm"), async () => {
+          try {
+            await this._ws("cover_automatic/log/clear");
+            this._logSeq = (this._logSeq || 0) + 1;
+            this._logLoading = false;
+            this._logEntries = [];
+            this._render();
+          } catch (err) { console.error(err); this._showError(err); }
         });
         break;
-      case "confirm-ok":
-        if (this._confirmCallback) this._confirmCallback();
+      case "confirm-ok": {
+        const cb = this._confirmCallback;
         this._hideConfirm();
+        if (cb) cb();
         break;
+      }
       case "confirm-cancel":
         if (e.target === actionEl) this._hideConfirm();
         break;
@@ -4666,9 +8702,15 @@ class CoverAutomaticPanel extends HTMLElement {
   _handleChange(e) {
     const el = e.target;
 
+    // Threshold entity picked: show its current value right away
+    if (el.matches("[data-threshold-entity]")) {
+      const out = el.closest(".threshold-entity")?.querySelector(".threshold-entity-value");
+      if (out) out.innerHTML = this._thresholdEntityValue(el.value.trim());
+    }
+
     // Master toggle
     if (el.matches('[data-action="master-toggle"]')) {
-      this._onMasterToggle(el.checked);
+      this._onMasterToggle(el.checked, el);
       return;
     }
     // Cover select (dropdown) changes
@@ -4677,9 +8719,46 @@ class CoverAutomaticPanel extends HTMLElement {
       return;
     }
 
+    // Cover comfort-range behaviour: two flags saved together
+    if (el.matches('[data-action="cover-sun-comfort"]')) {
+      const flags = el.value === ""
+        ? { sun_neutral_ignore: null, preemptive_shading: null }
+        : this._sunComfortFlags(el.value);
+      this._debouncedCoverSave(el.dataset.id, flags);
+      return;
+    }
+
+    // Activity log: one cover or all (reloaded from the backend so the
+    // entry limit applies to that cover only)
+    if (el.matches('[data-action="log-cover"]')) {
+      this._logCover = el.value || null;
+      this._logEntries = null;
+      this._render();
+      return;
+    }
+
+    // Settings radio group: mirrored into its hidden draft field
+    if (el.matches("[data-settings-radio]")) {
+      const hidden = this.shadowRoot.querySelector(`[data-settings-field="${el.dataset.settingsRadio}"]`);
+      if (hidden && el.checked) hidden.value = el.value;
+      return;
+    }
+
+    // Cover tri-state select: "" = follow global (null)
+    if (el.matches('[data-action="cover-tristate"]')) {
+      const value = el.value === "true" ? true : (el.value === "false" ? false : null);
+      this._debouncedCoverSave(el.dataset.id, el.dataset.field, value);
+      return;
+    }
+
     // Cover toggle (checkbox) changes
     if (el.matches('[data-action="cover-toggle"]')) {
       this._debouncedCoverSave(el.dataset.id, el.dataset.field, el.checked);
+      if (el.dataset.field === "lock_hold_position") {
+        // The lock position is not used while the cover keeps its position
+        const pos = this.shadowRoot.querySelector(`[data-action="cover-input"][data-id="${CSS.escape(el.dataset.id)}"][data-field="lock_position"]`);
+        if (pos) pos.disabled = el.checked;
+      }
       return;
     }
 
@@ -4693,13 +8772,42 @@ class CoverAutomaticPanel extends HTMLElement {
 
     // Rule enabled toggle
     if (el.matches('[data-action="rule-toggle-enabled"]')) {
-      this._onRuleToggleEnabled(el.dataset.id, el.checked);
+      this._onRuleToggleEnabled(el.dataset.id, el.checked, el);
       return;
     }
 
     // Add condition type selector
     if (el.matches('[data-action="rule-add-condition-type"]')) {
-      this._onRuleAddCondition(el.dataset.rule, el.value);
+      this._onRuleAddCondition(el.dataset.rule, el.value, parseInt(el.dataset.group, 10) || 0, el);
+      return;
+    }
+
+    // Operator inside a condition group (kept locally until saved)
+    if (el.matches('[data-action="rule-group-op"]')) {
+      const rule = this._edRule(el.dataset.rule);
+      if (rule) {
+        const { ops } = this._ruleGroups(rule);
+        ops[parseInt(el.dataset.group, 10) || 0] = el.value;
+        rule.group_operators = ops;
+        if (ops.length === 1) rule.condition_operator = el.value;
+        this._refreshCondPreview();
+      }
+      return;
+    }
+
+    // Operator between groups: update the separators live
+    if (el.matches('[data-action="rule-field"][data-field="condition_operator"]')) {
+      const rule = this._edRule(el.dataset.id);
+      if (rule) rule.condition_operator = el.value;
+      this.shadowRoot.querySelectorAll(".cond-group-sep").forEach(sep => {
+        sep.textContent = this._t(el.value === "or" ? "rule_op_short_or" : "rule_op_short_and");
+      });
+      return;
+    }
+
+    // Move a condition to another group
+    if (el.matches('[data-action="rule-cond-group"]')) {
+      this._onRuleCondMove(el.dataset.rule, parseInt(el.dataset.idx, 10), parseInt(el.value, 10) || 0, el);
       return;
     }
 
@@ -4709,6 +8817,12 @@ class CoverAutomaticPanel extends HTMLElement {
       return;
     }
 
+    // Native HA condition form
+    if (el.matches('[data-action="ha-form"]')) {
+      this._onHaFormChange(el, false);
+      return;
+    }
+
     // Backup file selected
     if (el.matches('[data-action="backup-file"]')) {
       this._onBackupFileSelected(el);
@@ -4717,7 +8831,7 @@ class CoverAutomaticPanel extends HTMLElement {
 
     // Scenario rule toggle
     if (el.matches('[data-action="scenario-rule-toggle"]')) {
-      this._onScenarioRuleToggle(el.dataset.scenario, el.dataset.rule, el.checked);
+      this._onScenarioRuleToggle(el.dataset.scenario, el.dataset.rule, el.checked, el);
       return;
     }
 
@@ -4742,24 +8856,52 @@ class CoverAutomaticPanel extends HTMLElement {
   _handleInput(e) {
     const el = e.target;
 
+    // Rule editor field marked invalid on save: unmark once corrected
+    // (condition numbers are checked again just below).
+    if (el.classList && el.classList.contains("input-invalid") && el.closest && el.closest(".rule-editor")
+      && !this._fieldBadValidity(el) && !(el.dataset.field === "target_position" && el.value.trim() === "")) {
+      this._setInputInvalid(el, null);
+    }
+
     // Cover input fields (debounced save)
     if (el.matches('[data-action="cover-input"]')) {
       let value = el.value;
       if (el.type === "number") {
-        const n = value === "" ? NaN : Number(value);
-        value = Number.isFinite(n) ? n : null;
+        const check = this._checkCoverNumber(el);
+        if (!check.ok) {
+          // Invalid or intermediate value: mark it and send nothing
+          this._cancelCoverSave(`${el.dataset.id}.${el.dataset.field}`);
+          return;
+        }
+        value = check.value;
       }
       if (el.type === "text" && value === "") value = null;
       this._debouncedCoverSave(el.dataset.id, el.dataset.field, value);
       return;
     }
 
+    // Rule editor fields kept only in the DOM: mirror them into the draft
+    if (el.matches('[data-action="rule-field"]')) {
+      this._syncRuleDraftFromDom();
+      return;
+    }
+
     // Condition param input (live update local state)
     if (el.matches('[data-action="cond-param"]')) {
       this._updateConditionParam(el);
       return;
     }
 
+    // Native HA condition: YAML editor and number fields (live)
+    if (el.matches('[data-action="ha-yaml"]')) {
+      this._onHaYamlInput(el);
+      return;
+    }
+    if (el.matches('input[type="number"][data-action="ha-form"]')) {
+      this._onHaFormChange(el, true);
+      return;
+    }
+
     // Live compass update
     if (el.id === "house-rotation-input") {
       const parsed = parseFloat(el.value);
@@ -4819,23 +8961,49 @@ class CoverAutomaticPanel extends HTMLElement {
     const targetId = row.dataset.ruleId;
     if (draggedId && targetId && draggedId !== targetId) {
       const rules = this._config.rules || {};
-      const sorted = Object.values(rules).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+      const sorted = this._rulesByPriority(rules);
       const ids = sorted.map(r => r.id);
       const fromIdx = ids.indexOf(draggedId);
       const toIdx = ids.indexOf(targetId);
       if (fromIdx !== -1 && toIdx !== -1) {
         ids.splice(fromIdx, 1);
         ids.splice(toIdx, 0, draggedId);
-        try {
-          const result = await this._ws("cover_automatic/rule/reorder", { rule_ids: ids });
-          this._updateConfigFromResult(result);
-        } catch (err) { console.error(err); }
+        await this._reorderRules(ids);
       }
     }
     this._dragRuleId = null;
     this._dragOverId = null;
   }
 
+  async _reorderRules(ids) {
+    try {
+      const result = await this._ws("cover_automatic/rule/reorder", { rule_ids: ids });
+      this._updateConfigFromResult(result);
+      return true;
+    } catch (err) { console.error(err); this._showError(err); return false; }
+  }
+
+  // Up/down buttons: move a rule one step in priority.
+  async _onRuleMove(ruleId, delta) {
+    if (this._ruleMoving) return;
+    const ids = this._rulesByPriority(this._config.rules || {}).map(r => r.id);
+    const from = ids.indexOf(ruleId);
+    const to = from + delta;
+    if (from === -1 || to < 0 || to >= ids.length) return;
+    ids.splice(from, 1);
+    ids.splice(to, 0, ruleId);
+    this._ruleMoving = true;
+    let ok = false;
+    try { ok = await this._reorderRules(ids); } finally { this._ruleMoving = false; }
+    if (!ok) return;
+    // Keep keyboard focus on the moved rule (fall back to the other arrow at the ends)
+    const row = this.shadowRoot.querySelector(`.rule-row[data-rule-id="${CSS.escape(ruleId)}"]`);
+    if (!row) return;
+    const want = row.querySelector(`[data-action="${delta < 0 ? "rule-prio-up" : "rule-prio-down"}"]`);
+    const other = row.querySelector(`[data-action="${delta < 0 ? "rule-prio-down" : "rule-prio-up"}"]`);
+    (want && !want.disabled ? want : other)?.focus();
+  }
+
   /* ---------- House compass drag-rotation ---------- */
   _handleHouseDragStart(e) {
     if (e.button !== 0 && e.pointerType === "mouse") return;
@@ -4912,7 +9080,7 @@ class CoverAutomaticPanel extends HTMLElement {
     try {
       const result = await this._ws("cover_automatic/cover/resume", { entity_id: entityId });
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   async _onCoverAdd() {
@@ -4925,7 +9093,7 @@ class CoverAutomaticPanel extends HTMLElement {
       this._addingCover = false;
       this._updateConfigFromResult(result);
       this._showToast();
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   _onCoverDelete(entityId) {
@@ -4934,19 +9102,26 @@ class CoverAutomaticPanel extends HTMLElement {
         const result = await this._ws("cover_automatic/cover/delete", { entity_id: entityId });
         if (this._selectedCover === entityId) { this._selectedCover = null; this._slideOpen = false; }
         this._updateConfigFromResult(result);
-      } catch (e) { console.error(e); }
+      } catch (e) { console.error(e); this._showError(e); }
     });
   }
 
+  // Facade azimuth: any number, normalized to [0, 360) (-90 -> 270, 450 -> 90).
+  _facadeAz(raw, def) {
+    const v = raw === "" || raw == null ? NaN : parseFloat(raw);
+    if (!Number.isFinite(v)) return def;
+    return Math.round((((v % 360) + 360) % 360) * 1000) / 1000;
+  }
+
   async _onFacadeAddSave(btn) {
     const form = btn.closest(".inline-form");
     if (!form) return;
     const name = form.querySelector('[data-facade-field="name"]')?.value || "";
     if (!name.trim()) return;
     const direction = form.querySelector('[data-facade-field="direction"]')?.value || "south";
-    const azStart = (() => { const v = form.querySelector('[data-facade-field="azimuth_start"]')?.value; return v !== "" && v != null ? parseFloat(v) : 135; })();
-    const azEnd = (() => { const v = form.querySelector('[data-facade-field="azimuth_end"]')?.value; return v !== "" && v != null ? parseFloat(v) : 225; })();
-    const minElev = (() => { const v = form.querySelector('[data-facade-field="min_elevation"]')?.value; return v !== "" && v != null ? parseFloat(v) : 0; })();
+    const azStart = this._facadeAz(form.querySelector('[data-facade-field="azimuth_start"]')?.value, 135);
+    const azEnd = this._facadeAz(form.querySelector('[data-facade-field="azimuth_end"]')?.value, 225);
+    const minElev = (() => { const v = parseFloat(form.querySelector('[data-facade-field="min_elevation"]')?.value); return Number.isFinite(v) ? Math.max(0, v) : 0; })();
     const coverIds = [];
     form.querySelectorAll('[data-action="facade-cover-toggle"].selected').forEach(b => coverIds.push(b.dataset.cover));
     try {
@@ -4955,7 +9130,7 @@ class CoverAutomaticPanel extends HTMLElement {
       });
       this._addingFacade = false;
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   async _onFacadeEditSave(btn) {
@@ -4965,9 +9140,9 @@ class CoverAutomaticPanel extends HTMLElement {
     const name = form.querySelector('[data-facade-field="name"]')?.value || "";
     if (!name.trim()) return;
     const direction = form.querySelector('[data-facade-field="direction"]')?.value || "south";
-    const azStart = (() => { const v = form.querySelector('[data-facade-field="azimuth_start"]')?.value; return v !== "" && v != null ? parseFloat(v) : 135; })();
-    const azEnd = (() => { const v = form.querySelector('[data-facade-field="azimuth_end"]')?.value; return v !== "" && v != null ? parseFloat(v) : 225; })();
-    const minElev = (() => { const v = form.querySelector('[data-facade-field="min_elevation"]')?.value; return v !== "" && v != null ? parseFloat(v) : 0; })();
+    const azStart = this._facadeAz(form.querySelector('[data-facade-field="azimuth_start"]')?.value, 135);
+    const azEnd = this._facadeAz(form.querySelector('[data-facade-field="azimuth_end"]')?.value, 225);
+    const minElev = (() => { const v = parseFloat(form.querySelector('[data-facade-field="min_elevation"]')?.value); return Number.isFinite(v) ? Math.max(0, v) : 0; })();
     const coverIds = [];
     form.querySelectorAll('[data-action="facade-cover-toggle"].selected').forEach(b => coverIds.push(b.dataset.cover));
     try {
@@ -4976,7 +9151,7 @@ class CoverAutomaticPanel extends HTMLElement {
       });
       this._editingFacade = null;
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   _onFacadeDelete(facadeId) {
@@ -4984,15 +9159,19 @@ class CoverAutomaticPanel extends HTMLElement {
       try {
         const result = await this._ws("cover_automatic/facade/delete", { facade_id: facadeId });
         this._updateConfigFromResult(result);
-      } catch (e) { console.error(e); }
+      } catch (e) { console.error(e); this._showError(e); }
     });
   }
 
-  async _onRuleToggleEnabled(ruleId, checked) {
+  async _onRuleToggleEnabled(ruleId, checked, el = null) {
     try {
       const result = await this._ws("cover_automatic/rule/update", { rule_id: ruleId, enabled: checked });
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) {
+      console.error(e);
+      if (el) el.checked = !checked;
+      this._showError(e);
+    }
   }
 
   async _onRuleDuplicate(ruleId) {
@@ -5031,59 +9210,263 @@ class CoverAutomaticPanel extends HTMLElement {
     this._showConfirm(this._t("confirm_delete"), async () => {
       try {
         const result = await this._ws("cover_automatic/rule/delete", { rule_id: ruleId });
-        this._expandedRule = null;
+        if (this._expandedRule === ruleId) this._setExpandedRule(null);
         this._updateConfigFromResult(result);
-      } catch (e) { console.error(e); }
+      } catch (e) { console.error(e); this._showError(e); }
     });
   }
 
+  // Native validity without stepMismatch: decimals like 25.5 or 0.5 min are
+  // valid values even where the input has an integer step.
+  _fieldBadValidity(el) {
+    const v = el.validity;
+    if (!v) return false;
+    return !!(v.badInput || v.rangeUnderflow || v.rangeOverflow || v.valueMissing || v.typeMismatch || v.patternMismatch);
+  }
+
+  // First invalid field of the open rule editor (marked red), or null.
+  // An empty/invalid number would otherwise silently keep its old value.
+  _ruleEditorInvalid(ruleId) {
+    const row = this.shadowRoot.querySelector(`.rule-row[data-rule-id="${CSS.escape(ruleId)}"]`);
+    const editor = row && row.nextElementSibling && row.nextElementSibling.classList.contains("rule-editor") ? row.nextElementSibling : null;
+    if (!editor) return null;
+    let first = null;
+    for (const el of editor.querySelectorAll("input, select, textarea")) {
+      if (el.disabled || el.type === "hidden") continue;
+      let bad = el.classList.contains("input-invalid") || this._fieldBadValidity(el);
+      // The target position is required (empty = old value kept)
+      if (!bad && el.dataset.field === "target_position" && el.value.trim() === "") bad = true;
+      if (bad) {
+        if (!el.classList.contains("input-invalid")) this._setInputInvalid(el, this._t("input_invalid_number"));
+        if (!first) first = el;
+      }
+    }
+    return first;
+  }
+
   async _onRuleSave(ruleId) {
+    const invalid = this._ruleEditorInvalid(ruleId);
+    if (invalid) {
+      this._showToast(this._t("rule_invalid_fields"), true);
+      // Field hidden in a collapsed condition card: expand that card first
+      const card = invalid.closest && invalid.closest(".condition-card.collapsed");
+      if (card && card.dataset.condCard) {
+        const key = card.dataset.condCard;
+        const cut = key.lastIndexOf(":");
+        const idx = parseInt(key.slice(cut + 1), 10);
+        if (Number.isInteger(idx)) this._setCondCollapsed(key.slice(0, cut), idx, false);
+      }
+      if (invalid.offsetParent !== null) {
+        invalid.scrollIntoView({ block: "center", behavior: "smooth" });
+        invalid.focus({ preventScroll: true });
+      }
+      return;
+    }
+    // YAML conditions: wait until params.config matches the typed YAML
+    await this._flushHaValidations(ruleId);
     const data = this._collectRuleEditorData(this.shadowRoot, ruleId);
     if (!data) return;
+    // A valid YAML condition the form can show goes back to the form view
+    // (templates and other complex conditions stay in YAML).
+    (data.conditions || []).forEach((c, idx) => {
+      if (!c || c.type !== "ha_condition" || !c.params || c.params.ui !== "yaml") return;
+      const live = this._haLive && this._haLive[ruleId + ":" + idx];
+      if (live && (live.pending || live.valid === false)) return;
+      if (this._haFormModel(c.params.config, c.params.op)) c.params = { ...c.params, ui: "form" };
+    });
     try {
       const result = await this._ws("cover_automatic/rule/update", data);
-      this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+      this._updateConfigFromResult(result, { resetDraft: true });
+      this._refreshCondPreview();
+    } catch (e) { console.error(e); this._showError(e); }
+  }
+
+  // Apply a structural change (conditions/groups) to the editor draft only:
+  // like every other edit it reaches the server with "Save". Callers flush
+  // pending HA validations first. indexMap(oldIdx) -> newIdx | null keeps the
+  // collapsed state and live HA status of each card with its condition.
+  // Resolves to true when applied.
+  async _saveRuleStructure(ruleId, conditions, groups, indexMap = null) {
+    if (ruleId === this._expandedRule) this._syncRuleDraftFromDom();
+    const rule = this._edRule(ruleId);
+    if (!rule) { this._render(); return false; }
+    // Indices may change: void pending validations and previews.
+    this._cancelHaTimers(ruleId);
+    this._previewSeq++;
+    if (conditions) rule.conditions = conditions.map(c => ({ ...c }));
+    if (groups) {
+      rule.group_operators = [...groups.ops];
+      rule.condition_operator = groups.between;
+    }
+    // A single group left: its own operator is the rule's operator (the
+    // "between groups" one no longer applies).
+    const info = this._ruleGroups(rule);
+    if (info.n === 1) {
+      rule.group_operators = [info.ops[0]];
+      rule.condition_operator = info.ops[0];
+    }
+    if (indexMap) this._remapRuleIndexState(ruleId, indexMap);
+    // The DOM still shows the old structure: don't read it back into the
+    // draft while re-rendering (indices changed).
+    this._noDomSync = true;
+    try { this._render(); } finally { this._noDomSync = false; }
+    this._refreshCondPreview();
+    return true;
+  }
+
+  // Move per-condition editor state (collapsed cards, live HA status) to the
+  // new condition indices; null drops the entry.
+  _remapRuleIndexState(ruleId, indexMap) {
+    const pre = ruleId + ":";
+    const remap = (keys, put) => {
+      for (const key of keys) {
+        if (!key.startsWith(pre)) continue;
+        const next = indexMap(parseInt(key.slice(pre.length), 10));
+        if (next != null) put(pre + next, key);
+      }
+    };
+    if (this._collapsedConds) {
+      const old = this._collapsedConds;
+      const next = new Set([...old].filter(k => !k.startsWith(pre)));
+      remap(old, (k) => next.add(k));
+      this._collapsedConds = next;
+    }
+    if (this._haLive) {
+      const old = this._haLive;
+      const next = {};
+      for (const [k, v] of Object.entries(old)) if (!k.startsWith(pre)) next[k] = v;
+      remap(Object.keys(old), (k, from) => { if (!old[from].pending) next[k] = old[from]; });
+      this._haLive = next;
+    }
   }
 
-  async _onRuleAddCondition(ruleId, condType) {
-    if (!condType) return;
-    const rule = (this._config.rules || {})[ruleId];
+  _onRuleCondNegate(btn) {
+    const rule = this._edRule(btn.dataset.rule);
+    const idx = parseInt(btn.dataset.idx, 10);
+    const cond = rule && rule.conditions ? rule.conditions[idx] : null;
+    if (!cond) return;
+    cond.negate = !cond.negate;
+    btn.classList.toggle("active", cond.negate);
+    btn.closest(".condition-card")?.classList.toggle("negated", cond.negate);
+    this._refreshCondPreview();
+  }
+
+  async _onRuleGroupAdd(ruleId) {
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
     if (!rule) return;
-    const paramDefs = CONDITION_PARAMS[condType] || [];
-    const params = {};
-    for (const p of paramDefs) params[p.key] = p.default;
-    // Build next conditions locally; mutate _config only after successful WS call
-    const nextConditions = [...(rule.conditions || []), { type: condType, params: params }];
-    const data = this._collectRuleEditorData(this.shadowRoot, ruleId, nextConditions);
-    if (data) {
-      try {
-        const result = await this._ws("cover_automatic/rule/update", data);
-        this._updateConfigFromResult(result);
-        this._refreshCondPreview();
-      } catch (e) { console.error(e); }
+    const { ops, n, between } = this._ruleGroups(rule);
+    if (n >= MAX_CONDITION_GROUPS) return;
+    // From one group to two: the groups are joined by the opposite operator,
+    // e.g. (A or B) and (C or D), and the new group copies the first one's.
+    const nextBetween = n === 1 ? (ops[0] === "or" ? "and" : "or") : between;
+    await this._saveRuleStructure(ruleId, null, { ops: [...ops, ops[n - 1]], between: nextBetween });
+  }
+
+  _onRuleGroupDelete(ruleId, group) {
+    const rule = this._edRule(ruleId);
+    const g = parseInt(group, 10);
+    if (!rule || !Number.isFinite(g)) return;
+    const inGroup = (c) => (parseInt(c.group, 10) || 0) === g;
+    // Built from the draft when confirmed: the confirm dialog re-renders the
+    // editor, the draft keeps every unsaved edit meanwhile.
+    const run = async () => {
+      await this._flushHaValidations(ruleId);
+      const r = this._edRule(ruleId);
+      if (!r) return false;
+      const { ops, between } = this._ruleGroups(r);
+      const conds = (r.conditions || [])
+        .filter(c => !inGroup(c))
+        .map(c => { const cg = parseInt(c.group, 10) || 0; return { ...c, group: cg > g ? cg - 1 : cg }; });
+      const nextOps = ops.filter((_, i) => i !== g);
+      // Old index -> new index of the kept conditions
+      const kept = (r.conditions || []).map((c, i) => (inGroup(c) ? -1 : i)).filter(i => i >= 0);
+      return this._saveRuleStructure(ruleId, conds, { ops: nextOps.length ? nextOps : ["and"], between },
+        (i) => { const k = kept.indexOf(i); return k < 0 ? null : k; });
+    };
+    const removed = (rule.conditions || []).filter(inGroup).length;
+    if (removed > 0) this._showConfirm(this._t("rule_group_delete_confirm"), run);
+    else run();
+  }
+
+  async _onRuleCondMove(ruleId, idx, group, el = null) {
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
+    if (!rule || !rule.conditions || !rule.conditions[idx]) return;
+    const prevGroup = parseInt(rule.conditions[idx].group, 10) || 0;
+    const conds = rule.conditions.map((c, i) => (i === idx ? { ...c, group } : c));
+    const ok = await this._saveRuleStructure(ruleId, conds, null, (i) => i);
+    if (!ok && el && el.isConnected) el.value = String(prevGroup);
+  }
+
+  // Move a condition up (dir -1) or down (dir 1) within its group: it swaps
+  // places with the previous/next condition of the same group; the other
+  // conditions keep their positions.
+  async _onRuleCondReorder(ruleId, idx, dir) {
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
+    if (!rule || !rule.conditions || !rule.conditions[idx]) return;
+    const siblings = this._groupCondIndices(rule.conditions, parseInt(rule.conditions[idx].group, 10) || 0);
+    const pos = siblings.indexOf(idx);
+    const other = siblings[pos + dir];
+    if (pos < 0 || other === undefined) return;
+    const perm = rule.conditions.map((_, i) => (i === idx ? other : i === other ? idx : i));
+    const conds = perm.map(i => rule.conditions[i]);
+    await this._saveRuleStructure(ruleId, conds, null, (i) => perm.indexOf(i));
+  }
+
+  // Move a whole group up/down: swaps its index (conditions' group and
+  // group_operators entry) with the neighbouring group.
+  async _onRuleGroupReorder(ruleId, g, dir) {
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
+    if (!rule || !Number.isFinite(g)) return;
+    const { ops, n, between } = this._ruleGroups(rule);
+    const h = g + dir;
+    if (g < 0 || g >= n || h < 0 || h >= n) return;
+    const conds = (rule.conditions || []).map(c => {
+      const cg = parseInt(c.group, 10) || 0;
+      return cg === g ? { ...c, group: h } : cg === h ? { ...c, group: g } : c;
+    });
+    const nextOps = [...ops];
+    [nextOps[g], nextOps[h]] = [nextOps[h], nextOps[g]];
+    // Flat condition order is unchanged: per-index state stays valid.
+    await this._saveRuleStructure(ruleId, conds, { ops: nextOps, between }, (i) => i);
+  }
+
+  async _onRuleAddCondition(ruleId, condType, group = 0, el = null) {
+    if (!condType) return;
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
+    if (!rule) { if (el) el.value = ""; return; }
+    let newCond;
+    if (condType.startsWith("ha:")) {
+      const kind = condType.slice(3);
+      newCond = kind === "yaml"
+        ? { type: "ha_condition", params: { ui: "yaml", config: null, yaml: "" } }
+        : { type: "ha_condition", params: { ui: "form", config: this._haDefaultConfig(kind), yaml: "" } };
     } else {
-      this._render();
+      const paramDefs = CONDITION_PARAMS[condType] || [];
+      const params = {};
+      for (const p of paramDefs) params[p.key] = p.default;
+      newCond = { type: condType, params: params };
     }
+    newCond.group = group;
+    newCond.negate = false;
+    const nextConditions = [...(rule.conditions || []), newCond];
+    const ok = await this._saveRuleStructure(ruleId, nextConditions, null, (i) => i);
+    if (!ok && el && el.isConnected) el.value = "";
   }
 
   async _onRuleDeleteCondition(ruleId, idx) {
-    const rule = (this._config.rules || {})[ruleId];
+    await this._flushHaValidations(ruleId);
+    const rule = this._edRule(ruleId);
     if (!rule || !rule.conditions) return;
     const idxInt = parseInt(idx, 10);
     if (!Number.isFinite(idxInt)) return;
-    // Build next conditions locally; mutate _config only after successful WS call
     const nextConditions = rule.conditions.filter((_, i) => i !== idxInt);
-    const data = this._collectRuleEditorData(this.shadowRoot, ruleId, nextConditions);
-    if (data) {
-      try {
-        const result = await this._ws("cover_automatic/rule/update", data);
-        this._updateConfigFromResult(result);
-        this._refreshCondPreview();
-      } catch (e) { console.error(e); }
-    } else {
-      this._render();
-    }
+    await this._saveRuleStructure(ruleId, nextConditions, null,
+      (i) => (i === idxInt ? null : i > idxInt ? i - 1 : i));
   }
 
   async _onRuleAddSave(btn) {
@@ -5102,18 +9485,57 @@ class CoverAutomaticPanel extends HTMLElement {
       const result = await this._ws("cover_automatic/rule/add", data);
       this._addingRule = false;
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
+  }
+
+  _setInputInvalid(el, message) {
+    if (message) {
+      el.classList.add("input-invalid");
+      el.setAttribute("aria-invalid", "true");
+      el.title = message;
+    } else if (el.classList.contains("input-invalid")) {
+      el.classList.remove("input-invalid");
+      el.removeAttribute("aria-invalid");
+      el.removeAttribute("title");
+    }
+  }
+
+  // Validate a cover number input against the cover/update schema.
+  // Returns { ok, value } (value null = cleared, falls back to the default).
+  _checkCoverNumber(el) {
+    const lim = COVER_INT_LIMITS[el.dataset.field];
+    if (el.value === "" && !(el.validity && el.validity.badInput)) {
+      this._setInputInvalid(el, null);
+      return { ok: true, value: null };
+    }
+    const n = el.value === "" ? NaN : Number(el.value);
+    let msg = null;
+    if (!Number.isFinite(n)) msg = this._t("input_invalid_number");
+    else if (lim && (!Number.isInteger(n) || n < lim[0] || n > lim[1])) {
+      msg = this._t("input_invalid_range").replace("{min}", lim[0]).replace("{max}", lim[1]);
+    }
+    this._setInputInvalid(el, msg);
+    return msg ? { ok: false, value: null } : { ok: true, value: n };
   }
 
   _updateConditionParam(el) {
     const ruleId = el.dataset.rule;
     const idx = parseInt(el.dataset.idx, 10);
     const key = el.dataset.key;
-    const rule = (this._config.rules || {})[ruleId];
+    const rule = this._edRule(ruleId);
     if (rule && rule.conditions && rule.conditions[idx]) {
-      if (!rule.conditions[idx].params) rule.conditions[idx].params = {};
       let val = el.value;
-      if (el.type === "number") val = Number(val);
+      if (el.type === "number") {
+        // Empty or "-" while typing: keep the previous value, mark the field
+        const n = val === "" ? NaN : Number(val);
+        if (!Number.isFinite(n)) {
+          this._setInputInvalid(el, this._t("input_invalid_number"));
+          return;
+        }
+        this._setInputInvalid(el, null);
+        val = n;
+      }
+      if (!rule.conditions[idx].params) rule.conditions[idx].params = {};
       rule.conditions[idx].params[key] = val;
     }
   }
@@ -5123,7 +9545,7 @@ class CoverAutomaticPanel extends HTMLElement {
     const idx = parseInt(el.dataset.idx, 10);
     const key = el.dataset.key;
     const day = el.dataset.day;
-    const rule = (this._config.rules || {})[ruleId];
+    const rule = this._edRule(ruleId);
     if (rule && rule.conditions && rule.conditions[idx]) {
       if (!rule.conditions[idx].params) rule.conditions[idx].params = {};
       let days = rule.conditions[idx].params[key];
@@ -5143,7 +9565,7 @@ class CoverAutomaticPanel extends HTMLElement {
     const idx = parseInt(el.dataset.idx, 10);
     const key = el.dataset.key;
     const val = el.dataset.val;
-    const rule = (this._config.rules || {})[ruleId];
+    const rule = this._edRule(ruleId);
     if (rule && rule.conditions && rule.conditions[idx]) {
       if (!rule.conditions[idx].params) rule.conditions[idx].params = {};
       let arr = rule.conditions[idx].params[key];
@@ -5162,22 +9584,45 @@ class CoverAutomaticPanel extends HTMLElement {
     try {
       const result = await this._ws("cover_automatic/scenario/update", { scenario_id: scenarioId, activate: true });
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
-  async _onScenarioRuleToggle(scenarioId, ruleId, checked) {
-    const scenario = (this._config.scenarios || {})[scenarioId];
-    if (!scenario) return;
-    let disabled = [...(scenario.rules_disabled || [])];
-    if (checked) {
-      disabled = disabled.filter(id => id !== ruleId);
-    } else {
-      if (!disabled.includes(ruleId)) disabled.push(ruleId);
-    }
-    try {
-      const result = await this._ws("cover_automatic/scenario/update", { scenario_id: scenarioId, rules_disabled: disabled });
-      this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+  // Calls are serialized per scenario: each one starts from the list the
+  // previous call returned, so quick successive clicks are all kept.
+  _onScenarioRuleToggle(scenarioId, ruleId, checked, el = null) {
+    if (!this._scRuleQueue) this._scRuleQueue = {};
+    if (!this._scRuleQueueLen) this._scRuleQueueLen = {};
+    this._scRuleQueueLen[scenarioId] = (this._scRuleQueueLen[scenarioId] || 0) + 1;
+    const run = async () => {
+      let rerender = false;
+      try {
+        const scenario = (this._config.scenarios || {})[scenarioId];
+        if (!scenario) return;
+        let disabled = [...(scenario.rules_disabled || [])];
+        if (checked) {
+          disabled = disabled.filter(id => id !== ruleId);
+        } else if (!disabled.includes(ruleId)) {
+          disabled.push(ruleId);
+        }
+        const result = await this._ws("cover_automatic/scenario/update", { scenario_id: scenarioId, rules_disabled: disabled });
+        // More clicks queued: keep their checkboxes as clicked until the last one
+        const more = this._scRuleQueueLen[scenarioId] > 1;
+        this._updateConfigFromResult(result, more ? { render: false } : {});
+      } catch (e) {
+        console.error(e);
+        if (el && el.isConnected) el.checked = !checked;
+        rerender = true;
+        this._showError(e);
+      } finally {
+        this._scRuleQueueLen[scenarioId] -= 1;
+        // Last queued call failed or an earlier result was not rendered
+        if (rerender && this._scRuleQueueLen[scenarioId] === 0) this._render();
+      }
+    };
+    const prev = this._scRuleQueue[scenarioId] || Promise.resolve();
+    const next = prev.then(run, run);
+    this._scRuleQueue[scenarioId] = next;
+    return next;
   }
 
   _onScenarioIconPick(btn) {
@@ -5210,7 +9655,7 @@ class CoverAutomaticPanel extends HTMLElement {
       const result = await this._ws("cover_automatic/scenario/add", { name: name.trim(), icon: icon });
       this._addingScenario = false;
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   async _onScenarioEditSave(btn) {
@@ -5224,7 +9669,7 @@ class CoverAutomaticPanel extends HTMLElement {
       const result = await this._ws("cover_automatic/scenario/update", { scenario_id: scenarioId, name: name.trim(), icon: icon });
       this._editingScenario = null;
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) { console.error(e); this._showError(e); }
   }
 
   _onScenarioDelete(scenarioId) {
@@ -5232,40 +9677,175 @@ class CoverAutomaticPanel extends HTMLElement {
       try {
         const result = await this._ws("cover_automatic/scenario/delete", { scenario_id: scenarioId });
         this._updateConfigFromResult(result);
-      } catch (e) { console.error(e); }
+      } catch (e) { console.error(e); this._showError(e); }
     });
   }
 
-  async _onMasterToggle(checked) {
+  async _onMasterToggle(checked, el = null) {
     try {
       const result = await this._ws("cover_automatic/settings/update", { enabled: checked });
       this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+    } catch (e) {
+      console.error(e);
+      if (el) el.checked = !checked;
+      this._showError(e);
+    }
+  }
+
+  // Unsaved settings inputs survive section switches and re-renders.
+  _captureSettingsDraft() {
+    if (this._activeTab !== "settings" || !this.shadowRoot || this._skipSettingsCapture || this._settingsDomStale) return;
+    const inputs = this.shadowRoot.querySelectorAll("[data-settings-field]");
+    if (!inputs.length) return;
+    const draft = this._settingsDraft || {};
+    inputs.forEach(input => {
+      const kind = input.type === "checkbox" ? "checkbox" : (input.type === "number" ? "number" : "text");
+      const field = input.dataset.settingsField;
+      const value = kind === "checkbox" ? input.checked : input.value;
+      // The stored value the input was rendered with (first capture only)
+      const initial = draft[field] ? draft[field].initial : this._settingsInputDefault(input);
+      draft[field] = { kind, value, initial };
+    });
+    this._settingsDraft = draft;
+  }
+
+  // Value an input was rendered with (the stored setting), not the edited one.
+  _settingsInputDefault(input) {
+    // Hidden inputs change their attribute with their value: explicit initial
+    if (input.dataset.initial !== undefined) return input.dataset.initial;
+    if (input.type === "checkbox") return input.defaultChecked;
+    if (input.tagName === "SELECT") {
+      const opt = Array.from(input.options).find(o => o.defaultSelected) || input.options[0];
+      return opt ? opt.value : "";
+    }
+    return input.defaultValue;
+  }
+
+  // True when a settings input differs from its stored value.
+  _settingsDirty() {
+    this._captureSettingsDraft();
+    return Object.values(this._settingsDraft || {}).some(d => !this._draftSame(d));
+  }
+
+  // Draft entry unchanged? Numbers compare by value ("21.0" == "21").
+  _draftSame(d) {
+    if (d.kind === "number") {
+      const a = String(d.value ?? "").trim(), b = String(d.initial ?? "").trim();
+      if (a === "" || b === "") return a === b;
+      return Number(a) === Number(b);
+    }
+    return d.value === d.initial;
+  }
+
+  // Run `then` after the user agreed to drop unsaved settings (if any).
+  _confirmLeaveSettings(then) {
+    if (this._activeTab === "settings" && this._settingsDirty()) {
+      this._showConfirm(this._t("settings_unsaved_confirm"), then, this._t("discard"));
+    } else then();
+  }
+
+  // Radio groups follow their hidden draft field (restored drafts)
+  _syncSettingsRadios() {
+    if (!this.shadowRoot) return;
+    this.shadowRoot.querySelectorAll("[data-settings-radio]").forEach(r => {
+      const hidden = this.shadowRoot.querySelector(`[data-settings-field="${r.dataset.settingsRadio}"]`);
+      if (hidden) r.checked = r.value === hidden.value;
+    });
+  }
+
+  _applySettingsDraft() {
+    const draft = this._settingsDraft;
+    if (!draft || this._activeTab !== "settings" || !this.shadowRoot) return;
+    this.shadowRoot.querySelectorAll("[data-settings-field]").forEach(input => {
+      const d = draft[input.dataset.settingsField];
+      if (!d) return;
+      // Stored value after a server-side change: taken from the fresh render
+      if (d.initial === undefined) d.initial = this._settingsInputDefault(input);
+      if (d.kind === "checkbox") input.checked = !!d.value;
+      else if (input.value !== d.value) {
+        input.value = d.value;
+        // Compass preview follows the restored rotation
+        if (input.id === "house-rotation-input") input.dispatchEvent(new Event("input", { bubbles: true }));
+      }
+    });
   }
 
   async _onSettingsSave() {
+    this._captureSettingsDraft();
+    return this._saveSettingsDraft();
+  }
+
+  // Returns true once saved (false when invalid or on error).
+  async _saveSettingsDraft() {
+    // Only these numeric settings accept null (= unset); an empty field of
+    // any other numeric setting is left out and keeps its stored value.
+    const NULLABLE = new Set(["lock_tilt_position", "vent_tilt_position", "default_travel_time"]);
     const data = {};
-    this.shadowRoot.querySelectorAll("[data-settings-field]").forEach(input => {
-      const field = input.dataset.settingsField;
-      let val;
-      if (input.type === "checkbox") {
-        val = input.checked;
-      } else if (input.type === "number") {
-        val = input.value === "" ? null : parseFloat(input.value);
+    for (const [field, d] of Object.entries(this._settingsDraft || {})) {
+      // Send only the fields really changed: an untouched field must not
+      // overwrite a value changed meanwhile elsewhere (other window, import).
+      if (this._draftSame(d)) continue;
+      if (d.kind === "checkbox") {
+        data[field] = !!d.value;
+      } else if (d.kind === "number") {
+        const raw = String(d.value ?? "").trim();
+        const n = raw === "" ? NaN : parseFloat(raw);
+        if (Number.isFinite(n)) data[field] = n;
+        else if (raw === "" && NULLABLE.has(field)) data[field] = null;
       } else {
-        val = input.value.trim() || null;
+        data[field] = String(d.value ?? "").trim() || null;
       }
-      data[field] = val;
-    });
-    // Validate comfort range
-    if (data.comfort_temp_min != null && data.comfort_temp_max != null && data.comfort_temp_min >= data.comfort_temp_max) {
+    }
+    // Comfort-range behaviour: one choice stored as two flags
+    if (data.sun_comfort_mode !== undefined) {
+      if (data.sun_comfort_mode) Object.assign(data, this._sunComfortFlags(data.sun_comfort_mode));
+      delete data.sun_comfort_mode;
+    }
+    // Temperature colours: radio choice stored as one flag
+    if (data.temp_color_mode !== undefined) {
+      if (data.temp_color_mode) data.temp_color_thermometer = data.temp_color_mode === "thermometer";
+      delete data.temp_color_mode;
+    }
+    if (data.wind_position !== undefined && !(Number.isInteger(data.wind_position) && data.wind_position >= 0 && data.wind_position <= 100)) {
+      alert(this._t("settings_wind_position") + this._colon() + this._t("input_invalid_range").replace("{min}", 0).replace("{max}", 100));
+      return false;
+    }
+    // Whole-number settings: refuse decimals instead of letting the backend
+    // silently truncate them (10.5 -> 10).
+    const INTEGER = ["pause_duration", "lock_position", "vent_position", "lock_tilt_position",
+      "vent_tilt_position", "min_position_change", "min_time_between_changes", "default_travel_time"];
+    const badInt = INTEGER.find(f => data[f] != null && !Number.isInteger(data[f]));
+    if (badInt) {
+      const input = this.shadowRoot.querySelector(`[data-settings-field="${badInt}"]`);
+      const label = input?.closest(".form-group")?.querySelector("label")?.textContent?.trim() || badInt;
+      alert(label + this._colon() + this._t("input_not_integer"));
+      return false;
+    }
+    // Validate comfort range: the static numbers only (entities are resolved
+    // by the backend, the numbers stay the fallback)
+    const cur = this._config.settings || {};
+    const cmin = data.comfort_temp_min ?? cur.comfort_temp_min;
+    const cmax = data.comfort_temp_max ?? cur.comfort_temp_max;
+    if (cmin != null && cmax != null && cmin >= cmax) {
       alert(this._t("settings_validation_min_max"));
-      return;
+      return false;
     }
     try {
       const result = await this._ws("cover_automatic/settings/update", data);
-      this._updateConfigFromResult(result);
-    } catch (e) { console.error(e); }
+      this._settingsDraft = null;
+      this._skipSettingsCapture = true;
+      try { this._updateConfigFromResult(result); } finally { this._skipSettingsCapture = false; }
+      return true;
+    } catch (e) { console.error(e); this._showError(e); return false; }
+  }
+
+  // Unsaved settings would be missing from the export: offer to save first.
+  _onBackupExportClick() {
+    if (this._settingsDirty()) {
+      this._showConfirm(this._t("settings_export_unsaved_confirm"), async () => {
+        if (await this._saveSettingsDraft()) await this._onBackupExport();
+      }, this._t("settings_save_and_export"));
+    } else this._onBackupExport();
   }
 
   async _onBackupExport() {
@@ -5277,11 +9857,15 @@ class CoverAutomaticPanel extends HTMLElement {
       const a = document.createElement("a");
       a.href = url;
       a.download = "cover_automatic_backup.json";
+      a.style.display = "none";
+      // Firefox/Safari need the link in the document; revoking right away
+      // can cancel the download before it starts.
+      document.body.appendChild(a);
       a.click();
-      URL.revokeObjectURL(url);
+      setTimeout(() => { a.remove(); URL.revokeObjectURL(url); }, 1000);
     } catch (e) {
       console.error(e);
-      alert(this._t("settings_export_error") + ": " + e.message);
+      alert(this._t("settings_export_error") + this._colon() + e.message);
     }
   }
 
@@ -5295,71 +9879,179 @@ class CoverAutomaticPanel extends HTMLElement {
       try {
         data = JSON.parse(reader.result);
       } catch (e) {
-        alert(this._t("settings_import_error") + ": Invalid JSON");
+        alert(this._t("settings_import_error") + this._colon() + this._t("import_invalid_json"));
         return;
       }
       if (!confirm(this._t("settings_import_confirm"))) return;
       try {
         const result = await this._ws("cover_automatic/import", { data });
+        // Everything shown now comes from the imported file
+        this._settingsDraft = null;
         this._updateConfigFromResult(result);
         this._showToast();
         alert(this._t("settings_import_success"));
       } catch (e) {
         console.error(e);
-        alert(this._t("settings_import_error") + ": " + e.message);
+        this._showError(e);
       }
     };
     reader.readAsText(file);
   }
 
-  _collectRuleEditorData(root, ruleId, overrideConditions = null) {
-    const rule = (this._config.rules || {})[ruleId];
-    if (!rule) return null;
+  /* ---------- Rule editor draft ---------- */
 
-    // Collect from DOM
-    const nameEl = root.querySelector(`[data-action="rule-field"][data-id="${ruleId}"][data-field="name"]`);
-    const tpEl = root.querySelector(`[data-action="rule-field"][data-id="${ruleId}"][data-field="target_position"]`);
-    const ttpEl = root.querySelector(`[data-action="rule-field"][data-id="${ruleId}"][data-field="target_tilt_position"]`);
-    const opEl = root.querySelector(`[data-action="rule-field"][data-id="${ruleId}"][data-field="condition_operator"]`);
-
-    const name = nameEl ? nameEl.value.trim() : rule.name;
-    const tp = tpEl && tpEl.value !== "" ? parseInt(tpEl.value, 10) : rule.target_position;
-    const ttpVal = ttpEl ? ttpEl.value : null;
-    const ttp = (() => {
-      if (ttpVal === "" || ttpVal == null) return null;
-      const n = parseInt(ttpVal, 10);
-      return Number.isFinite(n) ? n : null;
-    })();
-    const op = opEl ? opEl.value : rule.condition_operator;
+  // Rule as the editor sees it: the draft of the open rule, else the saved one.
+  _edRule(ruleId) {
+    if (ruleId == null) return null;
+    const d = this._ruleDraft;
+    if (d && d.id === ruleId) return d.rule;
+    const saved = (this._config && this._config.rules || {})[ruleId] || null;
+    // The open editor always works on a draft (created on first use)
+    if (saved && ruleId === this._expandedRule) {
+      this._ruleDraft = { id: ruleId, rule: this._clone(saved) };
+      return this._ruleDraft.rule;
+    }
+    return saved;
+  }
 
-    // Collect selected facades
-    const facadeIds = [];
-    root.querySelectorAll(`[data-action="rule-facade-toggle"][data-rule="${ruleId}"].selected`).forEach(el => {
-      facadeIds.push(el.dataset.facade);
-    });
+  // Open another rule editor (or none): the previous draft is discarded.
+  // Copy placed right below the original, active, and opened for editing.
+  async _onRuleDuplicate(ruleId) {
+    const rule = (this._config.rules || {})[ruleId];
+    if (!rule) return;
+    try {
+      const suffix = " - " + this._t("rule_copy_suffix");
+      // Rule names are limited to 100 characters (room left for " 2", " 3"...)
+      const name = rule.name.slice(0, Math.max(1, 97 - suffix.length)).trimEnd() + suffix;
+      const result = await this._ws("cover_automatic/rule/duplicate", { rule_id: ruleId, name });
+      this._setExpandedRule(null);
+      this._updateConfigFromResult(result);
+      if (result.new_rule_id) {
+        this._setExpandedRule(result.new_rule_id);
+        this._render();
+        this._startCondPreview();
+        setTimeout(() => this.shadowRoot.querySelector(`.rule-row[data-rule-id="${CSS.escape(result.new_rule_id)}"]`)?.scrollIntoView({ block: "center", behavior: "smooth" }), 50);
+      }
+    } catch (e) { console.error(e); this._showError(e); }
+  }
+
+  _setExpandedRule(ruleId) {
+    this._discardRuleDraft();
+    this._expandedRule = ruleId || null;
+    const saved = ruleId ? (this._config && this._config.rules || {})[ruleId] : null;
+    if (saved) {
+      this._ruleDraft = { id: ruleId, rule: this._clone(saved) };
+      // Existing conditions open collapsed; conditions added afterwards open expanded.
+      if (!this._collapsedConds) this._collapsedConds = new Set();
+      const pre = ruleId + ":";
+      for (const k of [...this._collapsedConds]) if (k.startsWith(pre)) this._collapsedConds.delete(k);
+      (saved.conditions || []).forEach((_, i) => this._collapsedConds.add(pre + i));
+    }
+  }
 
-    // Collect selected covers
-    const coverIds = [];
-    root.querySelectorAll(`[data-action="rule-cover-toggle"][data-rule="${ruleId}"].selected`).forEach(el => {
-      coverIds.push(el.dataset.cover);
-    });
+  _discardRuleDraft() {
+    const d = this._ruleDraft;
+    if (!d) return;
+    this._ruleDraft = null;
+    // Pending validations/previews refer to the discarded conditions
+    this._cancelHaTimers(d.id);
+    this._previewSeq++;
+    if (this._haLive) {
+      const pre = d.id + ":";
+      for (const k of Object.keys(this._haLive)) if (k.startsWith(pre)) delete this._haLive[k];
+    }
+  }
 
-    // Conditions from override (pending add/delete) or local state
+  // Copy the editor fields that live only in the DOM (name, targets,
+  // scenario/facade/cover chips) into the draft.
+  _syncRuleDraftFromDom() {
+    const d = this._ruleDraft;
+    if (!d || this._noDomSync || !this.shadowRoot) return;
+    const root = this.shadowRoot;
+    const id = CSS.escape(d.id);
+    const field = (f) => root.querySelector(`[data-action="rule-field"][data-id="${id}"][data-field="${f}"]`);
+    const nameEl = field("name");
+    if (!nameEl) return; // editor not rendered
+    const r = d.rule;
+    r.name = nameEl.value;
+    const safetyEl = field("safety");
+    if (safetyEl) r.safety = !!safetyEl.checked;
+    const tpEl = field("target_position");
+    if (tpEl && tpEl.value !== "") {
+      const n = parseInt(tpEl.value, 10);
+      if (Number.isFinite(n)) r.target_position = n;
+    }
+    const ttpEl = field("target_tilt_position");
+    if (ttpEl) {
+      if (ttpEl.value === "" && !(ttpEl.validity && ttpEl.validity.badInput)) r.target_tilt_position = null;
+      else {
+        const n = parseInt(ttpEl.value, 10);
+        if (Number.isFinite(n)) r.target_tilt_position = n;
+      }
+    }
+    const chips = (action, attr) => [...root.querySelectorAll(`[data-action="${action}"][data-rule="${id}"].selected`)].map(el => el.dataset[attr]);
+    r.scenario_ids = chips("rule-scenario-toggle", "scenario");
+    r.facade_ids = chips("rule-facade-toggle", "facade");
+    r.cover_ids = chips("rule-cover-toggle", "cover");
+  }
+
+  // True when the open rule's draft differs from the saved rule.
+  _ruleDraftDirty() {
+    const d = this._ruleDraft;
+    if (!d) return false;
+    const saved = (this._config && this._config.rules || {})[d.id];
+    if (!saved) return false;
+    this._syncRuleDraftFromDom();
+    // Chip order is not meaningful
+    const norm = (p) => JSON.stringify({ ...p, scenario_ids: [...p.scenario_ids].sort(), facade_ids: [...p.facade_ids].sort(), cover_ids: [...p.cover_ids].sort() });
+    return norm(this._buildRulePayload(d.id, d.rule)) !== norm(this._buildRulePayload(d.id, saved));
+  }
+
+  // Run `then` after the user agreed to drop unsaved rule edits (if any).
+  _confirmLeaveRule(then) {
+    if (this._ruleDraftDirty()) this._showConfirm(this._t("rule_unsaved_confirm"), then, this._t("discard"));
+    else then();
+  }
+
+  _buildRulePayload(ruleId, rule, overrideConditions = null, overrideGroups = null) {
+    const groupInfo = this._ruleGroups(rule);
+    let op = groupInfo.between;
+    let groupOps = groupInfo.ops;
+    if (overrideGroups) { groupOps = overrideGroups.ops; op = overrideGroups.between; }
+    // scenario_ids null = member of every scenario (all chips selected)
+    const scenarioIds = Array.isArray(rule.scenario_ids)
+      ? [...rule.scenario_ids] : Object.values(this._config.scenarios || {}).map(sc => sc.id);
+    const ttp = rule.target_tilt_position;
+    // Conditions from override (pending add/delete) or the draft
     const source = overrideConditions ?? (rule.conditions || []);
-    const conditions = source.map(c => ({ type: c.type, params: c.params || {} }));
-
+    const conditions = source.map(c => ({
+      type: c.type, params: c.params || {},
+      group: Math.min(parseInt(c.group, 10) || 0, Math.max(groupOps.length - 1, 0)),
+      negate: !!c.negate,
+    }));
     return {
       rule_id: ruleId,
-      name: name,
-      target_position: tp,
-      target_tilt_position: ttp,
+      name: String(rule.name ?? "").trim(),
+      target_position: rule.target_position,
+      target_tilt_position: Number.isFinite(ttp) ? ttp : null,
       condition_operator: op,
-      facade_ids: facadeIds,
-      cover_ids: coverIds,
+      group_operators: groupOps,
+      scenario_ids: scenarioIds,
+      facade_ids: [...(rule.facade_ids || [])],
+      cover_ids: [...(rule.cover_ids || [])],
+      safety: !!rule.safety,
       conditions: conditions
     };
   }
 
+  // Payload of rule/update for the open editor (draft + DOM-only fields).
+  _collectRuleEditorData(root, ruleId, overrideConditions = null, overrideGroups = null) {
+    if (ruleId === this._expandedRule) this._syncRuleDraftFromDom();
+    const rule = this._edRule(ruleId);
+    if (!rule) return null;
+    return this._buildRulePayload(ruleId, rule, overrideConditions, overrideGroups);
+  }
+
 }
 
 customElements.define("cover-automatic-panel", CoverAutomaticPanel);
diff --git a/custom_components/cover_automatic/select.py b/custom_components/cover_automatic/select.py
index 2efd8c7..a7482ac 100644
--- a/custom_components/cover_automatic/select.py
+++ b/custom_components/cover_automatic/select.py
@@ -2,13 +2,15 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.select import SelectEntity
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from . import i18n
 from .const import DOMAIN
 from .coordinator import CoverAutomaticCoordinator
+from .storage import resolve_active_scenario
 
 if TYPE_CHECKING:
     from homeassistant.core import HomeAssistant
@@ -48,7 +50,7 @@ def __init__(
             "identifiers": {(DOMAIN, entry_id)},
             "name": "CoverAutomatic",
             "manufacturer": "CoverAutomatic",
-            "model": "Controller",
+            "model": i18n.text(coordinator.hass, "model_controller"),
         }
 
     @property
@@ -60,11 +62,17 @@ def options(self) -> list[str]:
     @property
     def current_option(self) -> str | None:
         """Return current scenario (validated against available options)."""
-        current = self.coordinator.storage.active_scenario
-        available = self.options
-        if current and current in available:
-            return current
-        return available[0] if available else None
+        storage = self.coordinator.storage
+        return resolve_active_scenario(storage.active_scenario, storage.scenarios)
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Display names of the scenarios (options are their ids)."""
+        return {
+            "scenario_names": {
+                sid: scenario.name for sid, scenario in self.coordinator.storage.scenarios.items()
+            }
+        }
 
     async def async_select_option(self, option: str) -> None:
         """Change the selected scenario."""
diff --git a/custom_components/cover_automatic/sensor.py b/custom_components/cover_automatic/sensor.py
index 7a505b7..8f4e96f 100644
--- a/custom_components/cover_automatic/sensor.py
+++ b/custom_components/cover_automatic/sensor.py
@@ -4,12 +4,20 @@
 import logging
 from typing import TYPE_CHECKING, Any
 
-from homeassistant.components.sensor import SensorEntity
+from datetime import datetime
+from typing import Any
+
+from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import callback
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util import dt as dt_util
 
+from . import i18n
 from .const import DOMAIN
 from .coordinator import CoverAutomaticCoordinator
-from .models import CoverStatus
+from .models import ComfortMode, CoverStatus
 from .sun import get_facade_sun_times
 
 if TYPE_CHECKING:
@@ -38,32 +46,103 @@ async def async_setup_entry(
     """Set up sensor entities."""
     coordinator = entry.runtime_data.coordinator
 
-    entities: list[SensorEntity] = []
-
-    for entity_id, cover in coordinator.storage.covers.items():
-        entities.append(
-            CoverAutomaticStatusSensor(coordinator, entity_id, cover.name)
-        )
-
-    for facade_id, facade in coordinator.storage.facades.items():
-        entities.append(
-            FacadeSunSensor(coordinator, facade_id, facade.name)
-        )
-        entities.append(
-            FacadeSunTimeSensor(coordinator, facade_id, facade.name, is_entry=True)
-        )
-        entities.append(
-            FacadeSunTimeSensor(coordinator, facade_id, facade.name, is_entry=False)
-        )
-
-    async_add_entities(entities)
+    known_covers: set[str] = set()
+    known_facades: set[str] = set()
+
+    def _new_entities() -> list[SensorEntity]:
+        """Build entities for covers/facades that have none yet."""
+        storage = coordinator.storage
+        covers = storage.covers
+        facades = storage.facades
+        # Forget deleted objects so re-adding them later creates entities again
+        known_covers.intersection_update(covers)
+        known_facades.intersection_update(facades)
+
+        entities: list[SensorEntity] = []
+        for entity_id, cover in covers.items():
+            if entity_id in known_covers:
+                continue
+            known_covers.add(entity_id)
+            entities.append(
+                CoverAutomaticStatusSensor(coordinator, entity_id, cover.name)
+            )
+            entities.extend(
+                cls(coordinator, entity_id, cover.name)
+                for cls in (
+                    CoverRuleSensor,
+                    CoverTargetPositionSensor,
+                    CoverPositionSensor,
+                    CoverComfortSensor,
+                    CoverPauseEndSensor,
+                )
+            )
+        for facade_id, facade in facades.items():
+            if facade_id in known_facades:
+                continue
+            known_facades.add(facade_id)
+            entities.append(FacadeSunSensor(coordinator, facade_id, facade.name))
+            entities.append(
+                FacadeSunTimeSensor(coordinator, facade_id, facade.name, is_entry=True)
+            )
+            entities.append(
+                FacadeSunTimeSensor(coordinator, facade_id, facade.name, is_entry=False)
+            )
+        return entities
+
+    async_add_entities(
+        [
+            *_new_entities(),
+            *(
+                CoversInStatusSensor(coordinator, entry.entry_id, status)
+                for status in COUNTED_STATUSES
+            ),
+        ]
+    )
+
+    @callback
+    def _async_add_new() -> None:
+        """Add sensors for covers/facades added at runtime (panel/import)."""
+        if entities := _new_entities():
+            async_add_entities(entities)
+
+    entry.async_on_unload(coordinator.async_add_listener(_async_add_new))
+
+
+def _cover_device_info(coordinator: CoverAutomaticCoordinator, cover_entity_id: str, cover_name: str) -> dict[str, Any]:
+    """Device of a managed cover (shared by all its entities)."""
+    return {
+        "identifiers": {(DOMAIN, cover_entity_id)},
+        "name": f"CoverAutomatic {cover_name}",
+        "manufacturer": "CoverAutomatic",
+        "model": i18n.text(coordinator.hass, "model_cover"),
+    }
+
+
+def _controller_device_info(coordinator: CoverAutomaticCoordinator, entry_id: str) -> dict[str, Any]:
+    """Device of the integration itself (global entities)."""
+    return {
+        "identifiers": {(DOMAIN, entry_id)},
+        "name": "CoverAutomatic",
+        "manufacturer": "CoverAutomatic",
+        "model": i18n.text(coordinator.hass, "model_controller"),
+    }
+
+
+def _timestamp(value: Any) -> datetime | None:
+    """Unix timestamp -> aware datetime (None when unset/invalid)."""
+    if value is None:
+        return None
+    try:
+        return dt_util.utc_from_timestamp(float(value))
+    except (TypeError, ValueError, OverflowError, OSError):
+        return None
 
 
-class CoverAutomaticStatusSensor(CoordinatorEntity[CoverAutomaticCoordinator], SensorEntity):
-    """Sensor showing cover automation status."""
+class _CoverSensorBase(CoordinatorEntity[CoverAutomaticCoordinator], SensorEntity):
+    """Common base of the per-cover sensors."""
 
     _attr_has_entity_name = True
-    _attr_translation_key = "status"
+    _suffix = ""
 
     def __init__(
         self,
@@ -74,13 +153,24 @@ def __init__(
         """Initialize the sensor."""
         super().__init__(coordinator)
         self._cover_entity_id = cover_entity_id
-        self._attr_unique_id = f"{DOMAIN}_{cover_entity_id}_status"
-        self._attr_device_info = {
-            "identifiers": {(DOMAIN, cover_entity_id)},
-            "name": f"CoverAutomatic {cover_name}",
-            "manufacturer": "CoverAutomatic",
-            "model": "Cover Controller",
-        }
+        self._attr_unique_id = f"{DOMAIN}_{cover_entity_id}_{self._suffix}"
+        self._attr_device_info = _cover_device_info(coordinator, cover_entity_id, cover_name)
+
+    @property
+    def _live(self) -> dict[str, Any]:
+        return self.coordinator.get_cover_live(self._cover_entity_id)
+
+
+class CoverAutomaticStatusSensor(_CoverSensorBase):
+    """Sensor showing cover automation status.
+
+    Its attributes gather everything the dashboard card needs for one cover.
+    """
+
+    _attr_translation_key = "status"
+    _attr_device_class = SensorDeviceClass.ENUM
+    _attr_options = [status.value for status in CoverStatus]
+    _suffix = "status"
 
     @property
     def native_value(self) -> str:
@@ -88,6 +178,32 @@ def native_value(self) -> str:
         status = self.coordinator.get_cover_status(self._cover_entity_id)
         return status.value
 
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Cover, rule, positions and pause info (used by the dashboard card)."""
+        live = self._live
+        cover = self.coordinator.storage.covers.get(self._cover_entity_id)
+        pause_end = _timestamp(live.get("pause_until"))
+        last_change = _timestamp(live.get("last_change"))
+        switch_id = er.async_get(self.hass).async_get_entity_id(
+            "switch", DOMAIN, f"{DOMAIN}_{self._cover_entity_id}_auto"
+        ) if self.hass else None
+        return {
+            "cover_entity_id": self._cover_entity_id,
+            "cover_name": cover.name if cover else None,
+            "auto_enabled": cover.auto_enabled if cover else False,
+            "auto_switch": switch_id,
+            "inverted": cover.inverted if cover else False,
+            "position": self.coordinator.get_logical_position(self._cover_entity_id),
+            "target_position": live.get("target_position"),
+            "rule": live.get("rule_name"),
+            "rule_id": live.get("rule_id"),
+            "safety_rule": live.get("safety", False),
+            "comfort_mode": live.get("comfort_mode"),
+            "pause_until": pause_end.isoformat() if pause_end else None,
+            "last_change": last_change.isoformat() if last_change else None,
+        }
+
     @property
     def icon(self) -> str:
         """Return icon based on status."""
@@ -105,11 +221,146 @@ def extra_state_attributes(self) -> dict[str, Any]:
         }
 
 
+class CoverRuleSensor(_CoverSensorBase):
+    """Name of the rule currently driving the cover (None = no rule)."""
+
+    _attr_translation_key = "active_rule"
+    _attr_icon = "mdi:script-text-outline"
+    _suffix = "rule"
+
+    @property
+    def native_value(self) -> str:
+        """Rule name, or the translated 'none' text."""
+        # HA rejects states longer than 255 characters
+        return (self._live.get("rule_name") or i18n.text(self.hass, "no_rule"))[:255]
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Rule id, its target and whether it is a safety rule."""
+        live = self._live
+        return {
+            "rule_id": live.get("rule_id"),
+            "target_position": live.get("target_position"),
+            "safety_rule": live.get("safety", False),
+        }
+
+
+class CoverTargetPositionSensor(_CoverSensorBase):
+    """Position requested by the active rule (rules' scale, %)."""
+
+    _attr_translation_key = "target_position"
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_icon = "mdi:target"
+    _suffix = "target"
+
+    @property
+    def native_value(self) -> int | None:
+        """Target position, None without an active rule."""
+        return self._live.get("target_position")
+
+
+class CoverPositionSensor(_CoverSensorBase):
+    """Current position on the rules' scale (inverted covers mirrored)."""
+
+    _attr_translation_key = "position"
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_icon = "mdi:window-shutter-settings"
+    _suffix = "position"
+
+    @property
+    def native_value(self) -> int | None:
+        """Logical current position."""
+        return self.coordinator.get_logical_position(self._cover_entity_id)
+
+
+class CoverComfortSensor(_CoverSensorBase):
+    """Comfort mode of the cover's room (heating / neutral / cooling)."""
+
+    _attr_translation_key = "comfort_mode"
+    _attr_device_class = SensorDeviceClass.ENUM
+    _attr_options = [mode.value for mode in ComfortMode]
+    _attr_icon = "mdi:home-thermometer"
+    _suffix = "comfort"
+
+    @property
+    def native_value(self) -> str | None:
+        """Comfort mode, None without an indoor temperature."""
+        return self._live.get("comfort_mode")
+
+
+class CoverPauseEndSensor(_CoverSensorBase):
+    """End of the current pause (None when not paused)."""
+
+    _attr_translation_key = "pause_end"
+    _attr_device_class = SensorDeviceClass.TIMESTAMP
+    _attr_icon = "mdi:timer-pause-outline"
+    _suffix = "pause_end"
+
+    @property
+    def native_value(self) -> datetime | None:
+        """Pause end, only while the cover is paused."""
+        if self.coordinator.get_cover_status(self._cover_entity_id) != CoverStatus.PAUSED:
+            return None
+        return _timestamp(self._live.get("pause_until"))
+
+
+# Statuses counted by the global "covers in status" sensors
+COUNTED_STATUSES: tuple[CoverStatus, ...] = (
+    CoverStatus.PAUSED,
+    CoverStatus.MANUAL,
+    CoverStatus.LOCKED,
+)
+
+
+class CoversInStatusSensor(CoordinatorEntity[CoverAutomaticCoordinator], SensorEntity):
+    """Number of covers in a status (paused / manual / locked), names as attribute."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: CoverAutomaticCoordinator,
+        entry_id: str,
+        status: CoverStatus,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self._status = status
+        self._attr_translation_key = f"covers_{status.value}"
+        self._attr_unique_id = f"{DOMAIN}_{entry_id}_covers_{status.value}"
+        self._attr_device_info = _controller_device_info(coordinator, entry_id)
+        self._attr_icon = _STATUS_ICONS.get(status)
+
+    def _matching(self) -> list[tuple[str, str]]:
+        return [
+            (entity_id, cover.name)
+            for entity_id, cover in self.coordinator.storage.covers.items()
+            if self.coordinator.get_cover_status(entity_id) == self._status
+        ]
+
+    @property
+    def native_value(self) -> int:
+        """How many covers are in this status."""
+        return len(self._matching())
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Names and entity ids of those covers."""
+        matching = self._matching()
+        return {
+            "covers": [name for _, name in matching],
+            "entity_ids": [entity_id for entity_id, _ in matching],
+        }
+
+
 class FacadeSunSensor(CoordinatorEntity[CoverAutomaticCoordinator], SensorEntity):
     """Sensor showing if sun is on facade."""
 
     _attr_has_entity_name = True
     _attr_translation_key = "sun_on_facade"
+    # ENUM so the frontend shows the translated state (e.g. "Oui"/"Non")
+    _attr_device_class = SensorDeviceClass.ENUM
+    _attr_options = ["on", "off"]
 
     def __init__(
         self,
@@ -123,9 +374,11 @@ def __init__(
         self._attr_unique_id = f"{DOMAIN}_facade_{facade_id}_sun"
         self._attr_device_info = {
             "identifiers": {(DOMAIN, f"facade_{facade_id}")},
-            "name": f"CoverAutomatic Facade {facade_name}",
+            # Name translated by HA ("device.facade.name" in translations)
+            "translation_key": "facade",
+            "translation_placeholders": {"name": facade_name},
             "manufacturer": "CoverAutomatic",
-            "model": "Facade",
+            "model": i18n.text(coordinator.hass, "model_facade"),
         }
 
     @property
@@ -169,9 +422,11 @@ def __init__(
         self._attr_unique_id = f"{DOMAIN}_facade_{facade_id}_{suffix}"
         self._attr_device_info = {
             "identifiers": {(DOMAIN, f"facade_{facade_id}")},
-            "name": f"CoverAutomatic Facade {facade_name}",
+            # Name translated by HA ("device.facade.name" in translations)
+            "translation_key": "facade",
+            "translation_placeholders": {"name": facade_name},
             "manufacturer": "CoverAutomatic",
-            "model": "Facade",
+            "model": i18n.text(coordinator.hass, "model_facade"),
         }
 
     @property
diff --git a/custom_components/cover_automatic/services.py b/custom_components/cover_automatic/services.py
index ba4bca5..e0f53db 100644
--- a/custom_components/cover_automatic/services.py
+++ b/custom_components/cover_automatic/services.py
@@ -22,6 +22,10 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+
+class _ImportRejected(Exception):
+    """Import file rejected before reading (message is logged)."""
+
 # Exports are confined to this subdirectory below the HA config dir
 EXPORT_SUBDIR = "cover_automatic"
 EXPORT_ALLOWED_SUFFIXES = (".yaml", ".yml")
@@ -112,8 +116,9 @@ async def handle_pause(call: ServiceCall) -> None:
         entity_id = call.data.get("entity_id")
         for entry_data in _get_entries().values():
             if entity_id in entry_data.coordinator.storage.covers:
+                # Explicit pause: not ended by resume-on-match
                 entry_data.coordinator.pause_cover(
-                    entry_data.coordinator.storage.covers[entity_id]
+                    entry_data.coordinator.storage.covers[entity_id], manual=False
                 )
                 break
 
@@ -129,7 +134,7 @@ async def handle_pause_all(call: ServiceCall) -> None:
         """Handle pause_all service call."""
         for entry_data in _get_entries().values():
             for cover in entry_data.coordinator.storage.covers.values():
-                entry_data.coordinator.pause_cover(cover)
+                entry_data.coordinator.pause_cover(cover, manual=False)
 
     async def handle_resume_all(call: ServiceCall) -> None:
         """Handle resume_all service call."""
@@ -171,7 +176,11 @@ async def _require_admin(call: ServiceCall) -> None:
             return  # Internal/automation call -- no user context
         user = await hass.auth.async_get_user(call.context.user_id)
         if not user or not user.is_admin:
-            raise HomeAssistantError("Admin access required for this service")
+            raise HomeAssistantError(
+                "Admin access required for this service",
+                translation_domain=DOMAIN,
+                translation_key="admin_required",
+            )
 
     async def handle_export_config(call: ServiceCall) -> None:
         """Handle export_config service call."""
@@ -180,30 +189,35 @@ async def handle_export_config(call: ServiceCall) -> None:
             EXPORT_SUBDIR, "cover_automatic_backup.yaml"
         )
 
-        # Confine exports to <config>/cover_automatic/ with YAML extension
-        validated_path = _validate_export_path(path_str, hass.config.config_dir)
-        if validated_path is None:
-            _LOGGER.error(
-                "Export rejected: path '%s' must be a YAML file inside '%s'",
-                path_str,
-                Path(hass.config.config_dir) / EXPORT_SUBDIR,
-            )
-            return
+        config_dir = hass.config.config_dir
 
         for entry_data in _get_entries().values():
-            data = entry_data.storage.get_raw_data()
-
-            def write_yaml(export_data=data):
+            data = entry_data.storage.get_export_data()
+
+            def write_yaml(export_data=data) -> Path | None:
+                # Path resolution touches the filesystem: validate here, in
+                # the executor, and write only inside <config>/cover_automatic/
+                validated_path = _validate_export_path(path_str, config_dir)
+                if validated_path is None:
+                    return None
                 validated_path.parent.mkdir(parents=True, exist_ok=True)
                 with open(validated_path, "w", encoding="utf-8") as f:
                     yaml.dump(export_data, f, default_flow_style=False, allow_unicode=True)
+                return validated_path
 
             try:
-                await hass.async_add_executor_job(write_yaml)
+                written = await hass.async_add_executor_job(write_yaml)
             except (OSError, yaml.YAMLError) as err:
                 _LOGGER.error("Export failed: %s", err)
                 return
-            _LOGGER.info("Configuration exported to %s", validated_path)
+            if written is None:
+                _LOGGER.error(
+                    "Export rejected: path '%s' must be a YAML file inside '%s'",
+                    path_str,
+                    Path(config_dir) / EXPORT_SUBDIR,
+                )
+                return
+            _LOGGER.info("Configuration exported to %s", written)
             break
 
     async def handle_import_config(call: ServiceCall) -> None:
@@ -214,38 +228,37 @@ async def handle_import_config(call: ServiceCall) -> None:
             _LOGGER.error("Import rejected: no path provided")
             return
 
-        # Validate path to prevent path traversal attacks
-        validated_path = _validate_config_path(path_str, hass.config.config_dir)
-        if validated_path is None:
-            _LOGGER.error(
-                "Import rejected: path '%s' is outside allowed directories", path_str
-            )
-            return
+        config_dir = hass.config.config_dir
 
-        if not validated_path.exists():
-            _LOGGER.error("Import file not found: %s", validated_path)
-            return
-
-        # Check file size before reading
-        try:
-            file_size = validated_path.stat().st_size
+        def read_yaml():
+            # All filesystem access (resolve, exists, stat, read) runs here,
+            # in the executor, never on the event loop.
+            # Validate path to prevent path traversal attacks
+            validated_path = _validate_config_path(path_str, config_dir)
+            if validated_path is None:
+                raise _ImportRejected(
+                    f"Import rejected: path '{path_str}' is outside allowed directories"
+                )
+            if not validated_path.exists():
+                raise _ImportRejected(f"Import file not found: {validated_path}")
+            # Check file size before reading
+            try:
+                file_size = validated_path.stat().st_size
+            except OSError as err:
+                raise _ImportRejected(f"Import failed: cannot stat file: {err}") from err
             if file_size > MAX_IMPORT_FILE_SIZE:
-                _LOGGER.error(
-                    "Import rejected: file too large (%d bytes, max %d)",
-                    file_size,
-                    MAX_IMPORT_FILE_SIZE,
+                raise _ImportRejected(
+                    f"Import rejected: file too large ({file_size} bytes, "
+                    f"max {MAX_IMPORT_FILE_SIZE})"
                 )
-                return
-        except OSError as err:
-            _LOGGER.error("Import failed: cannot stat file: %s", err)
-            return
-
-        def read_yaml():
             with open(validated_path, encoding="utf-8") as f:
                 return yaml.safe_load(f)
 
         try:
             data = await hass.async_add_executor_job(read_yaml)
+        except _ImportRejected as err:
+            _LOGGER.error("%s", err)
+            return
         except (OSError, yaml.YAMLError) as err:
             _LOGGER.error("Import failed: could not read file: %s", err)
             return
@@ -257,8 +270,11 @@ def read_yaml():
                 _LOGGER.error("Import failed: invalid data format: %s", err)
                 return
             entry_data.coordinator.refresh_state_tracking()
+            # auto_enabled may have changed: leave MANUAL / enter it now
+            entry_data.coordinator.reconcile_after_import()
+            entry_data.coordinator.async_sync_entities()
             await entry_data.coordinator.async_request_refresh()
-            _LOGGER.info("Configuration imported from %s", validated_path)
+            _LOGGER.info("Configuration imported from %s", path_str)
             break
 
     schema_entity = vol.Schema({vol.Required("entity_id"): cv.entity_id})
diff --git a/custom_components/cover_automatic/services.yaml b/custom_components/cover_automatic/services.yaml
index 440c7bf..3da77bc 100644
--- a/custom_components/cover_automatic/services.yaml
+++ b/custom_components/cover_automatic/services.yaml
@@ -1,65 +1,41 @@
 pause:
-  name: Pause automation
-  description: Pause automation for a specific cover.
   fields:
     entity_id:
-      name: Cover
-      description: The cover entity to pause automation for.
       required: true
       selector:
         entity:
           domain: cover
 
 resume:
-  name: Resume automation
-  description: Resume automation for a specific cover.
   fields:
     entity_id:
-      name: Cover
-      description: The cover entity to resume automation for.
       required: true
       selector:
         entity:
           domain: cover
 
 pause_all:
-  name: Pause all
-  description: Pause automation for all managed covers.
 
 resume_all:
-  name: Resume all
-  description: Resume automation for all managed covers.
 
 set_scenario:
-  name: Set scenario
-  description: Set the active automation scenario. Use scenario IDs from your configuration.
   fields:
     scenario:
-      name: Scenario
-      description: The scenario ID to activate (e.g., everyday, summer, winter, or custom scenarios).
       required: true
       example: "everyday"
       selector:
         text:
 
 export_config:
-  name: Export configuration
-  description: Export the current configuration to a YAML file.
   fields:
     path:
-      name: File path
-      description: Path to save the configuration file. Must be a YAML file (.yaml/.yml) inside the cover_automatic folder below the Home Assistant config directory; relative paths resolve there.
       default: /config/cover_automatic/cover_automatic_backup.yaml
       selector:
         text:
 
 import_config:
-  name: Import configuration
-  description: Import configuration from a YAML file.
   fields:
     path:
-      name: File path
-      description: Path to the configuration file to import.
       required: true
       selector:
         text:
diff --git a/custom_components/cover_automatic/storage.py b/custom_components/cover_automatic/storage.py
index 90ef0df..01a48c8 100644
--- a/custom_components/cover_automatic/storage.py
+++ b/custom_components/cover_automatic/storage.py
@@ -4,14 +4,30 @@
 import asyncio
 import copy
 import logging
+from collections.abc import Callable, Collection
 from typing import TYPE_CHECKING, Any
 
+import voluptuous as vol
+from homeassistant.core import valid_entity_id
 from homeassistant.helpers.storage import Store
 
 from homeassistant.util import dt as dt_util
 
 from .const import LOG_RETENTION_DAYS, LOG_STORAGE_KEY, STORAGE_KEY, STORAGE_VERSION
-from .models import CoverConfig, Facade, Rule, Scenario
+from .models import (
+    Condition,
+    CoverConfig,
+    Facade,
+    Rule,
+    Scenario,
+    _opt_bool,
+    _to_bool,
+    _to_float,
+    _to_int,
+    finite_range,
+    int_range,
+    optional_entity_id,
+)
 
 if TYPE_CHECKING:
     from homeassistant.core import HomeAssistant
@@ -24,6 +40,343 @@
 # Required top-level keys for import validation
 _REQUIRED_DICT_KEYS = ("facades", "covers", "rules", "scenarios")
 
+# Every global setting: exported with its effective value, restored on import.
+GLOBAL_SETTING_KEYS = (
+        "enabled",
+        "outdoor_temp_sensor",
+        "indoor_temp_sensor",
+        "weather_entity",
+        "comfort_temp_min",
+        "comfort_temp_max",
+        "comfort_hysteresis",
+        "threshold_hysteresis",
+        "pause_duration",
+        "lock_position",
+        "vent_position",
+        "lock_tilt_position",
+        "vent_tilt_position",
+        "min_position_change",
+        "min_time_between_changes",
+        "house_rotation",
+        "workday_sensor",
+        "wind_sensor",
+        "wind_speed_threshold",
+        "wind_speed_hysteresis",
+        "solar_sensor",
+        "solar_threshold",
+        "solar_hysteresis",
+        "command_stagger",
+        "logbook_enabled",
+        "update_check_enabled",
+        "default_travel_time",
+        "wind_position",
+        "solar_threshold_entity",
+        "comfort_temp_min_entity",
+        "comfort_temp_max_entity",
+        "sun_heating_ignore",
+        "sun_neutral_ignore",
+        "preemptive_shading",
+        "temp_color_thermometer",
+        "pause_resume_on_match",
+)
+# Value types of the global settings, checked on import (a hand-edited
+# file may hold "false" or "15" as text).
+_BOOL_SETTINGS = frozenset({
+    "enabled", "logbook_enabled", "update_check_enabled",
+    "sun_heating_ignore", "sun_neutral_ignore", "preemptive_shading",
+    "temp_color_thermometer", "pause_resume_on_match",
+})
+_INT_SETTINGS = frozenset({
+    "pause_duration", "lock_position", "vent_position", "lock_tilt_position",
+    "vent_tilt_position", "min_position_change", "min_time_between_changes",
+    "default_travel_time", "wind_position",
+})
+_FLOAT_SETTINGS = frozenset({
+    "comfort_temp_min", "comfort_temp_max", "comfort_hysteresis",
+    "threshold_hysteresis", "house_rotation", "wind_speed_threshold",
+    "wind_speed_hysteresis", "solar_threshold", "solar_hysteresis", "command_stagger",
+})
+
+# Accepted values of every global setting: shared by the settings/update
+# WebSocket command and the import, so both apply the same bounds.
+_COMFORT_TEMP = finite_range(-50, 60)
+SETTING_VALIDATORS: dict[str, Any] = {
+    "enabled": bool,
+    "outdoor_temp_sensor": optional_entity_id,
+    "indoor_temp_sensor": optional_entity_id,
+    "weather_entity": optional_entity_id,
+    "comfort_temp_min": _COMFORT_TEMP,
+    "comfort_temp_max": _COMFORT_TEMP,
+    "comfort_hysteresis": finite_range(0.1, 5.0),
+    "threshold_hysteresis": finite_range(0, 5.0),
+    "pause_duration": int_range(1, 480),
+    "lock_position": int_range(0, 100),
+    "vent_position": int_range(0, 100),
+    "lock_tilt_position": vol.Any(None, int_range(0, 100)),
+    "vent_tilt_position": vol.Any(None, int_range(0, 100)),
+    "min_position_change": int_range(1, 50),
+    "min_time_between_changes": int_range(60, 3600),
+    "house_rotation": finite_range(-180, 180),
+    "workday_sensor": optional_entity_id,
+    "wind_sensor": optional_entity_id,
+    "wind_speed_threshold": finite_range(0),
+    "wind_speed_hysteresis": finite_range(0),
+    "solar_sensor": optional_entity_id,
+    "solar_threshold": finite_range(0),
+    "solar_hysteresis": finite_range(0),
+    "command_stagger": finite_range(0, 2.0),
+    "logbook_enabled": bool,
+    "update_check_enabled": bool,
+    "default_travel_time": vol.Any(None, int_range(1, 300)),
+    "wind_position": int_range(0, 100),
+    "solar_threshold_entity": optional_entity_id,
+    "comfort_temp_min_entity": optional_entity_id,
+    "comfort_temp_max_entity": optional_entity_id,
+    "sun_heating_ignore": bool,
+    "sun_neutral_ignore": bool,
+    "preemptive_shading": bool,
+    "temp_color_thermometer": bool,
+    "pause_resume_on_match": bool,
+}
+_SETTING_SCHEMAS = {key: vol.Schema(validator) for key, validator in SETTING_VALIDATORS.items()}
+
+
+def _check_comfort(get: Callable[[str], Any]) -> str | None:
+    low, high = get("comfort_temp_min"), get("comfort_temp_max")
+    if low >= high:
+        return f"comfort_temp_min ({low}) must be lower than comfort_temp_max ({high})"
+    return None
+
+
+def _check_wind(get: Callable[[str], Any]) -> str | None:
+    # Deactivation happens at threshold - hysteresis; <= 0 would keep wind
+    # protection (and the block on all automation) on forever.
+    threshold, hysteresis = get("wind_speed_threshold"), get("wind_speed_hysteresis")
+    if threshold > 0 and hysteresis >= threshold:
+        return (
+            f"wind_speed_hysteresis ({hysteresis}) must be lower than "
+            f"wind_speed_threshold ({threshold})"
+        )
+    return None
+
+
+def _check_solar(get: Callable[[str], Any]) -> str | None:
+    # Same deadband logic as the wind: release at threshold - hysteresis.
+    threshold, hysteresis = get("solar_threshold"), get("solar_hysteresis")
+    if threshold > 0 and hysteresis >= threshold:
+        return (
+            f"solar_hysteresis ({hysteresis}) must be lower than "
+            f"solar_threshold ({threshold})"
+        )
+    return None
+
+
+# (error code, settings involved, check) -- the code is the WS error code
+SETTINGS_CROSS_CHECKS: tuple[tuple[str, tuple[str, str], Callable[..., str | None]], ...] = (
+    ("invalid_comfort_range", ("comfort_temp_min", "comfort_temp_max"), _check_comfort),
+    ("invalid_wind_hysteresis", ("wind_speed_threshold", "wind_speed_hysteresis"), _check_wind),
+    ("invalid_solar_hysteresis", ("solar_threshold", "solar_hysteresis"), _check_solar),
+)
+
+
+def settings_cross_error(
+    get: Callable[[str], Any], changed: Collection[str] | None = None
+) -> tuple[str, str] | None:
+    """First failing cross-field check as (error code, message), else None.
+
+    get(key) returns the resulting value of a setting (new or current).
+    When changed is given, only the checks involving at least one of those
+    keys run: a pair stored before a check existed (e.g. solar_hysteresis >=
+    solar_threshold accepted before v1.87) must not block saving unrelated
+    settings, only a change of one of its own fields.
+    """
+    for code, keys, check in SETTINGS_CROSS_CHECKS:
+        if changed is not None and not any(key in changed for key in keys):
+            continue
+        message = check(get)
+        if message:
+            return code, message
+    return None
+
+
+# Per-cover runtime state: kept from this installation on import, never
+# taken from the file (a stale pause or lock would not match the automation),
+# and not exported.
+_COVER_RUNTIME_FIELDS = ("status", "pause_until", "last_position_change")
+
+# Per-cover learned values: exported (a restore on a new installation keeps
+# them), taken from the file on import only for covers that do not exist
+# locally -- an existing cover keeps the value learned here.
+_COVER_LEARNED_FIELDS = ("measured_travel_time",)
+
+# Internal runtime keys the coordinator may keep in the store: never
+# exported, never taken from a file, kept across an import.
+_RUNTIME_TOP_KEYS = ("wind_protected_state", "pre_lock_states")
+
+_INVALID = object()
+
+
+def _coerce_setting(key: str, value: Any) -> Any:
+    """Imported global setting in its proper type, _INVALID if unusable.
+
+    The value is then checked against the same bounds as the settings/update
+    WebSocket command. None is passed through (handled by the nullable
+    logic of the import).
+    """
+    if value is None:
+        return None
+    if key in _BOOL_SETTINGS:
+        result = _opt_bool(value)
+    elif key in _INT_SETTINGS:
+        result = _to_int(value, None)
+    elif key in _FLOAT_SETTINGS:
+        result = _to_float(value, None)
+    elif isinstance(value, str):
+        # Entity ids / sensors: non-empty text or nothing
+        result = value.strip()
+        if not result:
+            return None
+    else:
+        return _INVALID
+    if result is None:
+        return _INVALID
+    schema = _SETTING_SCHEMAS.get(key)
+    if schema is None:
+        return result
+    try:
+        return schema(result)
+    except vol.Invalid:
+        return _INVALID
+
+
+# Settings where None is a meaningful value ("no sensor configured").
+NULLABLE_SETTING_KEYS = frozenset({
+        "outdoor_temp_sensor", "indoor_temp_sensor", "weather_entity",
+        "workday_sensor", "wind_sensor", "solar_sensor",
+        "lock_tilt_position", "vent_tilt_position", "default_travel_time",
+        "solar_threshold_entity", "comfort_temp_min_entity", "comfort_temp_max_entity",
+})
+
+# One-shot data migrations; applied ids are persisted in _data["migrations"]
+MIGRATION_PAUSE_DURATION_120 = "pause_duration_120"
+MIGRATION_PREEMPTIVE_TRISTATE = "preemptive_tristate"
+_ALL_MIGRATIONS = (MIGRATION_PAUSE_DURATION_120, MIGRATION_PREEMPTIVE_TRISTATE)
+
+# Top-level keys of a configuration: everything else in an imported file is
+# dropped, and only these are exported.
+_CONFIG_TOP_KEYS = frozenset({
+    "facades", "covers", "rules", "scenarios", "active_scenario", "migrations",
+    *GLOBAL_SETTING_KEYS,
+})
+
+
+def _migrate_pause_duration_120(covers: Any) -> None:
+    """v1.6.0: remove per-cover pause_duration matching the old default (120)."""
+    if not isinstance(covers, dict):
+        return
+    for cover_data in covers.values():
+        if isinstance(cover_data, dict) and cover_data.get("pause_duration") == 120:
+            cover_data["pause_duration"] = None
+
+
+def _migrate_preemptive_tristate(covers: Any) -> None:
+    """Per-cover preemptive_shading True becomes None (follow global, default True).
+
+    False stays an explicit override, so behaviour is unchanged.
+    """
+    if not isinstance(covers, dict):
+        return
+    for cover_data in covers.values():
+        if isinstance(cover_data, dict) and cover_data.get("preemptive_shading") is True:
+            cover_data["preemptive_shading"] = None
+
+
+def _apply_migrations(data: dict[str, Any], done: list[str]) -> bool:
+    """Run on data every one-shot migration missing from done (in place).
+
+    done is extended with the applied ids. Returns True if one ran.
+    """
+    steps = (
+        # Runs once only: a deliberate 120 set later must survive.
+        (MIGRATION_PAUSE_DURATION_120, _migrate_pause_duration_120),
+        # Per-cover preemptive_shading became tri-state (None = global)
+        (MIGRATION_PREEMPTIVE_TRISTATE, _migrate_preemptive_tristate),
+    )
+    changed = False
+    for migration_id, step in steps:
+        if migration_id in done:
+            continue
+        step(data.get("covers"))
+        done.append(migration_id)
+        changed = True
+    return changed
+
+
+def _has_invalid_condition(rule_data: dict[str, Any]) -> bool:
+    """True when a condition of the rule cannot be loaded (Rule.from_dict drops it)."""
+    raw = rule_data.get("conditions")
+    for cond in raw if isinstance(raw, list) else []:
+        try:
+            Condition.from_dict(cond)
+        except (ValueError, KeyError):
+            return True
+    return False
+
+
+def _normalize_stored_data(data: dict[str, Any]) -> bool:
+    """Align the raw stored data with what the models load (in place, idempotent).
+
+    - a per-cover pause_duration of 0 (allowed by older versions, now at
+      least 1 minute) is stored as 1;
+    - an enabled rule with a condition that cannot be loaded (non-finite
+      param, unknown type...) is stored disabled: without that condition it
+      would match more often than configured (always, when none is left).
+    Returns True if something changed.
+    """
+    changed = False
+    covers = data.get("covers")
+    for cover_data in covers.values() if isinstance(covers, dict) else ():
+        if not isinstance(cover_data, dict):
+            continue
+        duration = _to_int(cover_data.get("pause_duration"), None)
+        if duration is not None and duration < 1:
+            cover_data["pause_duration"] = 1
+            changed = True
+    rules = data.get("rules")
+    for rule_id, rule_data in rules.items() if isinstance(rules, dict) else ():
+        if not isinstance(rule_data, dict) or not _to_bool(rule_data.get("enabled"), True):
+            continue
+        if _has_invalid_condition(rule_data):
+            _LOGGER.warning(
+                "Rule '%s' has invalid condition(s) and was disabled",
+                rule_data.get("name", rule_id),
+            )
+            rule_data["enabled"] = False
+            changed = True
+    return changed
+
+
+def _is_cover_entity_id(value: Any) -> bool:
+    """True for a valid entity id of the cover domain."""
+    return isinstance(value, str) and value.startswith("cover.") and valid_entity_id(value)
+
+
+def resolve_active_scenario(active: str | None, scenarios: Any) -> str:
+    """Return the effective active scenario id.
+
+    An empty or unknown id resolves to the first scenario, like the scenario
+    select entity shows it ("everyday" when no scenario exists).
+    """
+    available = list(scenarios or ()) or ["everyday"]
+    if active and active in available:
+        return active
+    return available[0]
+
+
+def _entry_key(section: str, entry: Any) -> str:
+    """Storage key of an imported entry (its id, entity_id for covers)."""
+    return entry.entity_id if section == "covers" else entry.id
+
 
 class CoverAutomaticStorage:
     """Manage persistent storage for CoverAutomatic."""
@@ -35,7 +388,6 @@ def __init__(self, hass: HomeAssistant) -> None:
             hass, STORAGE_VERSION, STORAGE_KEY
         )
         self._data: dict[str, Any] = {}
-        self._save_task: asyncio.Task[None] | None = None
         self._save_lock = asyncio.Lock()
         # Deserialization cache
         self._cache_facades: dict[str, Facade] | None = None
@@ -43,6 +395,20 @@ def __init__(self, hass: HomeAssistant) -> None:
         self._cache_rules: dict[str, Rule] | None = None
         self._cache_scenarios: dict[str, Scenario] | None = None
 
+    def _setting(self, key: str, default: Any) -> Any:
+        """Return a global setting, falling back to default when unset or None.
+
+        A key present with value None (e.g. from an older import) must not
+        leak None into the coordinator/engine, which compare these numerically.
+        """
+        value = self._data.get(key)
+        return default if value is None else value
+
+    def _entity_setting(self, key: str) -> str | None:
+        """Return an optional entity id setting (None when unset/invalid)."""
+        value = self._data.get(key)
+        return value if isinstance(value, str) and value else None
+
     def _invalidate_cache(self) -> None:
         """Invalidate all deserialization caches."""
         self._cache_facades = None
@@ -71,78 +437,117 @@ async def async_load(self) -> None:
                 "wind_speed_hysteresis": 0.0,
                 "solar_sensor": None,
                 "solar_threshold": 0.0,
+                # New installs have nothing to migrate
+                "migrations": list(_ALL_MIGRATIONS),
             }
         else:
             self._data = data
-            self._migrate()
+            if self._migrate():
+                # Persist the migrated data and the migration markers
+                self._schedule_save()
         self._invalidate_cache()
 
-    def _migrate(self) -> None:
-        """Run data migrations for older storage versions."""
-        # v1.6.0: Remove per-cover pause_duration if it matches the old default (120)
-        for cover_data in self._data.get("covers", {}).values():
-            if cover_data.get("pause_duration") == 120:
-                cover_data["pause_duration"] = None
+    def _migrate(self) -> bool:
+        """Run data migrations for older storage versions.
+
+        Returns True if the data changed (and must be saved).
+        """
+        done = self._data.get("migrations")
+        if not isinstance(done, list):
+            done = []
+        changed = _apply_migrations(self._data, done)
+        self._data["migrations"] = done
+        if self._migrate_rule_scenarios():
+            changed = True
+        if _normalize_stored_data(self._data):
+            changed = True
+        return changed
+
+    def _migrate_rule_scenarios(self) -> bool:
+        """v1.68.0: give every rule an explicit scenario list (all scenarios).
+
+        Rules created before per-rule scenario selection belong to every
+        scenario. Switching a rule off inside a scenario is unchanged
+        (Scenario.rules_disabled), so existing behaviour is preserved.
+        Returns True if a rule was changed.
+        """
+        all_ids = list(self._data.get("scenarios", {}).keys())
+        changed = False
+        for rule_data in self._data.get("rules", {}).values():
+            if not isinstance(rule_data.get("scenario_ids"), list):
+                rule_data["scenario_ids"] = list(all_ids)
+                changed = True
+        return changed
 
     async def async_save(self) -> None:
         """Save data to storage.
 
         Uses the same lock as debounced saves to prevent concurrent writes.
         """
-        # Cancel any pending debounced save since we're saving now
-        if self._save_task is not None:
-            self._save_task.cancel()
-            self._save_task = None
-
+        # Store.async_save supersedes any pending async_delay_save.
         async with self._save_lock:
             await self._store.async_save(self._data)
 
+    def _load_section(self, section: str, model_cls: Any) -> dict[str, Any]:
+        """Deserialize one section, skipping (and logging) corrupted entries.
+
+        A single bad entry (e.g. a NaN azimuth written as null) must not make
+        the whole section -- and every caller -- raise.
+        """
+        raw = self._data.get(section)
+        result: dict[str, Any] = {}
+        if not isinstance(raw, dict):
+            return result
+        for key, value in raw.items():
+            try:
+                result[key] = model_cls.from_dict(value)
+            except Exception as err:  # noqa: BLE001
+                _LOGGER.error("Ignoring corrupted %s entry '%s' in storage: %s", section, key, err)
+        return result
+
     @property
     def facades(self) -> dict[str, Facade]:
         """Get all facades (cached)."""
         if self._cache_facades is None:
-            self._cache_facades = {
-                k: Facade.from_dict(v) for k, v in self._data.get("facades", {}).items()
-            }
+            self._cache_facades = self._load_section("facades", Facade)
         return self._cache_facades
 
     @property
     def covers(self) -> dict[str, CoverConfig]:
         """Get all cover configurations (cached)."""
         if self._cache_covers is None:
-            self._cache_covers = {
-                k: CoverConfig.from_dict(v) for k, v in self._data.get("covers", {}).items()
-            }
+            self._cache_covers = self._load_section("covers", CoverConfig)
         return self._cache_covers
 
     @property
     def rules(self) -> dict[str, Rule]:
         """Get all rules (cached)."""
         if self._cache_rules is None:
-            self._cache_rules = {
-                k: Rule.from_dict(v) for k, v in self._data.get("rules", {}).items()
-            }
+            self._cache_rules = self._load_section("rules", Rule)
         return self._cache_rules
 
     @property
     def scenarios(self) -> dict[str, Scenario]:
         """Get all scenarios (cached)."""
         if self._cache_scenarios is None:
-            self._cache_scenarios = {
-                k: Scenario.from_dict(v) for k, v in self._data.get("scenarios", {}).items()
-            }
+            self._cache_scenarios = self._load_section("scenarios", Scenario)
         return self._cache_scenarios
 
     @property
     def active_scenario(self) -> str:
         """Get active scenario ID."""
-        return self._data.get("active_scenario", "everyday")
+        return self._setting("active_scenario", "everyday")
 
     @active_scenario.setter
     def active_scenario(self, value: str) -> None:
         """Set active scenario ID."""
         self._data["active_scenario"] = value
 
+    @property
+    def effective_active_scenario(self) -> str:
+        """Active scenario ID, an unknown/empty one resolved to the first."""
+        return resolve_active_scenario(self.active_scenario, self._data.get("scenarios", {}))
+
     @property
     def outdoor_temp_sensor(self) -> str | None:
         """Get outdoor temperature sensor entity ID."""
@@ -176,7 +581,7 @@ def weather_entity(self, value: str | None) -> None:
     @property
     def comfort_temp_min(self) -> float:
         """Get minimum comfort temperature."""
-        return self._data.get("comfort_temp_min", 21.0)
+        return self._setting("comfort_temp_min", 21.0)
 
     @comfort_temp_min.setter
     def comfort_temp_min(self, value: float) -> None:
@@ -186,7 +591,7 @@ def comfort_temp_min(self, value: float) -> None:
     @property
     def comfort_temp_max(self) -> float:
         """Get maximum comfort temperature."""
-        return self._data.get("comfort_temp_max", 25.0)
+        return self._setting("comfort_temp_max", 25.0)
 
     @comfort_temp_max.setter
     def comfort_temp_max(self, value: float) -> None:
@@ -196,7 +601,7 @@ def comfort_temp_max(self, value: float) -> None:
     @property
     def comfort_hysteresis(self) -> float:
         """Get comfort temperature hysteresis."""
-        return self._data.get("comfort_hysteresis", 1.0)
+        return self._setting("comfort_hysteresis", 1.0)
 
     @comfort_hysteresis.setter
     def comfort_hysteresis(self, value: float) -> None:
@@ -206,7 +611,7 @@ def comfort_hysteresis(self, value: float) -> None:
     @property
     def threshold_hysteresis(self) -> float:
         """Get deadband for temperature_above/below conditions."""
-        return self._data.get("threshold_hysteresis", 0.5)
+        return self._setting("threshold_hysteresis", 0.5)
 
     @threshold_hysteresis.setter
     def threshold_hysteresis(self, value: float) -> None:
@@ -216,7 +621,7 @@ def threshold_hysteresis(self, value: float) -> None:
     @property
     def enabled(self) -> bool:
         """Get global automation enabled state."""
-        return self._data.get("enabled", True)
+        return self._setting("enabled", True)
 
     @enabled.setter
     def enabled(self, value: bool) -> None:
@@ -225,18 +630,18 @@ def enabled(self, value: bool) -> None:
 
     @property
     def pause_duration(self) -> int:
-        """Get global default pause duration in seconds."""
-        return self._data.get("pause_duration", 10)
+        """Get global default pause duration in minutes."""
+        return self._setting("pause_duration", 10)
 
     @pause_duration.setter
     def pause_duration(self, value: int) -> None:
-        """Set global default pause duration in seconds."""
+        """Set global default pause duration in minutes."""
         self._data["pause_duration"] = int(value)
 
     @property
     def lock_position(self) -> int:
         """Get global default lock position."""
-        return self._data.get("lock_position", 100)
+        return self._setting("lock_position", 100)
 
     @lock_position.setter
     def lock_position(self, value: int) -> None:
@@ -246,7 +651,7 @@ def lock_position(self, value: int) -> None:
     @property
     def vent_position(self) -> int:
         """Get global default vent position."""
-        return self._data.get("vent_position", 30)
+        return self._setting("vent_position", 30)
 
     @vent_position.setter
     def vent_position(self, value: int) -> None:
@@ -276,7 +681,7 @@ def vent_tilt_position(self, value: int | None) -> None:
     @property
     def min_position_change(self) -> int:
         """Get global default minimum position change."""
-        return self._data.get("min_position_change", 5)
+        return self._setting("min_position_change", 5)
 
     @min_position_change.setter
     def min_position_change(self, value: int) -> None:
@@ -286,7 +691,7 @@ def min_position_change(self, value: int) -> None:
     @property
     def min_time_between_changes(self) -> int:
         """Get global default minimum time between changes."""
-        return self._data.get("min_time_between_changes", 300)
+        return self._setting("min_time_between_changes", 300)
 
     @min_time_between_changes.setter
     def min_time_between_changes(self, value: int) -> None:
@@ -316,7 +721,7 @@ def wind_sensor(self, value: str | None) -> None:
     @property
     def wind_speed_threshold(self) -> float:
         """Get wind speed activation threshold."""
-        return self._data.get("wind_speed_threshold", 0.0)
+        return self._setting("wind_speed_threshold", 0.0)
 
     @wind_speed_threshold.setter
     def wind_speed_threshold(self, value: float) -> None:
@@ -326,7 +731,7 @@ def wind_speed_threshold(self, value: float) -> None:
     @property
     def wind_speed_hysteresis(self) -> float:
         """Get wind speed deactivation hysteresis."""
-        return self._data.get("wind_speed_hysteresis", 0.0)
+        return self._setting("wind_speed_hysteresis", 0.0)
 
     @wind_speed_hysteresis.setter
     def wind_speed_hysteresis(self, value: float) -> None:
@@ -346,7 +751,7 @@ def solar_sensor(self, value: str | None) -> None:
     @property
     def solar_threshold(self) -> float:
         """Get solar intensity threshold for preemptive shading."""
-        return self._data.get("solar_threshold", 0.0)
+        return self._setting("solar_threshold", 0.0)
 
     @solar_threshold.setter
     def solar_threshold(self, value: float) -> None:
@@ -356,27 +761,131 @@ def solar_threshold(self, value: float) -> None:
     @property
     def solar_hysteresis(self) -> float:
         """Get deadband for the preemptive-shading solar threshold."""
-        return self._data.get("solar_hysteresis", 0.0)
+        return self._setting("solar_hysteresis", 0.0)
 
     @solar_hysteresis.setter
     def solar_hysteresis(self, value: float) -> None:
         """Set deadband for the preemptive-shading solar threshold."""
         self._data["solar_hysteresis"] = float(value)
 
+    @property
+    def sun_heating_ignore(self) -> bool:
+        """Sun on facade: answer 'no sun' in heating mode."""
+        return bool(self._setting("sun_heating_ignore", True))
+
+    @sun_heating_ignore.setter
+    def sun_heating_ignore(self, value: bool) -> None:
+        """Set the heating-mode sun switch."""
+        self._data["sun_heating_ignore"] = bool(value)
+
+    @property
+    def sun_neutral_ignore(self) -> bool:
+        """Sun on facade: answer 'no sun' in neutral mode (unless preemptive)."""
+        return bool(self._setting("sun_neutral_ignore", True))
+
+    @sun_neutral_ignore.setter
+    def sun_neutral_ignore(self, value: bool) -> None:
+        """Set the neutral-mode sun switch."""
+        self._data["sun_neutral_ignore"] = bool(value)
+
+    @property
+    def preemptive_shading(self) -> bool:
+        """Global default for preemptive shading (per-cover override wins)."""
+        return bool(self._setting("preemptive_shading", True))
+
+    @preemptive_shading.setter
+    def preemptive_shading(self, value: bool) -> None:
+        """Set the global preemptive shading default."""
+        self._data["preemptive_shading"] = bool(value)
+
+    @property
+    def temp_color_thermometer(self) -> bool:
+        """Display only: cold room blue / hot room red (False: cold red, hot blue)."""
+        return bool(self._setting("temp_color_thermometer", False))
+
+    @temp_color_thermometer.setter
+    def temp_color_thermometer(self, value: bool) -> None:
+        """Set the temperature colour convention."""
+        self._data["temp_color_thermometer"] = bool(value)
+
+    @property
+    def pause_resume_on_match(self) -> bool:
+        """End a manual pause once the cover is back at its rule's position."""
+        return bool(self._setting("pause_resume_on_match", True))
+
+    @pause_resume_on_match.setter
+    def pause_resume_on_match(self, value: bool) -> None:
+        """Set the global resume-on-match default (per-cover override wins)."""
+        self._data["pause_resume_on_match"] = bool(value)
+
+    @property
+    def solar_threshold_entity(self) -> str | None:
+        """Entity holding the solar threshold (overrides solar_threshold)."""
+        return self._entity_setting("solar_threshold_entity")
+
+    @solar_threshold_entity.setter
+    def solar_threshold_entity(self, value: str | None) -> None:
+        """Set the entity holding the solar threshold."""
+        self._data["solar_threshold_entity"] = value or None
+
+    @property
+    def comfort_temp_min_entity(self) -> str | None:
+        """Entity holding the minimum comfort temperature."""
+        return self._entity_setting("comfort_temp_min_entity")
+
+    @comfort_temp_min_entity.setter
+    def comfort_temp_min_entity(self, value: str | None) -> None:
+        """Set the entity holding the minimum comfort temperature."""
+        self._data["comfort_temp_min_entity"] = value or None
+
+    @property
+    def comfort_temp_max_entity(self) -> str | None:
+        """Entity holding the maximum comfort temperature."""
+        return self._entity_setting("comfort_temp_max_entity")
+
+    @comfort_temp_max_entity.setter
+    def comfort_temp_max_entity(self, value: str | None) -> None:
+        """Set the entity holding the maximum comfort temperature."""
+        self._data["comfort_temp_max_entity"] = value or None
+
+    @property
+    def wind_position(self) -> int:
+        """Logical position covers move to while wind protection is active."""
+        value = self._data.get("wind_position")
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            return 100
+        return max(0, min(100, int(value)))
+
+    @wind_position.setter
+    def wind_position(self, value: int) -> None:
+        """Set the wind protection position (0-100)."""
+        self._data["wind_position"] = max(0, min(100, int(value)))
+
     @property
     def house_rotation(self) -> float:
         """Get global house rotation offset in degrees."""
-        return self._data.get("house_rotation", 0.0)
+        return self._setting("house_rotation", 0.0)
 
     @house_rotation.setter
     def house_rotation(self, value: float) -> None:
         """Set global house rotation offset in degrees."""
         self._data["house_rotation"] = float(value)
 
+    @property
+    def default_travel_time(self) -> int | None:
+        """Default full travel time (s) for covers without own/measured value."""
+        value = self._data.get("default_travel_time")
+        return int(value) if isinstance(value, (int, float)) and value > 0 else None
+
+    @default_travel_time.setter
+    def default_travel_time(self, value: int | None) -> None:
+        """Set the default travel time (None = no default, 30 s settle)."""
+        self._data["default_travel_time"] = int(value) if value else None
+
     @property
     def command_stagger(self) -> float:
         """Get command stagger delay in seconds between cover commands."""
-        return self._data.get("command_stagger", 0.0)
+        return self._setting("command_stagger", 0.0)
 
     @command_stagger.setter
     def command_stagger(self, value: float) -> None:
@@ -386,7 +895,7 @@ def command_stagger(self, value: float) -> None:
     @property
     def logbook_enabled(self) -> bool:
         """Get whether to write HA logbook entries for cover actions."""
-        return self._data.get("logbook_enabled", True)
+        return self._setting("logbook_enabled", True)
 
     @logbook_enabled.setter
     def logbook_enabled(self, value: bool) -> None:
@@ -396,7 +905,7 @@ def logbook_enabled(self, value: bool) -> None:
     @property
     def update_check_enabled(self) -> bool:
         """Get whether the panel may query GitHub for the latest release."""
-        return self._data.get("update_check_enabled", True)
+        return self._setting("update_check_enabled", True)
 
     @update_check_enabled.setter
     def update_check_enabled(self, value: bool) -> None:
@@ -427,6 +936,7 @@ async def async_remove_facade(self, facade_id: str) -> None:
                 fids = rule_data.get("facade_ids", [])
                 if facade_id in fids:
                     fids.remove(facade_id)
+                    self._disable_if_unassigned(rule_data)
             self._cache_rules = None
             await self.async_save()
 
@@ -455,9 +965,43 @@ async def async_remove_cover(self, entity_id: str) -> None:
                 cids = rule_data.get("cover_ids", [])
                 if entity_id in cids:
                     cids.remove(entity_id)
+                    self._disable_if_unassigned(rule_data)
             self._cache_rules = None
             await self.async_save()
 
+    @staticmethod
+    def _disable_if_unassigned(rule_data: dict[str, Any]) -> None:
+        """Disable a rule whose last cover/facade assignment was removed.
+
+        Without any assignment the engine treats a rule as global (applies
+        to every cover), which the removal must not silently turn it into.
+        """
+        if rule_data.get("cover_ids") or rule_data.get("facade_ids"):
+            return
+        if rule_data.get("enabled", True):
+            _LOGGER.warning(
+                "Rule '%s' has no cover or facade left and was disabled",
+                rule_data.get("name", rule_data.get("id", "?")),
+            )
+        rule_data["enabled"] = False
+
+    @staticmethod
+    def _disable_if_no_scenario(rule_data: dict[str, Any]) -> None:
+        """Disable a rule whose last scenario was removed.
+
+        Consistent with facade/cover removal: a rule left without any
+        scenario is switched off (and logged) rather than kept dangling.
+        """
+        ids = rule_data.get("scenario_ids")
+        if not isinstance(ids, list) or ids:
+            return
+        if rule_data.get("enabled", True):
+            _LOGGER.warning(
+                "Rule '%s' has no scenario left and was disabled",
+                rule_data.get("name", rule_data.get("id", "?")),
+            )
+        rule_data["enabled"] = False
+
     async def async_add_rule(self, rule: Rule, *, save: bool = True) -> None:
         """Add or update a rule."""
         if "rules" not in self._data:
@@ -480,12 +1024,94 @@ async def async_remove_rule(self, rule_id: str) -> None:
             self._cache_scenarios = None
             await self.async_save()
 
+    async def async_rename_rule(self, old_id: str, new_id: str, *, save: bool = True) -> bool:
+        """Move a rule to a new id, keeping its position and references.
+
+        Scenario rules_disabled entries follow the new id. Returns False
+        (nothing changed) when old_id is unknown or new_id is already taken.
+        """
+        rules = self._data.get("rules", {})
+        if old_id not in rules or old_id == new_id or new_id in rules:
+            return False
+        # Rebuild the dict so the rule keeps its place in the order
+        self._data["rules"] = {
+            (new_id if key == old_id else key): value for key, value in rules.items()
+        }
+        self._data["rules"][new_id]["id"] = new_id
+        for scenario_data in self._data.get("scenarios", {}).values():
+            disabled = scenario_data.get("rules_disabled")
+            if isinstance(disabled, list) and old_id in disabled:
+                scenario_data["rules_disabled"] = [
+                    new_id if rid == old_id else rid for rid in disabled
+                ]
+        self._cache_rules = None
+        self._cache_scenarios = None
+        if save:
+            await self.async_save()
+        return True
+
+    def rule_order(self) -> list[str]:
+        """Rule ids from highest to lowest priority (ties by id), as evaluated."""
+        rules = self._data.get("rules", {})
+
+        def key(rid: str) -> tuple[float, str]:
+            try:
+                prio = float(rules[rid].get("priority") or 0)
+            except (TypeError, ValueError):
+                prio = 0.0
+            return (-prio, rid)
+
+        return sorted(rules, key=key)
+
+    def renumber_priorities(self, ordered_ids: list[str]) -> None:
+        """Give priorities from the list order: first = highest."""
+        rules = self._data.get("rules", {})
+        total = len(ordered_ids)
+        for idx, rid in enumerate(ordered_ids):
+            rules[rid]["priority"] = (total - idx) * 10
+        self._cache_rules = None
+
+    async def async_duplicate_rule(self, rule_id: str, new_id: str, name: str) -> bool:
+        """Copy a rule right below the original, active.
+
+        The copy keeps every setting (conditions, targets, scenarios, safety)
+        and is switched off in the same scenarios as the original. Returns
+        False when rule_id is unknown or new_id is already taken.
+        """
+        rules = self._data.get("rules", {})
+        if rule_id not in rules or new_id in rules:
+            return False
+        order = self.rule_order()
+        copy_data = copy.deepcopy(rules[rule_id])
+        copy_data.update({"id": new_id, "name": name, "enabled": True})
+        rules[new_id] = copy_data
+        order.insert(order.index(rule_id) + 1, new_id)
+        self.renumber_priorities(order)
+        for scenario_data in self._data.get("scenarios", {}).values():
+            disabled = scenario_data.get("rules_disabled")
+            if isinstance(disabled, list) and rule_id in disabled and new_id not in disabled:
+                disabled.append(new_id)
+        self._cache_scenarios = None
+        await self.async_save()
+        return True
+
     async def async_add_scenario(self, scenario: Scenario, *, save: bool = True) -> None:
-        """Add or update a scenario."""
+        """Add or update a scenario.
+
+        A new scenario is added to the scenario list of every rule (rules
+        belong to all scenarios by default; deselect them per rule).
+        """
         if "scenarios" not in self._data:
             self._data["scenarios"] = {}
+        is_new = scenario.id not in self._data["scenarios"]
         self._data["scenarios"][scenario.id] = scenario.to_dict()
         self._cache_scenarios = None
+        if is_new:
+            for rule_data in self._data.get("rules", {}).values():
+                ids = rule_data.get("scenario_ids")
+                if isinstance(ids, list) and scenario.id not in ids:
+                    ids.append(scenario.id)
+            self._cache_rules = None
         if save:
             await self.async_save()
 
@@ -494,15 +1120,54 @@ async def async_remove_scenario(self, scenario_id: str) -> None:
         if scenario_id in self._data.get("scenarios", {}):
             del self._data["scenarios"][scenario_id]
             self._cache_scenarios = None
+            for rule_data in self._data.get("rules", {}).values():
+                ids = rule_data.get("scenario_ids")
+                if isinstance(ids, list) and scenario_id in ids:
+                    ids.remove(scenario_id)
+                    self._disable_if_no_scenario(rule_data)
+            self._cache_rules = None
             if self._data.get("active_scenario") == scenario_id:
                 remaining = self._data.get("scenarios", {})
                 self._data["active_scenario"] = next(iter(remaining), "everyday")
             await self.async_save()
 
     def get_raw_data(self) -> dict[str, Any]:
-        """Get raw data for export (deep copy to prevent race conditions)."""
+        """Get raw data (deep copy to prevent race conditions)."""
         return copy.deepcopy(self._data)
 
+    def get_export_data(self) -> dict[str, Any]:
+        """Complete configuration for a backup.
+
+        Unlike the raw store, every global setting is written with its
+        effective value (defaults included) and every entry in its full
+        normalised form, so a restore reproduces exactly what is in use
+        even when a setting was never saved or a field added later.
+
+        Runtime state (cover status, pause, last move) and internal keys
+        (e.g. wind_protected_state) are not exported; the learned travel
+        time is (see _COVER_LEARNED_FIELDS). The
+        migration markers are, so an import does not replay migrations on
+        data already in the current format.
+        """
+        data: dict[str, Any] = {}
+        for key in GLOBAL_SETTING_KEYS:
+            data[key] = getattr(self, key)
+        data["active_scenario"] = self.active_scenario
+        sections = {
+            "facades": self.facades,
+            "covers": self.covers,
+            "rules": self.rules,
+            "scenarios": self.scenarios,
+        }
+        for section, entries in sections.items():
+            data[section] = {key: entry.to_dict() for key, entry in entries.items()}
+        for cover_data in data["covers"].values():
+            for runtime_field in _COVER_RUNTIME_FIELDS:
+                cover_data.pop(runtime_field, None)
+        # Exported entries are normalised: every known migration applies
+        data["migrations"] = list(_ALL_MIGRATIONS)
+        return data
+
     async def async_import_data(self, data: dict[str, Any]) -> None:
         """Import data from dict with validation."""
         if not isinstance(data, dict):
@@ -512,8 +1177,21 @@ async def async_import_data(self, data: dict[str, Any]) -> None:
             if key in data and not isinstance(data[key], dict):
                 raise ValueError(f"Import data key '{key}' must be a dictionary")
 
-        # Deep copy to prevent external mutation
-        data = copy.deepcopy(data)
+        # Refuse files that are not a CoverAutomatic export at all: without
+        # this, any YAML mapping (e.g. secrets.yaml) silently replaced the
+        # whole configuration with empty sections.
+        if not any(key in data for key in _REQUIRED_DICT_KEYS):
+            raise ValueError(
+                "Import data is not a CoverAutomatic configuration "
+                f"(none of {', '.join(_REQUIRED_DICT_KEYS)} found)"
+            )
+
+        # Only configuration keys are taken from the file (deep copy to
+        # prevent external mutation); unknown or internal keys are dropped.
+        unknown_keys = sorted(str(key) for key in data if key not in _CONFIG_TOP_KEYS)
+        if unknown_keys:
+            _LOGGER.warning("Import: ignoring unknown keys %s", ", ".join(unknown_keys))
+        data = copy.deepcopy({k: v for k, v in data.items() if k in _CONFIG_TOP_KEYS})
 
         # Ensure required keys exist
         for key in _REQUIRED_DICT_KEYS:
@@ -523,7 +1201,9 @@ async def async_import_data(self, data: dict[str, Any]) -> None:
             self._data.get("active_scenario", "everyday"),
         )
 
-        # Validate sub-elements can be deserialized (skip corrupt entries)
+        # Deserialize sub-elements (skip corrupt entries) and store the
+        # normalised form, keyed by the entry's own id, so bad types cannot
+        # crash the update cycle later.
         _validators: dict[str, type] = {
             "facades": Facade,
             "covers": CoverConfig,
@@ -534,56 +1214,159 @@ async def async_import_data(self, data: dict[str, Any]) -> None:
             valid: dict[str, Any] = {}
             for k, v in data.get(section, {}).items():
                 try:
-                    model_cls.from_dict(v)
-                    valid[k] = v
+                    entry = model_cls.from_dict(v)
+                    key = _entry_key(section, entry)
+                    if not isinstance(key, str) or not key:
+                        raise ValueError("missing id")
+                    if section == "covers" and not _is_cover_entity_id(key):
+                        raise ValueError(f"'{key}' is not a cover entity id")
+                    normalised = entry.to_dict()
                 except Exception as err:  # noqa: BLE001
                     _LOGGER.warning(
                         "Skipping invalid %s entry '%s' during import: %s",
                         section, k, err,
                     )
+                    continue
+                if key != k:
+                    _LOGGER.warning(
+                        "Import: %s entry '%s' stored under its id '%s'", section, k, key
+                    )
+                if key in valid:
+                    _LOGGER.warning("Import: duplicate %s id '%s', keeping the last", section, key)
+                valid[key] = normalised
             data[section] = valid
 
+        self._reconcile_import_references(data)
+
         # Validate active_scenario exists in imported scenarios
         if data.get("active_scenario") not in data.get("scenarios", {}):
             first_scenario = next(iter(data.get("scenarios", {})), "everyday")
             data["active_scenario"] = first_scenario
 
+        # Imported global settings in their proper type and within the bounds
+        # of the settings form; unusable values are dropped (the local value
+        # is then kept, as for a missing key).
+        for gkey in GLOBAL_SETTING_KEYS:
+            if gkey not in data:
+                continue
+            coerced = _coerce_setting(gkey, data[gkey])
+            if coerced is _INVALID:
+                _LOGGER.warning(
+                    "Import: invalid value %r for setting '%s', keeping the current one",
+                    data[gkey], gkey,
+                )
+                data.pop(gkey)
+            else:
+                data[gkey] = coerced
+
+        # Cross-field checks (comfort band, wind/solar deadbands) on the
+        # resulting values: an inconsistent imported pair keeps the local one.
+        def _resulting(key: str) -> Any:
+            value = data.get(key)
+            return getattr(self, key) if value is None else value
+
+        for code, keys, check in SETTINGS_CROSS_CHECKS:
+            message = check(_resulting)
+            if message and any(data.get(key) is not None for key in keys):
+                _LOGGER.warning(
+                    "Import: %s (%s), keeping the current values", message, code
+                )
+                for key in keys:
+                    data.pop(key, None)
+
+        # Runtime state of the covers stays the one of this installation
+        local_covers = self._data.get("covers", {})
+        for entity_id, cover_data in data.get("covers", {}).items():
+            local = local_covers.get(entity_id) or {}
+            for field in _COVER_RUNTIME_FIELDS:
+                cover_data[field] = local.get(field)
+            for field in _COVER_LEARNED_FIELDS:
+                if entity_id in local_covers:
+                    cover_data[field] = local.get(field)
+                else:
+                    # New cover: the file's value, if usable (positive)
+                    value = _to_float(cover_data.get(field), None)
+                    cover_data[field] = value if value is not None and value > 0 else None
+            if cover_data.get("status") is None:
+                cover_data["status"] = "auto"
+
         # Preserve global settings not present in import data
-        _global_keys = (
-            "enabled",
-            "outdoor_temp_sensor",
-            "indoor_temp_sensor",
-            "weather_entity",
-            "comfort_temp_min",
-            "comfort_temp_max",
-            "comfort_hysteresis",
-            "threshold_hysteresis",
-            "pause_duration",
-            "lock_position",
-            "vent_position",
-            "lock_tilt_position",
-            "vent_tilt_position",
-            "min_position_change",
-            "min_time_between_changes",
-            "house_rotation",
-            "workday_sensor",
-            "wind_sensor",
-            "wind_speed_threshold",
-            "wind_speed_hysteresis",
-            "solar_sensor",
-            "solar_threshold",
-            "solar_hysteresis",
-            "command_stagger",
-            "logbook_enabled",
+        for gkey in GLOBAL_SETTING_KEYS:
+            if gkey in NULLABLE_SETTING_KEYS and gkey in data:
+                continue  # explicit value (including None) wins
+            if data.get(gkey) is not None:
+                continue
+            # Only carry over settings that actually exist locally; copying
+            # an absent key would store None and override the getter default
+            # (e.g. enabled=None silently disabled all automation).
+            if self._data.get(gkey) is not None:
+                data[gkey] = self._data[gkey]
+            else:
+                data.pop(gkey, None)
+
+        # Replay on the imported entries every migration the file has not
+        # been through yet (older exports, hand-written files): idempotent,
+        # as each applied id is recorded.
+        imported_done = data.get("migrations")
+        done = (
+            [m for m in imported_done if isinstance(m, str)]
+            if isinstance(imported_done, list) else []
         )
-        for gkey in _global_keys:
-            if gkey not in data:
-                data[gkey] = self._data.get(gkey)
+        _apply_migrations(data, done)
+        data["migrations"] = list(dict.fromkeys(done))
+
+        # Internal runtime keys stay the ones of this installation
+        for key in _RUNTIME_TOP_KEYS:
+            if key in self._data:
+                data[key] = self._data[key]
 
         self._data = data
+        self._migrate_rule_scenarios()
         self._invalidate_cache()
         await self.async_save()
 
+    def _reconcile_import_references(self, data: dict[str, Any]) -> None:
+        """Make the references between imported entries consistent (in place).
+
+        Unknown facade/cover/scenario/rule ids are dropped, the facade cover
+        lists are rebuilt from cover.facade_id (the source of truth), and a
+        rule left without any of its covers/facades or scenarios is disabled
+        instead of silently becoming global.
+        """
+        facades = data["facades"]
+        covers = data["covers"]
+        rules = data["rules"]
+        scenarios = data["scenarios"]
+
+        for entity_id, cover_data in covers.items():
+            fid = cover_data.get("facade_id")
+            if fid is not None and fid not in facades:
+                _LOGGER.warning(
+                    "Import: cover '%s' refers to unknown facade '%s', unassigned", entity_id, fid
+                )
+                cover_data["facade_id"] = None
+
+        for fid, facade_data in facades.items():
+            members = [eid for eid, c in covers.items() if c.get("facade_id") == fid]
+            listed = [eid for eid in facade_data.get("cover_ids", []) if eid in members]
+            facade_data["cover_ids"] = list(dict.fromkeys([*listed, *members]))
+
+        for rule_data in rules.values():
+            assigned = bool(rule_data.get("facade_ids") or rule_data.get("cover_ids"))
+            rule_data["facade_ids"] = [f for f in rule_data.get("facade_ids", []) if f in facades]
+            rule_data["cover_ids"] = [c for c in rule_data.get("cover_ids", []) if c in covers]
+            if assigned:
+                self._disable_if_unassigned(rule_data)
+            ids = rule_data.get("scenario_ids")
+            if isinstance(ids, list) and ids:
+                rule_data["scenario_ids"] = [s for s in ids if s in scenarios]
+                self._disable_if_no_scenario(rule_data)
+
+        for scenario_data in scenarios.values():
+            scenario_data["rules_disabled"] = [
+                r for r in scenario_data.get("rules_disabled", []) if r in rules
+            ]
+
     def update_cover_status(
         self, entity_id: str, status: str, pause_until: float | None = None
     ) -> None:
@@ -611,41 +1394,29 @@ def update_cover_last_change(self, entity_id: str, timestamp: float) -> None:
             self._cache_covers = None
             self._schedule_save()
 
-    def flush_pending_save(self) -> None:
-        """Cancel pending debounced save task (public API for coordinator shutdown)."""
-        if self._save_task is not None:
-            self._save_task.cancel()
-            self._save_task = None
+    def update_cover_measured_travel(self, entity_id: str, seconds: float | None) -> None:
+        """Store the measured full travel time of a cover (debounced save)."""
+        if entity_id in self._data.get("covers", {}):
+            self._data["covers"][entity_id]["measured_travel_time"] = seconds
+            self._cache_covers = None
+            self._schedule_save()
 
-    def _schedule_save(self) -> None:
-        """Schedule a debounced save operation.
+    def flush_pending_save(self) -> None:
+        """Kept for API compatibility.
 
-        Multiple rapid updates will be batched into a single save
-        after SAVE_DEBOUNCE_DELAY seconds of inactivity.
+        Pending delayed writes are owned by the HA Store: they are replaced by
+        the next async_save() and flushed by HA itself on shutdown
+        (EVENT_HOMEASSISTANT_FINAL_WRITE), so nothing needs cancelling here.
         """
-        if self._save_task is not None:
-            self._save_task.cancel()
 
-        self._save_task = self.hass.async_create_task(
-            self._debounced_save(),
-            name="cover_automatic_debounced_save",
-        )
+    def _schedule_save(self) -> None:
+        """Schedule a debounced save through the HA Store.
 
-    async def _debounced_save(self) -> None:
-        """Perform debounced save after delay."""
-        current = asyncio.current_task()
-        try:
-            await asyncio.sleep(SAVE_DEBOUNCE_DELAY)
-            async with self._save_lock:
-                await self._store.async_save(self._data)
-                _LOGGER.debug("Runtime changes persisted to storage")
-        except asyncio.CancelledError:
-            pass
-        except Exception as err:
-            _LOGGER.error("Failed to save runtime changes: %s", err)
-        finally:
-            if self._save_task is current:
-                self._save_task = None
+        Multiple rapid updates are batched into a single write after
+        SAVE_DEBOUNCE_DELAY seconds. Unlike a hand-rolled task, the Store
+        also writes pending data when Home Assistant stops.
+        """
+        self._store.async_delay_save(lambda: self._data, SAVE_DEBOUNCE_DELAY)
 
 
 class ActivityLogStorage:
@@ -655,7 +1426,6 @@ def __init__(self, hass: HomeAssistant) -> None:
         self.hass = hass
         self._store: Store[dict[str, Any]] = Store(hass, STORAGE_VERSION, LOG_STORAGE_KEY)
         self._entries: list[dict[str, Any]] = []
-        self._save_task: asyncio.Task[None] | None = None
         self._save_lock = asyncio.Lock()
 
     async def async_load(self) -> None:
@@ -695,21 +1465,14 @@ def add_entry(
     async def async_clear(self) -> None:
         """Clear all log entries and save immediately."""
         self._entries = []
-        if self._save_task is not None:
-            self._save_task.cancel()
-            self._save_task = None
         async with self._save_lock:
             await self._store.async_save({"entries": self._entries})
 
     async def async_save(self) -> None:
         """Save log entries to storage immediately.
 
-        Cancels any pending debounced save first so the in-memory state wins.
-        Used during shutdown to flush pending entries before the loop stops.
+        Supersedes any pending delayed save so the in-memory state wins.
         """
-        if self._save_task is not None:
-            self._save_task.cancel()
-            self._save_task = None
         async with self._save_lock:
             await self._store.async_save({"entries": self._entries})
 
@@ -718,42 +1481,29 @@ def get_entries(
         event_type: str | None = None,
         entity_id: str | None = None,
         limit: int = 500,
+        include_global: bool = False,
     ) -> list[dict[str, Any]]:
-        """Get log entries, newest first, with optional filters."""
+        """Get log entries, newest first, with optional filters.
+
+        include_global keeps, with an entity filter, the entries that concern
+        no cover in particular (wind protection on/off) for context.
+        """
         self._cleanup_old_entries()
         entries = self._entries
         if event_type:
             entries = [e for e in entries if e.get("type") == event_type]
         if entity_id:
-            entries = [e for e in entries if e.get("entity_id") == entity_id]
+            entries = [
+                e for e in entries
+                if e.get("entity_id") == entity_id or (include_global and not e.get("entity_id"))
+            ]
         return list(reversed(entries))[:limit]
 
     def flush_pending_save(self) -> None:
-        """Cancel pending debounced save task."""
-        if self._save_task is not None:
-            self._save_task.cancel()
-            self._save_task = None
+        """Kept for API compatibility (the HA Store owns pending writes)."""
 
     def _schedule_save(self) -> None:
-        """Schedule a debounced save."""
-        if self._save_task is not None:
-            self._save_task.cancel()
-        self._save_task = self.hass.async_create_task(
-            self._debounced_save(),
-            name="cover_automatic_log_save",
+        """Schedule a debounced save through the HA Store."""
+        self._store.async_delay_save(
+            lambda: {"entries": self._entries}, SAVE_DEBOUNCE_DELAY
         )
-
-    async def _debounced_save(self) -> None:
-        """Perform debounced save after delay."""
-        current = asyncio.current_task()
-        try:
-            await asyncio.sleep(SAVE_DEBOUNCE_DELAY)
-            async with self._save_lock:
-                await self._store.async_save({"entries": self._entries})
-        except asyncio.CancelledError:
-            pass
-        except Exception as err:
-            _LOGGER.error("Failed to save activity log: %s", err)
-        finally:
-            if self._save_task is current:
-                self._save_task = None
diff --git a/custom_components/cover_automatic/strings.json b/custom_components/cover_automatic/strings.json
index 2580721..c49c3cb 100644
--- a/custom_components/cover_automatic/strings.json
+++ b/custom_components/cover_automatic/strings.json
@@ -51,19 +51,135 @@
         }
       },
       "sun_on_facade": {
-        "name": "Sun on facade"
+        "name": "Sun on facade",
+        "state": {
+          "on": "On",
+          "off": "Off"
+        }
       },
       "sun_entry_time": {
         "name": "Sun entry time"
       },
       "sun_exit_time": {
         "name": "Sun exit time"
+      },
+      "active_rule": {
+        "name": "Active rule"
+      },
+      "target_position": {
+        "name": "Target position"
+      },
+      "position": {
+        "name": "Position (rules scale)"
+      },
+      "comfort_mode": {
+        "name": "Comfort mode",
+        "state": {
+          "heating": "Cold",
+          "neutral": "Comfort",
+          "cooling": "Hot"
+        }
+      },
+      "pause_end": {
+        "name": "Pause end"
+      },
+      "covers_paused": {
+        "name": "Covers paused"
+      },
+      "covers_manual": {
+        "name": "Covers in manual mode"
+      },
+      "covers_locked": {
+        "name": "Covers locked"
       }
     },
     "select": {
       "scenario": {
-        "name": "Scenario"
+        "name": "Scenario",
+        "state": {
+          "everyday": "Everyday",
+          "summer": "Summer",
+          "winter": "Winter",
+          "vacation": "Vacation",
+          "cinema": "Cinema",
+          "manual": "Manual"
+        }
+      }
+    },
+    "binary_sensor": {
+      "wind_protection": {
+        "name": "Wind protection"
+      }
+    }
+  },
+  "device": {
+    "facade": {
+      "name": "CoverAutomatic Facade {name}"
+    }
+  },
+  "services": {
+    "pause": {
+      "name": "Pause automation",
+      "description": "Pause automation for a specific cover.",
+      "fields": {
+        "entity_id": {
+          "name": "Cover",
+          "description": "The cover entity to pause automation for."
+        }
+      }
+    },
+    "resume": {
+      "name": "Resume automation",
+      "description": "Resume automation for a specific cover.",
+      "fields": {
+        "entity_id": {
+          "name": "Cover",
+          "description": "The cover entity to resume automation for."
+        }
       }
+    },
+    "pause_all": {
+      "name": "Pause all",
+      "description": "Pause automation for all managed covers."
+    },
+    "resume_all": {
+      "name": "Resume all",
+      "description": "Resume automation for all managed covers."
+    },
+    "set_scenario": {
+      "name": "Set scenario",
+      "description": "Set the active automation scenario. Use scenario IDs from your configuration.",
+      "fields": {
+        "scenario": {
+          "name": "Scenario",
+          "description": "The scenario ID to activate (e.g., everyday, summer, winter, or custom scenarios)."
+        }
+      }
+    },
+    "export_config": {
+      "name": "Export configuration",
+      "description": "Export the current configuration to a YAML file.",
+      "fields": {
+        "path": {
+          "name": "File path",
+          "description": "Path to save the configuration file. Must be a YAML file (.yaml/.yml) inside the cover_automatic folder below the Home Assistant config directory; relative paths resolve there."
+        }
+      }
+    },
+    "import_config": {
+      "name": "Import configuration",
+      "description": "Import configuration from a YAML file.",
+      "fields": {
+        "path": {
+          "name": "File path",
+          "description": "Path to the configuration file to import."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "admin_required": {
+      "message": "Admin access required for this service."
     }
   }
 }
diff --git a/custom_components/cover_automatic/sun.py b/custom_components/cover_automatic/sun.py
index 0a16603..aa0cc99 100644
--- a/custom_components/cover_automatic/sun.py
+++ b/custom_components/cover_automatic/sun.py
@@ -2,12 +2,20 @@
 from __future__ import annotations
 
 import logging
+<<<<<<< Updated upstream
 from datetime import date, datetime, timedelta
 from typing import TYPE_CHECKING, Any
+=======
+from datetime import timedelta
+from typing import TYPE_CHECKING
+>>>>>>> Stashed changes
 
 from astral import Observer
 from astral.sun import zenith_and_azimuth
 from homeassistant.const import SUN_EVENT_SUNRISE, SUN_EVENT_SUNSET
+from astral import Observer
+from astral.sun import azimuth as solar_azimuth
+from astral.sun import elevation as solar_elevation
 from homeassistant.helpers.sun import get_astral_event_date
 from homeassistant.util import dt as dt_util
 
@@ -22,12 +30,18 @@
 
 SUN_ENTITY_ID = "sun.sun"
 
+<<<<<<< Updated upstream
 # Facade sun times: coarse scan of the day, then bisection at each boundary
 _SCAN_STEP = timedelta(minutes=5)
 _BOUNDARY_PRECISION = timedelta(seconds=15)
 
 # (day, facade geometry, location) -> (entry, exit); holds the current day only
 _times_cache: dict[tuple[Any, ...], tuple[str | None, str | None]] = {}
+=======
+# Astral event names (civil twilight: sun 6 degrees below the horizon)
+SUN_EVENT_DAWN = "dawn"
+SUN_EVENT_DUSK = "dusk"
+>>>>>>> Stashed changes
 
 
 def get_sun_position(hass: HomeAssistant) -> tuple[float, float] | None:
@@ -74,18 +88,37 @@ def is_sun_on_facade(
     azimuth, elevation = position
     return _sun_hits_facade(facade, azimuth, elevation)
 
+<<<<<<< Updated upstream
 
 def _sun_hits_facade(facade: Facade, azimuth: float, elevation: float) -> bool:
     """Return True if a sun at azimuth/elevation shines on the facade."""
     if elevation < facade.min_elevation:
+=======
+    # Same bound as get_facade_sun_times: the sun is never "on" a facade
+    # while below the horizon, whatever a negative min_elevation says.
+    if elevation < max(facade.min_elevation, 0.0):
+>>>>>>> Stashed changes
         return False
 
-    start = facade.azimuth_start
-    end = facade.azimuth_end
+    return _azimuth_in_facade(azimuth, facade.azimuth_start, facade.azimuth_end)
 
+<<<<<<< Updated upstream
     if start <= end:
         return start <= azimuth <= end
     return azimuth >= start or azimuth <= end
+=======
+
+def get_sun_event_time(
+    hass: HomeAssistant, event: str, day_offset: int = 0
+) -> float | None:
+    """Get a sun event (sunrise/sunset) timestamp for today + day_offset days."""
+    event_dt = get_astral_event_date(
+        hass, event, dt_util.now() + timedelta(days=day_offset)
+    )
+    if event_dt is None:
+        return None
+    return event_dt.timestamp()
+>>>>>>> Stashed changes
 
 
 def get_sunrise_time(hass: HomeAssistant) -> float | None:
@@ -104,16 +137,55 @@ def get_sunset_time(hass: HomeAssistant) -> float | None:
     return sunset.timestamp()
 
 
+<<<<<<< Updated upstream
 def get_facade_sun_times(
     hass: HomeAssistant, facade: Facade,
 ) -> tuple[str | None, str | None]:
     """Return today's sun entry and exit time (local HH:MM) for a facade.
+=======
+def get_dawn_time(hass: HomeAssistant) -> float | None:
+    """Get today's dawn (civil twilight start, sun 6 deg below horizon)."""
+    return get_sun_event_time(hass, SUN_EVENT_DAWN)
+
+
+def get_dusk_time(hass: HomeAssistant) -> float | None:
+    """Get today's dusk (civil twilight end, sun 6 deg below horizon)."""
+    return get_sun_event_time(hass, SUN_EVENT_DUSK)
+
+
+# Sampling step for facade sun entry/exit times (minutes)
+SUN_TIME_SAMPLE_MINUTES = 5
+
+# Per-day cache: (date, lat, lon, facade geometry) -> (entry, exit)
+_SUN_TIME_CACHE: dict[tuple, tuple[str | None, str | None]] = {}
+
+
+def _azimuth_in_facade(azimuth: float, start: float, end: float) -> bool:
+    """Return True if the azimuth lies within the facade range (wrap-aware).
+
+    start == end means a full circle (every azimuth): the models normalise
+    360 to 0, so a 0-360 range entered by the user is stored as 0/0 and must
+    not shrink to the single bearing 0.
+    """
+    if start == end:
+        return True
+    if start <= end:
+        return start <= azimuth <= end
+    return azimuth >= start or azimuth <= end
+
+
+def get_facade_sun_times(
+    hass: HomeAssistant, facade: Facade,
+) -> tuple[str | None, str | None]:
+    """Calculate today's sun entry and exit times for a facade.
+>>>>>>> Stashed changes
 
     Derived from the real sun path at the configured location with the same
     test as is_sun_on_facade, so the times match when the automation sees the
     sun on the facade. Facade azimuth values are real compass bearings (house
     rotation already applied at configuration time).
 
+<<<<<<< Updated upstream
     A facade lit in two separate periods (wrap-around facade in summer) reports
     the first one. Returns (None, None) if the sun does not reach it today.
     Computed once per day and facade, both sensors share the result.
@@ -164,9 +236,23 @@ def lit(moment: datetime) -> bool:
         moment += _SCAN_STEP
 
     if entry is None or exit_ is None:
+=======
+    The real solar path for the configured location is sampled every
+    SUN_TIME_SAMPLE_MINUTES between sunrise and sunset (astral), so the result
+    is correct for any season and latitude. The first contiguous period in
+    which the sun is on the facade (azimuth in range, elevation at least
+    max(min_elevation, 0)) is returned as local HH:MM strings; (None, None)
+    when the sun does not reach the facade today (or during polar day/night).
+    Results are cached per day and facade geometry.
+    """
+    sunrise = get_sunrise_time(hass)
+    sunset = get_sunset_time(hass)
+    if sunrise is None or sunset is None or sunset <= sunrise:
+>>>>>>> Stashed changes
         return None, None
     return _format_local(entry), _format_local(exit_)
 
+<<<<<<< Updated upstream
 
 def _boundary(
     lit: Callable[[datetime], bool], inside: datetime, outside: datetime,
@@ -183,3 +269,51 @@ def _boundary(
 
 def _format_local(moment: datetime) -> str:
     return dt_util.as_local(moment).strftime("%H:%M")
+=======
+    today = dt_util.as_local(dt_util.utc_from_timestamp(sunrise)).date()
+    key = (
+        today, hass.config.latitude, hass.config.longitude,
+        facade.azimuth_start, facade.azimuth_end, facade.min_elevation,
+    )
+    cached = _SUN_TIME_CACHE.get(key)
+    if cached is not None:
+        return cached
+
+    # Drop entries of previous days so the cache cannot grow unbounded
+    for old_key in [k for k in _SUN_TIME_CACHE if k[0] != today]:
+        del _SUN_TIME_CACHE[old_key]
+
+    # Observer built directly (HA's get_astral_location is deprecated and
+    # removed in 2027.7); same computation as Location.solar_azimuth/elevation.
+    observer = Observer(
+        hass.config.latitude, hass.config.longitude, hass.config.elevation or 0
+    )
+    min_elevation = max(facade.min_elevation, 0.0)
+    step = SUN_TIME_SAMPLE_MINUTES * 60
+    entry_ts: float | None = None
+    exit_ts: float | None = None
+    ts = sunrise
+    while ts <= sunset:
+        moment = dt_util.utc_from_timestamp(ts)
+        azimuth = solar_azimuth(observer, moment)
+        elevation = solar_elevation(observer, moment)
+        on_facade = elevation >= min_elevation and _azimuth_in_facade(
+            azimuth, facade.azimuth_start, facade.azimuth_end
+        )
+        if on_facade:
+            if entry_ts is None:
+                entry_ts = ts
+            exit_ts = ts
+        elif entry_ts is not None:
+            break  # end of the first contiguous period
+        ts += step
+
+    def _fmt(value: float | None) -> str | None:
+        if value is None:
+            return None
+        return dt_util.as_local(dt_util.utc_from_timestamp(value)).strftime("%H:%M")
+
+    result = (_fmt(entry_ts), _fmt(exit_ts))
+    _SUN_TIME_CACHE[key] = result
+    return result
+>>>>>>> Stashed changes
diff --git a/custom_components/cover_automatic/switch.py b/custom_components/cover_automatic/switch.py
index 3ab9f8c..bd1e0f4 100644
--- a/custom_components/cover_automatic/switch.py
+++ b/custom_components/cover_automatic/switch.py
@@ -4,8 +4,10 @@
 from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.switch import SwitchEntity
+from homeassistant.core import callback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from . import i18n
 from .const import DOMAIN
 from .coordinator import CoverAutomaticCoordinator
 
@@ -28,13 +30,30 @@ async def async_setup_entry(
         CoverAutomaticMasterSwitch(coordinator, entry.entry_id),
     ]
 
+    known: set[str] = set()
     for entity_id, cover in coordinator.storage.covers.items():
         entities.append(
             CoverAutomaticAutoSwitch(coordinator, entity_id, cover.name)
         )
+        known.add(entity_id)
 
     async_add_entities(entities)
 
+    @callback
+    def _async_add_new_covers() -> None:
+        """Add switches for covers added at runtime (panel/import)."""
+        covers = coordinator.storage.covers
+        known.intersection_update(covers)  # forget deleted covers
+        new = [eid for eid in covers if eid not in known]
+        if not new:
+            return
+        known.update(new)
+        async_add_entities(
+            CoverAutomaticAutoSwitch(coordinator, eid, covers[eid].name) for eid in new
+        )
+
+    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_covers))
+
 
 class CoverAutomaticMasterSwitch(CoordinatorEntity[CoverAutomaticCoordinator], SwitchEntity):
     """Global master switch to enable/disable all CoverAutomatic automation."""
@@ -50,7 +69,7 @@ def __init__(self, coordinator: CoverAutomaticCoordinator, entry_id: str) -> Non
             "identifiers": {(DOMAIN, entry_id)},
             "name": "CoverAutomatic",
             "manufacturer": "CoverAutomatic",
-            "model": "Controller",
+            "model": i18n.text(coordinator.hass, "model_controller"),
         }
 
     @property
@@ -91,7 +110,7 @@ def __init__(
             "identifiers": {(DOMAIN, cover_entity_id)},
             "name": f"CoverAutomatic {cover_name}",
             "manufacturer": "CoverAutomatic",
-            "model": "Cover Controller",
+            "model": i18n.text(coordinator.hass, "model_cover"),
         }
 
     @property
diff --git a/custom_components/cover_automatic/translations/de.json b/custom_components/cover_automatic/translations/de.json
index d8adbe4..0ab54d3 100644
--- a/custom_components/cover_automatic/translations/de.json
+++ b/custom_components/cover_automatic/translations/de.json
@@ -51,19 +51,135 @@
         }
       },
       "sun_on_facade": {
-        "name": "Sonne auf Fassade"
+        "name": "Sonne auf Fassade",
+        "state": {
+          "on": "An",
+          "off": "Aus"
+        }
       },
       "sun_entry_time": {
         "name": "Sonneneintritt"
       },
       "sun_exit_time": {
         "name": "Sonnenaustritt"
+      },
+      "active_rule": {
+        "name": "Aktive Regel"
+      },
+      "target_position": {
+        "name": "Zielposition"
+      },
+      "position": {
+        "name": "Position (Regelskala)"
+      },
+      "comfort_mode": {
+        "name": "Komfortmodus",
+        "state": {
+          "heating": "Kalt",
+          "neutral": "Komfort",
+          "cooling": "Warm"
+        }
+      },
+      "pause_end": {
+        "name": "Pausenende"
+      },
+      "covers_paused": {
+        "name": "Pausierte Rollläden"
+      },
+      "covers_manual": {
+        "name": "Rollläden im manuellen Modus"
+      },
+      "covers_locked": {
+        "name": "Gesperrte Rollläden"
       }
     },
     "select": {
       "scenario": {
-        "name": "Szenario"
+        "name": "Szenario",
+        "state": {
+          "everyday": "Alltag",
+          "summer": "Sommer",
+          "winter": "Winter",
+          "vacation": "Urlaub",
+          "cinema": "Kino",
+          "manual": "Manuell"
+        }
+      }
+    },
+    "binary_sensor": {
+      "wind_protection": {
+        "name": "Windschutz"
+      }
+    }
+  },
+  "device": {
+    "facade": {
+      "name": "CoverAutomatic Fassade {name}"
+    }
+  },
+  "services": {
+    "pause": {
+      "name": "Automatik pausieren",
+      "description": "Pausiert die Automatik für einen bestimmten Rollladen.",
+      "fields": {
+        "entity_id": {
+          "name": "Rollladen",
+          "description": "Der Rollladen, dessen Automatik pausiert werden soll."
+        }
+      }
+    },
+    "resume": {
+      "name": "Automatik fortsetzen",
+      "description": "Setzt die Automatik für einen bestimmten Rollladen fort.",
+      "fields": {
+        "entity_id": {
+          "name": "Rollladen",
+          "description": "Der Rollladen, dessen Automatik fortgesetzt werden soll."
+        }
       }
+    },
+    "pause_all": {
+      "name": "Alle pausieren",
+      "description": "Pausiert die Automatik für alle verwalteten Rollläden."
+    },
+    "resume_all": {
+      "name": "Alle fortsetzen",
+      "description": "Setzt die Automatik für alle verwalteten Rollläden fort."
+    },
+    "set_scenario": {
+      "name": "Szenario setzen",
+      "description": "Setzt das aktive Szenario. Verwende die Szenario-IDs aus deiner Konfiguration.",
+      "fields": {
+        "scenario": {
+          "name": "Szenario",
+          "description": "Die zu aktivierende Szenario-ID (z. B. everyday, summer, winter oder eigene Szenarien)."
+        }
+      }
+    },
+    "export_config": {
+      "name": "Konfiguration exportieren",
+      "description": "Exportiert die aktuelle Konfiguration in eine YAML-Datei.",
+      "fields": {
+        "path": {
+          "name": "Dateipfad",
+          "description": "Speicherort der Datei. Muss eine YAML-Datei (.yaml/.yml) im Ordner cover_automatic unterhalb des Home-Assistant-Konfigurationsverzeichnisses sein; relative Pfade werden dort aufgelöst."
+        }
+      }
+    },
+    "import_config": {
+      "name": "Konfiguration importieren",
+      "description": "Importiert die Konfiguration aus einer YAML-Datei.",
+      "fields": {
+        "path": {
+          "name": "Dateipfad",
+          "description": "Pfad zur zu importierenden Konfigurationsdatei."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "admin_required": {
+      "message": "Für diesen Dienst sind Administratorrechte erforderlich."
     }
   }
 }
diff --git a/custom_components/cover_automatic/translations/en.json b/custom_components/cover_automatic/translations/en.json
index 2580721..c49c3cb 100644
--- a/custom_components/cover_automatic/translations/en.json
+++ b/custom_components/cover_automatic/translations/en.json
@@ -51,19 +51,135 @@
         }
       },
       "sun_on_facade": {
-        "name": "Sun on facade"
+        "name": "Sun on facade",
+        "state": {
+          "on": "On",
+          "off": "Off"
+        }
       },
       "sun_entry_time": {
         "name": "Sun entry time"
       },
       "sun_exit_time": {
         "name": "Sun exit time"
+      },
+      "active_rule": {
+        "name": "Active rule"
+      },
+      "target_position": {
+        "name": "Target position"
+      },
+      "position": {
+        "name": "Position (rules scale)"
+      },
+      "comfort_mode": {
+        "name": "Comfort mode",
+        "state": {
+          "heating": "Cold",
+          "neutral": "Comfort",
+          "cooling": "Hot"
+        }
+      },
+      "pause_end": {
+        "name": "Pause end"
+      },
+      "covers_paused": {
+        "name": "Covers paused"
+      },
+      "covers_manual": {
+        "name": "Covers in manual mode"
+      },
+      "covers_locked": {
+        "name": "Covers locked"
       }
     },
     "select": {
       "scenario": {
-        "name": "Scenario"
+        "name": "Scenario",
+        "state": {
+          "everyday": "Everyday",
+          "summer": "Summer",
+          "winter": "Winter",
+          "vacation": "Vacation",
+          "cinema": "Cinema",
+          "manual": "Manual"
+        }
+      }
+    },
+    "binary_sensor": {
+      "wind_protection": {
+        "name": "Wind protection"
+      }
+    }
+  },
+  "device": {
+    "facade": {
+      "name": "CoverAutomatic Facade {name}"
+    }
+  },
+  "services": {
+    "pause": {
+      "name": "Pause automation",
+      "description": "Pause automation for a specific cover.",
+      "fields": {
+        "entity_id": {
+          "name": "Cover",
+          "description": "The cover entity to pause automation for."
+        }
+      }
+    },
+    "resume": {
+      "name": "Resume automation",
+      "description": "Resume automation for a specific cover.",
+      "fields": {
+        "entity_id": {
+          "name": "Cover",
+          "description": "The cover entity to resume automation for."
+        }
       }
+    },
+    "pause_all": {
+      "name": "Pause all",
+      "description": "Pause automation for all managed covers."
+    },
+    "resume_all": {
+      "name": "Resume all",
+      "description": "Resume automation for all managed covers."
+    },
+    "set_scenario": {
+      "name": "Set scenario",
+      "description": "Set the active automation scenario. Use scenario IDs from your configuration.",
+      "fields": {
+        "scenario": {
+          "name": "Scenario",
+          "description": "The scenario ID to activate (e.g., everyday, summer, winter, or custom scenarios)."
+        }
+      }
+    },
+    "export_config": {
+      "name": "Export configuration",
+      "description": "Export the current configuration to a YAML file.",
+      "fields": {
+        "path": {
+          "name": "File path",
+          "description": "Path to save the configuration file. Must be a YAML file (.yaml/.yml) inside the cover_automatic folder below the Home Assistant config directory; relative paths resolve there."
+        }
+      }
+    },
+    "import_config": {
+      "name": "Import configuration",
+      "description": "Import configuration from a YAML file.",
+      "fields": {
+        "path": {
+          "name": "File path",
+          "description": "Path to the configuration file to import."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "admin_required": {
+      "message": "Admin access required for this service."
     }
   }
 }
diff --git a/custom_components/cover_automatic/translations/fr.json b/custom_components/cover_automatic/translations/fr.json
new file mode 100644
index 0000000..fc7aa97
--- /dev/null
+++ b/custom_components/cover_automatic/translations/fr.json
@@ -0,0 +1,174 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "title": "CoverAutomatic",
+        "description": "Ajouter l'intégration CoverAutomatic. Configurez l'ensemble des réglages dans le panneau CoverAutomatic (barre latérale) après l'installation."
+      }
+    },
+    "abort": {
+      "already_configured": "CoverAutomatic est déjà configuré."
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Configuration de CoverAutomatic",
+        "description": "Utilisez le panneau CoverAutomatic dans la barre latérale pour configurer l'intégration. Accédez à l'entrée CoverAutomatic dans le menu de la barre latérale."
+      }
+    }
+  },
+  "entity": {
+    "switch": {
+      "auto_enabled": {
+        "name": "Automatisation"
+      },
+      "master_enabled": {
+        "name": "CoverAutomatic"
+      }
+    },
+    "sensor": {
+      "status": {
+        "name": "Statut",
+        "state": {
+          "auto": "Automatique",
+          "paused": "En pause",
+          "manual": "Manuel",
+          "locked": "Verrouillé",
+          "venting": "Aération",
+          "wind_protected": "Protection vent"
+        }
+      },
+      "sun_on_facade": {
+        "name": "Soleil sur la façade",
+        "state": {
+          "on": "Oui",
+          "off": "Non"
+        }
+      },
+      "sun_entry_time": {
+        "name": "Heure d'arrivée du soleil"
+      },
+      "sun_exit_time": {
+        "name": "Heure de départ du soleil"
+      },
+      "active_rule": {
+        "name": "Règle active"
+      },
+      "target_position": {
+        "name": "Position cible"
+      },
+      "position": {
+        "name": "Position (échelle des règles)"
+      },
+      "comfort_mode": {
+        "name": "Mode confort",
+        "state": {
+          "heating": "Froid",
+          "neutral": "Confort",
+          "cooling": "Chaud"
+        }
+      },
+      "pause_end": {
+        "name": "Fin de pause"
+      },
+      "covers_paused": {
+        "name": "Volets en pause"
+      },
+      "covers_manual": {
+        "name": "Volets en manuel"
+      },
+      "covers_locked": {
+        "name": "Volets verrouillés"
+      }
+    },
+    "select": {
+      "scenario": {
+        "name": "Scénario",
+        "state": {
+          "everyday": "Quotidien",
+          "summer": "Été",
+          "winter": "Hiver",
+          "vacation": "Vacances",
+          "cinema": "Cinéma",
+          "manual": "Manuel"
+        }
+      }
+    },
+    "binary_sensor": {
+      "wind_protection": {
+        "name": "Protection vent"
+      }
+    }
+  },
+  "device": {
+    "facade": {
+      "name": "CoverAutomatic Façade {name}"
+    }
+  },
+  "services": {
+    "pause": {
+      "name": "Mettre en pause l'automatisation",
+      "description": "Met en pause l'automatisation d'un volet.",
+      "fields": {
+        "entity_id": {
+          "name": "Volet",
+          "description": "Le volet dont l'automatisation doit être mise en pause."
+        }
+      }
+    },
+    "resume": {
+      "name": "Reprendre l'automatisation",
+      "description": "Reprend l'automatisation d'un volet.",
+      "fields": {
+        "entity_id": {
+          "name": "Volet",
+          "description": "Le volet dont l'automatisation doit reprendre."
+        }
+      }
+    },
+    "pause_all": {
+      "name": "Tout mettre en pause",
+      "description": "Met en pause l'automatisation de tous les volets gérés."
+    },
+    "resume_all": {
+      "name": "Tout reprendre",
+      "description": "Reprend l'automatisation de tous les volets gérés."
+    },
+    "set_scenario": {
+      "name": "Choisir le scénario",
+      "description": "Définit le scénario actif. Utilisez les identifiants de scénario de votre configuration.",
+      "fields": {
+        "scenario": {
+          "name": "Scénario",
+          "description": "Identifiant du scénario à activer (par ex. everyday, summer, winter ou un scénario personnalisé)."
+        }
+      }
+    },
+    "export_config": {
+      "name": "Exporter la configuration",
+      "description": "Exporte la configuration actuelle dans un fichier YAML.",
+      "fields": {
+        "path": {
+          "name": "Chemin du fichier",
+          "description": "Emplacement du fichier. Il doit s'agir d'un fichier YAML (.yaml/.yml) dans le dossier cover_automatic du répertoire de configuration de Home Assistant ; les chemins relatifs y sont résolus."
+        }
+      }
+    },
+    "import_config": {
+      "name": "Importer la configuration",
+      "description": "Importe la configuration depuis un fichier YAML.",
+      "fields": {
+        "path": {
+          "name": "Chemin du fichier",
+          "description": "Chemin du fichier de configuration à importer."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "admin_required": {
+      "message": "Ce service nécessite les droits administrateur."
+    }
+  }
+}
diff --git a/tests/test_api.py b/tests/test_api.py
index ab623c3..5b276b6 100644
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -79,6 +79,7 @@ def _make_storage(
     storage.async_remove_cover = AsyncMock()
     storage.async_add_rule = AsyncMock()
     storage.async_remove_rule = AsyncMock()
+    storage.async_rename_rule = AsyncMock(return_value=True)
     storage.async_add_scenario = AsyncMock()
     storage.async_remove_scenario = AsyncMock()
     storage.async_save = AsyncMock()
@@ -330,7 +331,11 @@ def test_registers_all_commands(self) -> None:
         ) as mock_ws:
             mock_ws.BASE_COMMAND_MESSAGE_SCHEMA = real_ws.BASE_COMMAND_MESSAGE_SCHEMA
             async_setup_api(hass, storage, coordinator)
+<<<<<<< Updated upstream
             assert mock_ws.async_register_command.call_count == 22
+=======
+            assert mock_ws.async_register_command.call_count == 24  # 21 + subscribe + condition/validate + rule/duplicate
+>>>>>>> Stashed changes
 
     def test_command_names_registered(self) -> None:
         hass = _make_hass()
@@ -352,7 +357,11 @@ def capture_register(hass, command_type, handler=None, schema=None):
             mock_ws.async_register_command.side_effect = capture_register
             async_setup_api(hass, storage, coordinator)
 
+<<<<<<< Updated upstream
         assert len(registered_schemas) == 22
+=======
+        assert len(registered_schemas) == 24  # 21 + subscribe + condition/validate + rule/duplicate
+>>>>>>> Stashed changes
 
 
 # ---------------------------------------------------------------------------
@@ -1123,6 +1132,7 @@ async def test_delete_unknown_rule_sends_error(self) -> None:
         conn.send_error.assert_called_once()
 
 
+<<<<<<< Updated upstream
 class TestWsRuleDuplicate:
     """Tests for cover_automatic/rule/duplicate handler."""
 
@@ -1237,6 +1247,14 @@ async def test_unknown_rule_sends_error(self) -> None:
         conn.send_error.assert_called_once()
         assert conn.send_error.call_args.args[1] == "not_found"
         storage.async_add_rule.assert_not_awaited()
+=======
+def _real_rule_ordering(storage) -> None:
+    """Use the real rule ordering helpers on a mocked storage."""
+    from custom_components.cover_automatic.storage import CoverAutomaticStorage
+
+    storage.rule_order = lambda: CoverAutomaticStorage.rule_order(storage)
+    storage.renumber_priorities = lambda ids: CoverAutomaticStorage.renumber_priorities(storage, ids)
+>>>>>>> Stashed changes
 
 
 class TestWsRuleReorder:
@@ -1261,6 +1279,7 @@ async def test_reorder_sets_priorities(self) -> None:
             "scenarios": {},
         }
 
+        _real_rule_ordering(storage)
         msg = {
             "id": 1,
             "type": "cover_automatic/rule/reorder",
@@ -1276,6 +1295,21 @@ async def test_reorder_sets_priorities(self) -> None:
         storage.async_save.assert_awaited_once()
         conn.send_result.assert_called_once()
 
+    @pytest.mark.asyncio
+    async def test_partial_reorder_keeps_the_rest_below(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_reorder
+
+        storage = _make_storage()
+        storage._data = {"rules": {
+            "a": {"id": "a", "priority": 30}, "b": {"id": "b", "priority": 20},
+            "c": {"id": "c", "priority": 10},
+        }}
+        _real_rule_ordering(storage)
+        msg = {"id": 1, "rule_ids": ["c", "c"]}
+        await ws_rule_reorder(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        prios = {k: v["priority"] for k, v in storage._data["rules"].items()}
+        assert prios == {"c": 30, "a": 20, "b": 10}
+
     @pytest.mark.asyncio
     async def test_reorder_unknown_rule_sends_error(self) -> None:
         """reorder with an unknown rule id is rejected without saving (regression)."""
@@ -1667,7 +1701,7 @@ async def test_export_returns_raw_data(self) -> None:
         storage = _make_storage()
         coordinator = _make_coordinator()
         raw = {"facades": {}, "covers": {}, "rules": {}}
-        storage.get_raw_data.return_value = raw
+        storage.get_export_data.return_value = raw
         msg = {"id": 1, "type": "cover_automatic/export"}
 
         await ws_export_config(hass, conn, msg, storage, coordinator)
@@ -1788,8 +1822,8 @@ async def test_active_scenario_accepts_existing(self) -> None:
         conn.send_result.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_active_scenario_accepts_empty_string(self) -> None:
-        """Test that clearing the scenario (empty string = falsy) is accepted."""
+    async def test_active_scenario_rejects_empty_string(self) -> None:
+        """An empty active_scenario is rejected instead of being stored."""
         from custom_components.cover_automatic.api import ws_settings_update
 
         hass = _make_hass()
@@ -1801,7 +1835,9 @@ async def test_active_scenario_accepts_empty_string(self) -> None:
 
         await ws_settings_update(hass, conn, msg, storage, coordinator)
 
-        conn.send_result.assert_called_once()
+        conn.send_error.assert_called_once()
+        assert "not_found" in conn.send_error.call_args[0]
+        conn.send_result.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_command_stagger_in_config_response(self) -> None:
diff --git a/tests/test_condition_groups.py b/tests/test_condition_groups.py
new file mode 100644
index 0000000..de5cddd
--- /dev/null
+++ b/tests/test_condition_groups.py
@@ -0,0 +1,197 @@
+"""Tests for condition groups ((A or B) and (C or D)) and negated conditions."""
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from custom_components.cover_automatic.models import (
+    MAX_CONDITION_GROUPS,
+    Condition,
+    ConditionType,
+    Rule,
+)
+from tests.test_api import _make_connection, _make_coordinator, _make_hass, _make_storage
+from tests.test_engine import (  # noqa: F401 -- pytest fixtures
+    MockState,
+    engine,
+    mock_hass,
+    mock_storage,
+    test_cover,
+)
+
+
+def _state(entity: str, group: int = 0, *, negate: bool = False, state: str = "on") -> Condition:
+    return Condition(
+        type=ConditionType.STATE_IS,
+        params={"entity_id": entity, "state": state},
+        group=group,
+        negate=negate,
+    )
+
+
+@pytest.fixture
+def states(mock_hass):
+    """Entity states by id; missing ids are unavailable (None)."""
+    values: dict[str, str] = {}
+    mock_hass.states.get.side_effect = lambda eid: MockState(values[eid]) if eid in values else None
+    return values
+
+
+class TestModel:
+    def test_legacy_rule_is_one_group_with_its_operator(self) -> None:
+        rule = Rule.from_dict({"id": "r", "name": "R", "condition_operator": "or", "conditions": []})
+        assert rule.group_operators == ["or"]
+        assert rule.to_dict()["group_operators"] == ["or"]
+
+    def test_direct_construction_uses_condition_operator(self) -> None:
+        rule = Rule(id="r", name="R", condition_operator="or", conditions=[_state("a")])
+        assert rule.condition_groups() == [("or", rule.conditions)]
+
+    def test_condition_roundtrip(self) -> None:
+        cond = _state("a", 2, negate=True)
+        again = Condition.from_dict(cond.to_dict())
+        assert (again.group, again.negate) == (2, True)
+
+    def test_legacy_condition_defaults(self) -> None:
+        cond = Condition.from_dict({"type": "state_is", "params": {}})
+        assert (cond.group, cond.negate) == (0, False)
+
+    def test_invalid_group_is_clamped(self) -> None:
+        assert Condition.from_dict({"type": "state_is", "params": {}, "group": "x"}).group == 0
+        assert Condition.from_dict({"type": "state_is", "params": {}, "group": -3}).group == 0
+        assert Condition.from_dict({"type": "state_is", "params": {}, "group": 99}).group == MAX_CONDITION_GROUPS - 1
+
+    def test_invalid_group_operators_sanitized(self) -> None:
+        rule = Rule.from_dict({"id": "r", "name": "R", "group_operators": ["or", "xor"]})
+        assert rule.group_operators == ["or", "and"]
+
+    def test_empty_groups_are_skipped(self) -> None:
+        rule = Rule(id="r", name="R", group_operators=["and", "or", "or"], conditions=[_state("a", 2)])
+        assert rule.condition_groups() == [("or", rule.conditions)]
+
+
+class TestEvaluation:
+    def _or_and_or(self, between: str = "and", inner: str = "or") -> Rule:
+        # (a OP b) BETWEEN (c OP d)
+        return Rule(
+            id="r", name="R", condition_operator=between, group_operators=[inner, inner],
+            conditions=[_state("a"), _state("b"), _state("c", 1), _state("d", 1)],
+        )
+
+    @pytest.mark.parametrize(
+        ("on", "expected"),
+        [({"a", "c"}, True), ({"b", "d"}, True), ({"a", "b"}, False), ({"c"}, False), (set(), False)],
+    )
+    def test_or_groups_joined_by_and(self, engine, states, test_cover, on, expected) -> None:
+        states.update({e: ("on" if e in on else "off") for e in "abcd"})
+        assert engine._evaluate_conditions(self._or_and_or(), test_cover) is expected
+
+    @pytest.mark.parametrize(
+        ("on", "expected"),
+        [({"a", "b"}, True), ({"c", "d"}, True), ({"a", "c"}, False), ({"a", "b", "c"}, True)],
+    )
+    def test_and_groups_joined_by_or(self, engine, states, test_cover, on, expected) -> None:
+        states.update({e: ("on" if e in on else "off") for e in "abcd"})
+        rule = self._or_and_or(between="or", inner="and")
+        assert engine._evaluate_conditions(rule, test_cover) is expected
+
+    def test_single_group_ignores_between_operator(self, engine, states, test_cover) -> None:
+        states.update({"a": "on", "b": "off"})
+        rule = Rule(
+            id="r", name="R", condition_operator="and", group_operators=["or"],
+            conditions=[_state("a"), _state("b")],
+        )
+        assert engine._evaluate_conditions(rule, test_cover) is True
+
+
+class TestNegate:
+    def test_negated_condition(self, engine, states, test_cover) -> None:
+        states["a"] = "off"
+        rule = Rule(id="r", name="R", conditions=[_state("a", negate=True)])
+        assert engine._evaluate_conditions(rule, test_cover) is True
+        states["a"] = "on"
+        assert engine._evaluate_conditions(rule, test_cover) is False
+
+    def test_negated_unavailable_entity_is_not_met(self, engine, states, test_cover) -> None:
+        rule = Rule(id="r", name="R", conditions=[_state("missing", negate=True)])
+        assert engine._evaluate_conditions(rule, test_cover) is False
+
+    def test_negated_weather_without_entity_is_not_met(self, engine, mock_storage, states, test_cover) -> None:
+        mock_storage.weather_entity = "weather.home"
+        cond = Condition(type=ConditionType.WEATHER_IS, params={"weather": ["rainy"]}, negate=True)
+        rule = Rule(id="r", name="R", conditions=[cond])
+        assert engine._evaluate_conditions(rule, test_cover) is False
+        states["weather.home"] = "sunny"
+        assert engine._evaluate_conditions(rule, test_cover) is True
+        states["weather.home"] = "rainy"
+        assert engine._evaluate_conditions(rule, test_cover) is False
+
+    def test_negated_time_condition(self, engine, test_cover) -> None:
+        cond = Condition(type=ConditionType.DAY_OF_WEEK, params={"days": ["mon"]}, negate=True)
+        rule = Rule(id="r", name="R", conditions=[cond])
+        with patch.object(engine, "_eval_day_of_week", return_value=True):
+            assert engine._evaluate_conditions(rule, test_cover) is False
+        with patch.object(engine, "_eval_day_of_week", return_value=False):
+            assert engine._evaluate_conditions(rule, test_cover) is True
+
+    def test_preview_applies_negation(self, engine, states) -> None:
+        states["a"] = "off"
+        assert engine.preview_condition(_state("a", negate=True))["matched"] is True
+        assert engine.preview_condition(_state("missing", negate=True))["matched"] is False
+
+
+class TestApi:
+    @pytest.mark.asyncio
+    async def test_add_without_groups_uses_operator(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_add
+
+        storage = _make_storage()
+        msg = {"id": 1, "name": "N", "condition_operator": "or"}
+        await ws_rule_add(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        assert storage.async_add_rule.call_args[0][0].group_operators == ["or"]
+
+    @pytest.mark.asyncio
+    async def test_update_with_groups(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_update
+
+        storage = _make_storage()
+        storage.rules = {"r": Rule(id="r", name="R")}
+        msg = {
+            "id": 1, "rule_id": "r", "condition_operator": "and", "group_operators": ["or", "or"],
+            "conditions": [
+                {"type": "state_is", "params": {}, "group": 0},
+                {"type": "state_is", "params": {}, "group": 1, "negate": True},
+            ],
+        }
+        await ws_rule_update(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        rule = storage.async_add_rule.call_args[0][0]
+        assert rule.group_operators == ["or", "or"]
+        assert rule.condition_operator == "and"
+        assert [(c.group, c.negate) for c in rule.conditions] == [(0, False), (1, True)]
+
+    @pytest.mark.asyncio
+    async def test_legacy_update_of_single_group_operator(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_update
+
+        storage = _make_storage()
+        storage.rules = {"r": Rule(id="r", name="R", group_operators=["and"])}
+        msg = {"id": 1, "rule_id": "r", "condition_operator": "or"}
+        await ws_rule_update(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        assert storage.async_add_rule.call_args[0][0].group_operators == ["or"]
+
+    @pytest.mark.asyncio
+    async def test_update_keeps_existing_groups(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_update
+
+        storage = _make_storage()
+        storage.rules = {"r": Rule(
+            id="r", name="R", group_operators=["or", "or"],
+            conditions=[_state("a"), _state("b", 1)],
+        )}
+        msg = {"id": 1, "rule_id": "r", "name": "Renamed", "condition_operator": "or"}
+        await ws_rule_update(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        rule = storage.async_add_rule.call_args[0][0]
+        assert rule.group_operators == ["or", "or"]
+        assert rule.condition_operator == "or"
diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py
index fa90559..e3a2830 100644
--- a/tests/test_coordinator.py
+++ b/tests/test_coordinator.py
@@ -94,7 +94,12 @@ def coordinator(mock_hass, mock_storage):
         coord._hysteresis_info = {}
         coord._last_matching_rules = {}
         coord._last_move_rule = {}
+        coord._last_sent_target = {}
+        coord._move_start = {}
         coord._post_protective_exit = set()
+        coord._safety_holds = {}
+        coord._sensor_unknown_kept = set()
+        coord._wind_sensor_warned = False
         coord._startup_time = -999.0
         coord._startup_skip = False
         coord._grace_synced = True
@@ -106,6 +111,7 @@ def coordinator(mock_hass, mock_storage):
         coord.async_request_refresh = AsyncMock()
         # Additional attributes needed by parent class
         coord._unsub_refresh = None
+        coord._unsub_shutdown = None
         coord._debounced_refresh = MagicMock()
         coord._listeners = {}
         coord.last_update_success = True
@@ -364,14 +370,22 @@ def test_unlock_cover_resets_status(self, coordinator, mock_hass, mock_storage)
             "cover.test", CoverStatus.AUTO.value, None
         )
 
-    def test_unlock_cover_noop_without_pre_lock_state(self, coordinator, mock_hass, mock_storage) -> None:
-        """Test unlocking cover is a no-op if no pre-lock state exists."""
+    def test_unlock_cover_without_pre_lock_state_falls_back_to_auto(self, coordinator, mock_hass, mock_storage) -> None:
+        """A LOCKED cover without recorded pre-lock state unlocks to AUTO (no stuck LOCKED)."""
         coordinator._cover_states["cover.test"] = CoverStatus.LOCKED
 
         coordinator._unlock_cover("cover.test")
 
-        # Status unchanged, no storage call
-        assert coordinator._cover_states["cover.test"] == CoverStatus.LOCKED
+        assert coordinator._cover_states["cover.test"] == CoverStatus.AUTO
+        mock_storage.update_cover_status.assert_called_with("cover.test", "auto", None)
+
+    def test_unlock_cover_noop_when_not_protective(self, coordinator, mock_hass, mock_storage) -> None:
+        """Unlocking a cover that is not LOCKED/VENTING changes nothing."""
+        coordinator._cover_states["cover.test"] = CoverStatus.PAUSED
+
+        coordinator._unlock_cover("cover.test")
+
+        assert coordinator._cover_states["cover.test"] == CoverStatus.PAUSED
         mock_storage.update_cover_status.assert_not_called()
 
 
@@ -968,6 +982,8 @@ def test_unlock_restores_manual_when_was_manual(
         self, coordinator, mock_storage
     ) -> None:
         """When previous was MANUAL, restores MANUAL without scheduling refresh."""
+        # v1.90: MANUAL is only restored while the automation is still off
+        coordinator.storage.get_cover_raw.return_value = {"auto_enabled": False}
         coordinator._pre_lock_states["cover.test"] = CoverStatus.MANUAL
         coordinator._cover_states["cover.test"] = CoverStatus.LOCKED
         coordinator.hass.states.get.return_value = MockState(
@@ -1366,6 +1382,7 @@ async def test_apply_cycle_clears_pending_settle(
         mock_storage.covers = {"cover.test": cover}
         coordinator._cover_states["cover.test"] = CoverStatus.AUTO
         coordinator._last_positions["cover.test"] = 100
+        coordinator._last_sent_target["cover.test"] = 100  # our earlier command
         coordinator._last_command_time["cover.test"] = 0.0
         coordinator._pending_settle.add("cover.test")
         coordinator.data = {
@@ -1632,8 +1649,8 @@ def test_restore_paused_expired_resets_to_auto(self, coordinator, mock_storage)
             "cover.living", "auto", None
         )
 
-    def test_restore_locked_resets_to_auto(self, coordinator, mock_storage) -> None:
-        """LOCKED covers are reset to AUTO (re-derived from sensors on sync)."""
+    def test_restore_locked_is_kept(self, coordinator, mock_storage) -> None:
+        """LOCKED covers stay LOCKED (v1.87: the window sensor may still be unknown)."""
         mock_storage._data = {
             "covers": {
                 "cover.kitchen": {
@@ -1650,7 +1667,7 @@ def test_restore_locked_resets_to_auto(self, coordinator, mock_storage) -> None:
 
         coordinator._restore_cover_states()
 
-        assert coordinator._cover_states["cover.kitchen"] == CoverStatus.AUTO
+        assert coordinator._cover_states["cover.kitchen"] == CoverStatus.LOCKED
 
     def test_restore_auto_stays_auto(self, coordinator, mock_storage) -> None:
         """AUTO covers stay AUTO."""
@@ -2116,7 +2133,17 @@ def test_update_position_none_value_resets_to_none(
 
         coordinator._update_last_position_from_state("cover.test")
 
-        # int(None) raises TypeError, reset to None
+        # No position attribute: read from the state (open -> 100)
+        assert coordinator._last_positions["cover.test"] == 100
+
+    def test_update_position_none_value_unknown_state_resets_to_none(
+        self, coordinator, mock_hass
+    ) -> None:
+        coordinator._last_positions["cover.test"] = 50
+        mock_hass.states.get.return_value = MockState(
+            "opening", {"current_position": None}
+        )
+        coordinator._update_last_position_from_state("cover.test")
         assert coordinator._last_positions["cover.test"] is None
 
     def test_update_tilt_invalid_value_resets_to_none(
@@ -2710,6 +2737,10 @@ async def test_send_staggered_commands(self, coordinator, mock_hass, mock_storag
         """Test _send_staggered_commands sends with delay."""
         mock_storage.command_stagger = 0.2
         commands = [("cover.a", 100), ("cover.b", 100), ("cover.c", 100)]
+        # v1.87: each wind command is re-checked right before it is sent
+        coordinator._wind_protected = True
+        for eid, _ in commands:
+            coordinator._cover_states[eid] = CoverStatus.WIND_PROTECTED
 
         with patch("asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
             await coordinator._send_staggered_commands(commands)
@@ -2839,7 +2870,7 @@ def test_sync_paused_expires_back_to_venting(
     def test_vent_sensor_close_cancels_pause(
         self, coordinator, mock_hass, mock_storage
     ) -> None:
-        """Vent sensor closing while PAUSED -> immediate AUTO (no stale pause)."""
+        """v1.90: vent sensor closing while PAUSED keeps the pause (timer unchanged)."""
         cover = self._make_cover()
         mock_storage.covers = {"cover.test": cover}
         coordinator._cover_states["cover.test"] = CoverStatus.PAUSED
@@ -2861,15 +2892,13 @@ def test_vent_sensor_close_cancels_pause(
                 MockState("off"),
             )
 
-        assert coordinator._cover_states["cover.test"] == CoverStatus.AUTO
-        mock_storage.update_cover_status.assert_called_with(
-            "cover.test", CoverStatus.AUTO.value, None
-        )
+        assert coordinator._cover_states["cover.test"] == CoverStatus.PAUSED
+        mock_storage.update_cover_status.assert_not_called()
 
     def test_paused_to_venting_syncs_last_positions(
         self, coordinator, mock_hass, mock_storage
     ) -> None:
-        """Vent sensor opening while PAUSED syncs _last_positions to prevent false override."""
+        """Vent sensor opening while PAUSED keeps the pause (v1.90) and syncs _last_positions."""
         cover = self._make_cover()
         mock_storage.covers = {"cover.test": cover}
         coordinator._cover_states["cover.test"] = CoverStatus.PAUSED
@@ -2894,7 +2923,7 @@ def test_paused_to_venting_syncs_last_positions(
                     MockState("on"),
                 )
 
-        assert coordinator._cover_states["cover.test"] == CoverStatus.VENTING
+        assert coordinator._cover_states["cover.test"] == CoverStatus.PAUSED
         # _last_positions synced to actual (80), not stale (50)
         assert coordinator._last_positions["cover.test"] == 80
 
diff --git a/tests/test_dawn_dusk.py b/tests/test_dawn_dusk.py
new file mode 100644
index 0000000..b341bba
--- /dev/null
+++ b/tests/test_dawn_dusk.py
@@ -0,0 +1,92 @@
+"""Tests for the dawn / dusk (civil twilight) rule conditions."""
+from __future__ import annotations
+
+import datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from custom_components.cover_automatic import sun
+from custom_components.cover_automatic.engine import RuleEngine
+from custom_components.cover_automatic.models import Condition, ConditionType
+from tests.test_sun import PARIS, _astral_hass
+
+MOD = "custom_components.cover_automatic.engine"
+
+
+def _engine() -> RuleEngine:
+    return RuleEngine(MagicMock(), MagicMock())
+
+
+def _eval(engine, ctype, now, *, dawn, dusk, yesterday_dusk=None, offset=0):
+    cond = Condition(type=ctype, params={"offset": offset})
+    with (
+        patch(f"{MOD}.get_dawn_time", return_value=dawn),
+        patch(f"{MOD}.get_dusk_time", return_value=dusk),
+        patch(f"{MOD}.get_sun_event_time", return_value=yesterday_dusk),
+        patch(f"{MOD}.dt_util.now") as mock_now,
+    ):
+        mock_now.return_value.timestamp.return_value = now
+        return engine._evaluate_condition(cond, None)
+
+
+H = 3600
+MIDNIGHT = 1_000_000.0
+DAWN = MIDNIGHT + 6 * H
+DUSK = MIDNIGHT + 21 * H
+
+
+class TestDawnDusk:
+    @pytest.mark.parametrize(
+        ("ctype", "now", "expected"),
+        [
+            (ConditionType.TIME_AFTER_DAWN, DAWN - 60, False),
+            (ConditionType.TIME_AFTER_DAWN, DAWN + 60, True),
+            (ConditionType.TIME_BEFORE_DAWN, DAWN - 60, True),
+            (ConditionType.TIME_BEFORE_DAWN, DAWN + 60, False),
+            (ConditionType.TIME_BEFORE_DUSK, DUSK - 60, True),
+            (ConditionType.TIME_BEFORE_DUSK, DUSK + 60, False),
+            (ConditionType.TIME_AFTER_DUSK, DUSK - 60, False),
+            (ConditionType.TIME_AFTER_DUSK, DUSK + 60, True),
+            # after midnight: still "after dusk" (yesterday's) until dawn
+            (ConditionType.TIME_AFTER_DUSK, MIDNIGHT + 2 * H, True),
+            (ConditionType.TIME_AFTER_DUSK, DAWN + 60, False),
+        ],
+    )
+    def test_evaluation(self, ctype, now, expected) -> None:
+        assert _eval(_engine(), ctype, now, dawn=DAWN, dusk=DUSK,
+                     yesterday_dusk=DUSK - 24 * H) is expected
+
+    def test_offset(self) -> None:
+        engine = _engine()
+        assert _eval(engine, ConditionType.TIME_AFTER_DAWN, DAWN + 10 * 60,
+                     dawn=DAWN, dusk=DUSK, offset=15) is False
+        assert _eval(engine, ConditionType.TIME_AFTER_DAWN, DAWN + 20 * 60,
+                     dawn=DAWN, dusk=DUSK, offset=15) is True
+
+    def test_polar_no_event_is_false(self) -> None:
+        engine = _engine()
+        for ctype in (ConditionType.TIME_AFTER_DAWN, ConditionType.TIME_BEFORE_DAWN,
+                      ConditionType.TIME_AFTER_DUSK, ConditionType.TIME_BEFORE_DUSK):
+            assert _eval(engine, ctype, MIDNIGHT, dawn=None, dusk=None) is False
+
+    def test_preview_shows_event_time(self) -> None:
+        engine = _engine()
+        cond = Condition(type=ConditionType.TIME_AFTER_DUSK, params={"offset": 0})
+        with patch(f"{MOD}.get_dusk_time", return_value=DUSK):
+            result = engine.preview_condition(cond)
+        assert result["kind"] == "sun_time" and result["actual"]
+
+
+class TestAstralTimes:
+    def test_dawn_before_sunrise_and_dusk_after_sunset(self) -> None:
+        lat, lon, tz = PARIS
+        hass = _astral_hass(lat, lon, tz)
+        day = datetime.datetime(2026, 6, 21, 12, 0, tzinfo=datetime.UTC)
+        with patch("custom_components.cover_automatic.sun.dt_util.now", return_value=day):
+            dawn, sunrise = sun.get_dawn_time(hass), sun.get_sunrise_time(hass)
+            sunset, dusk = sun.get_sunset_time(hass), sun.get_dusk_time(hass)
+        assert dawn < sunrise < sunset < dusk
+        # civil twilight lasts roughly 40-50 min in Paris at midsummer
+        assert 30 * 60 < sunrise - dawn < 60 * 60
+        assert 30 * 60 < dusk - sunset < 60 * 60
diff --git a/tests/test_engine.py b/tests/test_engine.py
index f4ad199..8373dd8 100644
--- a/tests/test_engine.py
+++ b/tests/test_engine.py
@@ -56,6 +56,9 @@ def mock_storage():
     storage.solar_sensor = None
     storage.solar_threshold = 0.0
     storage.solar_hysteresis = 0.0
+    storage.sun_heating_ignore = True
+    storage.sun_neutral_ignore = True
+    storage.preemptive_shading = True
     return storage
 
 
diff --git a/tests/test_ha_condition.py b/tests/test_ha_condition.py
new file mode 100644
index 0000000..108289b
--- /dev/null
+++ b/tests/test_ha_condition.py
@@ -0,0 +1,299 @@
+"""Tests for native Home Assistant conditions in rules (type ha_condition).
+
+These tests use a real (minimal) HomeAssistant instance so that validation
+and evaluation go through Home Assistant's own condition helpers.
+"""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+import pytest_asyncio
+
+from homeassistant import loader
+from homeassistant.core import HomeAssistant
+
+from custom_components.cover_automatic import ha_condition as hac
+from custom_components.cover_automatic.engine import RuleEngine
+from custom_components.cover_automatic.models import (
+    Condition,
+    ConditionType,
+    CoverConfig,
+    Rule,
+)
+
+
+@pytest_asyncio.fixture
+async def hass(tmp_path):
+    """Minimal running-loop HomeAssistant instance with some states."""
+    instance = HomeAssistant(str(tmp_path))
+    loader.async_setup(instance)
+    instance.states.async_set("person.sylvain", "not_home", {"friendly_name": "Sylvain"})
+    instance.states.async_set("weather.maison", "sunny", {"temperature": 29})
+    instance.states.async_set("sensor.lux", "25000")
+    instance.states.async_set("media_player.salon", "playing")
+    yield instance
+    await instance.async_stop(force=True)
+
+
+def _ha(config, **params) -> Condition:
+    return Condition(type=ConditionType.HA_CONDITION, params={"config": config, **params})
+
+
+# ---------------------------------------------------------------------------
+# Compile / evaluate
+# ---------------------------------------------------------------------------
+
+class TestCompileEvaluate:
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("config", "expected"),
+        [
+            ({"condition": "state", "entity_id": "person.sylvain", "state": "not_home"}, True),
+            ({"condition": "state", "entity_id": "person.sylvain", "state": ["home"]}, False),
+            ({"condition": "not", "conditions": [
+                {"condition": "state", "entity_id": "person.sylvain", "state": "home"}]}, True),
+            ({"condition": "numeric_state", "entity_id": "weather.maison",
+              "attribute": "temperature", "above": 26, "below": 35}, True),
+            ({"condition": "numeric_state", "entity_id": "weather.maison",
+              "attribute": "temperature", "above": 30}, False),
+            ({"condition": "template",
+              "value_template": "{{ states('sensor.lux') | float(0) > 20000 }}"}, True),
+            # just changed -> not yet "for 15 minutes"
+            ({"condition": "state", "entity_id": "person.sylvain", "state": "not_home",
+              "for": {"minutes": 15}}, False),
+            ({"condition": "or", "conditions": [
+                {"condition": "state", "entity_id": "person.sylvain", "state": "home"},
+                {"condition": "state", "entity_id": "media_player.salon", "state": ["playing", "paused"]}]}, True),
+            # disabled condition is ignored (treated as met), like in automations
+            ({"condition": "state", "entity_id": "person.sylvain", "state": "home", "enabled": False}, True),
+        ],
+    )
+    async def test_evaluate(self, hass, config, expected) -> None:
+        compiled = await hac.async_compile(hass, config)
+        assert compiled.valid, compiled.error
+        assert hac.evaluate(hass, compiled) is expected
+
+    @pytest.mark.asyncio
+    async def test_entities_include_templates(self, hass) -> None:
+        compiled = await hac.async_compile(hass, {"condition": "or", "conditions": [
+            {"condition": "state", "entity_id": "person.sylvain", "state": "home"},
+            {"condition": "template", "value_template": "{{ is_state('media_player.salon', 'playing') }}"},
+        ]})
+        assert compiled.entities == {"person.sylvain", "media_player.salon"}
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("config", "code"),
+        [
+            (None, "empty"),
+            ({}, "empty"),
+            ({"condition": "state", "entity_id": "bad id", "state": "x"}, "invalid"),
+            ({"condition": "state", "entity_id": "", "state": []}, "invalid"),
+            ({"condition": "does_not_exist"}, "invalid"),
+        ],
+    )
+    async def test_invalid_is_reported_and_never_matches(self, hass, config, code) -> None:
+        compiled = await hac.async_compile(hass, config)
+        assert not compiled.valid
+        assert compiled.error_code == code
+        assert hac.evaluate(hass, compiled) is False
+
+    @pytest.mark.asyncio
+    async def test_evaluation_error_is_false(self, hass) -> None:
+        compiled = await hac.async_compile(hass, {
+            "condition": "numeric_state", "entity_id": "person.sylvain", "above": 1,
+        })
+        assert compiled.valid
+        assert hac.evaluate(hass, compiled) is False  # "not_home" is not numeric
+
+    @pytest.mark.asyncio
+    async def test_stored_config_is_not_mutated(self, hass) -> None:
+        config = {"condition": "and", "conditions": [
+            {"condition": "state", "entity_id": "person.sylvain", "state": "not_home", "for": "00:01:00"}]}
+        snapshot = repr(config)
+        await hac.async_compile(hass, config)
+        assert repr(config) == snapshot
+
+
+class TestYaml:
+    def test_parse_mapping(self) -> None:
+        config, err = hac.parse_yaml("condition: state\nentity_id: person.sylvain\nstate: home\n")
+        assert err is None
+        assert config == {"condition": "state", "entity_id": "person.sylvain", "state": "home"}
+
+    def test_list_becomes_and(self) -> None:
+        config, err = hac.parse_yaml("- condition: state\n  entity_id: a.b\n  state: 'on'\n")
+        assert err is None
+        assert config["condition"] == "and" and len(config["conditions"]) == 1
+
+    def test_syntax_error_has_position(self) -> None:
+        config, err = hac.parse_yaml("condition: state\nfoo:: bar: baz\n")
+        assert config is None
+        assert err["code"] == "yaml" and err["line"] == 2
+
+    def test_scalar_is_rejected(self) -> None:
+        config, err = hac.parse_yaml("just text")
+        assert config is None and err["code"] == "not_mapping"
+
+    def test_empty_text(self) -> None:
+        assert hac.parse_yaml("   ") == (None, None)
+
+    def test_dump_roundtrip(self) -> None:
+        config = {"condition": "state", "entity_id": "person.sylvain", "state": ["home", "Travail"]}
+        assert hac.parse_yaml(hac.dump_yaml(config))[0] == config
+
+
+class TestSimpleReading:
+    @pytest.mark.asyncio
+    async def test_state_and_attribute(self, hass) -> None:
+        assert hac.simple_reading(hass, {"condition": "state", "entity_id": "person.sylvain", "state": "home"}) == {
+            "entity_id": "person.sylvain", "attribute": None, "value": "not_home"}
+        reading = hac.simple_reading(hass, {"condition": "numeric_state", "entity_id": "weather.maison",
+                                            "attribute": "temperature", "above": 1})
+        assert reading["value"] == 29
+
+    @pytest.mark.asyncio
+    async def test_not_wrapper_and_complex(self, hass) -> None:
+        cfg = {"condition": "not", "conditions": [{"condition": "state", "entity_id": "person.sylvain", "state": "x"}]}
+        assert hac.simple_reading(hass, cfg)["value"] == "not_home"
+        assert hac.simple_reading(hass, {"condition": "template", "value_template": "{{ true }}"}) is None
+
+
+# ---------------------------------------------------------------------------
+# Engine
+# ---------------------------------------------------------------------------
+
+def _engine(hass, rules: dict[str, Rule]) -> RuleEngine:
+    storage = MagicMock()
+    storage.rules = rules
+    storage.scenarios = {}
+    storage.active_scenario = "everyday"
+    storage.facades = {}
+    storage.indoor_temp_sensor = None
+    return RuleEngine(hass, storage)
+
+
+class TestEngine:
+    @pytest.mark.asyncio
+    async def test_rule_with_ha_condition(self, hass) -> None:
+        rule = Rule(id="absent", name="Absent", target_position=0, conditions=[
+            _ha({"condition": "state", "entity_id": "person.sylvain", "state": "not_home"}),
+        ])
+        engine = _engine(hass, {"absent": rule})
+        cover = CoverConfig(entity_id="cover.salon", name="Salon")
+
+        # Not compiled yet -> not met (never raises in the sync evaluation)
+        assert engine.evaluate_cover(cover) is None
+
+        changed = await engine.async_prepare_ha_conditions()
+        assert changed is True
+        assert engine.ha_condition_entities() == {"person.sylvain"}
+        target = engine.evaluate_cover(cover)
+        assert target is not None and target.rule_id == "absent"
+
+        hass.states.async_set("person.sylvain", "home")
+        assert engine.evaluate_cover(cover) is None
+
+    @pytest.mark.asyncio
+    async def test_prepare_drops_unused_and_reports_status(self, hass) -> None:
+        good = _ha({"condition": "state", "entity_id": "person.sylvain", "state": "home"})
+        bad = _ha({"condition": "state", "entity_id": "bad id", "state": "x"})
+        rules = {"r": Rule(id="r", name="R", conditions=[good, bad])}
+        engine = _engine(hass, rules)
+        await engine.async_prepare_ha_conditions()
+        assert engine.ha_condition_status(good)["valid"] is True
+        status = engine.ha_condition_status(bad)
+        assert status["valid"] is False and status["error_code"] == "invalid"
+
+        rules["r"].conditions = [good]
+        await engine.async_prepare_ha_conditions()
+        assert len(engine._ha_compiled) == 1
+
+    @pytest.mark.asyncio
+    async def test_preview(self, hass) -> None:
+        engine = _engine(hass, {})
+        cond = _ha({"condition": "state", "entity_id": "person.sylvain", "state": "not_home"})
+        await engine.async_prepare_ha_conditions([cond])
+        result = engine.preview_condition(cond)
+        assert result["evaluable"] is True and result["matched"] is True
+        assert result["kind"] == "ha_reading"
+        assert result["actual"]["value"] == "not_home"
+
+
+# ---------------------------------------------------------------------------
+# WebSocket API
+# ---------------------------------------------------------------------------
+
+class TestValidateApi:
+    async def _call(self, hass, msg):
+        from custom_components.cover_automatic.api import ws_condition_validate
+
+        conn = MagicMock()
+        await ws_condition_validate(hass, conn, {"id": 1, **msg}, MagicMock(), MagicMock())
+        return conn.send_result.call_args.args[1]
+
+    @pytest.mark.asyncio
+    async def test_valid_yaml(self, hass) -> None:
+        res = await self._call(hass, {"yaml": "condition: state\nentity_id: person.sylvain\nstate: not_home\n"})
+        assert res["valid"] is True and res["matched"] is True
+        assert res["config"]["entity_id"] == "person.sylvain"
+        assert res["entities"] == ["person.sylvain"] and res["unknown_entities"] == []
+
+    @pytest.mark.asyncio
+    async def test_unknown_entity_is_flagged(self, hass) -> None:
+        res = await self._call(hass, {"config": {"condition": "state", "entity_id": "person.nobody", "state": "home"}})
+        assert res["valid"] is True
+        assert res["unknown_entities"] == ["person.nobody"]
+        assert "entity_id: person.nobody" in res["yaml"]
+
+    @pytest.mark.asyncio
+    async def test_yaml_syntax_error(self, hass) -> None:
+        res = await self._call(hass, {"yaml": "condition: state\nfoo:: bar: baz\n"})
+        assert res["valid"] is False and res["error_code"] == "yaml" and res["error_line"] == 2
+
+    @pytest.mark.asyncio
+    async def test_invalid_condition(self, hass) -> None:
+        res = await self._call(hass, {"yaml": "condition: state\nentity_id: bad id\nstate: x\n"})
+        assert res["valid"] is False and res["error_code"] == "invalid" and res["error"]
+
+    @pytest.mark.asyncio
+    async def test_config_response_contains_condition_status(self, hass) -> None:
+        from custom_components.cover_automatic.api import _build_config_response
+
+        good = _ha({"condition": "state", "entity_id": "person.sylvain", "state": "home"})
+        rules = {"r": Rule(id="r", name="R", conditions=[Condition(type=ConditionType.WORKDAY), good])}
+        engine = _engine(hass, rules)
+        await engine.async_prepare_ha_conditions()
+        storage = engine.storage
+        storage.covers, storage.facades = {}, {}
+        coordinator = MagicMock()
+        coordinator.engine = engine
+        response = _build_config_response(storage, None, coordinator)
+        assert response["condition_status"] == {"r": {"1": {"valid": True, "error": None, "error_code": None}}}
+
+
+class TestCoordinatorTracking:
+    def test_tracking_includes_engine_entities(self) -> None:
+        from custom_components.cover_automatic.coordinator import CoverAutomaticCoordinator
+
+        coord = CoverAutomaticCoordinator.__new__(CoverAutomaticCoordinator)
+        coord.hass = MagicMock()
+        coord.storage = MagicMock()
+        coord.storage._data = {"covers": {}, "rules": {}}
+        coord.storage.outdoor_temp_sensor = None
+        coord.storage.indoor_temp_sensor = None
+        coord.storage.weather_entity = None
+        coord.storage.wind_sensor = None
+        coord.storage.solar_sensor = None
+        coord.storage.workday_sensor = None
+        coord.engine = MagicMock()
+        coord.engine.ha_condition_entities.return_value = {"person.sylvain"}
+        coord._tracked_entities = set()
+        coord._unsub_state_change = []
+        from unittest.mock import patch
+
+        with patch("custom_components.cover_automatic.coordinator.async_track_state_change_event") as track:
+            coord._setup_state_tracking()
+        assert "person.sylvain" in track.call_args.args[1]
+        assert coord._is_rule_entity("person.sylvain") is True
diff --git a/tests/test_i18n.py b/tests/test_i18n.py
new file mode 100644
index 0000000..1339917
--- /dev/null
+++ b/tests/test_i18n.py
@@ -0,0 +1,197 @@
+"""Tests for localization (backend texts and translation files)."""
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from custom_components.cover_automatic import i18n
+from custom_components.cover_automatic.models import CoverConfig, CoverStatus
+from tests.test_coordinator import (  # noqa: F401 -- pytest fixtures
+    MockState,
+    coordinator,
+    mock_hass,
+    mock_storage,
+)
+
+COMPONENT = Path(__file__).parent.parent / "custom_components" / "cover_automatic"
+LANGS = ("en", "de", "fr")
+
+
+def _hass(language: str) -> MagicMock:
+    hass = MagicMock()
+    hass.config.language = language
+    return hass
+
+
+def _keys(obj, prefix=""):
+    keys = set()
+    for key, value in obj.items():
+        path = f"{prefix}{key}"
+        if isinstance(value, dict):
+            keys |= _keys(value, path + ".")
+        else:
+            keys.add(path)
+    return keys
+
+
+class TestBackendTexts:
+    @pytest.mark.parametrize(
+        ("configured", "expected"),
+        [("fr", "fr"), ("fr-CA", "fr"), ("de", "de"), ("en-GB", "en"), ("it", "en"), (None, "en")],
+    )
+    def test_language_resolution(self, configured, expected) -> None:
+        assert i18n.language(_hass(configured)) == expected
+
+    def test_all_languages_have_all_keys(self) -> None:
+        reference = set(i18n._TEXTS["en"])
+        for lang in LANGS:
+            assert set(i18n._TEXTS[lang]) == reference, lang
+
+    def test_placeholders_identical_across_languages(self) -> None:
+        for key, template in i18n._TEXTS["en"].items():
+            expected = set(re.findall(r"{(\w+)}", template))
+            for lang in LANGS:
+                assert set(re.findall(r"{(\w+)}", i18n._TEXTS[lang][key])) == expected, (lang, key)
+
+    def test_french_logbook_text(self) -> None:
+        text = i18n.text(_hass("fr"), "paused", minutes=10)
+        assert text == "en pause pendant 10 min (commande manuelle)"
+
+    def test_logbook_uses_ha_language(self, coordinator, mock_hass, mock_storage) -> None:
+        mock_hass.config.language = "fr"
+        mock_storage.logbook_enabled = True
+        mock_storage.pause_duration = 10
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        with patch("custom_components.cover_automatic.coordinator.async_log_entry") as log:
+            coordinator.pause_cover(CoverConfig(entity_id="cover.t", name="T"))
+        assert log.call_args.args[2] == "en pause pendant 10 min (commande manuelle)"
+
+    def test_activity_log_has_structured_key(self, coordinator, mock_storage) -> None:
+        coordinator.log_storage = MagicMock()
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        mock_storage.pause_duration = 10
+        coordinator.pause_cover(CoverConfig(entity_id="cover.t", name="T"))
+        data = coordinator.log_storage.add_entry.call_args.args[3]
+        assert data == {"key": "status_change", "from": "auto", "to": "paused"}
+
+
+class TestDefaultScenarios:
+    @pytest.mark.asyncio
+    async def test_created_in_ha_language(self, coordinator, mock_hass, mock_storage) -> None:
+        mock_hass.config.language = "fr"
+        mock_storage.scenarios = {}
+        mock_storage.async_add_scenario = AsyncMock()
+        await coordinator._async_setup_default_scenarios()
+        names = {c.args[0].id: c.args[0].name for c in mock_storage.async_add_scenario.call_args_list}
+        assert names == {
+            "everyday": "Quotidien", "summer": "Été", "winter": "Hiver",
+            "vacation": "Vacances", "cinema": "Cinéma", "manual": "Manuel",
+        }
+
+    @pytest.mark.asyncio
+    async def test_untouched_default_names_are_localized(self, coordinator, mock_hass, mock_storage) -> None:
+        mock_hass.config.language = "fr"
+        mock_storage.scenarios = {"everyday": MagicMock()}
+        mock_storage._data["scenarios"] = {
+            "everyday": {"id": "everyday", "name": "Everyday"},
+            "summer": {"id": "summer", "name": "Mon été à moi"},  # renamed by user
+            "custom": {"id": "custom", "name": "Everyday"},  # not a default id
+        }
+        await coordinator._async_setup_default_scenarios()
+        scen = mock_storage._data["scenarios"]
+        assert scen["everyday"]["name"] == "Quotidien"
+        assert scen["summer"]["name"] == "Mon été à moi"
+        assert scen["custom"]["name"] == "Everyday"
+        mock_storage.async_save.assert_awaited_once()
+
+
+class TestTranslationFiles:
+    def _load(self, name: str) -> dict:
+        return json.loads((COMPONENT / name).read_text(encoding="utf-8"))
+
+    def test_strings_equals_english(self) -> None:
+        assert self._load("strings.json") == self._load("translations/en.json")
+
+    @pytest.mark.parametrize("lang", ["de", "fr"])
+    def test_same_keys_as_english(self, lang) -> None:
+        assert _keys(self._load(f"translations/{lang}.json")) == _keys(self._load("translations/en.json"))
+
+    def test_every_service_is_translated(self) -> None:
+        import yaml
+
+        services = yaml.safe_load((COMPONENT / "services.yaml").read_text(encoding="utf-8"))
+        for lang in LANGS:
+            translated = self._load(f"translations/{lang}.json")["services"]
+            for service, spec in services.items():
+                assert service in translated, (lang, service)
+                for field in (spec or {}).get("fields", {}):
+                    assert field in translated[service]["fields"], (lang, service, field)
+
+    def test_default_scenarios_have_select_state_translations(self) -> None:
+        for lang in LANGS:
+            states = self._load(f"translations/{lang}.json")["entity"]["select"]["scenario"]["state"]
+            assert set(states) == set(i18n.DEFAULT_SCENARIO_IDS)
+            for scenario_id in i18n.DEFAULT_SCENARIO_IDS:
+                assert states[scenario_id] == i18n._TEXTS[lang][f"scenario_{scenario_id}"]
+
+    def test_french_panel_dictionary_complete(self) -> None:
+        """Every panel i18n key exists in French and German (no English fallback)."""
+        src = (COMPONENT / "panel" / "cover-automatic-panel.js").read_text(encoding="utf-8")
+        start = src.index("const I18N = {")
+        end = src.index("\n};", start)
+        body = src[start:end]
+        blocks = {}
+        for lang in LANGS:
+            m = re.search(rf"\n  {lang}: {{\n(.*?)\n  }},?\n", body + "\n", re.S)
+            assert m, lang
+            # Drop string literals first so text like "condition: state" inside
+            # a translation is not mistaken for a key.
+            without_strings = re.sub(r'"(?:[^"\\]|\\.)*"', '""', m.group(1))
+            blocks[lang] = set(re.findall(r"([a-z0-9_]+)\s*:", without_strings))
+        assert blocks["fr"] == blocks["en"]
+        assert blocks["de"] == blocks["en"]
+
+
+class TestWeatherConditions:
+    """All Home Assistant weather conditions are selectable and translated."""
+
+    HA_CONDITIONS = {
+        "clear-night", "cloudy", "exceptional", "fog", "hail", "lightning",
+        "lightning-rainy", "partlycloudy", "pouring", "rainy", "snowy",
+        "snowy-rainy", "sunny", "windy", "windy-variant",
+    }
+
+    def _panel(self) -> str:
+        return (COMPONENT / "panel" / "cover-automatic-panel.js").read_text(encoding="utf-8")
+
+    def test_ha_condition_list_is_current(self) -> None:
+        from homeassistant.components import weather
+
+        ha = {
+            value for name, value in vars(weather).items()
+            if name.startswith("ATTR_CONDITION_") and name != "ATTR_CONDITION_CLASS"
+        }
+        assert ha == self.HA_CONDITIONS
+
+    def test_panel_offers_every_condition(self) -> None:
+        m = re.search(r'weather_is: \[\{ key: "weather", type: "multiselect", options: \[([^\]]*)\]', self._panel())
+        assert m
+        offered = set(re.findall(r'"([a-z-]+)"', m.group(1)))
+        assert offered == self.HA_CONDITIONS
+
+    def test_every_condition_translated(self) -> None:
+        src = self._panel()
+        for lang in LANGS:
+            block = re.search(rf"\n  {lang}: {{\n(.*?)\n  }},?\n", src + "\n", re.S).group(1)
+            for cond in self.HA_CONDITIONS:
+                assert re.search(rf"\bweather_{cond.replace('-', '_')}:", block), (lang, cond)
+
+    def test_windy_group_includes_windy_variant(self) -> None:
+        from custom_components.cover_automatic.engine import _WEATHER_MAP
+
+        assert "windy-variant" in _WEATHER_MAP["windy"]
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 9ea2bb0..abef4e5 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -104,7 +104,12 @@ def coordinator(mock_hass, mock_storage):
         coord._hysteresis_info = {}
         coord._last_matching_rules = {}
         coord._last_move_rule = {}
+        coord._last_sent_target = {}
+        coord._move_start = {}
         coord._post_protective_exit = set()
+        coord._safety_holds = {}
+        coord._sensor_unknown_kept = set()
+        coord._wind_sensor_warned = False
         coord._startup_time = -999.0
         coord._startup_skip = False
         coord._grace_synced = True
@@ -1077,7 +1082,9 @@ async def test_version_comes_from_cached_manifest(self) -> None:
             patch(f"{mod}.async_setup_services", AsyncMock()),
             patch(f"{mod}.async_setup_api") as setup_api,
             patch(f"{mod}.async_register_built_in_panel") as register_panel,
+            patch(f"{mod}.add_extra_js_url"),
             patch(f"{mod}.er.async_get", MagicMock()),
+            patch(f"{mod}.async_cleanup_orphan_entities"),
         ):
             storage_cls.return_value.async_load = AsyncMock()
             storage_cls.return_value.covers = {}
@@ -1124,7 +1131,9 @@ async def test_missing_version_falls_back(self) -> None:
             patch(f"{mod}.async_setup_services", AsyncMock()),
             patch(f"{mod}.async_setup_api") as setup_api,
             patch(f"{mod}.async_register_built_in_panel"),
+            patch(f"{mod}.add_extra_js_url"),
             patch(f"{mod}.er.async_get", MagicMock()),
+            patch(f"{mod}.async_cleanup_orphan_entities"),
         ):
             storage_cls.return_value.async_load = AsyncMock()
             storage_cls.return_value.covers = {}
diff --git a/tests/test_lock_hold.py b/tests/test_lock_hold.py
new file mode 100644
index 0000000..920c0f9
--- /dev/null
+++ b/tests/test_lock_hold.py
@@ -0,0 +1,76 @@
+"""Tests for the per-cover "keep position when the window opens" lock option."""
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from custom_components.cover_automatic.coordinator import CoverAutomaticCoordinator
+from custom_components.cover_automatic.models import CoverConfig, CoverStatus
+from tests.test_coordinator import (  # noqa: F401 -- pytest fixtures
+    MockState,
+    coordinator,
+    mock_hass,
+    mock_storage,
+)
+
+
+class _Cover(MockState):
+    def __init__(self, position: int) -> None:
+        super().__init__("open")
+        self.attributes = {"current_position": position}
+
+
+def _raw(hold: bool) -> dict:
+    return {
+        "auto_enabled": True, "lock_sensor": "binary_sensor.window", "lock_position": 100,
+        "vent_sensor": None, "inverted": False, "lock_hold_position": hold,
+    }
+
+
+class TestModel:
+    def test_default_and_roundtrip(self) -> None:
+        cover = CoverConfig(entity_id="cover.t", name="T")
+        assert cover.lock_hold_position is False
+        cover.lock_hold_position = True
+        assert CoverConfig.from_dict(cover.to_dict()).lock_hold_position is True
+
+
+class TestLockMoves:
+    @pytest.mark.parametrize(
+        ("hold", "current", "expected"),
+        [(False, 20, True), (False, None, True), (False, 100, False), (True, 20, False), (True, None, False)],
+    )
+    def test_lock_moves(self, hold, current, expected) -> None:
+        assert CoverAutomaticCoordinator._lock_moves(_raw(hold), current, 100) is expected
+
+
+class TestSensorEvent:
+    @pytest.mark.parametrize(("hold", "moved"), [(True, False), (False, True)])
+    def test_window_opens(self, coordinator, mock_hass, mock_storage, hold, moved) -> None:
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        mock_storage.get_cover_raw.return_value = _raw(hold)
+        mock_hass.states.get.return_value = _Cover(20)
+        with patch.object(coordinator, "_lock_cover") as lock:
+            coordinator._handle_contact_sensor_change(
+                "binary_sensor.window", ["cover.t"], [], MockState("off"), MockState("on"),
+            )
+        assert lock.called is moved
+        if not moved:  # _lock_cover (mocked here) sets LOCKED itself when moving
+            assert coordinator._cover_states["cover.t"] == CoverStatus.LOCKED
+
+
+class TestSync:
+    @pytest.mark.parametrize(("hold", "moved"), [(True, False), (False, True)])
+    def test_sync_locks(self, coordinator, mock_hass, mock_storage, hold, moved) -> None:
+        mock_storage._data = {"covers": {"cover.t": _raw(hold)}}
+        mock_storage.get_cover_raw.return_value = mock_storage._data["covers"]["cover.t"]
+        mock_hass.states.get.side_effect = lambda eid: MockState("on") if eid.startswith("binary_sensor") else _Cover(20)
+        mock_hass.async_create_task = MagicMock()
+        with patch.object(coordinator, "_lock_cover", wraps=coordinator._lock_cover) as lock, \
+                patch("custom_components.cover_automatic.coordinator.dt_util") as mock_dt:
+            mock_dt.now.return_value.timestamp.return_value = 1000.0
+            coordinator._sync_cover_statuses()
+        assert coordinator._cover_states["cover.t"] == CoverStatus.LOCKED
+        assert lock.called is moved
diff --git a/tests/test_models.py b/tests/test_models.py
index 716bea6..26493be 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -317,7 +317,11 @@ def test_condition_type_values(self) -> None:
         assert ConditionType.TIME_BEFORE_SUNRISE.value == "time_before_sunrise"
         assert ConditionType.TIME_BEFORE_SUNSET.value == "time_before_sunset"
         assert ConditionType.NUMERIC_STATE.value == "numeric_state"
-        assert len(ConditionType) == 16
+        assert ConditionType.HA_CONDITION.value == "ha_condition"
+        assert ConditionType.TIME_AFTER_DUSK.value == "time_after_dusk"
+        assert ConditionType.OUTDOOR_VS_INDOOR.value == "outdoor_vs_indoor"
+        assert ConditionType.ROOM_OCCUPIED.value == "room_occupied"
+        assert len(ConditionType) == 23
 
 
 class TestComfortMode:
@@ -398,11 +402,11 @@ def test_cover_config_from_dict_valid_status(self) -> None:
             cover = CoverConfig.from_dict(data)
             assert cover.status == status
 
-    def test_cover_config_preemptive_shading_default_true(self) -> None:
-        """CoverConfig.preemptive_shading defaults to True when missing (backward compat)."""
+    def test_cover_config_preemptive_shading_default_follows_global(self) -> None:
+        """CoverConfig.preemptive_shading defaults to None (follow global) when missing."""
         data = {"entity_id": "cover.test", "name": "Test Cover"}
         cover = CoverConfig.from_dict(data)
-        assert cover.preemptive_shading is True
+        assert cover.preemptive_shading is None
 
     def test_cover_config_preemptive_shading_roundtrip_false(self) -> None:
         """CoverConfig serializes and restores preemptive_shading=False."""
diff --git a/tests/test_regressions.py b/tests/test_regressions.py
new file mode 100644
index 0000000..741dc95
--- /dev/null
+++ b/tests/test_regressions.py
@@ -0,0 +1,524 @@
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+"""Regression tests for the issues fixed in 1.62.0."""
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from custom_components.cover_automatic.const import DOMAIN
+from custom_components.cover_automatic.models import (
+    Condition,
+    ConditionType,
+    CoverConfig,
+    CoverStatus,
+)
+from tests.test_api import _make_connection, _make_coordinator, _make_hass, _make_storage
+from tests.test_coordinator import (  # noqa: F401 -- pytest fixtures
+    MockState,
+    coordinator,
+    mock_hass,
+    mock_storage,
+)
+from tests.test_storage import mock_store, storage  # noqa: F401 -- pytest fixtures
+
+MOD = "custom_components.cover_automatic"
+
+
+# ---------------------------------------------------------------------------
+# 1. Reload: static panel path registered only once
+# ---------------------------------------------------------------------------
+
+class TestReloadStaticPath:
+    @pytest.mark.asyncio
+    async def test_second_setup_does_not_register_static_path_again(self) -> None:
+        from custom_components.cover_automatic import async_setup_entry
+
+        hass = MagicMock()
+        hass.data = {}
+        hass.config_entries.async_forward_entry_setups = AsyncMock()
+        hass.http.async_register_static_paths = AsyncMock()
+        entry = MagicMock()
+        entry.data = {}
+        entry.entry_id = "e1"
+        integration = MagicMock()
+        integration.manifest = {"version": "1.62.0"}
+
+        with (
+            patch(f"{MOD}.async_get_integration", AsyncMock(return_value=integration)),
+            patch(f"{MOD}.CoverAutomaticStorage") as storage_cls,
+            patch(f"{MOD}.ActivityLogStorage") as log_cls,
+            patch(f"{MOD}.CoverAutomaticCoordinator") as coord_cls,
+            patch(f"{MOD}.async_setup_services", AsyncMock()),
+            patch(f"{MOD}.async_setup_api"),
+            patch(f"{MOD}.async_register_built_in_panel") as register_panel,
+            patch(f"{MOD}.add_extra_js_url") as add_js,
+            patch(f"{MOD}.er.async_get", MagicMock()),
+            patch(f"{MOD}.async_cleanup_orphan_entities"),
+        ):
+            storage_cls.return_value.async_load = AsyncMock()
+            storage_cls.return_value.covers = {}
+            log_cls.return_value.async_load = AsyncMock()
+            coord_cls.return_value.async_setup = AsyncMock()
+            coord_cls.return_value.async_config_entry_first_refresh = AsyncMock()
+
+            await async_setup_entry(hass, entry)
+            await async_setup_entry(hass, entry)  # reload
+
+        hass.http.async_register_static_paths.assert_awaited_once()
+        # Dashboard card module added once, with the version for cache busting
+        add_js.assert_called_once()
+        assert add_js.call_args[0][1] == "/cover_automatic/cover-automatic-card.js?v=1.62.0"
+        assert register_panel.call_count == 2
+        assert register_panel.call_args.kwargs["update"] is True
+
+
+# ---------------------------------------------------------------------------
+# 2. No cover stuck in LOCKED / VENTING
+# ---------------------------------------------------------------------------
+
+def _wind_cover(mock_storage, **extra):
+    raw = {
+        "entity_id": "cover.t", "name": "T", "auto_enabled": True, "inverted": False,
+        "lock_sensor": None, "lock_position": 100, "vent_sensor": None, "vent_position": 30,
+    }
+    raw.update(extra)
+    mock_storage._data["covers"] = {"cover.t": raw}
+    mock_storage.get_cover_raw.return_value = raw
+    return raw
+
+
+class TestNoStuckProtectiveStatus:
+    def test_lock_released_after_wind_protection(self, coordinator, mock_storage, mock_hass) -> None:
+        mock_storage.wind_sensor = "sensor.wind"
+        mock_storage.wind_speed_threshold = 50.0
+        mock_storage.wind_speed_hysteresis = 10.0
+        _wind_cover(mock_storage, lock_sensor="binary_sensor.win")
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        states = {
+            "sensor.wind": MockState("60"),
+            "binary_sensor.win": MockState("on"),
+            "cover.t": MockState("open", {"current_position": 100}),
+        }
+        mock_hass.states.get = states.get
+
+        coordinator._check_wind_protection()
+        states["sensor.wind"] = MockState("30")
+        coordinator._check_wind_protection()
+        assert coordinator._cover_states["cover.t"] == CoverStatus.LOCKED
+
+        states["binary_sensor.win"] = MockState("off")
+        coordinator._handle_contact_sensor_change(
+            "binary_sensor.win", ["cover.t"], [], MockState("on"), MockState("off")
+        )
+        assert coordinator._cover_states["cover.t"] == CoverStatus.AUTO
+
+    def test_venting_released_when_vent_sensor_removed(self, coordinator, mock_storage, mock_hass) -> None:
+        _wind_cover(mock_storage, vent_sensor=None)  # sensor removed in the panel
+        coordinator._cover_states["cover.t"] = CoverStatus.VENTING
+        mock_hass.states.get.return_value = MockState("open", {"current_position": 30})
+
+        coordinator._sync_cover_statuses()
+
+        assert coordinator._cover_states["cover.t"] == CoverStatus.AUTO
+
+
+# ---------------------------------------------------------------------------
+# 3. Import
+# ---------------------------------------------------------------------------
+
+class TestImportGlobals:
+    @pytest.mark.asyncio
+    async def test_export_import_roundtrip_keeps_defaults(self, storage) -> None:
+        await storage.async_load()
+        await storage.async_import_data(storage.get_raw_data())
+
+        assert storage.enabled is True
+        assert storage.min_position_change == 5
+        assert storage.min_time_between_changes == 300
+        assert storage.pause_duration == 10
+        assert storage.command_stagger == 0.0
+        assert storage.logbook_enabled is True
+        assert "enabled" not in storage._data
+
+    @pytest.mark.asyncio
+    async def test_getters_ignore_stored_none(self, storage) -> None:
+        storage._data = {"enabled": None, "min_position_change": None, "pause_duration": None}
+        assert storage.enabled is True
+        assert storage.min_position_change == 5
+        assert storage.pause_duration == 10
+
+    @pytest.mark.asyncio
+    async def test_explicit_none_sensor_is_kept(self, storage) -> None:
+        storage._data = {"outdoor_temp_sensor": "sensor.out", "covers": {}}
+        await storage.async_import_data({"covers": {}, "outdoor_temp_sensor": None})
+        assert storage.outdoor_temp_sensor is None
+
+    @pytest.mark.asyncio
+    async def test_unrelated_yaml_is_rejected(self, storage) -> None:
+        storage._data = {"covers": {"cover.a": {"entity_id": "cover.a", "name": "A"}}}
+        with pytest.raises(ValueError):
+            await storage.async_import_data({"db_password": "secret"})
+        assert "cover.a" in storage._data["covers"]
+
+
+# ---------------------------------------------------------------------------
+# 4. End stops reachable despite min_position_change
+# ---------------------------------------------------------------------------
+
+class TestEndStops:
+    def _setup(self, coordinator, mock_storage, mock_hass, current, target):
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        coordinator._last_positions["cover.t"] = current
+        coordinator.data = {"covers": {"cover.t": {"status": "auto", "target_position": target}}}
+        mock_storage.get_cover_raw.return_value = {
+            "min_position_change": 5, "min_time_between_changes": 0, "inverted": False,
+        }
+        mock_hass.states.get.return_value = MockState("open", {"current_position": current})
+
+    @pytest.mark.asyncio
+    async def test_closes_fully_from_3_percent(self, coordinator, mock_storage, mock_hass) -> None:
+        self._setup(coordinator, mock_storage, mock_hass, current=3, target=0)
+        await coordinator.async_apply_positions()
+        mock_hass.services.async_call.assert_awaited_once()
+        assert mock_hass.services.async_call.await_args.args[2]["position"] == 0
+
+    @pytest.mark.asyncio
+    async def test_opens_fully_from_98_percent(self, coordinator, mock_storage, mock_hass) -> None:
+        self._setup(coordinator, mock_storage, mock_hass, current=98, target=100)
+        await coordinator.async_apply_positions()
+        assert mock_hass.services.async_call.await_args.args[2]["position"] == 100
+
+    @pytest.mark.asyncio
+    async def test_end_stop_not_resent_once_commanded(self, coordinator, mock_storage, mock_hass) -> None:
+        self._setup(coordinator, mock_storage, mock_hass, current=1, target=0)
+        coordinator._last_sent_target["cover.t"] = 0  # motor settled at 1%
+        await coordinator.async_apply_positions()
+        mock_hass.services.async_call.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_intermediate_target_keeps_hysteresis(self, coordinator, mock_storage, mock_hass) -> None:
+        self._setup(coordinator, mock_storage, mock_hass, current=48, target=50)
+        await coordinator.async_apply_positions()
+        mock_hass.services.async_call.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# 5. Wind / comfort validation
+# ---------------------------------------------------------------------------
+
+class TestSettingsValidation:
+    @pytest.mark.asyncio
+    async def test_wind_hysteresis_must_be_below_threshold(self) -> None:
+        from custom_components.cover_automatic.api import ws_settings_update
+
+        conn = _make_connection()
+        storage = _make_storage(wind_speed_threshold=50.0)
+        storage.house_rotation = 0.0
+        msg = {"id": 1, "type": f"{DOMAIN}/settings/update", "wind_speed_hysteresis": 60.0}
+        await ws_settings_update(_make_hass(), conn, msg, storage, _make_coordinator())
+        conn.send_error.assert_called_once()
+        storage.async_save.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_comfort_min_must_be_below_max(self) -> None:
+        from custom_components.cover_automatic.api import ws_settings_update
+
+        conn = _make_connection()
+        storage = _make_storage()
+        storage.house_rotation = 0.0
+        msg = {"id": 1, "type": f"{DOMAIN}/settings/update", "comfort_temp_min": 26.0}
+        await ws_settings_update(_make_hass(), conn, msg, storage, _make_coordinator())
+        conn.send_error.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_cover_comfort_min_must_be_below_max(self) -> None:
+        from custom_components.cover_automatic.api import ws_cover_update
+
+        conn = _make_connection()
+        storage = _make_storage()
+        raw = {"entity_id": "cover.t", "name": "T", "comfort_temp_max": 22.0}
+        storage.get_cover_raw = MagicMock(return_value=raw)
+        msg = {"id": 1, "type": f"{DOMAIN}/cover/update", "entity_id": "cover.t",
+               "comfort_temp_min": 23.0}
+        await ws_cover_update(_make_hass(), conn, msg, storage, _make_coordinator())
+        conn.send_error.assert_called_once()
+        assert "comfort_temp_min" not in raw
+
+    def test_wind_released_when_feature_disabled(self, coordinator, mock_storage, mock_hass) -> None:
+        mock_storage.wind_sensor = None
+        mock_storage.wind_speed_threshold = 50.0
+        _wind_cover(mock_storage)
+        coordinator._wind_protected = True
+        coordinator._cover_states["cover.t"] = CoverStatus.WIND_PROTECTED
+        mock_hass.states.get.return_value = MockState("open", {"current_position": 100})
+
+        coordinator._check_wind_protection()
+
+        assert coordinator._wind_protected is False
+        assert coordinator._cover_states["cover.t"] == CoverStatus.AUTO
+
+    def test_invalid_hysteresis_does_not_block_release(self, coordinator, mock_storage, mock_hass) -> None:
+        mock_storage.wind_sensor = "sensor.wind"
+        mock_storage.wind_speed_threshold = 50.0
+        mock_storage.wind_speed_hysteresis = 80.0  # legacy invalid value
+        _wind_cover(mock_storage)
+        coordinator._wind_protected = True
+        coordinator._cover_states["cover.t"] = CoverStatus.WIND_PROTECTED
+        mock_hass.states.get.return_value = MockState("20", {"current_position": 100})
+
+        coordinator._check_wind_protection()
+
+        assert coordinator._wind_protected is False
+
+
+# ---------------------------------------------------------------------------
+# 6. State tracking of rule entities
+# ---------------------------------------------------------------------------
+
+class TestStateTracking:
+    def test_entity_id_param_and_workday_are_tracked(self, coordinator, mock_storage) -> None:
+        mock_storage.workday_sensor = "binary_sensor.workday"
+        mock_storage.solar_sensor = None
+        mock_storage._data["rules"] = {
+            "r": {"conditions": [
+                {"type": "state_is", "params": {"entity_id": "input_boolean.guest"}},
+                {"type": "numeric_state", "params": {"entity_id": "sensor.lux"}},
+            ]}
+        }
+        with patch(f"{MOD}.coordinator.async_track_state_change_event") as track:
+            coordinator._setup_state_tracking(full_refresh=True)
+        tracked = set(track.call_args.args[1])
+        assert {"input_boolean.guest", "sensor.lux", "binary_sensor.workday"} <= tracked
+
+    @pytest.mark.asyncio
+    async def test_rule_add_refreshes_tracking(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_add
+
+        coordinator = _make_coordinator()
+        msg = {"id": 1, "type": f"{DOMAIN}/rule/add", "name": "R", "conditions": []}
+        await ws_rule_add(_make_hass(), _make_connection(), msg, _make_storage(), coordinator)
+        coordinator.refresh_state_tracking.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# 7. Entity registry sync
+# ---------------------------------------------------------------------------
+
+class TestEntitySync:
+    def test_expected_unique_ids(self) -> None:
+        from custom_components.cover_automatic.entities import expected_unique_ids
+
+        storage = MagicMock()
+        storage._data = {"covers": {"cover.a": {}}, "facades": {"south": {}}}
+        ids = expected_unique_ids("e1", storage)
+        assert ids == {
+            f"{DOMAIN}_master", f"{DOMAIN}_e1_scenario",
+            f"{DOMAIN}_e1_wind_protection", f"{DOMAIN}_e1_covers_paused",
+            f"{DOMAIN}_e1_covers_manual", f"{DOMAIN}_e1_covers_locked",
+            f"{DOMAIN}_cover.a_auto", f"{DOMAIN}_cover.a_status",
+            f"{DOMAIN}_cover.a_rule", f"{DOMAIN}_cover.a_target",
+            f"{DOMAIN}_cover.a_position", f"{DOMAIN}_cover.a_comfort",
+            f"{DOMAIN}_cover.a_pause_end",
+            f"{DOMAIN}_facade_south_sun", f"{DOMAIN}_facade_south_sun_entry",
+            f"{DOMAIN}_facade_south_sun_exit",
+        }
+
+    def test_cleanup_removes_orphans_only(self) -> None:
+        from custom_components.cover_automatic import entities
+
+        storage = MagicMock()
+        storage._data = {"covers": {"cover.a": {}}, "facades": {}}
+        entry = MagicMock(entry_id="e1")
+        keep = MagicMock(platform=DOMAIN, unique_id=f"{DOMAIN}_cover.a_auto", entity_id="switch.a")
+        orphan = MagicMock(platform=DOMAIN, unique_id=f"{DOMAIN}_cover.gone_auto", entity_id="switch.gone")
+        ent_reg = MagicMock()
+        dev_keep = MagicMock(identifiers={(DOMAIN, "cover.a")}, id="d1")
+        dev_orphan = MagicMock(identifiers={(DOMAIN, "cover.gone")}, id="d2")
+        dev_reg = MagicMock()
+        with (
+            patch.object(entities.er, "async_get", return_value=ent_reg),
+            patch.object(entities.er, "async_entries_for_config_entry", return_value=[keep, orphan]),
+            patch.object(entities.dr, "async_get", return_value=dev_reg),
+            patch.object(entities.dr, "async_entries_for_config_entry", return_value=[dev_keep, dev_orphan]),
+        ):
+            entities.async_cleanup_orphan_entities(MagicMock(), entry, storage)
+
+        ent_reg.async_remove.assert_called_once_with("switch.gone")
+        dev_reg.async_update_device.assert_called_once_with("d2", remove_config_entry_id="e1")
+
+    @pytest.mark.asyncio
+    async def test_cover_add_and_delete_sync_entities(self) -> None:
+        from custom_components.cover_automatic.api import ws_cover_add, ws_cover_delete
+
+        coordinator = _make_coordinator()
+        hass = _make_hass()
+        await ws_cover_add(hass, _make_connection(), {"id": 1, "entity_ids": ["cover.x"]},
+                           _make_storage(), coordinator)
+        await ws_cover_delete(hass, _make_connection(), {"id": 2, "entity_id": "cover.x"},
+                              _make_storage(), coordinator)
+        assert coordinator.async_sync_entities.call_count == 2
+
+    def test_switch_platform_adds_runtime_covers(self) -> None:
+        from custom_components.cover_automatic import switch
+
+        coordinator = MagicMock()
+        coordinator.storage.covers = {"cover.a": CoverConfig(entity_id="cover.a", name="A")}
+        entry = MagicMock()
+        entry.runtime_data.coordinator = coordinator
+        added: list = []
+
+        import asyncio
+
+        asyncio.run(switch.async_setup_entry(MagicMock(), entry, lambda ents: added.extend(list(ents))))
+        assert len(added) == 2  # master + cover.a
+        listener = coordinator.async_add_listener.call_args.args[0]
+
+        coordinator.storage.covers = {
+            "cover.a": CoverConfig(entity_id="cover.a", name="A"),
+            "cover.b": CoverConfig(entity_id="cover.b", name="B"),
+        }
+        listener()
+        listener()  # idempotent
+        assert len(added) == 3
+        assert added[-1]._cover_entity_id == "cover.b"
+
+
+# ---------------------------------------------------------------------------
+# 8. Shutdown calls the base class
+# ---------------------------------------------------------------------------
+
+class TestShutdownBase:
+    @pytest.mark.asyncio
+    async def test_base_shutdown_called(self, coordinator) -> None:
+        coordinator._unsub_state_change = []
+        await coordinator.async_shutdown()
+        assert coordinator._shutdown_requested is True
+        coordinator._debounced_refresh.async_shutdown.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# 9. Tilt re-sent after a position move
+# ---------------------------------------------------------------------------
+
+class TestTiltResend:
+    @pytest.mark.asyncio
+    async def test_tilt_resent_after_move_even_if_unchanged(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        coordinator._last_positions["cover.t"] = 100
+        coordinator._last_tilt_positions["cover.t"] = 50
+        coordinator.data = {"covers": {"cover.t": {
+            "status": "auto", "target_position": 20, "target_tilt_position": 50,
+        }}}
+        mock_storage.get_cover_raw.return_value = {
+            "min_position_change": 5, "min_time_between_changes": 0,
+            "inverted": False, "supports_tilt": True,
+        }
+        mock_hass.states.get.return_value = MockState(
+            "open", {"current_position": 100, "current_tilt_position": 50, "supported_features": 255}
+        )
+        with patch.object(coordinator, "_schedule_tilt") as schedule:
+            await coordinator.async_apply_positions()
+        schedule.assert_called_once()
+        assert schedule.call_args.args[1] == 50
+
+
+# ---------------------------------------------------------------------------
+# 11. Slow covers: progress towards our target extends the settle window
+# ---------------------------------------------------------------------------
+
+class TestSlowCoverSettle:
+    def test_progress_is_not_a_manual_override(self, coordinator, mock_storage, mock_hass) -> None:
+        cover = CoverConfig(entity_id="cover.t", name="T")
+        mock_storage.covers = {"cover.t": cover}
+        coordinator._cover_states["cover.t"] = CoverStatus.AUTO
+        coordinator._last_positions["cover.t"] = 0  # commanded to close
+        coordinator._last_command_time["cover.t"] = 0.0  # > SETTLE_TIME ago
+        coordinator._pending_settle.add("cover.t")
+
+        with patch(f"{MOD}.coordinator.time_mod") as mock_time, \
+                patch.object(coordinator, "pause_cover") as pause:
+            mock_time.monotonic.return_value = 9999.0
+            coordinator._handle_cover_state_change(
+                "cover.t",
+                MockState("open", {"current_position": 60}),
+                MockState("open", {"current_position": 40}),
+            )
+        pause.assert_not_called()
+        assert coordinator._last_command_time["cover.t"] == 9999.0
+        assert "cover.t" in coordinator._pending_settle
+
+
+# ---------------------------------------------------------------------------
+# Minor fixes
+# ---------------------------------------------------------------------------
+
+class TestMinorFixes:
+    def test_pause_ignored_while_locked(self, coordinator, mock_storage) -> None:
+        coordinator._cover_states["cover.t"] = CoverStatus.LOCKED
+        coordinator.pause_cover(CoverConfig(entity_id="cover.t", name="T"))
+        assert coordinator._cover_states["cover.t"] == CoverStatus.LOCKED
+        mock_storage.update_cover_status.assert_not_called()
+
+    def test_after_sunset_still_true_after_midnight(self) -> None:
+        from custom_components.cover_automatic.engine import RuleEngine
+
+        engine = RuleEngine(MagicMock(), MagicMock())
+        cond = Condition(type=ConditionType.TIME_AFTER_SUNSET, params={"offset": 0})
+        now = 1_000_000.0  # 01:00
+        with (
+            patch(f"{MOD}.engine.get_sunset_time", return_value=now + 19 * 3600),
+            patch(f"{MOD}.engine.get_sunrise_time", return_value=now + 5 * 3600),
+            patch(f"{MOD}.engine.get_sun_event_time", return_value=now - 5 * 3600),
+            patch(f"{MOD}.engine.dt_util.now") as mock_now,
+        ):
+            mock_now.return_value.timestamp.return_value = now
+            assert engine._evaluate_condition(cond, None) is True
+            # after sunrise, before sunset: false
+            mock_now.return_value.timestamp.return_value = now + 8 * 3600
+            assert engine._evaluate_condition(cond, None) is False
+
+    @pytest.mark.asyncio
+    async def test_house_rotation_rotates_existing_facades(self) -> None:
+        from custom_components.cover_automatic.api import ws_settings_update
+
+        storage = _make_storage()
+        storage.house_rotation = 0.0
+        storage._data = {"facades": {"south": {"azimuth_start": 135.0, "azimuth_end": 225.0}}}
+        msg = {"id": 1, "type": f"{DOMAIN}/settings/update", "house_rotation": 10.0}
+        await ws_settings_update(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        assert storage._data["facades"]["south"] == {"azimuth_start": 145.0, "azimuth_end": 235.0}
+
+    def test_subscribe_forwards_dispatcher_signal(self) -> None:
+        from custom_components.cover_automatic.api import ws_subscribe_updates
+
+        conn = MagicMock()
+        conn.subscriptions = {}
+        with patch(f"{MOD}.api.async_dispatcher_connect") as connect:
+            ws_subscribe_updates(MagicMock(), conn, {"id": 7})
+            forward = connect.call_args.args[2]
+        conn.send_result.assert_called_once_with(7)
+        assert 7 in conn.subscriptions
+        forward()
+        conn.send_message.assert_called_once()
+
+    @pytest.mark.parametrize("target", [-1, 101])
+    def test_rule_target_position_range(self, target) -> None:
+        import voluptuous as vol
+        from homeassistant.components import websocket_api as real_ws
+
+        from custom_components.cover_automatic.api import async_setup_api
+
+        schemas: dict = {}
+        with patch(f"{MOD}.api.websocket_api") as mock_ws:
+            mock_ws.BASE_COMMAND_MESSAGE_SCHEMA = real_ws.BASE_COMMAND_MESSAGE_SCHEMA
+            mock_ws.async_register_command.side_effect = (
+                lambda hass, ct, handler=None, schema=None: schemas.__setitem__(ct, schema)
+            )
+            async_setup_api(MagicMock(), MagicMock(), MagicMock())
+        with pytest.raises(vol.Invalid):
+            schemas[f"{DOMAIN}/rule/add"](
+                {"id": 1, "type": f"{DOMAIN}/rule/add", "name": "R", "target_position": target}
+            )
diff --git a/tests/test_rule_scenarios.py b/tests/test_rule_scenarios.py
new file mode 100644
index 0000000..657605d
--- /dev/null
+++ b/tests/test_rule_scenarios.py
@@ -0,0 +1,158 @@
+"""Tests for per-rule scenario membership (Rule.scenario_ids)."""
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+from __future__ import annotations
+
+import pytest
+
+from custom_components.cover_automatic.models import Rule, Scenario
+from tests.test_api import _make_connection, _make_coordinator, _make_hass, _make_storage
+from tests.test_engine import engine, mock_hass, mock_storage  # noqa: F401 -- pytest fixtures
+from tests.test_storage import mock_store, storage  # noqa: F401 -- pytest fixtures
+
+
+def _raw_rule(rule_id: str, **extra) -> dict:
+    return {"id": rule_id, "name": rule_id, "conditions": [], "target_position": 0, **extra}
+
+
+class TestModel:
+    def test_default_is_none(self) -> None:
+        assert Rule(id="r", name="R").scenario_ids is None
+
+    def test_roundtrip(self) -> None:
+        rule = Rule(id="r", name="R", scenario_ids=["everyday", "summer"])
+        assert Rule.from_dict(rule.to_dict()).scenario_ids == ["everyday", "summer"]
+
+    def test_missing_or_invalid_field_means_all(self) -> None:
+        assert Rule.from_dict(_raw_rule("r")).scenario_ids is None
+        assert Rule.from_dict(_raw_rule("r", scenario_ids="everyday")).scenario_ids is None
+
+
+class TestMigration:
+    def test_existing_rules_get_every_scenario(self, storage) -> None:
+        storage._data = {
+            "rules": {"r1": _raw_rule("r1"), "r2": _raw_rule("r2", scenario_ids=["summer"])},
+            "scenarios": {"everyday": {"id": "everyday"}, "summer": {"id": "summer"}},
+        }
+        storage._migrate_rule_scenarios()
+        assert storage._data["rules"]["r1"]["scenario_ids"] == ["everyday", "summer"]
+        # An explicit selection is kept as is.
+        assert storage._data["rules"]["r2"]["scenario_ids"] == ["summer"]
+
+    @pytest.mark.asyncio
+    async def test_import_migrates_old_export(self, storage) -> None:
+        await storage.async_import_data({
+            "rules": {"r1": _raw_rule("r1")},
+            "scenarios": {"everyday": {"id": "everyday", "name": "E"}, "cinema": {"id": "cinema", "name": "C"}},
+        })
+        assert storage.rules["r1"].scenario_ids == ["everyday", "cinema"]
+
+
+class TestScenarioSync:
+    @pytest.mark.asyncio
+    async def test_new_scenario_added_to_every_rule(self, storage) -> None:
+        storage._data = {
+            "rules": {"r1": _raw_rule("r1", scenario_ids=["everyday"]), "r2": _raw_rule("r2", scenario_ids=[])},
+            "scenarios": {"everyday": {"id": "everyday", "name": "E"}},
+        }
+        await storage.async_add_scenario(Scenario(id="party", name="Party"))
+        assert storage.rules["r1"].scenario_ids == ["everyday", "party"]
+        assert storage.rules["r2"].scenario_ids == ["party"]
+
+    @pytest.mark.asyncio
+    async def test_updating_scenario_does_not_reselect_it(self, storage) -> None:
+        storage._data = {
+            "rules": {"r1": _raw_rule("r1", scenario_ids=["everyday"])},
+            "scenarios": {"everyday": {"id": "everyday", "name": "E"}, "party": {"id": "party", "name": "P"}},
+        }
+        await storage.async_add_scenario(Scenario(id="party", name="Party renamed"))
+        assert storage.rules["r1"].scenario_ids == ["everyday"]
+
+    @pytest.mark.asyncio
+    async def test_removed_scenario_dropped_from_rules(self, storage) -> None:
+        storage._data = {
+            "rules": {"r1": _raw_rule("r1", scenario_ids=["everyday", "party"])},
+            "scenarios": {"everyday": {"id": "everyday", "name": "E"}, "party": {"id": "party", "name": "P"}},
+            "active_scenario": "everyday",
+        }
+        await storage.async_remove_scenario("party")
+        assert storage.rules["r1"].scenario_ids == ["everyday"]
+
+
+class TestEngineMembership:
+    def test_rule_outside_scenario_is_inactive(self, engine, mock_storage) -> None:
+        mock_storage.scenarios = {"cinema": Scenario(id="cinema", name="Cinema")}
+        rule = Rule(id="r", name="R", scenario_ids=["everyday"])
+        assert engine._rule_active_in_scenario(rule, "cinema") is False
+
+    def test_member_rule_is_active(self, engine, mock_storage) -> None:
+        mock_storage.scenarios = {"cinema": Scenario(id="cinema", name="Cinema")}
+        rule = Rule(id="r", name="R", scenario_ids=["cinema"])
+        assert engine._rule_active_in_scenario(rule, "cinema") is True
+
+    def test_member_rule_switched_off_in_scenario(self, engine, mock_storage) -> None:
+        mock_storage.scenarios = {"cinema": Scenario(id="cinema", name="Cinema", rules_disabled=["r"])}
+        rule = Rule(id="r", name="R", scenario_ids=["cinema"])
+        assert engine._rule_active_in_scenario(rule, "cinema") is False
+
+    def test_none_means_every_scenario(self, engine, mock_storage) -> None:
+        mock_storage.scenarios = {"cinema": Scenario(id="cinema", name="Cinema")}
+        assert engine._rule_active_in_scenario(Rule(id="r", name="R"), "cinema") is True
+
+
+class TestApi:
+    def _storage(self):
+        return _make_storage(scenarios={
+            "everyday": Scenario(id="everyday", name="E"),
+            "cinema": Scenario(id="cinema", name="C"),
+        })
+
+    @pytest.mark.asyncio
+    async def test_add_defaults_to_all_scenarios(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_add
+
+        storage = self._storage()
+        await ws_rule_add(_make_hass(), _make_connection(), {"id": 1, "name": "New"}, storage, _make_coordinator())
+        assert storage.async_add_rule.call_args[0][0].scenario_ids == ["everyday", "cinema"]
+
+    @pytest.mark.asyncio
+    async def test_add_with_selection(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_add
+
+        storage = self._storage()
+        msg = {"id": 1, "name": "New", "scenario_ids": ["cinema"]}
+        await ws_rule_add(_make_hass(), _make_connection(), msg, storage, _make_coordinator())
+        assert storage.async_add_rule.call_args[0][0].scenario_ids == ["cinema"]
+
+    @pytest.mark.asyncio
+    async def test_add_rejects_unknown_scenario(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_add
+
+        storage, conn = self._storage(), _make_connection()
+        msg = {"id": 1, "name": "New", "scenario_ids": ["nope"]}
+        await ws_rule_add(_make_hass(), conn, msg, storage, _make_coordinator())
+        assert conn.send_error.call_args[0][1] == "not_found"
+        storage.async_add_rule.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_update_changes_and_keeps_selection(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_update
+
+        storage = self._storage()
+        storage.rules = {"r": Rule(id="r", name="R", scenario_ids=["everyday"])}
+        coord = _make_coordinator()
+        await ws_rule_update(_make_hass(), _make_connection(), {"id": 1, "rule_id": "r", "name": "R2"}, storage, coord)
+        assert storage.async_add_rule.call_args[0][0].scenario_ids == ["everyday"]
+        msg = {"id": 2, "rule_id": "r", "scenario_ids": ["cinema", "everyday"]}
+        await ws_rule_update(_make_hass(), _make_connection(), msg, storage, coord)
+        assert storage.async_add_rule.call_args[0][0].scenario_ids == ["cinema", "everyday"]
+
+    @pytest.mark.asyncio
+    async def test_update_rejects_unknown_scenario(self) -> None:
+        from custom_components.cover_automatic.api import ws_rule_update
+
+        storage, conn = self._storage(), _make_connection()
+        storage.rules = {"r": Rule(id="r", name="R")}
+        msg = {"id": 1, "rule_id": "r", "scenario_ids": ["nope"]}
+        await ws_rule_update(_make_hass(), conn, msg, storage, _make_coordinator())
+        assert conn.send_error.call_args[0][1] == "not_found"
+        storage.async_add_rule.assert_not_awaited()
diff --git a/tests/test_services.py b/tests/test_services.py
index df92c34..0162a3a 100644
--- a/tests/test_services.py
+++ b/tests/test_services.py
@@ -181,7 +181,7 @@ def capture_register(domain, service, handler, **kwargs):
         # Execute pause handler
         await handlers["pause"](call)
 
-        coordinator.pause_cover.assert_called_once_with(cover)
+        coordinator.pause_cover.assert_called_once_with(cover, manual=False)
 
     @pytest.mark.asyncio
     async def test_resume_service_calls_coordinator(
@@ -299,7 +299,7 @@ def mock_hass_with_export_data(self):
         hass.async_add_executor_job = AsyncMock(side_effect=lambda fn, *args: fn(*args) if not args else fn())
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(
+        mock_storage.get_export_data = MagicMock(
             return_value={"facades": {}, "covers": {}}
         )
         mock_storage.async_import_data = AsyncMock()
@@ -333,14 +333,17 @@ def capture_register(domain, service, handler, **kwargs):
         call.data = {"path": "/etc/passwd"}
         call.context.user_id = None
 
-        with patch(
-            "custom_components.cover_automatic.services._validate_export_path",
-            return_value=None,
+        with (
+            patch(
+                "custom_components.cover_automatic.services._validate_export_path",
+                return_value=None,
+            ),
+            patch("builtins.open") as mock_open,
         ):
             await handlers["export_config"](call)
 
-        # Should not attempt to write
-        hass.async_add_executor_job.assert_not_called()
+        # Validation runs in the executor; nothing may be written
+        mock_open.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_import_validates_path(self, mock_hass_with_export_data) -> None:
@@ -531,7 +534,7 @@ def mock_hass_with_export_data(self):
         hass.config.config_dir = "/config"
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(return_value={"facades": {}, "covers": {}})
+        mock_storage.get_export_data = MagicMock(return_value={"facades": {}, "covers": {}})
         mock_storage.async_import_data = AsyncMock()
 
         mock_coordinator = MagicMock()
@@ -629,7 +632,7 @@ def mock_hass_for_export(self):
         )
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(return_value={"facades": {}, "covers": {}})
+        mock_storage.get_export_data = MagicMock(return_value={"facades": {}, "covers": {}})
 
         mock_coordinator = MagicMock()
         mock_coordinator.storage = mock_storage
@@ -663,9 +666,12 @@ async def test_export_rejects_path_outside_subdir(
         call.data = {"path": "/config/configuration.yaml"}
         call.context.user_id = None
 
-        await handler(call)
+        # Run executor jobs for real: validation happens inside the job
+        hass.async_add_executor_job = AsyncMock(side_effect=lambda fn: fn())
+        with patch("builtins.open") as mock_open:
+            await handler(call)
 
-        hass.async_add_executor_job.assert_not_called()
+        mock_open.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_export_default_path_in_subdir(self, mock_hass_for_export) -> None:
@@ -701,7 +707,7 @@ def mock_hass_with_import_data(self):
         hass.config.config_dir = "/config"
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(return_value={"facades": {}, "covers": {}})
+        mock_storage.get_export_data = MagicMock(return_value={"facades": {}, "covers": {}})
         mock_storage.async_import_data = AsyncMock()
 
         mock_coordinator = MagicMock()
@@ -769,7 +775,7 @@ def mock_hass_for_import_errors(self):
         hass.config.config_dir = "/config"
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(return_value={"facades": {}, "covers": {}})
+        mock_storage.get_export_data = MagicMock(return_value={"facades": {}, "covers": {}})
 
         mock_coordinator = MagicMock()
         mock_coordinator.storage = mock_storage
@@ -871,7 +877,7 @@ def mock_hass_with_auth(self):
         hass.config.config_dir = "/config"
 
         mock_storage = MagicMock()
-        mock_storage.get_raw_data = MagicMock(return_value={"facades": {}, "covers": {}})
+        mock_storage.get_export_data = MagicMock(return_value={"facades": {}, "covers": {}})
         mock_storage.async_import_data = AsyncMock()
 
         mock_coordinator = MagicMock()
diff --git a/tests/test_storage.py b/tests/test_storage.py
index bba1912..5f45e6c 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -550,57 +550,37 @@ async def test_import_empty_scenarios_resets_to_everyday(
 
 
 class TestDebouncedSave:
-    """Tests for debounced save mechanism."""
+    """Tests for the debounced save (delegated to Store.async_delay_save)."""
 
-    def test_schedule_save_creates_task(self, storage, mock_hass) -> None:
-        """Test _schedule_save creates a task."""
-        storage._save_task = None
-        mock_hass.async_create_task = MagicMock(return_value=MagicMock())
+    def test_schedule_save_uses_store_delay_save(self, storage, mock_store) -> None:
+        """_schedule_save hands the write to the HA Store with the debounce delay."""
+        storage._data = {"test": "data"}
         storage._schedule_save()
 
-        assert storage._save_task is not None
-        mock_hass.async_create_task.assert_called_once()
+        mock_store.async_delay_save.assert_called_once()
+        data_func, delay = mock_store.async_delay_save.call_args.args
+        assert delay == SAVE_DEBOUNCE_DELAY
+        # The callback returns the live data at write time
+        assert data_func() is storage._data
 
-    def test_schedule_save_cancels_previous_task(self, storage, mock_hass) -> None:
-        """Test _schedule_save cancels previous task."""
-        mock_task = MagicMock()
-        storage._save_task = mock_task
-        mock_hass.async_create_task = MagicMock(return_value=MagicMock())
+    def test_repeated_schedule_save_is_batched_by_store(self, storage, mock_store) -> None:
+        """Each call re-arms the Store's delayed write (Store keeps only the last)."""
         storage._schedule_save()
-
-        mock_task.cancel.assert_called_once()
+        storage._schedule_save()
+        assert mock_store.async_delay_save.call_count == 2
 
     @pytest.mark.asyncio
-    async def test_debounced_save_waits_and_saves(self, storage, mock_store) -> None:
-        """Test _debounced_save waits before saving."""
+    async def test_async_save_writes_immediately(self, storage, mock_store) -> None:
+        """async_save writes now (and thereby supersedes a pending delayed save)."""
         storage._data = {"test": "data"}
+        await storage.async_save()
+        mock_store.async_save.assert_called_once_with(storage._data)
 
-        with patch("asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
-            await storage._debounced_save()
-
-            mock_sleep.assert_called_once_with(SAVE_DEBOUNCE_DELAY)
-            mock_store.async_save.assert_called_once_with(storage._data)
-
-    @pytest.mark.asyncio
-    async def test_debounced_save_handles_cancellation(
-        self, storage, mock_store
-    ) -> None:
-        """Test _debounced_save handles cancellation gracefully."""
-        with patch("asyncio.sleep", side_effect=asyncio.CancelledError):
-            await storage._debounced_save()
-
+    def test_flush_pending_save_is_noop(self, storage, mock_store) -> None:
+        """flush_pending_save is kept for API compatibility and does not raise."""
+        storage.flush_pending_save()
         mock_store.async_save.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_debounced_save_handles_errors(
-        self, storage, mock_store
-    ) -> None:
-        """Test _debounced_save handles save errors."""
-        mock_store.async_save.side_effect = Exception("Save failed")
-
-        with patch("asyncio.sleep", new_callable=AsyncMock):
-            await storage._debounced_save()
-
 
 class TestImportCorruptEntries:
     """Tests for async_import_data skipping corrupt entries."""
@@ -994,12 +974,12 @@ async def test_async_clear_cancels_pending_save(self):
             log._store = mock_store
 
         log.add_entry("position", "cover.test", "moved")
-        assert log._save_task is not None
+        mock_store.async_delay_save.assert_called_once()
 
         await log.async_clear()
 
-        assert log._save_task is None
         assert log._entries == []
+        mock_store.async_save.assert_called_once_with({"entries": []})
 
     @pytest.mark.asyncio
     async def test_async_save_persists_entries(self):
@@ -1021,14 +1001,13 @@ async def test_async_save_persists_entries(self):
 
         await log.async_save()
 
-        assert log._save_task is None
         mock_store.async_save.assert_called_once()
         saved_payload = mock_store.async_save.call_args[0][0]
         assert len(saved_payload["entries"]) == 2
 
     @pytest.mark.asyncio
-    async def test_async_save_cancels_pending_debounced_task(self):
-        """async_save cancels any pending debounced save (no double write)."""
+    async def test_async_save_after_scheduled_save(self):
+        """add_entry schedules a delayed Store write; async_save writes now."""
         hass = self._make_log_hass()
         mock_store = MagicMock()
         mock_store.async_load = AsyncMock(return_value=None)
@@ -1042,11 +1021,11 @@ async def test_async_save_cancels_pending_debounced_task(self):
             log._store = mock_store
 
         log.add_entry("position", "cover.test", "moved")
-        assert log._save_task is not None
+        data_func, _delay = mock_store.async_delay_save.call_args.args
+        assert len(data_func()["entries"]) == 1
 
         await log.async_save()
 
-        assert log._save_task is None
         mock_store.async_save.assert_called_once()
 
 
diff --git a/tests/test_sun.py b/tests/test_sun.py
index 22848ed..5809781 100644
--- a/tests/test_sun.py
+++ b/tests/test_sun.py
@@ -10,6 +10,7 @@
 
 from custom_components.cover_automatic import sun as sun_mod
 from custom_components.cover_automatic.models import Facade
+from custom_components.cover_automatic import sun as sun_module
 from custom_components.cover_automatic.sun import (
     get_facade_sun_times,
     get_sun_position,
@@ -175,6 +176,7 @@ def test_sun_below_min_elevation(self, mock_hass, south_facade) -> None:
         assert result is False
 
 
+<<<<<<< Updated upstream
 # ---------------------------------------------------------------------------
 # Facade sun entry/exit times from the real sun path.
 # Reference values come from an independent 10-second brute-force scan with
@@ -282,3 +284,131 @@ def test_computed_once_per_day(self, located_hass) -> None:
                 assert calc.call_count > calls
         # Only the current day is kept
         assert {key[0] for key in sun_mod._times_cache} == {date(2026, 10, 2)}
+=======
+def _astral_hass(lat: float, lon: float, tz: str):
+    """Build a mock hass whose sun helpers use the real astral library."""
+    import zoneinfo
+
+    from homeassistant.util import dt as dt_util
+
+    dt_util.set_default_time_zone(zoneinfo.ZoneInfo(tz))
+    hass = MagicMock()
+    hass.data = {}
+    hass.config.latitude = lat
+    hass.config.longitude = lon
+    hass.config.elevation = 0
+    hass.config.time_zone = tz
+    return hass
+
+
+def _patch_sun_events(day, lat: float, lon: float, tz: str):
+    """Patch sunrise/sunset getters with astral's values for the given day."""
+    from astral import LocationInfo
+    from astral.sun import sunrise, sunset
+
+    observer = LocationInfo("", "", tz, lat, lon).observer
+    return (
+        patch(
+            "custom_components.cover_automatic.sun.get_sunrise_time",
+            return_value=sunrise(observer, date=day).timestamp(),
+        ),
+        patch(
+            "custom_components.cover_automatic.sun.get_sunset_time",
+            return_value=sunset(observer, date=day).timestamp(),
+        ),
+    )
+
+
+def _hhmm_to_min(value: str) -> int:
+    hours, minutes = value.split(":")
+    return int(hours) * 60 + int(minutes)
+
+
+PARIS = (48.85, 2.35, "Europe/Paris")
+
+
+class TestGetFacadeSunTimes:
+    """Tests for get_facade_sun_times (sampled real solar path)."""
+
+    @pytest.fixture(autouse=True)
+    def _clear_cache(self):
+        sun_module._SUN_TIME_CACHE.clear()
+        yield
+        sun_module._SUN_TIME_CACHE.clear()
+
+    def _times(self, facade, day, where=PARIS):
+        import datetime
+
+        lat, lon, tz = where
+        hass = _astral_hass(lat, lon, tz)
+        p_rise, p_set = _patch_sun_events(datetime.date(*day), lat, lon, tz)
+        with p_rise, p_set:
+            return get_facade_sun_times(hass, facade)
+
+    def test_returns_none_when_sunrise_unavailable(self, mock_hass, south_facade) -> None:
+        with patch(
+            "custom_components.cover_automatic.sun.get_sunrise_time", return_value=None
+        ):
+            assert get_facade_sun_times(mock_hass, south_facade) == (None, None)
+
+    def test_returns_none_when_sunset_unavailable(self, mock_hass, south_facade) -> None:
+        with patch(
+            "custom_components.cover_automatic.sun.get_sunrise_time", return_value=1000.0
+        ), patch(
+            "custom_components.cover_automatic.sun.get_sunset_time", return_value=None
+        ):
+            assert get_facade_sun_times(mock_hass, south_facade) == (None, None)
+
+    def test_east_facade_gets_sun_from_sunrise_in_summer(self, east_facade) -> None:
+        """Default east preset (45-135) must yield an entry time (was None before)."""
+        entry, exit_time = self._times(east_facade, (2026, 6, 21))
+        assert entry is not None and exit_time is not None
+        assert _hhmm_to_min(entry) < 7 * 60  # early morning
+        assert _hhmm_to_min(exit_time) < 13 * 60 + 30
+
+    def test_west_facade_gets_sun_until_sunset_in_summer(self, west_facade) -> None:
+        """Default west preset (225-315) must yield an exit time (was None before)."""
+        entry, exit_time = self._times(west_facade, (2026, 6, 21))
+        assert entry is not None and exit_time is not None
+        assert _hhmm_to_min(exit_time) > 21 * 60
+
+    def test_south_facade_entry_before_exit(self, south_facade) -> None:
+        entry, exit_time = self._times(south_facade, (2026, 6, 21))
+        assert _hhmm_to_min(entry) < _hhmm_to_min(exit_time)
+
+    def test_south_facade_longer_in_winter(self, south_facade) -> None:
+        """Seasonal dependency: the winter sun stays in the south much longer."""
+        s_entry, s_exit = self._times(south_facade, (2026, 6, 21))
+        w_entry, w_exit = self._times(south_facade, (2026, 12, 21))
+        summer = _hhmm_to_min(s_exit) - _hhmm_to_min(s_entry)
+        winter = _hhmm_to_min(w_exit) - _hhmm_to_min(w_entry)
+        assert winter > summer
+
+    def test_north_facade_no_sun_in_paris(self, north_facade) -> None:
+        """In Paris the sun rises/sets south of 45/315 deg: no sun on 315-45."""
+        assert self._times(north_facade, (2026, 6, 21)) == (None, None)
+
+    def test_north_facade_gets_morning_sun_far_north(self, north_facade) -> None:
+        """Wrap-around facade near the arctic circle gets the early sun."""
+        entry, exit_time = self._times(
+            north_facade, (2026, 6, 10), where=(65.0, 25.5, "Europe/Helsinki")
+        )
+        assert entry is not None and exit_time is not None
+        assert _hhmm_to_min(entry) < 6 * 60
+
+    def test_min_elevation_shortens_period(self, south_facade) -> None:
+        low = self._times(south_facade, (2026, 12, 21))
+        sun_module._SUN_TIME_CACHE.clear()
+        high_facade = Facade(
+            id="s2", name="S2", azimuth_start=135.0, azimuth_end=225.0, min_elevation=15.0
+        )
+        high = self._times(high_facade, (2026, 12, 21))
+        assert _hhmm_to_min(high[0]) > _hhmm_to_min(low[0])
+        assert _hhmm_to_min(high[1]) < _hhmm_to_min(low[1])
+
+    def test_result_is_cached(self, south_facade) -> None:
+        first = self._times(south_facade, (2026, 6, 21))
+        assert len(sun_module._SUN_TIME_CACHE) == 1
+        assert self._times(south_facade, (2026, 6, 21)) == first
+        assert len(sun_module._SUN_TIME_CACHE) == 1
+>>>>>>> Stashed changes
diff --git a/tests/test_sun_comfort_switches.py b/tests/test_sun_comfort_switches.py
new file mode 100644
index 0000000..ca2b30d
--- /dev/null
+++ b/tests/test_sun_comfort_switches.py
@@ -0,0 +1,378 @@
+"""Tests for the sun-on-facade comfort switches (global + per-cover override)."""
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+import voluptuous as vol
+
+from custom_components.cover_automatic import engine as engine_mod
+from custom_components.cover_automatic.models import (
+    Condition,
+    ConditionType,
+    CoverConfig,
+    Facade,
+)
+from custom_components.cover_automatic.storage import (
+    _ALL_MIGRATIONS,
+    MIGRATION_PAUSE_DURATION_120,
+    MIGRATION_PREEMPTIVE_TRISTATE,
+)
+from tests.test_api import _make_connection, _make_coordinator, _make_hass, _make_storage
+from tests.test_engine import MockState, engine, mock_hass, mock_storage  # noqa: F401
+from tests.test_storage import mock_store, storage  # noqa: F401
+
+HEATING, NEUTRAL, COOLING = "18.0", "23.0", "26.0"  # comfort band 21-25
+SOLAR_HIGH, SOLAR_LOW = "6000.0", "1000.0"
+
+SUN = Condition(type=ConditionType.SUN_ON_FACADE, params={})
+NOT_SUN = Condition(type=ConditionType.SUN_ON_FACADE, params={}, negate=True)
+
+
+def _setup(hass, store, *, temp: str | None, solar: str = SOLAR_HIGH,
+           heating: bool = True, neutral: bool = True, preemptive: bool = True,
+           sensor: str | None = "sensor.indoor_temp") -> None:
+    store.facades = {"south": Facade(id="south", name="S", azimuth_start=90, azimuth_end=270)}
+    store.indoor_temp_sensor = sensor
+    store.solar_sensor = "sensor.pv_power"
+    store.solar_threshold = 5000.0
+    store.solar_threshold_entity = None
+    store.comfort_temp_min_entity = None
+    store.comfort_temp_max_entity = None
+    store.sun_heating_ignore = heating
+    store.sun_neutral_ignore = neutral
+    store.preemptive_shading = preemptive
+    states = {"sensor.pv_power": MockState(solar)}
+    if temp is not None:
+        states["sensor.indoor_temp"] = MockState(temp)
+    hass.states.get = lambda eid: states.get(eid)
+
+
+def _cover(**kw) -> CoverConfig:
+    return CoverConfig(entity_id="cover.test", name="Test", facade_id="south", **kw)
+
+
+def _eval(engine, cover, cond=SUN, *, on_facade: bool = True) -> bool:  # noqa: F811
+    with (
+        patch.object(engine_mod, "is_sun_on_facade", return_value=on_facade),
+        patch.object(engine_mod, "get_sun_position", return_value=(180.0, 30.0)),
+    ):
+        return engine._evaluate_final(cond, cover)
+
+
+# ---------------------------------------------------------------------------
+# Engine semantics
+# ---------------------------------------------------------------------------
+
+class TestEngineSemantics:
+    @pytest.mark.parametrize(
+        ("temp", "heating", "neutral", "preemptive", "solar", "expected"),
+        [
+            # Defaults (current behaviour)
+            (COOLING, True, True, True, SOLAR_LOW, True),
+            (HEATING, True, True, True, SOLAR_HIGH, False),
+            (NEUTRAL, True, True, True, SOLAR_HIGH, True),
+            (NEUTRAL, True, True, True, SOLAR_LOW, False),
+            (NEUTRAL, True, True, False, SOLAR_HIGH, False),
+            # Heating switch off: sun counts in heating
+            (HEATING, False, True, True, SOLAR_LOW, True),
+            (NEUTRAL, False, True, True, SOLAR_LOW, False),
+            # Neutral switch off: sun counts in neutral, preemptive irrelevant
+            (NEUTRAL, True, False, False, SOLAR_LOW, True),
+            (HEATING, True, False, True, SOLAR_HIGH, False),
+            # Both off: position only
+            (HEATING, False, False, False, SOLAR_LOW, True),
+            (NEUTRAL, False, False, False, SOLAR_LOW, True),
+            (COOLING, False, False, False, SOLAR_LOW, True),
+        ],
+    )
+    def test_mode_by_flags(
+        self, engine, mock_hass, mock_storage,  # noqa: F811
+        temp, heating, neutral, preemptive, solar, expected,
+    ) -> None:
+        _setup(mock_hass, mock_storage, temp=temp, solar=solar,
+               heating=heating, neutral=neutral, preemptive=preemptive)
+        assert _eval(engine, _cover()) is expected
+
+    def test_sun_off_facade_always_false(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=COOLING, heating=False, neutral=False)
+        assert _eval(engine, _cover(), on_facade=False) is False
+
+    def test_no_sensor_position_only(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=HEATING, sensor=None)
+        assert _eval(engine, _cover()) is True
+
+    def test_cover_override_beats_global(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=HEATING)
+        assert _eval(engine, _cover()) is False
+        assert _eval(engine, _cover(sun_heating_ignore=False)) is True
+        # Global off, cover forces it back on
+        _setup(mock_hass, mock_storage, temp=HEATING, heating=False)
+        assert _eval(engine, _cover()) is True
+        assert _eval(engine, _cover(sun_heating_ignore=True)) is False
+
+    def test_neutral_override(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=NEUTRAL, solar=SOLAR_LOW)
+        assert _eval(engine, _cover()) is False
+        assert _eval(engine, _cover(sun_neutral_ignore=False)) is True
+        _setup(mock_hass, mock_storage, temp=NEUTRAL, solar=SOLAR_LOW, neutral=False)
+        assert _eval(engine, _cover(sun_neutral_ignore=True)) is False
+
+    def test_preemptive_override(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=NEUTRAL, preemptive=False)
+        assert _eval(engine, _cover()) is False
+        assert _eval(engine, _cover(preemptive_shading=True)) is True
+        _setup(mock_hass, mock_storage, temp=NEUTRAL, preemptive=True)
+        assert _eval(engine, _cover()) is True
+        assert _eval(engine, _cover(preemptive_shading=False)) is False
+
+    def test_sun_flags_resolution(self, engine, mock_storage) -> None:  # noqa: F811
+        mock_storage.sun_heating_ignore = True
+        mock_storage.sun_neutral_ignore = False
+        mock_storage.preemptive_shading = True
+        assert engine._sun_flags(_cover()) == (True, False, True)
+        assert engine._sun_flags(
+            _cover(sun_heating_ignore=False, sun_neutral_ignore=True, preemptive_shading=False)
+        ) == (False, True, False)
+
+
+class TestUnknownMode:
+    def test_unknown_defaults_false(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=None)
+        assert _eval(engine, _cover()) is False
+
+    @pytest.mark.parametrize(("heating", "neutral"), [(True, False), (False, True)])
+    def test_unknown_one_switch_false(
+        self, engine, mock_hass, mock_storage, heating, neutral,  # noqa: F811
+    ) -> None:
+        _setup(mock_hass, mock_storage, temp=None, heating=heating, neutral=neutral)
+        assert _eval(engine, _cover()) is False
+
+    def test_unknown_both_off_position_only(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=None, heating=False, neutral=False)
+        assert _eval(engine, _cover()) is True
+        # Per-cover override off on a global-on install
+        _setup(mock_hass, mock_storage, temp=None)
+        assert _eval(engine, _cover(sun_heating_ignore=False, sun_neutral_ignore=False)) is True
+
+
+class TestNegateKnown:
+    def test_negate_unknown_comfort_not_met(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=None)
+        assert _eval(engine, _cover(), NOT_SUN) is False
+        with patch.object(engine_mod, "get_sun_position", return_value=(180.0, 30.0)), \
+                patch.object(engine_mod, "is_sun_on_facade", return_value=True):
+            assert engine._input_available(SUN, _cover()) is False
+
+    def test_negate_both_off_sensor_irrelevant(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=None, heating=False, neutral=False)
+        with patch.object(engine_mod, "get_sun_position", return_value=(180.0, 30.0)), \
+                patch.object(engine_mod, "is_sun_on_facade", return_value=True):
+            assert engine._input_available(SUN, _cover()) is True
+        # Sun on the facade -> NOT not met; off the facade -> NOT met
+        assert _eval(engine, _cover(), NOT_SUN) is False
+        assert _eval(engine, _cover(), NOT_SUN, on_facade=False) is True
+
+    def test_negate_heating_switch_off_known(self, engine, mock_hass, mock_storage) -> None:  # noqa: F811
+        _setup(mock_hass, mock_storage, temp=HEATING, heating=False)
+        assert _eval(engine, _cover(), NOT_SUN) is False
+        _setup(mock_hass, mock_storage, temp=HEATING)
+        assert _eval(engine, _cover(), NOT_SUN) is True
+
+
+# ---------------------------------------------------------------------------
+# Storage migration / settings
+# ---------------------------------------------------------------------------
+
+def _legacy_data() -> dict:
+    return {
+        "covers": {
+            "cover.a": {"entity_id": "cover.a", "name": "A", "preemptive_shading": True},
+            "cover.b": {"entity_id": "cover.b", "name": "B", "preemptive_shading": False},
+            "cover.c": {"entity_id": "cover.c", "name": "C"},
+        },
+        "rules": {}, "scenarios": {}, "facades": {},
+        "migrations": [MIGRATION_PAUSE_DURATION_120],
+    }
+
+
+class TestMigration:
+    @pytest.mark.asyncio
+    async def test_preemptive_tristate(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = _legacy_data()
+        await storage.async_load()
+        covers = storage._data["covers"]
+        assert covers["cover.a"]["preemptive_shading"] is None
+        assert covers["cover.b"]["preemptive_shading"] is False
+        assert "preemptive_shading" not in covers["cover.c"]
+        assert MIGRATION_PREEMPTIVE_TRISTATE in storage._data["migrations"]
+        mock_store.async_delay_save.assert_called()
+        assert storage.covers["cover.a"].preemptive_shading is None
+        assert storage.covers["cover.b"].preemptive_shading is False
+        assert storage.covers["cover.c"].preemptive_shading is None
+
+    @pytest.mark.asyncio
+    async def test_runs_once(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = _legacy_data()
+        await storage.async_load()
+        # Explicit True set afterwards survives the next load
+        storage._data["covers"]["cover.a"]["preemptive_shading"] = True
+        mock_store.async_load.return_value = storage._data
+        mock_store.async_delay_save.reset_mock()
+        await storage.async_load()
+        assert storage._data["covers"]["cover.a"]["preemptive_shading"] is True
+        mock_store.async_delay_save.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_new_install_marker(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = None
+        await storage.async_load()
+        assert MIGRATION_PREEMPTIVE_TRISTATE in storage._data["migrations"]
+        assert MIGRATION_PREEMPTIVE_TRISTATE in _ALL_MIGRATIONS
+
+    @pytest.mark.asyncio
+    async def test_import_legacy_export_converted(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = None
+        await storage.async_load()
+        await storage.async_import_data(_legacy_data())
+        assert storage._data["covers"]["cover.a"]["preemptive_shading"] is None
+        assert storage._data["covers"]["cover.b"]["preemptive_shading"] is False
+
+    @pytest.mark.asyncio
+    async def test_import_current_export_kept(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = None
+        await storage.async_load()
+        data = _legacy_data()
+        data["migrations"] = list(_ALL_MIGRATIONS)
+        await storage.async_import_data(data)
+        assert storage._data["covers"]["cover.a"]["preemptive_shading"] is True
+
+
+class TestGlobalSettings:
+    @pytest.mark.asyncio
+    async def test_defaults_and_setters(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = None
+        await storage.async_load()
+        assert storage.sun_heating_ignore is True
+        assert storage.sun_neutral_ignore is True
+        assert storage.preemptive_shading is True
+        storage.sun_heating_ignore = False
+        storage.sun_neutral_ignore = False
+        storage.preemptive_shading = False
+        assert (storage.sun_heating_ignore, storage.sun_neutral_ignore, storage.preemptive_shading) == (
+            False, False, False,
+        )
+
+    @pytest.mark.asyncio
+    async def test_import_keeps_local_settings(self, storage, mock_store) -> None:  # noqa: F811
+        mock_store.async_load.return_value = None
+        await storage.async_load()
+        storage.sun_heating_ignore = False
+        await storage.async_import_data({"covers": {}})
+        assert storage.sun_heating_ignore is False
+        await storage.async_import_data({"covers": {}, "sun_heating_ignore": True})
+        assert storage.sun_heating_ignore is True
+        exported = storage.get_raw_data()
+        assert exported["sun_heating_ignore"] is True
+
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+class TestModels:
+    @pytest.mark.parametrize("value", [None, True, False])
+    def test_roundtrip(self, value) -> None:
+        cover = _cover(sun_heating_ignore=value, sun_neutral_ignore=value, preemptive_shading=value)
+        restored = CoverConfig.from_dict(cover.to_dict())
+        assert restored.sun_heating_ignore is value
+        assert restored.sun_neutral_ignore is value
+        assert restored.preemptive_shading is value
+
+    def test_defaults_none(self) -> None:
+        cover = CoverConfig.from_dict({"entity_id": "cover.x", "name": "X"})
+        assert cover.sun_heating_ignore is None
+        assert cover.sun_neutral_ignore is None
+        assert cover.preemptive_shading is None
+
+    @pytest.mark.parametrize(
+        ("raw", "expected"),
+        [("true", True), ("off", False), (1, True), (0, False), ("garbage", None), ([], None)],
+    )
+    def test_legacy_values(self, raw, expected) -> None:
+        cover = CoverConfig.from_dict({"entity_id": "cover.x", "name": "X", "preemptive_shading": raw})
+        assert cover.preemptive_shading is expected
+
+
+# ---------------------------------------------------------------------------
+# API
+# ---------------------------------------------------------------------------
+
+def _schemas() -> dict:
+    from homeassistant.components import websocket_api as real_ws
+
+    from custom_components.cover_automatic.api import async_setup_api
+
+    schemas: dict = {}
+    with patch("custom_components.cover_automatic.api.websocket_api") as mock_ws:
+        mock_ws.BASE_COMMAND_MESSAGE_SCHEMA = real_ws.BASE_COMMAND_MESSAGE_SCHEMA
+        mock_ws.async_register_command.side_effect = (
+            lambda hass, command_type, handler=None, schema=None: schemas.__setitem__(command_type, schema)
+        )
+        async_setup_api(_make_hass(), _make_storage(), _make_coordinator())
+    return schemas
+
+
+class TestApi:
+    @pytest.mark.parametrize("value", [None, True, False])
+    def test_cover_update_schema_tristate(self, value) -> None:
+        schema = _schemas()["cover_automatic/cover/update"]
+        msg = {"id": 1, "type": "cover_automatic/cover/update", "entity_id": "cover.a",
+               "sun_heating_ignore": value, "sun_neutral_ignore": value, "preemptive_shading": value}
+        out = schema(msg)
+        assert out["sun_heating_ignore"] is value
+        assert out["preemptive_shading"] is value
+
+    def test_cover_update_schema_rejects_garbage(self) -> None:
+        schema = _schemas()["cover_automatic/cover/update"]
+        with pytest.raises(vol.Invalid):
+            schema({"id": 1, "type": "cover_automatic/cover/update", "entity_id": "cover.a",
+                    "sun_neutral_ignore": "maybe"})
+
+    def test_settings_schema_bool_only(self) -> None:
+        schema = _schemas()["cover_automatic/settings/update"]
+        out = schema({"id": 1, "type": "cover_automatic/settings/update",
+                      "sun_heating_ignore": False, "sun_neutral_ignore": True, "preemptive_shading": False})
+        assert out["sun_heating_ignore"] is False
+        with pytest.raises(vol.Invalid):
+            schema({"id": 1, "type": "cover_automatic/settings/update", "preemptive_shading": None})
+
+    @pytest.mark.asyncio
+    async def test_cover_update_stores_null(self) -> None:
+        from custom_components.cover_automatic.api import ws_cover_update
+
+        st = _make_storage()
+        raw = {"entity_id": "cover.a", "name": "A", "preemptive_shading": False}
+        st.get_cover_raw = MagicMock(return_value=raw)
+        msg = {"id": 1, "type": "cover_automatic/cover/update", "entity_id": "cover.a",
+               "preemptive_shading": None, "sun_heating_ignore": False}
+        await ws_cover_update(_make_hass(), _make_connection(), msg, st, _make_coordinator())
+        assert raw["preemptive_shading"] is None
+        assert raw["sun_heating_ignore"] is False
+
+    @pytest.mark.asyncio
+    async def test_settings_update_and_response(self) -> None:
+        from custom_components.cover_automatic.api import ws_settings_update
+
+        st = _make_storage()
+        st.async_save = AsyncMock()
+        conn = _make_connection()
+        msg = {"id": 1, "type": "cover_automatic/settings/update",
+               "sun_heating_ignore": False, "sun_neutral_ignore": False, "preemptive_shading": False}
+        await ws_settings_update(_make_hass(), conn, msg, st, _make_coordinator())
+        assert st.sun_heating_ignore is False
+        assert st.sun_neutral_ignore is False
+        assert st.preemptive_shading is False
+        settings = conn.send_result.call_args[0][1]["settings"]
+        assert settings["sun_heating_ignore"] is False
+        assert settings["preemptive_shading"] is False
diff --git a/tests/test_travel.py b/tests/test_travel.py
new file mode 100644
index 0000000..9a89b5c
--- /dev/null
+++ b/tests/test_travel.py
@@ -0,0 +1,308 @@
+"""Tests for target changes during travel (D) and cover travel time (E)."""
+# ruff: noqa: F811 -- pytest fixtures are imported from sibling test modules
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from custom_components.cover_automatic.coordinator import (
+    MAX_MEASURED_TRAVEL,
+    SETTLE_TIME,
+    TRAVEL_TIME_MARGIN,
+)
+from custom_components.cover_automatic.models import CoverConfig, CoverStatus
+from tests.test_coordinator import (  # noqa: F401 -- pytest fixtures
+    MockState,
+    coordinator,
+    mock_hass,
+    mock_storage,
+)
+from tests.test_storage import mock_store, storage  # noqa: F401
+
+MOD = "custom_components.cover_automatic.coordinator"
+
+
+def _raw(**extra):
+    raw = {"min_position_change": 1, "min_time_between_changes": 300, "inverted": False,
+           "last_position_change": None}
+    raw.update(extra)
+    return raw
+
+
+# ---------------------------------------------------------------------------
+# D: own target change during travel is not a manual override
+# ---------------------------------------------------------------------------
+
+class TestTargetChangeDuringTravel:
+    def _setup(self, coordinator, mock_storage, mock_hass, *, current, new_target, sent=100):
+        cover = CoverConfig(entity_id="cover.salon", name="Salon")
+        mock_storage.covers = {"cover.salon": cover}
+        mock_storage.get_cover_raw.return_value = _raw(last_position_change=9990.0)
+        coordinator._cover_states["cover.salon"] = CoverStatus.AUTO
+        # Previous apply cycle sent 100 % ("Incendit"), cover still travelling
+        coordinator._last_positions["cover.salon"] = sent
+        coordinator._last_sent_target["cover.salon"] = sent
+        coordinator._last_move_rule["cover.salon"] = "incendit"
+        coordinator._pending_settle.add("cover.salon")
+        coordinator._last_command_time["cover.salon"] = 1000.0
+        coordinator.data = {"covers": {"cover.salon": {
+            "status": "auto", "target_position": new_target, "matching_rule_id": "nuit"}}}
+        mock_hass.states.get.return_value = MockState("open", {"current_position": current})
+        return cover
+
+    @pytest.mark.asyncio
+    async def test_rule_change_mid_travel_recommands_instead_of_pausing(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        """The 24/09 incident: 'Incendit' disabled 35 s after its command,
+        the cover still reports 17 %; 'Nuit' (0 %) must be sent, no pause."""
+        self._setup(coordinator, mock_storage, mock_hass, current=17, new_target=0)
+        with patch(f"{MOD}.time_mod") as t, patch.object(coordinator, "pause_cover") as pause:
+            t.monotonic.return_value = 1035.0
+            await coordinator.async_apply_positions()
+        pause.assert_not_called()
+        mock_hass.services.async_call.assert_awaited_once()
+        assert mock_hass.services.async_call.await_args.args[2]["position"] == 0
+        assert coordinator._last_positions["cover.salon"] == 0
+        assert "cover.salon" in coordinator._pending_settle
+
+    @pytest.mark.asyncio
+    async def test_target_change_within_settle_time_is_sent_immediately(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        self._setup(coordinator, mock_storage, mock_hass, current=40, new_target=0)
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1010.0  # only 10 s after the command
+            await coordinator.async_apply_positions()
+        assert mock_hass.services.async_call.await_args.args[2]["position"] == 0
+
+    @pytest.mark.asyncio
+    async def test_time_hysteresis_does_not_block_own_target_change(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        """Same rule, target edited: min_time_between_changes must not delay it."""
+        self._setup(coordinator, mock_storage, mock_hass, current=40, new_target=0)
+        coordinator.data["covers"]["cover.salon"]["matching_rule_id"] = "incendit"
+        with patch(f"{MOD}.time_mod") as t, patch(f"{MOD}.dt_util") as dt:
+            t.monotonic.return_value = 1010.0
+            dt.now.return_value.timestamp.return_value = 10000.0  # 10 s after last change
+            await coordinator.async_apply_positions()
+        mock_hass.services.async_call.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_same_target_still_waits_and_still_detects_manual_moves(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        """Without a target change the existing behaviour is unchanged."""
+        self._setup(coordinator, mock_storage, mock_hass, current=17, new_target=100)
+        with patch(f"{MOD}.time_mod") as t, patch.object(coordinator, "pause_cover") as pause:
+            t.monotonic.return_value = 1010.0  # within settle time: wait
+            await coordinator.async_apply_positions()
+            pause.assert_not_called()
+            mock_hass.services.async_call.assert_not_called()
+            t.monotonic.return_value = 1100.0  # long after: real deviation -> pause
+            await coordinator.async_apply_positions()
+            pause.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_protective_move_is_not_treated_as_own_target_change(
+        self, coordinator, mock_storage, mock_hass
+    ) -> None:
+        """Vent/lock moves (not sent by the apply cycle) keep their settle wait."""
+        self._setup(coordinator, mock_storage, mock_hass, current=10, new_target=0)
+        coordinator._last_positions["cover.salon"] = 30  # vent command
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1010.0
+            await coordinator.async_apply_positions()
+        mock_hass.services.async_call.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# E: travel time (configured / measured) drives the settle time
+# ---------------------------------------------------------------------------
+
+class TestTravelTime:
+    def test_default_settle_time(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw()
+        assert coordinator._settle_time("cover.salon") == SETTLE_TIME
+
+    def test_measured_travel_extends_settle_time(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw(measured_travel_time=36.0)
+        assert coordinator._settle_time("cover.salon") == 36.0 + TRAVEL_TIME_MARGIN
+
+    def test_configured_travel_wins_over_measured(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw(travel_time=50, measured_travel_time=36.0)
+        assert coordinator._settle_time("cover.salon") == 50 + TRAVEL_TIME_MARGIN
+
+    def test_fast_cover_keeps_minimum(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw(travel_time=10)
+        assert coordinator._settle_time("cover.salon") == SETTLE_TIME
+
+    def test_measure_full_travel(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw()
+        coordinator._move_start["cover.salon"] = (1000.0, 0, 100)
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1035.5
+            coordinator._measure_travel("cover.salon", MockState("open", {"current_position": 100}))
+        mock_storage.update_cover_measured_travel.assert_called_once_with("cover.salon", 35.5)
+        assert "cover.salon" not in coordinator._move_start
+
+    def test_partial_move_is_scaled_and_smoothed(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw(measured_travel_time=40.0)
+        coordinator._move_start["cover.salon"] = (1000.0, 100, 50)  # half travel in 16 s
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1016.0
+            coordinator._measure_travel("cover.salon", MockState("open", {"current_position": 50}))
+        # 16 s * 100/50 = 32 s, averaged with 40 s
+        mock_storage.update_cover_measured_travel.assert_called_once_with("cover.salon", 36.0)
+
+    def test_intermediate_position_does_not_finish_measurement(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw()
+        coordinator._move_start["cover.salon"] = (1000.0, 0, 100)
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1009.0
+            coordinator._measure_travel("cover.salon", MockState("open", {"current_position": 17}))
+        mock_storage.update_cover_measured_travel.assert_not_called()
+        assert "cover.salon" in coordinator._move_start
+
+    def test_small_or_stale_moves_are_ignored(self, coordinator, mock_storage) -> None:
+        mock_storage.get_cover_raw.return_value = _raw()
+        coordinator._move_start["cover.a"] = (1000.0, 40, 50)  # 10 % only
+        coordinator._move_start["cover.b"] = (1000.0, 0, 100)
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 1005.0
+            coordinator._measure_travel("cover.a", MockState("open", {"current_position": 50}))
+            t.monotonic.return_value = 1000.0 + MAX_MEASURED_TRAVEL + 1
+            coordinator._measure_travel("cover.b", MockState("open", {"current_position": 100}))
+        mock_storage.update_cover_measured_travel.assert_not_called()
+        assert coordinator._move_start == {}
+
+    def test_state_change_uses_cover_settle_time(self, coordinator, mock_storage, mock_hass) -> None:
+        """A 36 s cover reporting its final travel at 34 s is not paused."""
+        cover = CoverConfig(entity_id="cover.salon", name="Salon")
+        mock_storage.covers = {"cover.salon": cover}
+        mock_storage.get_cover_raw.return_value = _raw(measured_travel_time=36.0)
+        coordinator._cover_states["cover.salon"] = CoverStatus.AUTO
+        coordinator._last_positions["cover.salon"] = 100
+        coordinator._last_command_time["cover.salon"] = 1000.0
+        with patch(f"{MOD}.time_mod") as t, patch.object(coordinator, "pause_cover") as pause:
+            t.monotonic.return_value = 1034.0
+            coordinator._handle_cover_state_change(
+                "cover.salon", MockState("open", {"current_position": 17}),
+                MockState("open", {"current_position": 60}),
+            )
+        pause.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_apply_move_starts_measurement(self, coordinator, mock_storage, mock_hass) -> None:
+        mock_storage.covers = {"cover.salon": CoverConfig(entity_id="cover.salon", name="Salon")}
+        mock_storage.get_cover_raw.return_value = _raw(min_time_between_changes=0)
+        coordinator._cover_states["cover.salon"] = CoverStatus.AUTO
+        coordinator._last_positions["cover.salon"] = 0
+        coordinator.data = {"covers": {"cover.salon": {"status": "auto", "target_position": 100}}}
+        mock_hass.states.get.return_value = MockState("closed", {"current_position": 0})
+        with patch(f"{MOD}.time_mod") as t:
+            t.monotonic.return_value = 5000.0
+            await coordinator.async_apply_positions()
+        assert coordinator._move_start["cover.salon"] == (5000.0, 0, 100)
+
+
+class TestTravelStorage:
+    def test_update_measured_travel(self, storage) -> None:
+        storage._data = {"covers": {"cover.a": {"entity_id": "cover.a", "name": "A"}}}
+        storage.update_cover_measured_travel("cover.a", 36.5)
+        assert storage._data["covers"]["cover.a"]["measured_travel_time"] == 36.5
+        assert storage.covers["cover.a"].measured_travel_time == 36.5
+
+    def test_model_roundtrip(self) -> None:
+        cover = CoverConfig(entity_id="cover.a", name="A", travel_time=40, measured_travel_time=36.5)
+        again = CoverConfig.from_dict(cover.to_dict())
+        assert again.travel_time == 40 and again.measured_travel_time == 36.5
+
+
+class TestTravelApi:
+    def _schema(self):
+        from unittest.mock import MagicMock
+
+        from homeassistant.components import websocket_api as real_ws
+
+        from custom_components.cover_automatic.api import async_setup_api
+
+        schemas: dict = {}
+        with patch("custom_components.cover_automatic.api.websocket_api") as ws:
+            ws.BASE_COMMAND_MESSAGE_SCHEMA = real_ws.BASE_COMMAND_MESSAGE_SCHEMA
+            ws.async_register_command.side_effect = (
+                lambda hass, ct, handler=None, schema=None: schemas.__setitem__(ct, schema)
+            )
+            async_setup_api(MagicMock(), MagicMock(), MagicMock())
+        return schemas["cover_automatic/cover/update"]
+
+    def test_travel_time_accepted_and_reset(self) -> None:
+        schema = self._schema()
+        base = {"id": 1, "type": "cover_automatic/cover/update", "entity_id": "cover.a"}
+        assert schema({**base, "travel_time": 40})["travel_time"] == 40
+        assert schema({**base, "travel_time": None})["travel_time"] is None
+        assert schema({**base, "measured_travel_time": None})["measured_travel_time"] is None
+
+    @pytest.mark.parametrize("payload", [{"travel_time": 0}, {"travel_time": 999}, {"measured_travel_time": 12}])
+    def test_invalid_values_rejected(self, payload) -> None:
+        import voluptuous as vol
+
+        with pytest.raises(vol.Invalid):
+            self._schema()({"id": 1, "type": "cover_automatic/cover/update", "entity_id": "cover.a", **payload})
+
+
+class TestDefaultTravelTime:
+    def test_order_manual_measured_default(self, coordinator, mock_storage) -> None:
+        mock_storage.default_travel_time = 40
+        mock_storage.get_cover_raw.return_value = _raw()
+        assert coordinator._travel_time("cover.a") == 40.0
+        assert coordinator._settle_time("cover.a") == 40 + TRAVEL_TIME_MARGIN
+        mock_storage.get_cover_raw.return_value = _raw(measured_travel_time=36.0)
+        assert coordinator._travel_time("cover.a") == 36.0
+        mock_storage.get_cover_raw.return_value = _raw(travel_time=50, measured_travel_time=36.0)
+        assert coordinator._travel_time("cover.a") == 50.0
+
+    def test_no_default_keeps_30s(self, coordinator, mock_storage) -> None:
+        mock_storage.default_travel_time = None
+        mock_storage.get_cover_raw.return_value = _raw()
+        assert coordinator._settle_time("cover.a") == SETTLE_TIME
+
+    def test_storage_property(self, storage) -> None:
+        storage._data = {}
+        assert storage.default_travel_time is None
+        storage.default_travel_time = 40
+        assert storage.default_travel_time == 40
+        storage.default_travel_time = None
+        assert storage.default_travel_time is None
+
+    def test_settings_schema(self) -> None:
+        from unittest.mock import MagicMock
+
+        import voluptuous as vol
+        from homeassistant.components import websocket_api as real_ws
+
+        from custom_components.cover_automatic.api import async_setup_api
+
+        schemas: dict = {}
+        with patch("custom_components.cover_automatic.api.websocket_api") as ws:
+            ws.BASE_COMMAND_MESSAGE_SCHEMA = real_ws.BASE_COMMAND_MESSAGE_SCHEMA
+            ws.async_register_command.side_effect = (
+                lambda hass, ct, handler=None, schema=None: schemas.__setitem__(ct, schema)
+            )
+            async_setup_api(MagicMock(), MagicMock(), MagicMock())
+        schema = schemas["cover_automatic/settings/update"]
+        base = {"id": 1, "type": "cover_automatic/settings/update"}
+        assert schema({**base, "default_travel_time": 40.0})["default_travel_time"] == 40
+        assert schema({**base, "default_travel_time": None})["default_travel_time"] is None
+        with pytest.raises(vol.Invalid):
+            schema({**base, "default_travel_time": 0})
+
+    @pytest.mark.asyncio
+    async def test_import_keeps_explicit_none_and_carries_over(self, storage) -> None:
+        storage._data = {"covers": {}, "default_travel_time": 40}
+        await storage.async_import_data({"covers": {}})
+        assert storage.default_travel_time == 40
+        await storage.async_import_data({"covers": {}, "default_travel_time": None})
+        assert storage.default_travel_time is None