Improve docstrings in condition tests (#161431)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.claude/skills/ha-integration/BINARY-SENSOR.MD

@@ -1,238 +0,0 @@
-# Binary Sensor Platform Reference
-
-Binary sensors represent on/off states.
-
-## Basic Binary Sensor
-
-```python
-"""Binary sensor platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up binary sensors from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        DoorSensor(coordinator),
-        MotionSensor(coordinator),
-    ])
-
-
-class DoorSensor(MyEntity, BinarySensorEntity):
-    """Door open/close sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.DOOR
-    _attr_translation_key = "door"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_door"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if door is open."""
-        return self.coordinator.data.door_open
-```
-
-## Device Classes
-
-Common binary sensor device classes:
-
-| Device Class | On Means | Off Means |
-|--------------|----------|-----------|
-| `BATTERY` | Low | Normal |
-| `BATTERY_CHARGING` | Charging | Not charging |
-| `CONNECTIVITY` | Connected | Disconnected |
-| `DOOR` | Open | Closed |
-| `GARAGE_DOOR` | Open | Closed |
-| `LOCK` | Unlocked | Locked |
-| `MOISTURE` | Wet | Dry |
-| `MOTION` | Motion detected | Clear |
-| `OCCUPANCY` | Occupied | Clear |
-| `OPENING` | Open | Closed |
-| `PLUG` | Plugged in | Unplugged |
-| `POWER` | Power detected | No power |
-| `PRESENCE` | Present | Away |
-| `PROBLEM` | Problem | OK |
-| `RUNNING` | Running | Not running |
-| `SAFETY` | Unsafe | Safe |
-| `SMOKE` | Smoke detected | Clear |
-| `SOUND` | Sound detected | Clear |
-| `TAMPER` | Tampering | Clear |
-| `UPDATE` | Update available | Up-to-date |
-| `VIBRATION` | Vibration | Clear |
-| `WINDOW` | Open | Closed |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntityDescription,
-)
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Describe My binary sensor entity."""
-
-    is_on_fn: Callable[[MyData], bool | None]
-
-
-BINARY_SENSORS: tuple[MyBinarySensorEntityDescription, ...] = (
-    MyBinarySensorEntityDescription(
-        key="door",
-        translation_key="door",
-        device_class=BinarySensorDeviceClass.DOOR,
-        is_on_fn=lambda data: data.door_open,
-    ),
-    MyBinarySensorEntityDescription(
-        key="motion",
-        translation_key="motion",
-        device_class=BinarySensorDeviceClass.MOTION,
-        is_on_fn=lambda data: data.motion_detected,
-    ),
-    MyBinarySensorEntityDescription(
-        key="low_battery",
-        translation_key="low_battery",
-        device_class=BinarySensorDeviceClass.BATTERY,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda data: data.battery_level < 20 if data.battery_level else None,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up binary sensors from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MyBinarySensor(coordinator, description)
-        for description in BINARY_SENSORS
-    )
-
-
-class MyBinarySensor(MyEntity, BinarySensorEntity):
-    """Binary sensor using entity description."""
-
-    entity_description: MyBinarySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyBinarySensorEntityDescription,
-    ) -> None:
-        """Initialize the binary sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if the binary sensor is on."""
-        return self.entity_description.is_on_fn(self.coordinator.data)
-```
-
-## Connectivity Sensor
-
-```python
-class ConnectivitySensor(MyEntity, BinarySensorEntity):
-    """Device connectivity sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.CONNECTIVITY
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "connectivity"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if device is connected."""
-        return self.coordinator.data.is_connected
-```
-
-## Problem Sensor
-
-```python
-class ProblemSensor(MyEntity, BinarySensorEntity):
-    """Problem indicator sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.PROBLEM
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "problem"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if there's a problem."""
-        return self.coordinator.data.has_error
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return extra state attributes."""
-        return {
-            "error_code": self.coordinator.data.error_code,
-            "error_message": self.coordinator.data.error_message,
-        }
-```
-
-## Update Available Sensor
-
-```python
-class UpdateAvailableSensor(MyEntity, BinarySensorEntity):
-    """Firmware update available sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.UPDATE
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "update_available"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if an update is available."""
-        return self.coordinator.data.update_available
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "binary_sensor": {
-      "door": {
-        "name": "Door"
-      },
-      "motion": {
-        "name": "Motion"
-      },
-      "low_battery": {
-        "name": "Low battery"
-      },
-      "connectivity": {
-        "name": "Connectivity"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/BUTTON.MD

@@ -1,201 +0,0 @@
-# Button Platform Reference
-
-Button entities trigger actions when pressed.
-
-## Basic Button
-
-```python
-"""Button platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.button import ButtonDeviceClass, ButtonEntity
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up buttons from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        RestartButton(coordinator),
-        IdentifyButton(coordinator),
-    ])
-
-
-class RestartButton(MyEntity, ButtonEntity):
-    """Restart button."""
-
-    _attr_device_class = ButtonDeviceClass.RESTART
-    _attr_translation_key = "restart"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the button."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_restart"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        await self.coordinator.client.restart()
-```
-
-## Device Classes
-
-| Device Class | Icon | Use Case |
-|--------------|------|----------|
-| `IDENTIFY` | mdi:crosshairs-question | Flash light/beep to locate device |
-| `RESTART` | mdi:restart | Restart the device |
-| `UPDATE` | mdi:package-up | Trigger firmware update |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.button import ButtonDeviceClass, ButtonEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyButtonEntityDescription(ButtonEntityDescription):
-    """Describe My button entity."""
-
-    press_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-
-
-BUTTONS: tuple[MyButtonEntityDescription, ...] = (
-    MyButtonEntityDescription(
-        key="restart",
-        translation_key="restart",
-        device_class=ButtonDeviceClass.RESTART,
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.restart(),
-    ),
-    MyButtonEntityDescription(
-        key="identify",
-        translation_key="identify",
-        device_class=ButtonDeviceClass.IDENTIFY,
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.identify(),
-    ),
-    MyButtonEntityDescription(
-        key="factory_reset",
-        translation_key="factory_reset",
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.factory_reset(),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up buttons from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MyButton(coordinator, description)
-        for description in BUTTONS
-    )
-
-
-class MyButton(MyEntity, ButtonEntity):
-    """Button using entity description."""
-
-    entity_description: MyButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyButtonEntityDescription,
-    ) -> None:
-        """Initialize the button."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        await self.entity_description.press_fn(self.coordinator.client)
-```
-
-## Identify Button
-
-```python
-class IdentifyButton(MyEntity, ButtonEntity):
-    """Identify button to locate the device."""
-
-    _attr_device_class = ButtonDeviceClass.IDENTIFY
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_translation_key = "identify"
-
-    async def async_press(self) -> None:
-        """Flash the device LED to identify it."""
-        await self.coordinator.client.identify()
-```
-
-## Error Handling
-
-```python
-from homeassistant.exceptions import HomeAssistantError
-
-
-class SafeButton(MyEntity, ButtonEntity):
-    """Button with error handling."""
-
-    async def async_press(self) -> None:
-        """Handle the button press with error handling."""
-        try:
-            await self.coordinator.client.perform_action()
-        except MyDeviceError as err:
-            raise HomeAssistantError(f"Failed to perform action: {err}") from err
-```
-
-## Confirmation Buttons
-
-For dangerous operations, consider using a diagnostic category and clear naming:
-
-```python
-class FactoryResetButton(MyEntity, ButtonEntity):
-    """Factory reset button."""
-
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "factory_reset"
-    _attr_entity_registry_enabled_default = False  # Disabled by default
-
-    async def async_press(self) -> None:
-        """Perform factory reset."""
-        await self.coordinator.client.factory_reset()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "button": {
-      "restart": {
-        "name": "Restart"
-      },
-      "identify": {
-        "name": "Identify"
-      },
-      "factory_reset": {
-        "name": "Factory reset"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/CONFIG-FLOW.MD

@@ -1,254 +0,0 @@
-# Config Flow Reference
-
-Configuration flows allow users to set up integrations via the UI.
-
-## Basic Config Flow
-
-```python
-"""Config flow for My Integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_API_KEY
-from homeassistant.helpers.selector import TextSelector
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): TextSelector(),
-        vol.Required(CONF_API_KEY): TextSelector(),
-    }
-)
-
-
-class MyIntegrationConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for My Integration."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            try:
-                # Test connection
-                client = MyClient(user_input[CONF_HOST], user_input[CONF_API_KEY])
-                info = await client.get_device_info()
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                # Set unique ID and abort if already configured
-                await self.async_set_unique_id(info.serial_number)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title=info.name,
-                    data=user_input,
-                )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
-            errors=errors,
-        )
-```
-
-## Version Control
-
-Always set version numbers:
-
-```python
-VERSION = 1        # Bump for breaking changes requiring migration
-MINOR_VERSION = 1  # Bump for backward-compatible changes
-```
-
-## Unique ID Management
-
-```python
-# Set unique ID and abort if exists
-await self.async_set_unique_id(device_serial)
-self._abort_if_unique_id_configured()
-
-# Or abort if data matches (when no unique ID available)
-self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
-```
-
-## Reauthentication Flow
-
-```python
-async def async_step_reauth(
-    self, entry_data: Mapping[str, Any]
-) -> ConfigFlowResult:
-    """Handle reauthentication."""
-    return await self.async_step_reauth_confirm()
-
-async def async_step_reauth_confirm(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Handle reauthentication confirmation."""
-    errors: dict[str, str] = {}
-
-    if user_input is not None:
-        try:
-            client = MyClient(
-                self._get_reauth_entry().data[CONF_HOST],
-                user_input[CONF_API_KEY]
-            )
-            info = await client.get_device_info()
-        except InvalidAuth:
-            errors["base"] = "invalid_auth"
-        except Exception:
-            errors["base"] = "unknown"
-        else:
-            await self.async_set_unique_id(info.serial_number)
-            self._abort_if_unique_id_mismatch(reason="wrong_account")
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(),
-                data_updates={CONF_API_KEY: user_input[CONF_API_KEY]},
-            )
-
-    return self.async_show_form(
-        step_id="reauth_confirm",
-        data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
-        errors=errors,
-    )
-```
-
-## Reconfiguration Flow
-
-```python
-async def async_step_reconfigure(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Handle reconfiguration."""
-    errors: dict[str, str] = {}
-    reconfigure_entry = self._get_reconfigure_entry()
-
-    if user_input is not None:
-        try:
-            client = MyClient(user_input[CONF_HOST], reconfigure_entry.data[CONF_API_KEY])
-            info = await client.get_device_info()
-        except CannotConnect:
-            errors["base"] = "cannot_connect"
-        else:
-            await self.async_set_unique_id(info.serial_number)
-            self._abort_if_unique_id_mismatch(reason="wrong_device")
-            return self.async_update_reload_and_abort(
-                reconfigure_entry,
-                data_updates={CONF_HOST: user_input[CONF_HOST]},
-            )
-
-    return self.async_show_form(
-        step_id="reconfigure",
-        data_schema=vol.Schema({
-            vol.Required(CONF_HOST, default=reconfigure_entry.data[CONF_HOST]): str
-        }),
-        errors=errors,
-    )
-```
-
-## Discovery Flows
-
-### Zeroconf Discovery
-
-```python
-async def async_step_zeroconf(
-    self, discovery_info: ZeroconfServiceInfo
-) -> ConfigFlowResult:
-    """Handle zeroconf discovery."""
-    serial = discovery_info.properties.get("serialno")
-    if not serial:
-        return self.async_abort(reason="no_serial")
-
-    await self.async_set_unique_id(serial)
-    self._abort_if_unique_id_configured(
-        updates={CONF_HOST: str(discovery_info.host)}
-    )
-
-    self._discovered_host = str(discovery_info.host)
-    self._discovered_name = discovery_info.name.removesuffix("._mydevice._tcp.local.")
-
-    return await self.async_step_discovery_confirm()
-
-async def async_step_discovery_confirm(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Confirm discovery."""
-    if user_input is not None:
-        return self.async_create_entry(
-            title=self._discovered_name,
-            data={CONF_HOST: self._discovered_host},
-        )
-
-    self._set_confirm_only()
-    return self.async_show_form(
-        step_id="discovery_confirm",
-        description_placeholders={"name": self._discovered_name},
-    )
-```
-
-## strings.json for Config Flow
-
-```json
-{
-  "config": {
-    "step": {
-      "user": {
-        "title": "Connect to device",
-        "description": "Enter your device credentials.",
-        "data": {
-          "host": "Host",
-          "api_key": "API key"
-        }
-      },
-      "reauth_confirm": {
-        "title": "Reauthenticate",
-        "description": "Please enter a new API key for {name}.",
-        "data": {
-          "api_key": "API key"
-        }
-      },
-      "discovery_confirm": {
-        "title": "Discovered device",
-        "description": "Do you want to set up {name}?"
-      }
-    },
-    "error": {
-      "cannot_connect": "Failed to connect",
-      "invalid_auth": "Invalid authentication",
-      "unknown": "Unexpected error"
-    },
-    "abort": {
-      "already_configured": "Device is already configured",
-      "wrong_account": "Wrong account",
-      "wrong_device": "Wrong device"
-    }
-  }
-}
-```
-
-## Key Rules
-
-1. **Never allow user-configurable entry names** (except helper integrations)
-2. **Always test connection** before creating entry
-3. **Always set unique ID** when possible
-4. **Handle all exceptions** - bare `except Exception:` is allowed in config flows
-5. **100% test coverage required** for all flow paths

.claude/skills/ha-integration/COORDINATOR.MD

@@ -1,239 +0,0 @@
-# Data Update Coordinator Reference
-
-The coordinator pattern centralizes data fetching and provides efficient polling.
-
-## Basic Coordinator
-
-```python
-"""DataUpdateCoordinator for My Integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-from typing import TYPE_CHECKING
-
-from my_library import MyClient, MyData, MyError, AuthError
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-
-if TYPE_CHECKING:
-    from . import MyIntegrationConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    """My integration data update coordinator."""
-
-    config_entry: MyIntegrationConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: MyIntegrationConfigEntry,
-        client: MyClient,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=timedelta(minutes=1),
-            config_entry=entry,
-        )
-        self.client = client
-
-    async def _async_update_data(self) -> MyData:
-        """Fetch data from API."""
-        try:
-            return await self.client.get_data()
-        except AuthError as err:
-            raise ConfigEntryAuthFailed("Invalid credentials") from err
-        except MyError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
-```
-
-## Key Points
-
-### Always Pass config_entry
-
-```python
-super().__init__(
-    hass,
-    logger=_LOGGER,
-    name=DOMAIN,
-    update_interval=timedelta(minutes=1),
-    config_entry=entry,  # Always include this
-)
-```
-
-### Generic Type Parameter
-
-Specify the data type returned by `_async_update_data`:
-
-```python
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    ...
-```
-
-### Error Types
-
-- **`UpdateFailed`**: API communication errors (will retry)
-- **`ConfigEntryAuthFailed`**: Authentication issues (triggers reauth flow)
-
-## Polling Intervals
-
-**Integration determines intervals** - never make them user-configurable.
-
-```python
-# Constants (in const.py)
-SCAN_INTERVAL_LOCAL = timedelta(seconds=30)
-SCAN_INTERVAL_CLOUD = timedelta(minutes=5)
-
-# In coordinator
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    def __init__(self, hass: HomeAssistant, entry: MyIntegrationConfigEntry, client: MyClient) -> None:
-        # Determine interval based on connection type
-        interval = SCAN_INTERVAL_LOCAL if client.is_local else SCAN_INTERVAL_CLOUD
-
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=interval,
-            config_entry=entry,
-        )
-```
-
-**Minimum intervals:**
-- Local network: 5 seconds
-- Cloud services: 60 seconds
-
-## Coordinator with Device Info
-
-```python
-from homeassistant.helpers.device_registry import DeviceInfo
-
-from .const import DOMAIN
-
-
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    """Coordinator with device information."""
-
-    config_entry: MyIntegrationConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: MyIntegrationConfigEntry,
-        client: MyClient,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=timedelta(minutes=1),
-            config_entry=entry,
-        )
-        self.client = client
-        self.device_info = DeviceInfo(
-            identifiers={(DOMAIN, client.serial_number)},
-            name=client.name,
-            manufacturer="My Company",
-            model=client.model,
-            sw_version=client.firmware_version,
-        )
-
-    async def _async_update_data(self) -> MyData:
-        """Fetch data from API."""
-        try:
-            return await self.client.get_data()
-        except MyError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
-```
-
-## Multiple Data Sources
-
-```python
-from dataclasses import dataclass
-
-
-@dataclass
-class MyCoordinatorData:
-    """Data class for coordinator."""
-
-    sensors: dict[str, SensorData]
-    status: DeviceStatus
-    settings: DeviceSettings
-
-
-class MyCoordinator(DataUpdateCoordinator[MyCoordinatorData]):
-    """Coordinator for multiple data sources."""
-
-    async def _async_update_data(self) -> MyCoordinatorData:
-        """Fetch all data sources."""
-        try:
-            # Fetch all data concurrently
-            sensors, status, settings = await asyncio.gather(
-                self.client.get_sensors(),
-                self.client.get_status(),
-                self.client.get_settings(),
-            )
-        except MyError as err:
-            raise UpdateFailed(f"Error fetching data: {err}") from err
-
-        return MyCoordinatorData(
-            sensors=sensors,
-            status=status,
-            settings=settings,
-        )
-```
-
-## Setup in __init__.py
-
-```python
-async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
-    """Set up My Integration from a config entry."""
-    client = MyClient(entry.data[CONF_HOST], entry.data[CONF_API_KEY])
-
-    coordinator = MyCoordinator(hass, entry, client)
-
-    # Perform first refresh - raises ConfigEntryNotReady on failure
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-```
-
-## Testing Coordinators
-
-```python
-@pytest.fixture
-def mock_coordinator(hass: HomeAssistant, mock_config_entry: MockConfigEntry) -> MyCoordinator:
-    """Return a mocked coordinator."""
-    coordinator = MyCoordinator(hass, mock_config_entry, MagicMock())
-    coordinator.data = MyData(temperature=21.5, humidity=45)
-    return coordinator
-
-
-async def test_coordinator_update_failed(
-    hass: HomeAssistant,
-    mock_client: MagicMock,
-) -> None:
-    """Test coordinator handles update failure."""
-    mock_client.get_data.side_effect = MyError("Connection failed")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(UpdateFailed):
-        await coordinator._async_update_data()
-```

.claude/skills/ha-integration/DEVICE.MD

@@ -1,248 +0,0 @@
-# Device Management Reference
-
-Device management groups entities and provides device information.
-
-## Device Info
-
-```python
-from homeassistant.helpers.device_registry import DeviceInfo
-
-from .const import DOMAIN
-
-
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Base entity with device info."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, coordinator.client.serial_number)},
-            name=coordinator.client.name,
-            manufacturer="My Company",
-            model=coordinator.client.model,
-            sw_version=coordinator.client.firmware_version,
-            hw_version=coordinator.client.hardware_version,
-        )
-```
-
-## DeviceInfo Fields
-
-| Field | Description | Example |
-|-------|-------------|---------|
-| `identifiers` | Set of (domain, id) tuples | `{(DOMAIN, "ABC123")}` |
-| `connections` | Set of (type, id) tuples | `{(CONNECTION_NETWORK_MAC, mac)}` |
-| `name` | Device name | `"Living Room Thermostat"` |
-| `manufacturer` | Manufacturer name | `"My Company"` |
-| `model` | Model name | `"Smart Thermostat v2"` |
-| `model_id` | Model identifier | `"THM-2000"` |
-| `sw_version` | Software/firmware version | `"1.2.3"` |
-| `hw_version` | Hardware version | `"rev2"` |
-| `serial_number` | Serial number | `"ABC123456"` |
-| `configuration_url` | Device config URL | `"http://192.168.1.100"` |
-| `suggested_area` | Suggested room/area | `"Living Room"` |
-| `entry_type` | Device entry type | `DeviceEntryType.SERVICE` |
-| `via_device` | Parent device identifiers | `(DOMAIN, "hub_id")` |
-
-## Device with Connections
-
-Use connections (like MAC address) for better device merging:
-
-```python
-from homeassistant.helpers.device_registry import (
-    CONNECTION_NETWORK_MAC,
-    DeviceInfo,
-    format_mac,
-)
-
-
-def __init__(self, coordinator: MyCoordinator) -> None:
-    """Initialize the entity."""
-    super().__init__(coordinator)
-    self._attr_device_info = DeviceInfo(
-        connections={(CONNECTION_NETWORK_MAC, format_mac(coordinator.client.mac))},
-        identifiers={(DOMAIN, coordinator.client.serial_number)},
-        name=coordinator.client.name,
-        manufacturer="My Company",
-        model=coordinator.client.model,
-    )
-```
-
-## Hub and Child Devices
-
-```python
-# Hub device
-class HubEntity(CoordinatorEntity[MyCoordinator]):
-    """Hub entity."""
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the hub entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, coordinator.hub_id)},
-            name="My Hub",
-            manufacturer="My Company",
-            model="Hub Pro",
-        )
-
-
-# Child device connected via hub
-class ChildEntity(CoordinatorEntity[MyCoordinator]):
-    """Child device entity."""
-
-    def __init__(self, coordinator: MyCoordinator, device: ChildDevice) -> None:
-        """Initialize the child entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.id)},
-            name=device.name,
-            manufacturer="My Company",
-            model=device.model,
-            via_device=(DOMAIN, coordinator.hub_id),  # Links to parent hub
-        )
-```
-
-## Service Entry Type
-
-For cloud services without physical devices:
-
-```python
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-
-
-self._attr_device_info = DeviceInfo(
-    identifiers={(DOMAIN, entry.entry_id)},
-    name="My Cloud Service",
-    manufacturer="My Company",
-    entry_type=DeviceEntryType.SERVICE,
-)
-```
-
-## Dynamic Device Addition
-
-Auto-detect new devices after initial setup:
-
-```python
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
-
-    @callback
-    def _check_devices() -> None:
-        """Check for new devices."""
-        current_devices = set(coordinator.data.devices.keys())
-        new_devices = current_devices - known_devices
-
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                MySensor(coordinator, device_id)
-                for device_id in new_devices
-            )
-
-    # Initial setup
-    _check_devices()
-
-    # Listen for updates
-    entry.async_on_unload(coordinator.async_add_listener(_check_devices))
-```
-
-## Stale Device Removal
-
-Remove devices when they disappear:
-
-```python
-async def _async_update_data(self) -> MyData:
-    """Fetch data and handle device removal."""
-    data = await self.client.get_data()
-
-    # Check for removed devices
-    device_registry = dr.async_get(self.hass)
-    current_device_ids = set(data.devices.keys())
-
-    for device_entry in dr.async_entries_for_config_entry(
-        device_registry, self.config_entry.entry_id
-    ):
-        # Get device ID from identifiers
-        device_id = next(
-            (id for domain, id in device_entry.identifiers if domain == DOMAIN),
-            None,
-        )
-
-        if device_id and device_id not in current_device_ids:
-            # Device no longer exists, remove it
-            device_registry.async_update_device(
-                device_entry.id,
-                remove_config_entry_id=self.config_entry.entry_id,
-            )
-
-    return data
-```
-
-## Manual Device Removal
-
-Allow users to manually remove devices:
-
-```python
-# In __init__.py
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant, config_entry: MyIntegrationConfigEntry, device_entry: dr.DeviceEntry
-) -> bool:
-    """Remove a config entry from a device."""
-    # Get device ID from identifiers
-    device_id = next(
-        (id for domain, id in device_entry.identifiers if domain == DOMAIN),
-        None,
-    )
-
-    if device_id is None:
-        return False
-
-    # Check if device is still present (don't allow removal of active devices)
-    coordinator = config_entry.runtime_data
-    if device_id in coordinator.data.devices:
-        return False  # Device still exists, can't remove
-
-    return True  # Allow removal of stale device
-```
-
-## Device Registry Access
-
-```python
-from homeassistant.helpers import device_registry as dr
-
-
-# Get device registry
-device_registry = dr.async_get(hass)
-
-# Get device by identifiers
-device = device_registry.async_get_device(
-    identifiers={(DOMAIN, device_id)}
-)
-
-# Get all devices for config entry
-devices = dr.async_entries_for_config_entry(
-    device_registry, entry.entry_id
-)
-
-# Update device
-device_registry.async_update_device(
-    device.id,
-    sw_version="2.0.0",
-)
-```
-
-## Quality Scale Requirements
-
-- **Bronze**: No specific device requirements
-- **Gold**: Devices rule - group entities under devices
-- **Gold**: Stale device removal - auto-remove disconnected devices
-- **Gold**: Dynamic device addition - detect new devices at runtime

.claude/skills/ha-integration/DIAGNOSTICS.MD

@@ -1,278 +0,0 @@
-# Diagnostics Reference
-
-Diagnostics provide debug information for troubleshooting integrations.
-
-## Basic Diagnostics
-
-```python
-"""Diagnostics support for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_TOKEN
-from homeassistant.core import HomeAssistant
-
-from . import MyIntegrationConfigEntry
-
-TO_REDACT = {
-    CONF_API_KEY,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    "serial_number",
-    "mac_address",
-    "latitude",
-    "longitude",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    return {
-        "entry_data": async_redact_data(dict(entry.data), TO_REDACT),
-        "entry_options": async_redact_data(dict(entry.options), TO_REDACT),
-        "coordinator_data": async_redact_data(
-            coordinator.data.to_dict(), TO_REDACT
-        ),
-    }
-```
-
-## What to Include
-
-**Do include:**
-- Configuration data (redacted)
-- Current coordinator data
-- Device information
-- Error states and counts
-- Connection status
-- Firmware versions
-- Feature flags
-
-**Never include (always redact):**
-- API keys, tokens, passwords
-- Geographic coordinates (latitude/longitude)
-- Personal identifiable information
-- Email addresses
-- MAC addresses (unless needed for debugging)
-- Serial numbers (unless needed for debugging)
-
-## Comprehensive Diagnostics
-
-```python
-"""Diagnostics support for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import (
-    CONF_API_KEY,
-    CONF_LATITUDE,
-    CONF_LONGITUDE,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-
-from . import MyIntegrationConfigEntry
-from .const import DOMAIN
-
-TO_REDACT = {
-    CONF_API_KEY,
-    CONF_LATITUDE,
-    CONF_LONGITUDE,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    CONF_USERNAME,
-    "serial",
-    "serial_number",
-    "mac",
-    "mac_address",
-    "email",
-    "access_token",
-    "refresh_token",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    # Get device registry entries
-    device_registry = dr.async_get(hass)
-    entity_registry = er.async_get(hass)
-
-    devices = []
-    for device in dr.async_entries_for_config_entry(device_registry, entry.entry_id):
-        entities = []
-        for entity in er.async_entries_for_device(
-            entity_registry, device.id, include_disabled_entities=True
-        ):
-            entities.append({
-                "entity_id": entity.entity_id,
-                "unique_id": entity.unique_id,
-                "platform": entity.platform,
-                "disabled": entity.disabled,
-                "disabled_by": entity.disabled_by,
-            })
-
-        devices.append({
-            "name": device.name,
-            "model": device.model,
-            "manufacturer": device.manufacturer,
-            "sw_version": device.sw_version,
-            "hw_version": device.hw_version,
-            "identifiers": list(device.identifiers),
-            "connections": list(device.connections),
-            "entities": entities,
-        })
-
-    return {
-        "entry": {
-            "version": entry.version,
-            "minor_version": entry.minor_version,
-            "data": async_redact_data(dict(entry.data), TO_REDACT),
-            "options": async_redact_data(dict(entry.options), TO_REDACT),
-        },
-        "coordinator": {
-            "last_update_success": coordinator.last_update_success,
-            "last_exception": str(coordinator.last_exception) if coordinator.last_exception else None,
-            "data": async_redact_data(coordinator.data.to_dict(), TO_REDACT),
-        },
-        "devices": devices,
-    }
-```
-
-## Device-Level Diagnostics
-
-For integrations with multiple devices, you can also provide device-level diagnostics:
-
-```python
-async def async_get_device_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry, device: dr.DeviceEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a device."""
-    coordinator = entry.runtime_data
-
-    # Find device data based on device identifiers
-    device_id = next(
-        (id for domain, id in device.identifiers if domain == DOMAIN), None
-    )
-
-    if device_id is None:
-        return {"error": "Device not found"}
-
-    device_data = coordinator.data.devices.get(device_id)
-    if device_data is None:
-        return {"error": "Device data not found"}
-
-    return {
-        "device_info": {
-            "name": device.name,
-            "model": device.model,
-            "sw_version": device.sw_version,
-        },
-        "device_data": async_redact_data(device_data.to_dict(), TO_REDACT),
-    }
-```
-
-## Redaction Patterns
-
-### Simple Redaction
-
-```python
-from homeassistant.components.diagnostics import async_redact_data
-
-data = {"api_key": "secret123", "temperature": 21.5}
-redacted = async_redact_data(data, {"api_key"})
-# Result: {"api_key": "**REDACTED**", "temperature": 21.5}
-```
-
-### Nested Redaction
-
-`async_redact_data` handles nested dictionaries automatically:
-
-```python
-data = {
-    "config": {
-        "host": "192.168.1.1",
-        "api_key": "secret123",
-    },
-    "device": {
-        "name": "My Device",
-        "serial_number": "ABC123",
-    }
-}
-redacted = async_redact_data(data, {"api_key", "serial_number"})
-# Result: {"config": {"host": "192.168.1.1", "api_key": "**REDACTED**"},
-#          "device": {"name": "My Device", "serial_number": "**REDACTED**"}}
-```
-
-### Custom Redaction
-
-For complex redaction needs:
-
-```python
-def _redact_data(data: dict[str, Any]) -> dict[str, Any]:
-    """Redact sensitive data."""
-    result = dict(data)
-
-    # Redact specific keys
-    for key in ("api_key", "token", "password"):
-        if key in result:
-            result[key] = "**REDACTED**"
-
-    # Redact partial data (e.g., keep last 4 chars)
-    if "serial" in result:
-        result["serial"] = f"****{result['serial'][-4:]}"
-
-    # Redact coordinates to city level
-    if "latitude" in result:
-        result["latitude"] = round(result["latitude"], 1)
-    if "longitude" in result:
-        result["longitude"] = round(result["longitude"], 1)
-
-    return result
-```
-
-## Testing Diagnostics
-
-```python
-from homeassistant.components.diagnostics import REDACTED
-
-from custom_components.my_integration.diagnostics import (
-    async_get_config_entry_diagnostics,
-)
-
-
-async def test_diagnostics(
-    hass: HomeAssistant,
-    init_integration: MockConfigEntry,
-) -> None:
-    """Test diagnostics."""
-    diagnostics = await async_get_config_entry_diagnostics(hass, init_integration)
-
-    assert diagnostics["entry"]["data"]["host"] == "192.168.1.1"
-    assert diagnostics["entry"]["data"]["api_key"] == REDACTED
-    assert "temperature" in diagnostics["coordinator"]["data"]
-```
-
-## Quality Scale Requirement
-
-Diagnostics are required for **Gold** quality scale and above. Ensure your `quality_scale.yaml` includes:
-
-```yaml
-rules:
-  diagnostics: done
-```

.claude/skills/ha-integration/ENTITY.MD

@@ -1,286 +0,0 @@
-# Entity Development Reference
-
-Base patterns for entity development in Home Assistant.
-
-## Base Entity Class
-
-Create a shared base class to reduce duplication:
-
-```python
-"""Base entity for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import MyCoordinator
-
-
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Base entity for My Integration."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-```
-
-## Unique IDs
-
-Every entity must have a unique ID:
-
-```python
-class MySensor(MyEntity, SensorEntity):
-    """Sensor entity."""
-
-    def __init__(self, coordinator: MyCoordinator, sensor_type: str) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        # Unique per platform, don't include domain or platform name
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{sensor_type}"
-```
-
-**Acceptable unique ID sources:**
-- Device serial numbers
-- MAC addresses (use `format_mac` from device registry)
-- Physical identifiers
-
-**Never use:**
-- IP addresses, hostnames, URLs
-- Device names
-- Email addresses, usernames
-
-## Entity Naming
-
-```python
-class MySensor(MyEntity, SensorEntity):
-    """Sensor with proper naming."""
-
-    _attr_has_entity_name = True
-    _attr_translation_key = "temperature"  # Translatable name
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        # For the main/primary entity of a device, use None
-        # self._attr_name = None
-
-        # For secondary entities, set the name
-        self._attr_name = "Temperature"  # Or use translation_key
-```
-
-## Entity Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "temperature": {
-        "name": "Temperature"
-      },
-      "humidity": {
-        "name": "Humidity"
-      },
-      "battery": {
-        "name": "Battery",
-        "state": {
-          "charging": "Charging",
-          "discharging": "Discharging"
-        }
-      }
-    }
-  }
-}
-```
-
-## Entity Availability
-
-### Coordinator Pattern
-
-```python
-@property
-def available(self) -> bool:
-    """Return if entity is available."""
-    return super().available and self._sensor_key in self.coordinator.data.sensors
-```
-
-### Direct Update Pattern
-
-```python
-async def async_update(self) -> None:
-    """Update entity state."""
-    try:
-        data = await self.client.get_data()
-    except MyException:
-        self._attr_available = False
-        return
-
-    self._attr_available = True
-    self._attr_native_value = data.value
-```
-
-## Entity Categories
-
-```python
-from homeassistant.const import EntityCategory
-
-
-class DiagnosticSensor(MyEntity, SensorEntity):
-    """Diagnostic sensor (hidden by default in UI)."""
-
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-
-
-class ConfigSwitch(MyEntity, SwitchEntity):
-    """Configuration switch."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-```
-
-## Disabled by Default
-
-For noisy or less popular entities:
-
-```python
-class SignalStrengthSensor(MyEntity, SensorEntity):
-    """Signal strength sensor - disabled by default."""
-
-    _attr_entity_registry_enabled_default = False
-```
-
-## Event Lifecycle
-
-```python
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Entity with event subscriptions."""
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to events when added."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self.coordinator.client.events.subscribe(
-                "state_changed",
-                self._handle_state_change,
-            )
-        )
-
-    @callback
-    def _handle_state_change(self, event: Event) -> None:
-        """Handle state change event."""
-        self._attr_native_value = event.value
-        self.async_write_ha_state()
-```
-
-**Key rules:**
-- Subscribe in `async_added_to_hass`
-- Use `async_on_remove` for automatic cleanup
-- Never subscribe in `__init__`
-
-## State Handling
-
-```python
-@property
-def native_value(self) -> StateType:
-    """Return the state."""
-    value = self.coordinator.data.get(self._key)
-    # Use None for unknown values, never "unknown" or "unavailable" strings
-    if value is None:
-        return None
-    return value
-```
-
-## Extra State Attributes
-
-```python
-@property
-def extra_state_attributes(self) -> dict[str, Any]:
-    """Return extra state attributes."""
-    data = self.coordinator.data
-    # All keys must always be present, use None for unknown
-    return {
-        "last_updated": data.last_updated,
-        "error_count": data.error_count,
-        "firmware": data.firmware or None,  # Never omit keys
-    }
-```
-
-## Entity Descriptions Pattern
-
-For multiple similar entities:
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-
-from homeassistant.components.sensor import SensorEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySensorEntityDescription(SensorEntityDescription):
-    """Describe My sensor entity."""
-
-    value_fn: Callable[[MyData], StateType]
-
-
-SENSOR_DESCRIPTIONS: tuple[MySensorEntityDescription, ...] = (
-    MySensorEntityDescription(
-        key="temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        device_class=SensorDeviceClass.TEMPERATURE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.temperature,
-    ),
-    MySensorEntityDescription(
-        key="humidity",
-        translation_key="humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.humidity,
-    ),
-)
-
-
-class MySensor(MyEntity, SensorEntity):
-    """Sensor using entity description."""
-
-    entity_description: MySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-```
-
-## Multiline Lambdas
-
-When lambdas are too long:
-
-```python
-# Good pattern - parentheses on same line as lambda
-MySensorEntityDescription(
-    key="temperature",
-    value_fn=lambda data: (
-        round(data["temp_value"] * 1.8 + 32, 1)
-        if data.get("temp_value") is not None
-        else None
-    ),
-)
-```

.claude/skills/ha-integration/NUMBER.MD

@@ -1,229 +0,0 @@
-# Number Platform Reference
-
-Number entities represent numeric values that can be set.
-
-## Basic Number
-
-```python
-"""Number platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.number import NumberEntity, NumberMode
-from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up numbers from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        TargetTemperatureNumber(coordinator),
-    ])
-
-
-class TargetTemperatureNumber(MyEntity, NumberEntity):
-    """Target temperature number entity."""
-
-    _attr_native_min_value = 16
-    _attr_native_max_value = 30
-    _attr_native_step = 0.5
-    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
-    _attr_mode = NumberMode.SLIDER
-    _attr_translation_key = "target_temperature"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the number entity."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_target_temp"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the current value."""
-        return self.coordinator.data.target_temperature
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the target temperature."""
-        await self.coordinator.client.set_target_temperature(value)
-        await self.coordinator.async_request_refresh()
-```
-
-## Number Modes
-
-```python
-from homeassistant.components.number import NumberMode
-
-# Slider display in UI
-_attr_mode = NumberMode.SLIDER
-
-# Input box display in UI
-_attr_mode = NumberMode.BOX
-
-# Auto (slider if range <= 256, else box)
-_attr_mode = NumberMode.AUTO
-```
-
-## Device Classes
-
-```python
-from homeassistant.components.number import NumberDeviceClass
-
-# For temperature settings
-_attr_device_class = NumberDeviceClass.TEMPERATURE
-
-# Other device classes
-NumberDeviceClass.HUMIDITY
-NumberDeviceClass.POWER
-NumberDeviceClass.VOLTAGE
-NumberDeviceClass.CURRENT
-```
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.number import NumberEntityDescription, NumberMode
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyNumberEntityDescription(NumberEntityDescription):
-    """Describe My number entity."""
-
-    value_fn: Callable[[MyData], float | None]
-    set_value_fn: Callable[[MyClient, float], Coroutine[Any, Any, None]]
-
-
-NUMBERS: tuple[MyNumberEntityDescription, ...] = (
-    MyNumberEntityDescription(
-        key="target_temperature",
-        translation_key="target_temperature",
-        native_min_value=16,
-        native_max_value=30,
-        native_step=0.5,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        mode=NumberMode.SLIDER,
-        value_fn=lambda data: data.target_temperature,
-        set_value_fn=lambda client, value: client.set_target_temperature(value),
-    ),
-    MyNumberEntityDescription(
-        key="brightness",
-        translation_key="brightness",
-        native_min_value=0,
-        native_max_value=100,
-        native_step=1,
-        native_unit_of_measurement=PERCENTAGE,
-        mode=NumberMode.SLIDER,
-        entity_category=EntityCategory.CONFIG,
-        value_fn=lambda data: data.brightness,
-        set_value_fn=lambda client, value: client.set_brightness(int(value)),
-    ),
-)
-
-
-class MyNumber(MyEntity, NumberEntity):
-    """Number using entity description."""
-
-    entity_description: MyNumberEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyNumberEntityDescription,
-    ) -> None:
-        """Initialize the number entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the current value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the value."""
-        await self.entity_description.set_value_fn(self.coordinator.client, value)
-        await self.coordinator.async_request_refresh()
-```
-
-## Dynamic Min/Max Values
-
-```python
-class DynamicRangeNumber(MyEntity, NumberEntity):
-    """Number with dynamic range based on device capabilities."""
-
-    _attr_translation_key = "fan_speed"
-
-    @property
-    def native_min_value(self) -> float:
-        """Return minimum value."""
-        return self.coordinator.data.fan_speed_min
-
-    @property
-    def native_max_value(self) -> float:
-        """Return maximum value."""
-        return self.coordinator.data.fan_speed_max
-
-    @property
-    def native_step(self) -> float:
-        """Return step value."""
-        return self.coordinator.data.fan_speed_step or 1
-```
-
-## Configuration Number
-
-```python
-class ConfigNumber(MyEntity, NumberEntity):
-    """Configuration number entity."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_native_min_value = 1
-    _attr_native_max_value = 60
-    _attr_native_step = 1
-    _attr_native_unit_of_measurement = "min"
-    _attr_translation_key = "timeout"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the timeout setting."""
-        return self.coordinator.data.timeout_minutes
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the timeout."""
-        await self.coordinator.client.set_timeout(int(value))
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "number": {
-      "target_temperature": {
-        "name": "Target temperature"
-      },
-      "brightness": {
-        "name": "Brightness"
-      },
-      "timeout": {
-        "name": "Timeout"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/SELECT.MD

@@ -1,252 +0,0 @@
-# Select Platform Reference
-
-Select entities allow choosing from a predefined list of options.
-
-## Basic Select
-
-```python
-"""Select platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.select import SelectEntity
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up selects from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        ModeSelect(coordinator),
-    ])
-
-
-class ModeSelect(MyEntity, SelectEntity):
-    """Mode select entity."""
-
-    _attr_options = ["auto", "cool", "heat", "fan_only", "dry"]
-    _attr_translation_key = "mode"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the select entity."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_mode"
-
-    @property
-    def current_option(self) -> str | None:
-        """Return the current option."""
-        return self.coordinator.data.mode
-
-    async def async_select_option(self, option: str) -> None:
-        """Change the selected option."""
-        await self.coordinator.client.set_mode(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.select import SelectEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySelectEntityDescription(SelectEntityDescription):
-    """Describe My select entity."""
-
-    current_option_fn: Callable[[MyData], str | None]
-    select_option_fn: Callable[[MyClient, str], Coroutine[Any, Any, None]]
-
-
-SELECTS: tuple[MySelectEntityDescription, ...] = (
-    MySelectEntityDescription(
-        key="mode",
-        translation_key="mode",
-        options=["auto", "cool", "heat", "fan_only", "dry"],
-        current_option_fn=lambda data: data.mode,
-        select_option_fn=lambda client, option: client.set_mode(option),
-    ),
-    MySelectEntityDescription(
-        key="fan_speed",
-        translation_key="fan_speed",
-        options=["low", "medium", "high", "auto"],
-        entity_category=EntityCategory.CONFIG,
-        current_option_fn=lambda data: data.fan_speed,
-        select_option_fn=lambda client, option: client.set_fan_speed(option),
-    ),
-)
-
-
-class MySelect(MyEntity, SelectEntity):
-    """Select using entity description."""
-
-    entity_description: MySelectEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySelectEntityDescription,
-    ) -> None:
-        """Initialize the select entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def options(self) -> list[str]:
-        """Return available options."""
-        return list(self.entity_description.options)
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current option."""
-        return self.entity_description.current_option_fn(self.coordinator.data)
-
-    async def async_select_option(self, option: str) -> None:
-        """Select an option."""
-        await self.entity_description.select_option_fn(self.coordinator.client, option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Dynamic Options
-
-```python
-class DynamicSelect(MyEntity, SelectEntity):
-    """Select with options from device."""
-
-    _attr_translation_key = "preset"
-
-    @property
-    def options(self) -> list[str]:
-        """Return available presets from device."""
-        return self.coordinator.data.available_presets
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current preset."""
-        return self.coordinator.data.current_preset
-
-    async def async_select_option(self, option: str) -> None:
-        """Select a preset."""
-        await self.coordinator.client.set_preset(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Configuration Select
-
-```python
-class ConfigSelect(MyEntity, SelectEntity):
-    """Configuration select (settings)."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_options = ["silent", "normal", "boost"]
-    _attr_translation_key = "performance_mode"
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current performance mode."""
-        return self.coordinator.data.performance_mode
-
-    async def async_select_option(self, option: str) -> None:
-        """Set performance mode."""
-        await self.coordinator.client.set_performance_mode(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "name": "Mode",
-        "state": {
-          "auto": "Auto",
-          "cool": "Cool",
-          "heat": "Heat",
-          "fan_only": "Fan only",
-          "dry": "Dry"
-        }
-      },
-      "fan_speed": {
-        "name": "Fan speed",
-        "state": {
-          "low": "Low",
-          "medium": "Medium",
-          "high": "High",
-          "auto": "Auto"
-        }
-      },
-      "performance_mode": {
-        "name": "Performance mode",
-        "state": {
-          "silent": "Silent",
-          "normal": "Normal",
-          "boost": "Boost"
-        }
-      }
-    }
-  }
-}
-```
-
-## Icon by State
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "name": "Mode",
-        "default": "mdi:thermostat",
-        "state": {
-          "auto": "Auto",
-          "cool": "Cool",
-          "heat": "Heat"
-        },
-        "state_icons": {
-          "auto": "mdi:thermostat-auto",
-          "cool": "mdi:snowflake",
-          "heat": "mdi:fire"
-        }
-      }
-    }
-  }
-}
-```
-
-Note: State icons are defined in `icons.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "default": "mdi:thermostat",
-        "state": {
-          "auto": "mdi:thermostat-auto",
-          "cool": "mdi:snowflake",
-          "heat": "mdi:fire"
-        }
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/SENSOR.MD

@@ -1,271 +0,0 @@
-# Sensor Platform Reference
-
-Sensors represent read-only values from devices.
-
-## Basic Sensor
-
-```python
-"""Sensor platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorStateClass,
-)
-from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        TemperatureSensor(coordinator),
-        HumiditySensor(coordinator),
-    ])
-
-
-class TemperatureSensor(MyEntity, SensorEntity):
-    """Temperature sensor."""
-
-    _attr_device_class = SensorDeviceClass.TEMPERATURE
-    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
-    _attr_state_class = SensorStateClass.MEASUREMENT
-    _attr_translation_key = "temperature"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_temperature"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the temperature."""
-        return self.coordinator.data.temperature
-```
-
-## Device Classes
-
-Common sensor device classes:
-
-| Device Class | Unit Examples | Use Case |
-|--------------|---------------|----------|
-| `TEMPERATURE` | °C, °F | Temperature readings |
-| `HUMIDITY` | % | Humidity levels |
-| `PRESSURE` | hPa, mbar | Atmospheric pressure |
-| `BATTERY` | % | Battery level |
-| `POWER` | W, kW | Power consumption |
-| `ENERGY` | Wh, kWh | Energy usage |
-| `VOLTAGE` | V | Electrical voltage |
-| `CURRENT` | A, mA | Electrical current |
-| `CO2` | ppm | Carbon dioxide |
-| `PM25` | µg/m³ | Particulate matter |
-
-## State Classes
-
-```python
-from homeassistant.components.sensor import SensorStateClass
-
-# For instantaneous values that can go up or down
-_attr_state_class = SensorStateClass.MEASUREMENT
-
-# For ever-increasing totals (like energy consumption)
-_attr_state_class = SensorStateClass.TOTAL
-
-# For totals that reset periodically
-_attr_state_class = SensorStateClass.TOTAL_INCREASING
-```
-
-## Entity Description Pattern
-
-For multiple sensors with similar structure:
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-from typing import Any
-
-from homeassistant.components.sensor import SensorEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySensorEntityDescription(SensorEntityDescription):
-    """Describe My sensor entity."""
-
-    value_fn: Callable[[MyData], Any]
-
-
-SENSORS: tuple[MySensorEntityDescription, ...] = (
-    MySensorEntityDescription(
-        key="temperature",
-        translation_key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.temperature,
-    ),
-    MySensorEntityDescription(
-        key="humidity",
-        translation_key="humidity",
-        device_class=SensorDeviceClass.HUMIDITY,
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.humidity,
-    ),
-    MySensorEntityDescription(
-        key="signal_strength",
-        translation_key="signal_strength",
-        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
-        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,  # Disabled by default
-        value_fn=lambda data: data.rssi,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MySensor(coordinator, description)
-        for description in SENSORS
-    )
-
-
-class MySensor(MyEntity, SensorEntity):
-    """Sensor using entity description."""
-
-    entity_description: MySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-```
-
-## Suggested Display Precision
-
-```python
-# Control decimal places shown in UI
-_attr_suggested_display_precision = 1  # Show 21.5 instead of 21.456789
-```
-
-## Timestamp Sensors
-
-```python
-from datetime import datetime
-
-from homeassistant.components.sensor import SensorDeviceClass
-
-
-class LastUpdatedSensor(MyEntity, SensorEntity):
-    """Last updated timestamp sensor."""
-
-    _attr_device_class = SensorDeviceClass.TIMESTAMP
-    _attr_translation_key = "last_updated"
-
-    @property
-    def native_value(self) -> datetime | None:
-        """Return the last update timestamp."""
-        return self.coordinator.data.last_updated
-```
-
-## Enum Sensors
-
-```python
-from homeassistant.components.sensor import SensorDeviceClass
-
-
-class StatusSensor(MyEntity, SensorEntity):
-    """Status sensor with enum values."""
-
-    _attr_device_class = SensorDeviceClass.ENUM
-    _attr_options = ["idle", "running", "error", "offline"]
-    _attr_translation_key = "status"
-
-    @property
-    def native_value(self) -> str | None:
-        """Return the current status."""
-        return self.coordinator.data.status
-```
-
-With translations in `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "status": {
-        "name": "Status",
-        "state": {
-          "idle": "Idle",
-          "running": "Running",
-          "error": "Error",
-          "offline": "Offline"
-        }
-      }
-    }
-  }
-}
-```
-
-## Dynamic Icons
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "battery_level": {
-        "name": "Battery level",
-        "default": "mdi:battery-unknown",
-        "range": {
-          "0": "mdi:battery-outline",
-          "10": "mdi:battery-10",
-          "50": "mdi:battery-50",
-          "90": "mdi:battery-90",
-          "100": "mdi:battery"
-        }
-      }
-    }
-  }
-}
-```
-
-## PARALLEL_UPDATES
-
-```python
-# At module level - limit concurrent updates
-PARALLEL_UPDATES = 1  # Serialize to prevent overwhelming device
-
-# Or unlimited for coordinator-based platforms
-PARALLEL_UPDATES = 0
-```

.claude/skills/ha-integration/SERVICES.MD

@@ -1,335 +0,0 @@
-# Services Reference
-
-Services allow automations and users to trigger actions.
-
-## Service Registration
-
-Register services in `async_setup`, NOT in `async_setup_entry`:
-
-```python
-"""My Integration setup."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
-from homeassistant.const import ATTR_DEVICE_ID
-from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, SupportsResponse
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, device_registry as dr
-
-from .const import ATTR_CONFIG_ENTRY_ID, DOMAIN
-
-SERVICE_REFRESH = "refresh"
-SERVICE_SET_SCHEDULE = "set_schedule"
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up My Integration services."""
-
-    async def handle_refresh(call: ServiceCall) -> None:
-        """Handle refresh service call."""
-        entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-
-        if not (entry := hass.config_entries.async_get_entry(entry_id)):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_found",
-            )
-
-        if entry.state is not ConfigEntryState.LOADED:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_loaded",
-            )
-
-        coordinator = entry.runtime_data
-        await coordinator.async_request_refresh()
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_REFRESH,
-        handle_refresh,
-        schema=vol.Schema({
-            vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-        }),
-    )
-
-    return True
-```
-
-## Service with Response
-
-```python
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up services with response."""
-
-    async def handle_get_schedule(call: ServiceCall) -> ServiceResponse:
-        """Handle get_schedule service call."""
-        entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-
-        if not (entry := hass.config_entries.async_get_entry(entry_id)):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_found",
-            )
-
-        if entry.state is not ConfigEntryState.LOADED:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_loaded",
-            )
-
-        coordinator = entry.runtime_data
-        schedule = await coordinator.client.get_schedule()
-
-        return {
-            "schedule": [
-                {"day": item.day, "start": item.start, "end": item.end}
-                for item in schedule
-            ]
-        }
-
-    hass.services.async_register(
-        DOMAIN,
-        "get_schedule",
-        handle_get_schedule,
-        schema=vol.Schema({
-            vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-        }),
-        supports_response=SupportsResponse.ONLY,  # or SupportsResponse.OPTIONAL
-    )
-
-    return True
-```
-
-## Entity Services
-
-Register entity-specific services in platform setup:
-
-```python
-"""Switch platform with entity service."""
-
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-import voluptuous as vol
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up switches from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([PowerSwitch(coordinator)])
-
-    # Register entity service
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        "set_timer",
-        {
-            vol.Required("minutes"): vol.All(
-                vol.Coerce(int), vol.Range(min=1, max=120)
-            ),
-        },
-        "async_set_timer",
-    )
-
-
-class PowerSwitch(MyEntity, SwitchEntity):
-    """Power switch with timer service."""
-
-    async def async_set_timer(self, minutes: int) -> None:
-        """Set auto-off timer."""
-        await self.coordinator.client.set_timer(minutes)
-```
-
-## Service Validation
-
-```python
-from homeassistant.exceptions import ServiceValidationError
-
-
-async def handle_set_schedule(call: ServiceCall) -> None:
-    """Handle set_schedule service call."""
-    start_date = call.data["start_date"]
-    end_date = call.data["end_date"]
-
-    # Validate input
-    if end_date < start_date:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="end_date_before_start_date",
-        )
-
-    entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-    entry = hass.config_entries.async_get_entry(entry_id)
-
-    try:
-        await entry.runtime_data.client.set_schedule(start_date, end_date)
-    except MyConnectionError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="connection_failed",
-        ) from err
-```
-
-## services.yaml
-
-Define services in `services.yaml`:
-
-```yaml
-refresh:
-  name: Refresh
-  description: Force a data refresh from the device.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to refresh.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-
-set_schedule:
-  name: Set schedule
-  description: Set the device schedule.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to configure.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-    start_date:
-      name: Start date
-      description: Schedule start date.
-      required: true
-      selector:
-        date:
-    end_date:
-      name: End date
-      description: Schedule end date.
-      required: true
-      selector:
-        date:
-
-get_schedule:
-  name: Get schedule
-  description: Get the current device schedule.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to query.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-
-set_timer:
-  name: Set timer
-  description: Set auto-off timer for the switch.
-  target:
-    entity:
-      integration: my_integration
-      domain: switch
-  fields:
-    minutes:
-      name: Minutes
-      description: Timer duration in minutes.
-      required: true
-      selector:
-        number:
-          min: 1
-          max: 120
-          unit_of_measurement: min
-```
-
-## Exception Translations
-
-In `strings.json`:
-
-```json
-{
-  "exceptions": {
-    "entry_not_found": {
-      "message": "Config entry not found."
-    },
-    "entry_not_loaded": {
-      "message": "Config entry is not loaded."
-    },
-    "end_date_before_start_date": {
-      "message": "The end date cannot be before the start date."
-    },
-    "connection_failed": {
-      "message": "Failed to connect to the device."
-    }
-  }
-}
-```
-
-## Device-Based Service Targeting
-
-```python
-async def handle_device_service(call: ServiceCall) -> None:
-    """Handle service call targeting a device."""
-    device_id = call.data[ATTR_DEVICE_ID]
-
-    device_registry = dr.async_get(hass)
-    device = device_registry.async_get(device_id)
-
-    if device is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="device_not_found",
-        )
-
-    # Find config entry for device
-    entry_id = next(
-        (entry_id for entry_id in device.config_entries if entry_id),
-        None,
-    )
-
-    if entry_id is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="entry_not_found",
-        )
-
-    entry = hass.config_entries.async_get_entry(entry_id)
-    # ... continue with service logic
-```
-
-## Service Schema Patterns
-
-```python
-import voluptuous as vol
-from homeassistant.helpers import config_validation as cv
-
-# Basic schema
-SERVICE_SCHEMA = vol.Schema({
-    vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-    vol.Required("value"): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
-    vol.Optional("timeout", default=30): cv.positive_int,
-})
-
-# With entity targeting
-SERVICE_SCHEMA_ENTITY = vol.Schema({
-    vol.Required("entity_id"): cv.entity_ids,
-    vol.Required("parameter"): cv.string,
-})
-
-# With selectors (for services.yaml)
-# Use selector in services.yaml, not in Python schema
-```
-
-## Quality Scale Requirements
-
-- **Bronze**: `action-setup` - Register services in `async_setup` if integration has services
-- Services must validate config entry state before use
-- Use translated exceptions for error messages

.claude/skills/ha-integration/SKILL.md

@@ -1,165 +0,0 @@
----
-name: ha-integration
-description: Develop Home Assistant integrations following best practices. Use when creating, modifying, or reviewing integration code including config flows, entities, coordinators, diagnostics, services, and tests.
----
-
-# Home Assistant Integration Development
-
-You are developing a Home Assistant integration. Follow these guidelines and reference the supporting documentation for specific components.
-
-## Quick Reference
-
-| Component | Reference File |
-|-----------|----------------|
-| Config flow | [CONFIG-FLOW.MD](CONFIG-FLOW.MD) |
-| Data coordinator | [COORDINATOR.MD](COORDINATOR.MD) |
-| Entities (base) | [ENTITY.MD](ENTITY.MD) |
-| Sensors | [SENSOR.MD](SENSOR.MD) |
-| Binary sensors | [BINARY-SENSOR.MD](BINARY-SENSOR.MD) |
-| Switches | [SWITCH.MD](SWITCH.MD) |
-| Numbers | [NUMBER.MD](NUMBER.MD) |
-| Selects | [SELECT.MD](SELECT.MD) |
-| Buttons | [BUTTON.MD](BUTTON.MD) |
-| Device management | [DEVICE.MD](DEVICE.MD) |
-| Diagnostics | [DIAGNOSTICS.MD](DIAGNOSTICS.MD) |
-| Services | [SERVICES.MD](SERVICES.MD) |
-| Testing | [TESTING.MD](TESTING.MD) |
-
-## Integration Structure
-
-```
-homeassistant/components/my_integration/
-├── __init__.py          # Entry point with async_setup_entry
-├── manifest.json        # Integration metadata and dependencies
-├── const.py            # Domain and constants
-├── config_flow.py      # UI configuration flow
-├── coordinator.py      # Data update coordinator
-├── entity.py          # Base entity class
-├── sensor.py          # Sensor platform
-├── diagnostics.py     # Diagnostic data collection
-├── strings.json        # User-facing text and translations
-├── services.yaml       # Service definitions (if applicable)
-└── quality_scale.yaml  # Quality scale rule status
-```
-
-## Quality Scale Levels
-
-- **Bronze**: Basic requirements (ALL Bronze rules are mandatory)
-- **Silver**: Enhanced functionality (entity unavailability, parallel updates, auth flows)
-- **Gold**: Advanced features (device management, diagnostics, translations)
-- **Platinum**: Highest quality (strict typing, async dependencies, websession injection)
-
-Check `manifest.json` for `"quality_scale"` key and `quality_scale.yaml` for rule status.
-
-## Core Patterns
-
-### Entry Point (`__init__.py`)
-
-```python
-"""Integration for My Device."""
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .const import DOMAIN
-from .coordinator import MyCoordinator
-
-PLATFORMS = [Platform.SENSOR, Platform.BINARY_SENSOR]
-
-type MyIntegrationConfigEntry = ConfigEntry[MyCoordinator]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
-    """Set up My Integration from a config entry."""
-    coordinator = MyCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-```
-
-### Constants (`const.py`)
-
-```python
-"""Constants for My Integration."""
-
-DOMAIN = "my_integration"
-```
-
-### Manifest (`manifest.json`)
-
-```json
-{
-  "domain": "my_integration",
-  "name": "My Integration",
-  "codeowners": ["@username"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/my_integration",
-  "integration_type": "hub",
-  "iot_class": "local_polling",
-  "requirements": ["my-library==1.0.0"],
-  "quality_scale": "bronze"
-}
-```
-
-## Python Requirements
-
-- **Compatibility**: Python 3.13+
-- **Type hints**: Required for all functions and methods
-- **f-strings**: Preferred over `%` or `.format()`
-- **Async**: All external I/O must be async
-
-## Code Quality
-
-- **Formatting**: Ruff
-- **Linting**: PyLint and Ruff
-- **Type Checking**: MyPy
-- **Testing**: pytest with >95% coverage
-
-## Common Anti-Patterns to Avoid
-
-```python
-# Blocking operations
-data = requests.get(url)  # Use async or executor
-time.sleep(5)  # Use asyncio.sleep()
-
-# Hardcoded strings
-self._attr_name = "Temperature"  # Use translation_key
-
-# Too much in try block
-try:
-    data = await client.get_data()
-    processed = data["value"] * 100  # Move outside try
-except Error:
-    pass
-
-# User-configurable polling
-vol.Optional("scan_interval"): cv.positive_int  # Not allowed
-```
-
-## Development Commands
-
-```bash
-# Run tests with coverage
-pytest ./tests/components/<domain> \
-  --cov=homeassistant.components.<domain> \
-  --cov-report term-missing \
-  --numprocesses=auto
-
-# Type checking
-mypy homeassistant/components/<domain>
-
-# Linting
-pylint homeassistant/components/<domain>
-
-# Validate integration
-python -m script.hassfest --integration-path homeassistant/components/<domain>
-```

.claude/skills/ha-integration/SWITCH.MD

@@ -1,236 +0,0 @@
-# Switch Platform Reference
-
-Switches control on/off functionality.
-
-## Basic Switch
-
-```python
-"""Switch platform for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntity, SwitchDeviceClass
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up switches from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        PowerSwitch(coordinator),
-    ])
-
-
-class PowerSwitch(MyEntity, SwitchEntity):
-    """Power switch."""
-
-    _attr_device_class = SwitchDeviceClass.SWITCH
-    _attr_translation_key = "power"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_power"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if switch is on."""
-        return self.coordinator.data.is_on
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self.coordinator.client.turn_on()
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self.coordinator.client.turn_off()
-        await self.coordinator.async_request_refresh()
-```
-
-## Device Classes
-
-| Device Class | Use Case |
-|--------------|----------|
-| `OUTLET` | Electrical outlet |
-| `SWITCH` | Generic switch |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySwitchEntityDescription(SwitchEntityDescription):
-    """Describe My switch entity."""
-
-    is_on_fn: Callable[[MyData], bool | None]
-    turn_on_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-    turn_off_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-
-
-SWITCHES: tuple[MySwitchEntityDescription, ...] = (
-    MySwitchEntityDescription(
-        key="power",
-        translation_key="power",
-        device_class=SwitchDeviceClass.SWITCH,
-        is_on_fn=lambda data: data.is_on,
-        turn_on_fn=lambda client: client.turn_on(),
-        turn_off_fn=lambda client: client.turn_off(),
-    ),
-    MySwitchEntityDescription(
-        key="child_lock",
-        translation_key="child_lock",
-        entity_category=EntityCategory.CONFIG,
-        is_on_fn=lambda data: data.child_lock_enabled,
-        turn_on_fn=lambda client: client.set_child_lock(True),
-        turn_off_fn=lambda client: client.set_child_lock(False),
-    ),
-)
-
-
-class MySwitch(MyEntity, SwitchEntity):
-    """Switch using entity description."""
-
-    entity_description: MySwitchEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySwitchEntityDescription,
-    ) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if switch is on."""
-        return self.entity_description.is_on_fn(self.coordinator.data)
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self.entity_description.turn_on_fn(self.coordinator.client)
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self.entity_description.turn_off_fn(self.coordinator.client)
-        await self.coordinator.async_request_refresh()
-```
-
-## Configuration Switch
-
-```python
-class ConfigSwitch(MyEntity, SwitchEntity):
-    """Configuration switch (e.g., enable/disable a feature)."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_translation_key = "auto_mode"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if auto mode is enabled."""
-        return self.coordinator.data.auto_mode_enabled
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Enable auto mode."""
-        await self.coordinator.client.set_auto_mode(True)
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Disable auto mode."""
-        await self.coordinator.client.set_auto_mode(False)
-        await self.coordinator.async_request_refresh()
-```
-
-## Optimistic Updates
-
-For devices with slow response:
-
-```python
-class OptimisticSwitch(MyEntity, SwitchEntity):
-    """Switch with optimistic state updates."""
-
-    _attr_assumed_state = True  # Indicates state may not be accurate
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self._optimistic_state: bool | None = None
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return optimistic state if set, otherwise coordinator state."""
-        if self._optimistic_state is not None:
-            return self._optimistic_state
-        return self.coordinator.data.is_on
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn on with optimistic update."""
-        self._optimistic_state = True
-        self.async_write_ha_state()
-        try:
-            await self.coordinator.client.turn_on()
-        finally:
-            self._optimistic_state = None
-            await self.coordinator.async_request_refresh()
-```
-
-## Error Handling
-
-```python
-from homeassistant.exceptions import HomeAssistantError
-
-
-class RobustSwitch(MyEntity, SwitchEntity):
-    """Switch with proper error handling."""
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        try:
-            await self.coordinator.client.turn_on()
-        except MyDeviceError as err:
-            raise HomeAssistantError(f"Failed to turn on: {err}") from err
-
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "switch": {
-      "power": {
-        "name": "Power"
-      },
-      "child_lock": {
-        "name": "Child lock"
-      },
-      "auto_mode": {
-        "name": "Auto mode"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/TESTING.MD

@@ -1,396 +0,0 @@
-# Testing Reference
-
-Testing patterns for Home Assistant integrations.
-
-## Test Structure
-
-```
-tests/components/my_integration/
-├── __init__.py
-├── conftest.py              # Shared fixtures
-├── test_config_flow.py      # Config flow tests (100% coverage required)
-├── test_init.py             # Integration setup tests
-├── test_sensor.py           # Sensor platform tests
-├── test_diagnostics.py      # Diagnostics tests
-├── snapshots/               # Snapshot files
-│   └── test_sensor.ambr
-└── fixtures/                # Test data fixtures
-    └── device_data.json
-```
-
-## conftest.py
-
-```python
-"""Fixtures for My Integration tests."""
-
-from collections.abc import Generator
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from homeassistant.components.my_integration.const import DOMAIN
-from homeassistant.const import CONF_API_KEY, CONF_HOST, Platform
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry, load_fixture
-
-
-@pytest.fixture
-def mock_config_entry() -> MockConfigEntry:
-    """Return the default mocked config entry."""
-    return MockConfigEntry(
-        domain=DOMAIN,
-        title="My Device",
-        data={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_api_key",
-        },
-        unique_id="device_serial_123",
-    )
-
-
-@pytest.fixture
-def mock_client() -> Generator[MagicMock]:
-    """Return a mocked client."""
-    with patch(
-        "homeassistant.components.my_integration.MyClient",
-        autospec=True,
-    ) as client_mock:
-        client = client_mock.return_value
-        client.get_data = AsyncMock(
-            return_value=MyData.from_json(load_fixture("device_data.json", DOMAIN))
-        )
-        client.serial_number = "device_serial_123"
-        client.name = "My Device"
-        client.model = "Model X"
-        client.firmware_version = "1.2.3"
-        yield client
-
-
-@pytest.fixture
-def platforms() -> list[Platform]:
-    """Return platforms to test."""
-    return [Platform.SENSOR, Platform.BINARY_SENSOR]
-
-
-@pytest.fixture
-async def init_integration(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: MagicMock,
-    platforms: list[Platform],
-) -> MockConfigEntry:
-    """Set up the integration for testing."""
-    mock_config_entry.add_to_hass(hass)
-
-    with patch(
-        "homeassistant.components.my_integration.PLATFORMS",
-        platforms,
-    ):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-    return mock_config_entry
-```
-
-## Config Flow Tests
-
-**100% coverage required for all paths:**
-
-```python
-"""Test config flow for My Integration."""
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from homeassistant.components.my_integration.const import DOMAIN
-from homeassistant.config_entries import SOURCE_USER, SOURCE_ZEROCONF
-from homeassistant.const import CONF_API_KEY, CONF_HOST
-from homeassistant.core import HomeAssistant
-from homeassistant.data_entry_flow import FlowResultType
-
-from tests.common import MockConfigEntry
-
-
-async def test_user_flow_success(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test successful user flow."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {}
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == "My Device"
-    assert result["data"] == {
-        CONF_HOST: "192.168.1.100",
-        CONF_API_KEY: "test_key",
-    }
-    assert result["result"].unique_id == "device_serial_123"
-
-
-async def test_user_flow_cannot_connect(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test connection error in user flow."""
-    mock_client.get_data.side_effect = ConnectionError("Cannot connect")
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["errors"] == {"base": "cannot_connect"}
-
-
-async def test_user_flow_already_configured(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: AsyncMock,
-) -> None:
-    """Test already configured error."""
-    mock_config_entry.add_to_hass(hass)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "already_configured"
-
-
-async def test_reauth_flow(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: AsyncMock,
-) -> None:
-    """Test reauthentication flow."""
-    mock_config_entry.add_to_hass(hass)
-
-    result = await mock_config_entry.start_reauth_flow(hass)
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "reauth_confirm"
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={CONF_API_KEY: "new_api_key"},
-    )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "reauth_successful"
-    assert mock_config_entry.data[CONF_API_KEY] == "new_api_key"
-```
-
-## Entity Tests with Snapshots
-
-```python
-"""Test sensor platform."""
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-
-@pytest.fixture
-def platforms() -> list[Platform]:
-    """Override platforms for sensor tests."""
-    return [Platform.SENSOR]
-
-
-@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
-async def test_sensors(
-    hass: HomeAssistant,
-    snapshot: SnapshotAssertion,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test sensor entities."""
-    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_sensor_device_assignment(
-    hass: HomeAssistant,
-    device_registry: dr.DeviceRegistry,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test sensors are assigned to correct device."""
-    device = device_registry.async_get_device(
-        identifiers={("my_integration", "device_serial_123")}
-    )
-    assert device is not None
-
-    entities = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    for entity in entities:
-        assert entity.device_id == device.id
-```
-
-## Coordinator Tests
-
-```python
-"""Test coordinator."""
-
-from unittest.mock import AsyncMock
-
-import pytest
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import UpdateFailed
-
-
-async def test_coordinator_update_success(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test successful coordinator update."""
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-    await coordinator.async_refresh()
-
-    assert coordinator.data.temperature == 21.5
-    assert coordinator.last_update_success
-
-
-async def test_coordinator_update_failed(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test coordinator handles API error."""
-    mock_client.get_data.side_effect = MyError("Connection failed")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(UpdateFailed):
-        await coordinator._async_update_data()
-
-
-async def test_coordinator_auth_failed(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test coordinator handles auth error."""
-    mock_client.get_data.side_effect = AuthError("Invalid token")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(ConfigEntryAuthFailed):
-        await coordinator._async_update_data()
-```
-
-## Diagnostics Tests
-
-```python
-"""Test diagnostics."""
-
-from homeassistant.components.diagnostics import REDACTED
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry
-from tests.components.my_integration import snapshot_platform
-from tests.typing import ClientSessionGenerator
-
-
-async def test_diagnostics(
-    hass: HomeAssistant,
-    hass_client: ClientSessionGenerator,
-    init_integration: MockConfigEntry,
-    snapshot: SnapshotAssertion,
-) -> None:
-    """Test diagnostics."""
-    assert await get_diagnostics_for_config_entry(
-        hass, hass_client, init_integration
-    ) == snapshot
-```
-
-## Common Fixtures
-
-```python
-from tests.common import MockConfigEntry, load_fixture
-
-# Load JSON fixture
-data = load_fixture("device_data.json", DOMAIN)
-
-# Enable all entities (including disabled by default)
-@pytest.mark.usefixtures("entity_registry_enabled_by_default")
-
-# Freeze time
-from freezegun.api import FrozenDateTimeFactory
-
-async def test_with_frozen_time(
-    hass: HomeAssistant,
-    freezer: FrozenDateTimeFactory,
-) -> None:
-    freezer.tick(timedelta(minutes=5))
-    await hass.async_block_till_done()
-```
-
-## Update Snapshots
-
-```bash
-# Update snapshots
-pytest tests/components/my_integration --snapshot-update
-
-# Always re-run without flag to verify
-pytest tests/components/my_integration
-```
-
-## Test Commands
-
-```bash
-# Run tests with coverage
-pytest tests/components/my_integration \
-  --cov=homeassistant.components.my_integration \
-  --cov-report term-missing \
-  --numprocesses=auto
-
-# Run specific test
-pytest tests/components/my_integration/test_config_flow.py::test_user_flow_success
-
-# Quick test of changed files
-pytest --timeout=10 --picked
-```
-
-## Best Practices
-
-1. **Never access `hass.data` directly** - Use fixtures and proper setup
-2. **Mock all external APIs** - Use fixtures with realistic JSON data
-3. **Use snapshot testing** - For entity states and attributes
-4. **Test error paths** - Connection errors, auth failures, invalid data
-5. **Test edge cases** - Empty data, missing fields, None values
-6. **>95% coverage required** - All code paths must be tested

.claude/skills/integrations/SKILL.md

@@ -0,0 +1,784 @@
+---
+name: Home Assistant Integration knowledge
+description: Everything you need to know to build, test and review Home Assistant Integrations. If you're looking at an integration, you must use this as your primary reference.
+---
+
+### File Locations
+- **Integration code**: `./homeassistant/components/<integration_domain>/`
+- **Integration tests**: `./tests/components/<integration_domain>/`
+
+## Integration Templates
+
+### Standard Integration Structure
+```
+homeassistant/components/my_integration/
+├── __init__.py          # Entry point with async_setup_entry
+├── manifest.json        # Integration metadata and dependencies
+├── const.py            # Domain and constants
+├── config_flow.py      # UI configuration flow
+├── coordinator.py      # Data update coordinator (if needed)
+├── entity.py          # Base entity class (if shared patterns)
+├── sensor.py          # Sensor platform
+├── strings.json        # User-facing text and translations
+├── services.yaml       # Service definitions (if applicable)
+└── quality_scale.yaml  # Quality scale rule status
+```
+
+An integration can have platforms as needed (e.g., `sensor.py`, `switch.py`, etc.). The following platforms have extra guidelines:
+- **Diagnostics**: [`platform-diagnostics.md`](platform-diagnostics.md) for diagnostic data collection
+- **Repairs**: [`platform-repairs.md`](platform-repairs.md) for user-actionable repair issues
+
+### Minimal Integration Checklist
+- [ ] `manifest.json` with required fields (domain, name, codeowners, etc.)
+- [ ] `__init__.py` with `async_setup_entry` and `async_unload_entry`
+- [ ] `config_flow.py` with UI configuration support
+- [ ] `const.py` with `DOMAIN` constant
+- [ ] `strings.json` with at least config flow text
+- [ ] Platform files (`sensor.py`, etc.) as needed
+- [ ] `quality_scale.yaml` with rule status tracking
+
+## Integration Quality Scale
+
+Home Assistant uses an Integration Quality Scale to ensure code quality and consistency. The quality level determines which rules apply:
+
+### Quality Scale Levels
+- **Bronze**: Basic requirements (ALL Bronze rules are mandatory)
+- **Silver**: Enhanced functionality
+- **Gold**: Advanced features
+- **Platinum**: Highest quality standards
+
+### Quality Scale Progression
+- **Bronze → Silver**: Add entity unavailability, parallel updates, auth flows
+- **Silver → Gold**: Add device management, diagnostics, translations
+- **Gold → Platinum**: Add strict typing, async dependencies, websession injection
+
+### How Rules Apply
+1. **Check `manifest.json`**: Look for `"quality_scale"` key to determine integration level
+2. **Bronze Rules**: Always required for any integration with quality scale
+3. **Higher Tier Rules**: Only apply if integration targets that tier or higher
+4. **Rule Status**: Check `quality_scale.yaml` in integration folder for:
+   - `done`: Rule implemented
+   - `exempt`: Rule doesn't apply (with reason in comment)
+   - `todo`: Rule needs implementation
+
+### Example `quality_scale.yaml` Structure
+```yaml
+rules:
+  # Bronze (mandatory)
+  config-flow: done
+  entity-unique-id: done
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+
+  # Silver (if targeting Silver+)
+  entity-unavailable: done
+  parallel-updates: done
+
+  # Gold (if targeting Gold+)
+  devices: done
+  diagnostics: done
+
+  # Platinum (if targeting Platinum)
+  strict-typing: done
+```
+
+**When Reviewing/Creating Code**: Always check the integration's quality scale level and exemption status before applying rules.
+
+## Code Organization
+
+### Core Locations
+- Shared constants: `homeassistant/const.py` (use these instead of hardcoding)
+- Integration structure:
+  - `homeassistant/components/{domain}/const.py` - Constants
+  - `homeassistant/components/{domain}/models.py` - Data models
+  - `homeassistant/components/{domain}/coordinator.py` - Update coordinator
+  - `homeassistant/components/{domain}/config_flow.py` - Configuration flow
+  - `homeassistant/components/{domain}/{platform}.py` - Platform implementations
+
+### Common Modules
+- **coordinator.py**: Centralize data fetching logic
+  ```python
+  class MyCoordinator(DataUpdateCoordinator[MyData]):
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass,
+              logger=LOGGER,
+              name=DOMAIN,
+              update_interval=timedelta(minutes=1),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
+  ```
+- **entity.py**: Base entity definitions to reduce duplication
+  ```python
+  class MyEntity(CoordinatorEntity[MyCoordinator]):
+      _attr_has_entity_name = True
+  ```
+
+### Runtime Data Storage
+- **Use ConfigEntry.runtime_data**: Store non-persistent runtime data
+  ```python
+  type MyIntegrationConfigEntry = ConfigEntry[MyClient]
+
+  async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
+      client = MyClient(entry.data[CONF_HOST])
+      entry.runtime_data = client
+  ```
+
+### Manifest Requirements
+- **Required Fields**: `domain`, `name`, `codeowners`, `integration_type`, `documentation`, `requirements`
+- **Integration Types**: `device`, `hub`, `service`, `system`, `helper`
+- **IoT Class**: Always specify connectivity method (e.g., `cloud_polling`, `local_polling`, `local_push`)
+- **Discovery Methods**: Add when applicable: `zeroconf`, `dhcp`, `bluetooth`, `ssdp`, `usb`
+- **Dependencies**: Include platform dependencies (e.g., `application_credentials`, `bluetooth_adapters`)
+
+### Config Flow Patterns
+- **Version Control**: Always set `VERSION = 1` and `MINOR_VERSION = 1`
+- **Unique ID Management**:
+  ```python
+  await self.async_set_unique_id(device_unique_id)
+  self._abort_if_unique_id_configured()
+  ```
+- **Error Handling**: Define errors in `strings.json` under `config.error`
+- **Step Methods**: Use standard naming (`async_step_user`, `async_step_discovery`, etc.)
+
+### Integration Ownership
+- **manifest.json**: Add GitHub usernames to `codeowners`:
+  ```json
+  {
+    "domain": "my_integration",
+    "name": "My Integration",
+    "codeowners": ["@me"]
+  }
+  ```
+
+### Async Dependencies (Platinum)
+- **Requirement**: All dependencies must use asyncio
+- Ensures efficient task handling without thread context switching
+
+### WebSession Injection (Platinum)
+- **Pass WebSession**: Support passing web sessions to dependencies
+  ```python
+  async def async_setup_entry(hass: HomeAssistant, entry: MyConfigEntry) -> bool:
+      """Set up integration from config entry."""
+      client = MyClient(entry.data[CONF_HOST], async_get_clientsession(hass))
+  ```
+- For cookies: Use `async_create_clientsession` (aiohttp) or `create_async_httpx_client` (httpx)
+
+### Data Update Coordinator
+- **Standard Pattern**: Use for efficient data management
+  ```python
+  class MyCoordinator(DataUpdateCoordinator):
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass,
+              logger=LOGGER,
+              name=DOMAIN,
+              update_interval=timedelta(minutes=5),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
+          self.client = client
+
+      async def _async_update_data(self):
+          try:
+              return await self.client.fetch_data()
+          except ApiError as err:
+              raise UpdateFailed(f"API communication error: {err}")
+  ```
+- **Error Types**: Use `UpdateFailed` for API errors, `ConfigEntryAuthFailed` for auth issues
+- **Config Entry**: Always pass `config_entry` parameter to coordinator - it's accepted and recommended
+
+## Integration Guidelines
+
+### Configuration Flow
+- **UI Setup Required**: All integrations must support configuration via UI
+- **Manifest**: Set `"config_flow": true` in `manifest.json`
+- **Data Storage**:
+  - Connection-critical config: Store in `ConfigEntry.data`
+  - Non-critical settings: Store in `ConfigEntry.options`
+- **Validation**: Always validate user input before creating entries
+- **Config Entry Naming**:
+  - ❌ Do NOT allow users to set config entry names in config flows
+  - Names are automatically generated or can be customized later in UI
+  - ✅ Exception: Helper integrations MAY allow custom names in config flow
+- **Connection Testing**: Test device/service connection during config flow:
+  ```python
+  try:
+      await client.get_data()
+  except MyException:
+      errors["base"] = "cannot_connect"
+  ```
+- **Duplicate Prevention**: Prevent duplicate configurations:
+  ```python
+  # Using unique ID
+  await self.async_set_unique_id(identifier)
+  self._abort_if_unique_id_configured()
+
+  # Using unique data
+  self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
+  ```
+
+### Reauthentication Support
+- **Required Method**: Implement `async_step_reauth` in config flow
+- **Credential Updates**: Allow users to update credentials without re-adding
+- **Validation**: Verify account matches existing unique ID:
+  ```python
+  await self.async_set_unique_id(user_id)
+  self._abort_if_unique_id_mismatch(reason="wrong_account")
+  return self.async_update_reload_and_abort(
+      self._get_reauth_entry(),
+      data_updates={CONF_API_TOKEN: user_input[CONF_API_TOKEN]}
+  )
+  ```
+
+### Reconfiguration Flow
+- **Purpose**: Allow configuration updates without removing device
+- **Implementation**: Add `async_step_reconfigure` method
+- **Validation**: Prevent changing underlying account with `_abort_if_unique_id_mismatch`
+
+### Device Discovery
+- **Manifest Configuration**: Add discovery method (zeroconf, dhcp, etc.)
+  ```json
+  {
+    "zeroconf": ["_mydevice._tcp.local."]
+  }
+  ```
+- **Discovery Handler**: Implement appropriate `async_step_*` method:
+  ```python
+  async def async_step_zeroconf(self, discovery_info):
+      """Handle zeroconf discovery."""
+      await self.async_set_unique_id(discovery_info.properties["serialno"])
+      self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.host})
+  ```
+- **Network Updates**: Use discovery to update dynamic IP addresses
+
+### Network Discovery Implementation
+- **Zeroconf/mDNS**: Use async instances
+  ```python
+  aiozc = await zeroconf.async_get_async_instance(hass)
+  ```
+- **SSDP Discovery**: Register callbacks with cleanup
+  ```python
+  entry.async_on_unload(
+      ssdp.async_register_callback(
+          hass, _async_discovered_device,
+          {"st": "urn:schemas-upnp-org:device:ZonePlayer:1"}
+      )
+  )
+  ```
+
+### Bluetooth Integration
+- **Manifest Dependencies**: Add `bluetooth_adapters` to dependencies
+- **Connectable**: Set `"connectable": true` for connection-required devices
+- **Scanner Usage**: Always use shared scanner instance
+  ```python
+  scanner = bluetooth.async_get_scanner()
+  entry.async_on_unload(
+      bluetooth.async_register_callback(
+          hass, _async_discovered_device,
+          {"service_uuid": "example_uuid"},
+          bluetooth.BluetoothScanningMode.ACTIVE
+      )
+  )
+  ```
+- **Connection Handling**: Never reuse `BleakClient` instances, use 10+ second timeouts
+
+### Setup Validation
+- **Test Before Setup**: Verify integration can be set up in `async_setup_entry`
+- **Exception Handling**:
+  - `ConfigEntryNotReady`: Device offline or temporary failure
+  - `ConfigEntryAuthFailed`: Authentication issues
+  - `ConfigEntryError`: Unresolvable setup problems
+
+### Config Entry Unloading
+- **Required**: Implement `async_unload_entry` for runtime removal/reload
+- **Platform Unloading**: Use `hass.config_entries.async_unload_platforms`
+- **Cleanup**: Register callbacks with `entry.async_on_unload`:
+  ```python
+  async def async_unload_entry(hass: HomeAssistant, entry: MyConfigEntry) -> bool:
+      """Unload a config entry."""
+      if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+          entry.runtime_data.listener()  # Clean up resources
+      return unload_ok
+  ```
+
+### Service Actions
+- **Registration**: Register all service actions in `async_setup`, NOT in `async_setup_entry`
+- **Validation**: Check config entry existence and loaded state:
+  ```python
+  async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+      async def service_action(call: ServiceCall) -> ServiceResponse:
+          if not (entry := hass.config_entries.async_get_entry(call.data[ATTR_CONFIG_ENTRY_ID])):
+              raise ServiceValidationError("Entry not found")
+          if entry.state is not ConfigEntryState.LOADED:
+              raise ServiceValidationError("Entry not loaded")
+  ```
+- **Exception Handling**: Raise appropriate exceptions:
+  ```python
+  # For invalid input
+  if end_date < start_date:
+      raise ServiceValidationError("End date must be after start date")
+
+  # For service errors
+  try:
+      await client.set_schedule(start_date, end_date)
+  except MyConnectionError as err:
+      raise HomeAssistantError("Could not connect to the schedule") from err
+  ```
+
+### Service Registration Patterns
+- **Entity Services**: Register on platform setup
+  ```python
+  platform.async_register_entity_service(
+      "my_entity_service",
+      {vol.Required("parameter"): cv.string},
+      "handle_service_method"
+  )
+  ```
+- **Service Schema**: Always validate input
+  ```python
+  SERVICE_SCHEMA = vol.Schema({
+      vol.Required("entity_id"): cv.entity_ids,
+      vol.Required("parameter"): cv.string,
+      vol.Optional("timeout", default=30): cv.positive_int,
+  })
+  ```
+- **Services File**: Create `services.yaml` with descriptions and field definitions
+
+### Polling
+- Use update coordinator pattern when possible
+- **Polling intervals are NOT user-configurable**: Never add scan_interval, update_interval, or polling frequency options to config flows or config entries
+- **Integration determines intervals**: Set `update_interval` programmatically based on integration logic, not user input
+- **Minimum Intervals**:
+  - Local network: 5 seconds
+  - Cloud services: 60 seconds
+- **Parallel Updates**: Specify number of concurrent updates:
+  ```python
+  PARALLEL_UPDATES = 1  # Serialize updates to prevent overwhelming device
+  # OR
+  PARALLEL_UPDATES = 0  # Unlimited (for coordinator-based or read-only)
+  ```
+
+## Entity Development
+
+### Unique IDs
+- **Required**: Every entity must have a unique ID for registry tracking
+- Must be unique per platform (not per integration)
+- Don't include integration domain or platform in ID
+- **Implementation**:
+  ```python
+  class MySensor(SensorEntity):
+      def __init__(self, device_id: str) -> None:
+          self._attr_unique_id = f"{device_id}_temperature"
+  ```
+
+**Acceptable ID Sources**:
+- Device serial numbers
+- MAC addresses (formatted using `format_mac` from device registry)
+- Physical identifiers (printed/EEPROM)
+- Config entry ID as last resort: `f"{entry.entry_id}-battery"`
+
+**Never Use**:
+- IP addresses, hostnames, URLs
+- Device names
+- Email addresses, usernames
+
+### Entity Descriptions
+- **Lambda/Anonymous Functions**: Often used in EntityDescription for value transformation
+- **Multiline Lambdas**: When lambdas exceed line length, wrap in parentheses for readability
+- **Bad pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature",
+      name="Temperature",
+      value_fn=lambda data: round(data["temp_value"] * 1.8 + 32, 1) if data.get("temp_value") is not None else None,  # ❌ Too long
+  )
+  ```
+- **Good pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature",
+      name="Temperature",
+      value_fn=lambda data: (  # ✅ Parenthesis on same line as lambda
+          round(data["temp_value"] * 1.8 + 32, 1)
+          if data.get("temp_value") is not None
+          else None
+      ),
+  )
+  ```
+
+### Entity Naming
+- **Use has_entity_name**: Set `_attr_has_entity_name = True`
+- **For specific fields**:
+  ```python
+  class MySensor(SensorEntity):
+      _attr_has_entity_name = True
+      def __init__(self, device: Device, field: str) -> None:
+          self._attr_device_info = DeviceInfo(
+              identifiers={(DOMAIN, device.id)},
+              name=device.name,
+          )
+          self._attr_name = field  # e.g., "temperature", "humidity"
+  ```
+- **For device itself**: Set `_attr_name = None`
+
+### Event Lifecycle Management
+- **Subscribe in `async_added_to_hass`**:
+  ```python
+  async def async_added_to_hass(self) -> None:
+      """Subscribe to events."""
+      self.async_on_remove(
+          self.client.events.subscribe("my_event", self._handle_event)
+      )
+  ```
+- **Unsubscribe in `async_will_remove_from_hass`** if not using `async_on_remove`
+- Never subscribe in `__init__` or other methods
+
+### State Handling
+- Unknown values: Use `None` (not "unknown" or "unavailable")
+- Availability: Implement `available()` property instead of using "unavailable" state
+
+### Entity Availability
+- **Mark Unavailable**: When data cannot be fetched from device/service
+- **Coordinator Pattern**:
+  ```python
+  @property
+  def available(self) -> bool:
+      """Return if entity is available."""
+      return super().available and self.identifier in self.coordinator.data
+  ```
+- **Direct Update Pattern**:
+  ```python
+  async def async_update(self) -> None:
+      """Update entity."""
+      try:
+          data = await self.client.get_data()
+      except MyException:
+          self._attr_available = False
+      else:
+          self._attr_available = True
+          self._attr_native_value = data.value
+  ```
+
+### Extra State Attributes
+- All attribute keys must always be present
+- Unknown values: Use `None`
+- Provide descriptive attributes
+
+## Device Management
+
+### Device Registry
+- **Create Devices**: Group related entities under devices
+- **Device Info**: Provide comprehensive metadata:
+  ```python
+  _attr_device_info = DeviceInfo(
+      connections={(CONNECTION_NETWORK_MAC, device.mac)},
+      identifiers={(DOMAIN, device.id)},
+      name=device.name,
+      manufacturer="My Company",
+      model="My Sensor",
+      sw_version=device.version,
+  )
+  ```
+- For services: Add `entry_type=DeviceEntryType.SERVICE`
+
+### Dynamic Device Addition
+- **Auto-detect New Devices**: After initial setup
+- **Implementation Pattern**:
+  ```python
+  def _check_device() -> None:
+      current_devices = set(coordinator.data)
+      new_devices = current_devices - known_devices
+      if new_devices:
+          known_devices.update(new_devices)
+          async_add_entities([MySensor(coordinator, device_id) for device_id in new_devices])
+
+  entry.async_on_unload(coordinator.async_add_listener(_check_device))
+  ```
+
+### Stale Device Removal
+- **Auto-remove**: When devices disappear from hub/account
+- **Device Registry Update**:
+  ```python
+  device_registry.async_update_device(
+      device_id=device.id,
+      remove_config_entry_id=self.config_entry.entry_id,
+  )
+  ```
+- **Manual Deletion**: Implement `async_remove_config_entry_device` when needed
+
+### Entity Categories
+- **Required**: Assign appropriate category to entities
+- **Implementation**: Set `_attr_entity_category`
+  ```python
+  class MySensor(SensorEntity):
+      _attr_entity_category = EntityCategory.DIAGNOSTIC
+  ```
+- Categories include: `DIAGNOSTIC` for system/technical information
+
+### Device Classes
+- **Use When Available**: Set appropriate device class for entity type
+  ```python
+  class MyTemperatureSensor(SensorEntity):
+      _attr_device_class = SensorDeviceClass.TEMPERATURE
+  ```
+- Provides context for: unit conversion, voice control, UI representation
+
+### Disabled by Default
+- **Disable Noisy/Less Popular Entities**: Reduce resource usage
+  ```python
+  class MySignalStrengthSensor(SensorEntity):
+      _attr_entity_registry_enabled_default = False
+  ```
+- Target: frequently changing states, technical diagnostics
+
+### Entity Translations
+- **Required with has_entity_name**: Support international users
+- **Implementation**:
+  ```python
+  class MySensor(SensorEntity):
+      _attr_has_entity_name = True
+      _attr_translation_key = "phase_voltage"
+  ```
+- Create `strings.json` with translations:
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "phase_voltage": {
+          "name": "Phase voltage"
+        }
+      }
+    }
+  }
+  ```
+
+### Exception Translations (Gold)
+- **Translatable Errors**: Use translation keys for user-facing exceptions
+- **Implementation**:
+  ```python
+  raise ServiceValidationError(
+      translation_domain=DOMAIN,
+      translation_key="end_date_before_start_date",
+  )
+  ```
+- Add to `strings.json`:
+  ```json
+  {
+    "exceptions": {
+      "end_date_before_start_date": {
+        "message": "The end date cannot be before the start date."
+      }
+    }
+  }
+  ```
+
+### Icon Translations (Gold)
+- **Dynamic Icons**: Support state and range-based icon selection
+- **State-based Icons**:
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "tree_pollen": {
+          "default": "mdi:tree",
+          "state": {
+            "high": "mdi:tree-outline"
+          }
+        }
+      }
+    }
+  }
+  ```
+- **Range-based Icons** (for numeric values):
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "battery_level": {
+          "default": "mdi:battery-unknown",
+          "range": {
+            "0": "mdi:battery-outline",
+            "90": "mdi:battery-90",
+            "100": "mdi:battery"
+          }
+        }
+      }
+    }
+  }
+  ```
+
+## Testing Requirements
+
+- **Location**: `tests/components/{domain}/`
+- **Coverage Requirement**: Above 95% test coverage for all modules
+- **Best Practices**:
+  - Use pytest fixtures from `tests.common`
+  - Mock all external dependencies
+  - Use snapshots for complex data structures
+  - Follow existing test patterns
+
+### Config Flow Testing
+- **100% Coverage Required**: All config flow paths must be tested
+- **Test Scenarios**:
+  - All flow initiation methods (user, discovery, import)
+  - Successful configuration paths
+  - Error recovery scenarios
+  - Prevention of duplicate entries
+  - Flow completion after errors
+
+### Testing
+- **Integration-specific tests** (recommended):
+  ```bash
+  pytest ./tests/components/<integration_domain> \
+    --cov=homeassistant.components.<integration_domain> \
+    --cov-report term-missing \
+    --durations-min=1 \
+    --durations=0 \
+    --numprocesses=auto
+  ```
+
+### Testing Best Practices
+- **Never access `hass.data` directly** - Use fixtures and proper integration setup instead
+- **Use snapshot testing** - For verifying entity states and attributes
+- **Test through integration setup** - Don't test entities in isolation
+- **Mock external APIs** - Use fixtures with realistic JSON data
+- **Verify registries** - Ensure entities are properly registered with devices
+
+### Config Flow Testing Template
+```python
+async def test_user_flow_success(hass, mock_api):
+    """Test successful user flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    # Test form submission
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.CREATE_ENTRY
+    assert result["title"] == "My Device"
+    assert result["data"] == TEST_USER_INPUT
+
+async def test_flow_connection_error(hass, mock_api_error):
+    """Test connection error handling."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+```
+
+### Entity Testing Patterns
+```python
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Overridden fixture to specify platforms to test."""
+    return [Platform.SENSOR]  # Or another specific platform as needed.
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
+async def test_entities(
+    hass: HomeAssistant,
+    snapshot: SnapshotAssertion,
+    entity_registry: er.EntityRegistry,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the sensor entities."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+    # Ensure entities are correctly assigned to device
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, "device_unique_id")}
+    )
+    assert device_entry
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, mock_config_entry.entry_id
+    )
+    for entity_entry in entity_entries:
+        assert entity_entry.device_id == device_entry.id
+```
+
+### Mock Patterns
+```python
+# Modern integration fixture setup
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Return the default mocked config entry."""
+    return MockConfigEntry(
+        title="My Integration",
+        domain=DOMAIN,
+        data={CONF_HOST: "127.0.0.1", CONF_API_KEY: "test_key"},
+        unique_id="device_unique_id",
+    )
+
+@pytest.fixture
+def mock_device_api() -> Generator[MagicMock]:
+    """Return a mocked device API."""
+    with patch("homeassistant.components.my_integration.MyDeviceAPI", autospec=True) as api_mock:
+        api = api_mock.return_value
+        api.get_data.return_value = MyDeviceData.from_json(
+            load_fixture("device_data.json", DOMAIN)
+        )
+        yield api
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Fixture to specify platforms to test."""
+    return PLATFORMS
+
+@pytest.fixture
+async def init_integration(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_device_api: MagicMock,
+    platforms: list[Platform],
+) -> MockConfigEntry:
+    """Set up the integration for testing."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    return mock_config_entry
+```
+
+## Debugging & Troubleshooting
+
+### Common Issues & Solutions
+- **Integration won't load**: Check `manifest.json` syntax and required fields
+- **Entities not appearing**: Verify `unique_id` and `has_entity_name` implementation
+- **Config flow errors**: Check `strings.json` entries and error handling
+- **Discovery not working**: Verify manifest discovery configuration and callbacks
+- **Tests failing**: Check mock setup and async context
+
+### Debug Logging Setup
+```python
+# Enable debug logging in tests
+caplog.set_level(logging.DEBUG, logger="my_integration")
+
+# In integration code - use proper logging
+_LOGGER = logging.getLogger(__name__)
+_LOGGER.debug("Processing data: %s", data)  # Use lazy logging
+```
+
+### Validation Commands
+```bash
+# Check specific integration
+python -m script.hassfest --integration-path homeassistant/components/my_integration
+
+# Validate quality scale
+# Check quality_scale.yaml against current rules
+
+# Run integration tests with coverage
+pytest ./tests/components/my_integration \
+  --cov=homeassistant.components.my_integration \
+  --cov-report term-missing
+```

.claude/skills/integrations/platform-diagnostics.md

@@ -0,0 +1,19 @@
+# Integration Diagnostics
+
+Platform exists as `homeassistant/components/<domain>/diagnostics.py`.
+
+- **Required**: Implement diagnostic data collection
+- **Implementation**:
+  ```python
+  TO_REDACT = [CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE]
+
+  async def async_get_config_entry_diagnostics(
+      hass: HomeAssistant, entry: MyConfigEntry
+  ) -> dict[str, Any]:
+      """Return diagnostics for a config entry."""
+      return {
+          "entry_data": async_redact_data(entry.data, TO_REDACT),
+          "data": entry.runtime_data.data,
+      }
+  ```
+- **Security**: Never expose passwords, tokens, or sensitive coordinates

.claude/skills/integrations/platform-repairs.md

@@ -0,0 +1,55 @@
+# Repairs platform
+
+Platform exists as `homeassistant/components/<domain>/repairs.py`.
+
+- **Actionable Issues Required**: All repair issues must be actionable for end users
+- **Issue Content Requirements**:
+  - Clearly explain what is happening
+  - Provide specific steps users need to take to resolve the issue
+  - Use friendly, helpful language
+  - Include relevant context (device names, error details, etc.)
+- **Implementation**:
+  ```python
+  ir.async_create_issue(
+      hass,
+      DOMAIN,
+      "outdated_version",
+      is_fixable=False,
+      issue_domain=DOMAIN,
+      severity=ir.IssueSeverity.ERROR,
+      translation_key="outdated_version",
+  )
+  ```
+- **Translation Strings Requirements**: Must contain user-actionable text in `strings.json`:
+  ```json
+  {
+    "issues": {
+      "outdated_version": {
+        "title": "Device firmware is outdated",
+        "description": "Your device firmware version {current_version} is below the minimum required version {min_version}. To fix this issue: 1) Open the manufacturer's mobile app, 2) Navigate to device settings, 3) Select 'Update Firmware', 4) Wait for the update to complete, then 5) Restart Home Assistant."
+      }
+    }
+  }
+  ```
+- **String Content Must Include**:
+  - What the problem is
+  - Why it matters
+  - Exact steps to resolve (numbered list when multiple steps)
+  - What to expect after following the steps
+- **Avoid Vague Instructions**: Don't just say "update firmware" - provide specific steps
+- **Severity Guidelines**:
+  - `CRITICAL`: Reserved for extreme scenarios only
+  - `ERROR`: Requires immediate user attention
+  - `WARNING`: Indicates future potential breakage
+- **Additional Attributes**:
+  ```python
+  ir.async_create_issue(
+      hass, DOMAIN, "issue_id",
+      breaks_in_ha_version="2024.1.0",
+      is_fixable=True,
+      is_persistent=True,
+      severity=ir.IssueSeverity.ERROR,
+      translation_key="issue_description",
+  )
+  ```
+- Only create issues for problems users can potentially resolve

.github/workflows/builder.yml

@@ -30,10 +30,10 @@ jobs:
       architectures: ${{ env.ARCHITECTURES }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -96,7 +96,7 @@ jobs:
             os: ubuntu-24.04-arm
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
@@ -122,7 +122,7 @@ jobs:
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -273,7 +273,7 @@ jobs:
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set build additional args
         run: |
@@ -311,7 +311,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -474,10 +474,10 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -519,7 +519,7 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Login to GitHub Container Registry
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0

.github/workflows/ci.yaml

@@ -97,7 +97,7 @@ jobs:
     steps:
       - &checkout
         name: Check out code from GitHub
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |
@@ -297,7 +297,7 @@ jobs:
       - &setup-python-matrix
         name: Set up Python ${{ matrix.python-version }}
         id: python
-        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: &actions-setup-python actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
           check-latest: true
@@ -479,6 +479,22 @@ jobs:
           . venv/bin/activate
           python -m script.gen_requirements_all validate
 
+  gen-copilot-instructions:
+    name: Check copilot instructions
+    runs-on: *runs-on-ubuntu
+    needs:
+      - info
+    if: |
+      github.event.inputs.pylint-only != 'true'
+      && github.event.inputs.mypy-only != 'true'
+      && github.event.inputs.audit-licenses-only != 'true'
+    steps:
+      - *checkout
+      - *setup-python-default
+      - name: Run gen_copilot_instructions.py
+        run: |
+          python -m script.gen_copilot_instructions validate
+
   dependency-review:
     name: Dependency review
     runs-on: *runs-on-ubuntu

.github/workflows/codeql.yml

@@ -21,7 +21,7 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10

.github/workflows/translations.yml

@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 

.github/workflows/wheels.yml

@@ -31,11 +31,11 @@ jobs:
     steps:
       - &checkout
         name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           check-latest: true

AGENTS.md

@@ -1 +0,0 @@
-.github/copilot-instructions.md

AGENTS.md

@@ -0,0 +1,324 @@
+# GitHub Copilot & Claude Code Instructions
+
+This repository contains the core of Home Assistant, a Python 3 based home automation application.
+
+## Code Review Guidelines
+
+**When reviewing code, do NOT comment on:**
+- **Missing imports** - We use static analysis tooling to catch that
+- **Code formatting** - We have ruff as a formatting tool that will catch those if needed (unless specifically instructed otherwise in these instructions)
+
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
+
+## Python Requirements
+
+- **Compatibility**: Python 3.13+
+- **Language Features**: Use the newest features when possible:
+  - Pattern matching
+  - Type hints
+  - f-strings (preferred over `%` or `.format()`)
+  - Dataclasses
+  - Walrus operator
+
+### Strict Typing (Platinum)
+- **Comprehensive Type Hints**: Add type hints to all functions, methods, and variables
+- **Custom Config Entry Types**: When using runtime_data:
+  ```python
+  type MyIntegrationConfigEntry = ConfigEntry[MyClient]
+  ```
+- **Library Requirements**: Include `py.typed` file for PEP-561 compliance
+
+## Code Quality Standards
+
+- **Formatting**: Ruff
+- **Linting**: PyLint and Ruff
+- **Type Checking**: MyPy
+- **Lint/Type/Format Fixes**: Always prefer addressing the underlying issue (e.g., import the typed source, update shared stubs, align with Ruff expectations, or correct formatting at the source) before disabling a rule, adding `# type: ignore`, or skipping a formatter. Treat suppressions and `noqa` comments as a last resort once no compliant fix exists
+- **Testing**: pytest with plain functions and fixtures
+- **Language**: American English for all code, comments, and documentation (use sentence case, including titles)
+
+### Writing Style Guidelines
+- **Tone**: Friendly and informative
+- **Perspective**: Use second-person ("you" and "your") for user-facing messages
+- **Inclusivity**: Use objective, non-discriminatory language
+- **Clarity**: Write for non-native English speakers
+- **Formatting in Messages**:
+  - Use backticks for: file paths, filenames, variable names, field entries
+  - Use sentence case for titles and messages (capitalize only the first word and proper nouns)
+  - Avoid abbreviations when possible
+
+### Documentation Standards
+- **File Headers**: Short and concise
+  ```python
+  """Integration for Peblar EV chargers."""
+  ```
+- **Method/Function Docstrings**: Required for all
+  ```python
+  async def async_setup_entry(hass: HomeAssistant, entry: PeblarConfigEntry) -> bool:
+      """Set up Peblar from a config entry."""
+  ```
+- **Comment Style**:
+  - Use clear, descriptive comments
+  - Explain the "why" not just the "what"
+  - Keep code block lines under 80 characters when possible
+  - Use progressive disclosure (simple explanation first, complex details later)
+
+## Async Programming
+
+- All external I/O operations must be async
+- **Best Practices**:
+  - Avoid sleeping in loops
+  - Avoid awaiting in loops - use `gather` instead
+  - No blocking calls
+  - Group executor jobs when possible - switching between event loop and executor is expensive
+
+### Blocking Operations
+- **Use Executor**: For blocking I/O operations
+  ```python
+  result = await hass.async_add_executor_job(blocking_function, args)
+  ```
+- **Never Block Event Loop**: Avoid file operations, `time.sleep()`, blocking HTTP calls
+- **Replace with Async**: Use `asyncio.sleep()` instead of `time.sleep()`
+
+### Thread Safety
+- **@callback Decorator**: For event loop safe functions
+  ```python
+  @callback
+  def async_update_callback(self, event):
+      """Safe to run in event loop."""
+      self.async_write_ha_state()
+  ```
+- **Sync APIs from Threads**: Use sync versions when calling from non-event loop threads
+- **Registry Changes**: Must be done in event loop thread
+
+### Error Handling
+- **Exception Types**: Choose most specific exception available
+  - `ServiceValidationError`: User input errors (preferred over `ValueError`)
+  - `HomeAssistantError`: Device communication failures
+  - `ConfigEntryNotReady`: Temporary setup issues (device offline)
+  - `ConfigEntryAuthFailed`: Authentication problems
+  - `ConfigEntryError`: Permanent setup issues
+- **Try/Catch Best Practices**:
+  - Only wrap code that can throw exceptions
+  - Keep try blocks minimal - process data after the try/catch
+  - **Avoid bare exceptions** except in specific cases:
+    - ❌ Generally not allowed: `except:` or `except Exception:`
+    - ✅ Allowed in config flows to ensure robustness
+    - ✅ Allowed in functions/methods that run in background tasks
+  - Bad pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+        # ❌ Don't process data inside try block
+        processed = data.get("value", 0) * 100
+        self._attr_native_value = processed
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+    ```
+  - Good pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+        return
+
+    # ✅ Process data outside try block
+    processed = data.get("value", 0) * 100
+    self._attr_native_value = processed
+    ```
+- **Bare Exception Usage**:
+  ```python
+  # ❌ Not allowed in regular code
+  try:
+      data = await device.get_data()
+  except Exception:  # Too broad
+      _LOGGER.error("Failed")
+
+  # ✅ Allowed in config flow for robustness
+  async def async_step_user(self, user_input=None):
+      try:
+          await self._test_connection(user_input)
+      except Exception:  # Allowed here
+          errors["base"] = "unknown"
+
+  # ✅ Allowed in background tasks
+  async def _background_refresh():
+      try:
+          await coordinator.async_refresh()
+      except Exception:  # Allowed in task
+          _LOGGER.exception("Unexpected error in background task")
+  ```
+- **Setup Failure Patterns**:
+  ```python
+  try:
+      await device.async_setup()
+  except (asyncio.TimeoutError, TimeoutException) as ex:
+      raise ConfigEntryNotReady(f"Timeout connecting to {device.host}") from ex
+  except AuthFailed as ex:
+      raise ConfigEntryAuthFailed(f"Credentials expired for {device.name}") from ex
+  ```
+
+### Logging
+- **Format Guidelines**:
+  - No periods at end of messages
+  - No integration names/domains (added automatically)
+  - No sensitive data (keys, tokens, passwords)
+- Use debug level for non-user-facing messages
+- **Use Lazy Logging**:
+  ```python
+  _LOGGER.debug("This is a log message with %s", variable)
+  ```
+
+### Unavailability Logging
+- **Log Once**: When device/service becomes unavailable (info level)
+- **Log Recovery**: When device/service comes back online
+- **Implementation Pattern**:
+  ```python
+  _unavailable_logged: bool = False
+
+  if not self._unavailable_logged:
+      _LOGGER.info("The sensor is unavailable: %s", ex)
+      self._unavailable_logged = True
+  # On recovery:
+  if self._unavailable_logged:
+      _LOGGER.info("The sensor is back online")
+      self._unavailable_logged = False
+  ```
+
+## Development Commands
+
+### Code Quality & Linting
+- **Run all linters on all files**: `prek run --all-files`
+- **Run linters on staged files only**: `prek run`
+- **PyLint on everything** (slow): `pylint homeassistant`
+- **PyLint on specific folder**: `pylint homeassistant/components/my_integration`
+- **MyPy type checking (whole project)**: `mypy homeassistant/`
+- **MyPy on specific integration**: `mypy homeassistant/components/my_integration`
+
+### Testing
+- **Quick test of changed files**: `pytest --timeout=10 --picked`
+- **Update test snapshots**: Add `--snapshot-update` to pytest command
+  - ⚠️ Omit test results after using `--snapshot-update`
+  - Always run tests again without the flag to verify snapshots
+- **Full test suite** (AVOID - very slow): `pytest ./tests`
+
+### Dependencies & Requirements
+- **Update generated files after dependency changes**: `python -m script.gen_requirements_all`
+- **Install all Python requirements**:
+  ```bash
+  uv pip install -r requirements_all.txt -r requirements.txt -r requirements_test.txt
+  ```
+- **Install test requirements only**:
+  ```bash
+  uv pip install -r requirements_test_all.txt -r requirements.txt
+  ```
+
+### Translations
+- **Update translations after strings.json changes**:
+  ```bash
+  python -m script.translations develop --all
+  ```
+
+### Project Validation
+- **Run hassfest** (checks project structure and updates generated files):
+  ```bash
+  python -m script.hassfest
+  ```
+
+## Common Anti-Patterns & Best Practices
+
+### ❌ **Avoid These Patterns**
+```python
+# Blocking operations in event loop
+data = requests.get(url)  # ❌ Blocks event loop
+time.sleep(5)  # ❌ Blocks event loop
+
+# Reusing BleakClient instances
+self.client = BleakClient(address)
+await self.client.connect()
+# Later...
+await self.client.connect()  # ❌ Don't reuse
+
+# Hardcoded strings in code
+self._attr_name = "Temperature Sensor"  # ❌ Not translatable
+
+# Missing error handling
+data = await self.api.get_data()  # ❌ No exception handling
+
+# Storing sensitive data in diagnostics
+return {"api_key": entry.data[CONF_API_KEY]}  # ❌ Exposes secrets
+
+# Accessing hass.data directly in tests
+coordinator = hass.data[DOMAIN][entry.entry_id]  # ❌ Don't access hass.data
+
+# User-configurable polling intervals
+# In config flow
+vol.Optional("scan_interval", default=60): cv.positive_int  # ❌ Not allowed
+# In coordinator
+update_interval = timedelta(minutes=entry.data.get("scan_interval", 1))  # ❌ Not allowed
+
+# User-configurable config entry names (non-helper integrations)
+vol.Optional("name", default="My Device"): cv.string  # ❌ Not allowed in regular integrations
+
+# Too much code in try block
+try:
+    response = await client.get_data()  # Can throw
+    # ❌ Data processing should be outside try block
+    temperature = response["temperature"] / 10
+    humidity = response["humidity"]
+    self._attr_native_value = temperature
+except ClientError:
+    _LOGGER.error("Failed to fetch data")
+
+# Bare exceptions in regular code
+try:
+    value = await sensor.read_value()
+except Exception:  # ❌ Too broad - catch specific exceptions
+    _LOGGER.error("Failed to read sensor")
+```
+
+### ✅ **Use These Patterns Instead**
+```python
+# Async operations with executor
+data = await hass.async_add_executor_job(requests.get, url)
+await asyncio.sleep(5)  # ✅ Non-blocking
+
+# Fresh BleakClient instances
+client = BleakClient(address)  # ✅ New instance each time
+await client.connect()
+
+# Translatable entity names
+_attr_translation_key = "temperature_sensor"  # ✅ Translatable
+
+# Proper error handling
+try:
+    data = await self.api.get_data()
+except ApiException as err:
+    raise UpdateFailed(f"API error: {err}") from err
+
+# Redacted diagnostics data
+return async_redact_data(data, {"api_key", "password"})  # ✅ Safe
+
+# Test through proper integration setup and fixtures
+@pytest.fixture
+async def init_integration(hass, mock_config_entry, mock_api):
+    mock_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)  # ✅ Proper setup
+
+# Integration-determined polling intervals (not user-configurable)
+SCAN_INTERVAL = timedelta(minutes=5)  # ✅ Common pattern: constant in const.py
+
+class MyCoordinator(DataUpdateCoordinator[MyData]):
+    def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+        # ✅ Integration determines interval based on device capabilities, connection type, etc.
+        interval = timedelta(minutes=1) if client.is_local else SCAN_INTERVAL
+        super().__init__(
+            hass,
+            logger=LOGGER,
+            name=DOMAIN,
+            update_interval=interval,
+            config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+        )
+```

CLAUDE.md

@@ -1 +1 @@
-.github/copilot-instructions.md
+AGENTS.md

Dockerfile

@@ -30,7 +30,7 @@ RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
     # Install uv
-    && pip3 install uv==0.9.17
+    && pip3 install uv==0.9.26
 
 WORKDIR /usr/src
 

homeassistant/bootstrap.py

@@ -67,8 +67,6 @@ from .const import (
     BASE_PLATFORMS,
     FORMAT_DATETIME,
     KEY_DATA_LOGGING as DATA_LOGGING,
-    REQUIRED_NEXT_PYTHON_HA_RELEASE,
-    REQUIRED_NEXT_PYTHON_VER,
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
@@ -516,38 +514,6 @@ async def async_from_config_dict(
 
     stop = monotonic()
     _LOGGER.info("Home Assistant initialized in %.2fs", stop - start)
-
-    if (
-        REQUIRED_NEXT_PYTHON_HA_RELEASE
-        and sys.version_info[:3] < REQUIRED_NEXT_PYTHON_VER
-    ):
-        current_python_version = ".".join(str(x) for x in sys.version_info[:3])
-        required_python_version = ".".join(str(x) for x in REQUIRED_NEXT_PYTHON_VER[:2])
-        _LOGGER.warning(
-            (
-                "Support for the running Python version %s is deprecated and "
-                "will be removed in Home Assistant %s; "
-                "Please upgrade Python to %s"
-            ),
-            current_python_version,
-            REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            required_python_version,
-        )
-        issue_registry.async_create_issue(
-            hass,
-            core.DOMAIN,
-            f"python_version_{required_python_version}",
-            is_fixable=False,
-            severity=issue_registry.IssueSeverity.WARNING,
-            breaks_in_ha_version=REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            translation_key="python_version",
-            translation_placeholders={
-                "current_python_version": current_python_version,
-                "required_python_version": required_python_version,
-                "breaks_in_ha_version": REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            },
-        )
-
     return hass
 
 

homeassistant/components/advantage_air/__init__.py

@@ -8,12 +8,15 @@ from advantage_air import ApiError, advantage_air
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.debounce import Debouncer
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import ADVANTAGE_AIR_RETRY
+from .const import ADVANTAGE_AIR_RETRY, DOMAIN
 from .models import AdvantageAirData
+from .services import async_setup_services
 
 type AdvantageAirDataConfigEntry = ConfigEntry[AdvantageAirData]
 
@@ -32,6 +35,14 @@ PLATFORMS = [
 _LOGGER = logging.getLogger(__name__)
 REQUEST_REFRESH_DELAY = 0.5
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: AdvantageAirDataConfigEntry

homeassistant/components/advantage_air/sensor.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from decimal import Decimal
 from typing import Any
 
-import voluptuous as vol
-
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -14,7 +12,6 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AdvantageAirDataConfigEntry
@@ -24,7 +21,6 @@ from .models import AdvantageAirData
 
 ADVANTAGE_AIR_SET_COUNTDOWN_VALUE = "minutes"
 ADVANTAGE_AIR_SET_COUNTDOWN_UNIT = "min"
-ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
 
 PARALLEL_UPDATES = 0
 
@@ -53,13 +49,6 @@ async def async_setup_entry(
                     entities.append(AdvantageAirZoneSignal(instance, ac_key, zone_key))
     async_add_entities(entities)
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
-        {vol.Required("minutes"): cv.positive_int},
-        "set_time_to",
-    )
-
 
 class AdvantageAirTimeTo(AdvantageAirAcEntity, SensorEntity):
     """Representation of Advantage Air timer control."""

homeassistant/components/advantage_air/services.py

@@ -0,0 +1,27 @@
+"""Services for Advantage Air integration."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
+        entity_domain=SENSOR_DOMAIN,
+        schema={vol.Required("minutes"): cv.positive_int},
+        func="set_time_to",
+    )

homeassistant/components/apple_tv/__init__.py

@@ -51,7 +51,7 @@ DEFAULT_NAME_HP = "HomePod"
 BACKOFF_TIME_LOWER_LIMIT = 15  # seconds
 BACKOFF_TIME_UPPER_LIMIT = 300  # Five minutes
 
-PLATFORMS = [Platform.MEDIA_PLAYER, Platform.REMOTE]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.MEDIA_PLAYER, Platform.REMOTE]
 
 AUTH_EXCEPTIONS = (
     exceptions.AuthenticationError,

homeassistant/components/apple_tv/binary_sensor.py

@@ -0,0 +1,63 @@
+"""Binary sensor support for Apple TV."""
+
+from __future__ import annotations
+
+from pyatv.const import KeyboardFocusState
+from pyatv.interface import AppleTV, KeyboardListener
+
+from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.const import CONF_NAME
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AppleTvConfigEntry
+from .entity import AppleTVEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AppleTvConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Load Apple TV binary sensor based on a config entry."""
+    # apple_tv config entries always have a unique id
+    assert config_entry.unique_id is not None
+    name: str = config_entry.data[CONF_NAME]
+    manager = config_entry.runtime_data
+    async_add_entities([AppleTVKeyboardFocused(name, config_entry.unique_id, manager)])
+
+
+class AppleTVKeyboardFocused(AppleTVEntity, BinarySensorEntity, KeyboardListener):
+    """Binary sensor for Text input focused."""
+
+    _attr_translation_key = "keyboard_focused"
+    _attr_available = True
+
+    @callback
+    def async_device_connected(self, atv: AppleTV) -> None:
+        """Handle when connection is made to device."""
+        self._attr_available = True
+        # Listen to keyboard updates
+        atv.keyboard.listener = self
+        # Set initial state based on current focus state
+        self._update_state(atv.keyboard.text_focus_state == KeyboardFocusState.Focused)
+
+    @callback
+    def async_device_disconnected(self) -> None:
+        """Handle when connection was lost to device."""
+        self._attr_available = False
+        self._update_state(False)
+
+    def focusstate_update(
+        self, old_state: KeyboardFocusState, new_state: KeyboardFocusState
+    ) -> None:
+        """Update keyboard state when it changes.
+
+        This is a callback function from pyatv.interface.KeyboardListener.
+        """
+        self._update_state(new_state == KeyboardFocusState.Focused)
+
+    def _update_state(self, new_state: bool) -> None:
+        """Update and report."""
+        self._attr_is_on = new_state
+        self.async_write_ha_state()

homeassistant/components/apple_tv/entity.py

@@ -18,7 +18,6 @@ class AppleTVEntity(Entity):
 
     _attr_should_poll = False
     _attr_has_entity_name = True
-    _attr_name = None
     atv: AppleTVInterface | None = None
 
     def __init__(self, name: str, identifier: str, manager: AppleTVManager) -> None:

homeassistant/components/apple_tv/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "binary_sensor": {
+      "keyboard_focused": {
+        "default": "mdi:keyboard",
+        "state": {
+          "off": "mdi:keyboard-off"
+        }
+      }
+    }
+  }
+}

homeassistant/components/apple_tv/media_player.py

@@ -115,6 +115,7 @@ class AppleTvMediaPlayer(
     """Representation of an Apple TV media player."""
 
     _attr_supported_features = SUPPORT_APPLE_TV
+    _attr_name = None
 
     def __init__(self, name: str, identifier: str, manager: AppleTVManager) -> None:
         """Initialize the Apple TV media player."""

homeassistant/components/apple_tv/remote.py

@@ -51,6 +51,8 @@ async def async_setup_entry(
 class AppleTVRemote(AppleTVEntity, RemoteEntity):
     """Device that sends commands to an Apple TV."""
 
+    _attr_name = None
+
     @property
     def is_on(self) -> bool:
         """Return true if device is on."""

homeassistant/components/apple_tv/strings.json

@@ -62,6 +62,13 @@
       }
     }
   },
+  "entity": {
+    "binary_sensor": {
+      "keyboard_focused": {
+        "name": "Keyboard focus"
+      }
+    }
+  },
   "options": {
     "step": {
       "init": {

homeassistant/components/arve/__init__.py

@@ -2,14 +2,35 @@
 
 from __future__ import annotations
 
+import logging
+
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
 from .coordinator import ArveConfigEntry, ArveCoordinator
 
+_LOGGER = logging.getLogger(__name__)
+
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
+async def async_migrate_entry(hass: HomeAssistant, entry: ArveConfigEntry) -> bool:
+    """Migrate entry."""
+    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
+
+    if entry.version == 1:
+        # 1 -> 1.2: Unique ID from integer to string
+        if entry.minor_version == 1:
+            minor_version = 2
+            hass.config_entries.async_update_entry(
+                entry, unique_id=str(entry.unique_id), minor_version=minor_version
+            )
+
+    _LOGGER.debug("Migration successful")
+
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ArveConfigEntry) -> bool:
     """Set up Arve from a config entry."""
 

homeassistant/components/arve/config_flow.py

@@ -19,6 +19,9 @@ _LOGGER = logging.getLogger(__name__)
 class ArveConfigFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Arve."""
 
+    VERSION = 1
+    MINOR_VERSION = 2
+
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -35,7 +38,7 @@ class ArveConfigFlowHandler(ConfigFlow, domain=DOMAIN):
             except ArveConnectionError:
                 errors["base"] = "cannot_connect"
             else:
-                await self.async_set_unique_id(customer.customerId)
+                await self.async_set_unique_id(str(customer.customerId))
                 self._abort_if_unique_id_configured()
                 return self.async_create_entry(
                     title="Arve",

homeassistant/components/automation/__init__.py

@@ -125,6 +125,7 @@ NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
 _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
+    "device_tracker",
     "fan",
     "light",
     "siren",

homeassistant/components/bang_olufsen/__init__.py

@@ -17,10 +17,12 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_MODEL, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.ssl import get_default_context
 
 from .const import DOMAIN
+from .services import async_setup_services
 from .websocket import BeoWebsocket
 
 
@@ -41,6 +43,14 @@ PLATFORMS = [
     Platform.SENSOR,
 ]
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:
     """Set up from a config entry."""

homeassistant/components/bang_olufsen/media_player.py

@@ -38,7 +38,6 @@ from mozart_api.models import (
     VolumeState,
 )
 from mozart_api.mozart_client import MozartClient, get_highest_resolution_artwork
-import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -56,17 +55,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_MODEL, Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    entity_registry as er,
-)
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    async_get_current_platform,
-)
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.dt import utcnow
 
 from . import BeoConfigEntry
@@ -74,7 +66,6 @@ from .const import (
     BEO_REPEAT_FROM_HA,
     BEO_REPEAT_TO_HA,
     BEO_STATES,
-    BEOLINK_JOIN_SOURCES,
     BEOLINK_JOIN_SOURCES_TO_UPPER,
     CONF_BEOLINK_JID,
     CONNECTION_STATUS,
@@ -129,61 +120,6 @@ async def async_setup_entry(
         update_before_add=True,
     )
 
-    # Register actions.
-    platform = async_get_current_platform()
-
-    jid_regex = vol.Match(
-        r"(^\d{4})[.](\d{7})[.](\d{8})(@products\.bang-olufsen\.com)$"
-    )
-
-    platform.async_register_entity_service(
-        name="beolink_join",
-        schema={
-            vol.Optional("beolink_jid"): jid_regex,
-            vol.Optional("source_id"): vol.In(BEOLINK_JOIN_SOURCES),
-        },
-        func="async_beolink_join",
-    )
-
-    platform.async_register_entity_service(
-        name="beolink_expand",
-        schema={
-            vol.Exclusive("all_discovered", "devices", ""): cv.boolean,
-            vol.Exclusive(
-                "beolink_jids",
-                "devices",
-                "Define either specific Beolink JIDs or all discovered",
-            ): vol.All(
-                cv.ensure_list,
-                [jid_regex],
-            ),
-        },
-        func="async_beolink_expand",
-    )
-
-    platform.async_register_entity_service(
-        name="beolink_unexpand",
-        schema={
-            vol.Required("beolink_jids"): vol.All(
-                cv.ensure_list,
-                [jid_regex],
-            ),
-        },
-        func="async_beolink_unexpand",
-    )
-
-    platform.async_register_entity_service(
-        name="beolink_leave",
-        schema=None,
-        func="async_beolink_leave",
-    )
-
-    platform.async_register_entity_service(
-        name="beolink_allstandby",
-        schema=None,
-        func="async_beolink_allstandby",
-    )
-
 
 class BeoMediaPlayer(BeoEntity, MediaPlayerEntity):
     """Representation of a media player."""

homeassistant/components/bang_olufsen/services.py

@@ -0,0 +1,83 @@
+"""Services for Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import BEOLINK_JOIN_SOURCES, DOMAIN
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    jid_regex = vol.Match(
+        r"(^\d{4})[.](\d{7})[.](\d{8})(@products\.bang-olufsen\.com)$"
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "beolink_join",
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Optional("beolink_jid"): jid_regex,
+            vol.Optional("source_id"): vol.In(BEOLINK_JOIN_SOURCES),
+        },
+        func="async_beolink_join",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "beolink_expand",
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Exclusive("all_discovered", "devices", ""): cv.boolean,
+            vol.Exclusive(
+                "beolink_jids",
+                "devices",
+                "Define either specific Beolink JIDs or all discovered",
+            ): vol.All(
+                cv.ensure_list,
+                [jid_regex],
+            ),
+        },
+        func="async_beolink_expand",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "beolink_unexpand",
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={
+            vol.Required("beolink_jids"): vol.All(
+                cv.ensure_list,
+                [jid_regex],
+            ),
+        },
+        func="async_beolink_unexpand",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "beolink_leave",
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="async_beolink_leave",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "beolink_allstandby",
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="async_beolink_allstandby",
+    )

homeassistant/components/device_tracker/condition.py

@@ -0,0 +1,17 @@
+"""Provides conditions for device trackers."""
+
+from homeassistant.const import STATE_HOME, STATE_NOT_HOME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+from .const import DOMAIN
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_home": make_entity_state_condition(DOMAIN, STATE_HOME),
+    "is_not_home": make_entity_state_condition(DOMAIN, STATE_NOT_HOME),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for device trackers."""
+    return CONDITIONS

homeassistant/components/device_tracker/conditions.yaml

@@ -0,0 +1,17 @@
+.condition_common: &condition_common
+  target:
+    entity:
+      domain: device_tracker
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: condition_behavior
+          options:
+            - all
+            - any
+
+is_home: *condition_common
+is_not_home: *condition_common

homeassistant/components/device_tracker/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_home": {
+      "condition": "mdi:account"
+    },
+    "is_not_home": {
+      "condition": "mdi:account-arrow-right"
+    }
+  },
   "entity_component": {
     "_": {
       "default": "mdi:account",

homeassistant/components/device_tracker/strings.json

@@ -1,8 +1,32 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted device trackers.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted device trackers to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_home": {
+      "description": "Tests if one or more device trackers are home.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::device_tracker::common::condition_behavior_description%]",
+          "name": "[%key:component::device_tracker::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Device tracker is home"
+    },
+    "is_not_home": {
+      "description": "Tests if one or more device trackers are not home.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::device_tracker::common::condition_behavior_description%]",
+          "name": "[%key:component::device_tracker::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Device tracker is not home"
+    }
+  },
   "device_automation": {
     "condition_type": {
       "is_home": "{entity_name} is home",
@@ -49,6 +73,12 @@
     }
   },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/google_air_quality/icons.json

@@ -7,9 +7,6 @@
       "benzene": {
         "default": "mdi:molecule"
       },
-      "nitrogen_monoxide": {
-        "default": "mdi:molecule"
-      },
       "non_methane_hydrocarbons": {
         "default": "mdi:molecule"
       }

homeassistant/components/google_air_quality/sensor.py

@@ -138,8 +138,8 @@ AIR_QUALITY_SENSOR_TYPES: tuple[AirQualitySensorEntityDescription, ...] = (
     ),
     AirQualitySensorEntityDescription(
         key="no",
-        translation_key="nitrogen_monoxide",
         state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.NITROGEN_MONOXIDE,
         native_unit_of_measurement_fn=lambda x: x.pollutants.no.concentration.units,
         value_fn=lambda x: x.pollutants.no.concentration.value,
         exists_fn=lambda x: "no" in {p.code for p in x.pollutants},

homeassistant/components/google_air_quality/strings.json

@@ -205,9 +205,6 @@
           "so2": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]"
         }
       },
-      "nitrogen_monoxide": {
-        "name": "[%key:component::sensor::entity_component::nitrogen_monoxide::name%]"
-      },
       "non_methane_hydrocarbons": {
         "name": "Non-methane hydrocarbons"
       },

homeassistant/components/hikvision/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 import logging
+from xml.etree.ElementTree import ParseError
 
 from pyhik.constants import SENSOR_MAP
 from pyhik.hikvision import HikCamera
@@ -88,7 +89,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: HikvisionConfigEntry) ->
 
         def fetch_and_inject_nvr_events() -> None:
             """Fetch and inject NVR events in a single executor job."""
-            nvr_events = camera.get_event_triggers(nvr_notification_methods)
+            try:
+                nvr_events = camera.get_event_triggers(nvr_notification_methods)
+            except (requests.exceptions.RequestException, ParseError) as err:
+                _LOGGER.warning("Unable to fetch event triggers from %s: %s", host, err)
+                return
+
             _LOGGER.debug("NVR events fetched with extended methods: %s", nvr_events)
             if nvr_events:
                 # Map raw event type names to friendly names using SENSOR_MAP
@@ -101,6 +107,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: HikvisionConfigEntry) ->
                         mapped_events[friendly_name] = list(channels)
                 _LOGGER.debug("Mapped NVR events: %s", mapped_events)
                 camera.inject_events(mapped_events)
+            else:
+                _LOGGER.debug(
+                    "No event triggers returned from %s. "
+                    "Ensure events are configured on the device",
+                    host,
+                )
 
         await hass.async_add_executor_job(fetch_and_inject_nvr_events)
 

homeassistant/components/hikvision/binary_sensor.py

@@ -27,7 +27,6 @@ from homeassistant.const import (
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
     AddEntitiesCallback,
@@ -36,6 +35,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import HikvisionConfigEntry
 from .const import DEFAULT_PORT, DOMAIN
+from .entity import HikvisionEntity
 
 CONF_IGNORED = "ignored"
 
@@ -150,7 +150,12 @@ async def async_setup_entry(
 
     sensors = camera.current_event_states
     if sensors is None or not sensors:
-        _LOGGER.warning("Hikvision device has no sensors available")
+        _LOGGER.warning(
+            "Hikvision %s %s has no sensors available. "
+            "Ensure event detection is enabled and configured on the device",
+            data.device_type,
+            data.device_name,
+        )
         return
 
     async_add_entities(
@@ -164,10 +169,9 @@ async def async_setup_entry(
     )
 
 
-class HikvisionBinarySensor(BinarySensorEntity):
+class HikvisionBinarySensor(HikvisionEntity, BinarySensorEntity):
     """Representation of a Hikvision binary sensor."""
 
-    _attr_has_entity_name = True
     _attr_should_poll = False
 
     def __init__(
@@ -177,38 +181,14 @@ class HikvisionBinarySensor(BinarySensorEntity):
         channel: int,
     ) -> None:
         """Initialize the binary sensor."""
-        self._data = entry.runtime_data
-        self._camera = self._data.camera
+        super().__init__(entry, channel)
         self._sensor_type = sensor_type
-        self._channel = channel
 
-        # Build unique ID
+        # Build unique ID (includes sensor_type for uniqueness per sensor)
         self._attr_unique_id = f"{self._data.device_id}_{sensor_type}_{channel}"
 
-        # Device info for device registry
-        if self._data.device_type == "NVR":
-            # NVR channels get their own device linked to the NVR via via_device
-            self._attr_device_info = DeviceInfo(
-                identifiers={(DOMAIN, f"{self._data.device_id}_{channel}")},
-                via_device=(DOMAIN, self._data.device_id),
-                translation_key="nvr_channel",
-                translation_placeholders={
-                    "device_name": self._data.device_name,
-                    "channel_number": str(channel),
-                },
-                manufacturer="Hikvision",
-                model="NVR Channel",
-            )
-            self._attr_name = sensor_type
-        else:
-            # Single camera device
-            self._attr_device_info = DeviceInfo(
-                identifiers={(DOMAIN, self._data.device_id)},
-                name=self._data.device_name,
-                manufacturer="Hikvision",
-                model=self._data.device_type,
-            )
-            self._attr_name = sensor_type
+        # Set entity name
+        self._attr_name = sensor_type
 
         # Set device class
         self._attr_device_class = DEVICE_CLASS_MAP.get(sensor_type)

homeassistant/components/hikvision/camera.py

@@ -5,11 +5,10 @@ from __future__ import annotations
 from homeassistant.components.camera import Camera, CameraEntityFeature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HikvisionConfigEntry
-from .const import DOMAIN
+from .entity import HikvisionEntity
 
 PARALLEL_UPDATES = 0
 
@@ -35,10 +34,9 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class HikvisionCamera(Camera):
+class HikvisionCamera(HikvisionEntity, Camera):
     """Representation of a Hikvision camera."""
 
-    _attr_has_entity_name = True
     _attr_name = None
     _attr_supported_features = CameraEntityFeature.STREAM
 
@@ -48,37 +46,11 @@ class HikvisionCamera(Camera):
         channel: int,
     ) -> None:
         """Initialize the camera."""
-        super().__init__()
-        self._data = entry.runtime_data
-        self._channel = channel
-        self._camera = self._data.camera
+        super().__init__(entry, channel)
 
         # Build unique ID (unique per platform per integration)
         self._attr_unique_id = f"{self._data.device_id}_{channel}"
 
-        # Device info for device registry
-        if self._data.device_type == "NVR":
-            # NVR channels get their own device linked to the NVR via via_device
-            self._attr_device_info = DeviceInfo(
-                identifiers={(DOMAIN, f"{self._data.device_id}_{channel}")},
-                via_device=(DOMAIN, self._data.device_id),
-                translation_key="nvr_channel",
-                translation_placeholders={
-                    "device_name": self._data.device_name,
-                    "channel_number": str(channel),
-                },
-                manufacturer="Hikvision",
-                model="NVR Channel",
-            )
-        else:
-            # Single camera device
-            self._attr_device_info = DeviceInfo(
-                identifiers={(DOMAIN, self._data.device_id)},
-                name=self._data.device_name,
-                manufacturer="Hikvision",
-                model=self._data.device_type,
-            )
-
     async def async_camera_image(
         self, width: int | None = None, height: int | None = None
     ) -> bytes | None:

homeassistant/components/hikvision/entity.py

@@ -0,0 +1,49 @@
+"""Base entity for Hikvision integration."""
+
+from __future__ import annotations
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import Entity
+
+from . import HikvisionConfigEntry, HikvisionData
+from .const import DOMAIN
+
+
+class HikvisionEntity(Entity):
+    """Base class for Hikvision entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        entry: HikvisionConfigEntry,
+        channel: int,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__()
+        self._data: HikvisionData = entry.runtime_data
+        self._camera = self._data.camera
+        self._channel = channel
+
+        # Device info for device registry
+        if self._data.device_type == "NVR":
+            # NVR channels get their own device linked to the NVR via via_device
+            self._attr_device_info = DeviceInfo(
+                identifiers={(DOMAIN, f"{self._data.device_id}_{channel}")},
+                via_device=(DOMAIN, self._data.device_id),
+                translation_key="nvr_channel",
+                translation_placeholders={
+                    "device_name": self._data.device_name,
+                    "channel_number": str(channel),
+                },
+                manufacturer="Hikvision",
+                model="NVR Channel",
+            )
+        else:
+            # Single camera device
+            self._attr_device_info = DeviceInfo(
+                identifiers={(DOMAIN, self._data.device_id)},
+                name=self._data.device_name,
+                manufacturer="Hikvision",
+                model=self._data.device_type,
+            )

homeassistant/components/homeassistant/strings.json

@@ -157,10 +157,6 @@
       "description": "The {domain} integration does not support configuration under its own key, it must be configured under its supported platforms.\n\nTo resolve this:\n\n1. Remove `{domain}:` from your YAML configuration file.\n\n2. Restart Home Assistant.",
       "title": "The {domain} integration does not support YAML configuration under its own key"
     },
-    "python_version": {
-      "description": "Support for running Home Assistant in the currently used Python version {current_python_version} is deprecated and will be removed in Home Assistant {breaks_in_ha_version}. Please upgrade Python to {required_python_version} to prevent your Home Assistant instance from breaking.",
-      "title": "Support for Python {current_python_version} is being removed"
-    },
     "storage_corruption": {
       "fix_flow": {
         "step": {

homeassistant/components/http/__init__.py

@@ -108,7 +108,6 @@ _DEFAULT_BIND = ["0.0.0.0", "::"] if _HAS_IPV6 else ["0.0.0.0"]
 
 HTTP_SCHEMA: Final = vol.All(
     cv.deprecated(CONF_BASE_URL),
-    cv.deprecated(CONF_SERVER_HOST),  # Deprecated in HA Core 2025.12
     vol.Schema(
         {
             vol.Optional(CONF_SERVER_HOST): vol.All(
@@ -209,20 +208,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     if conf is None:
         conf = cast(ConfData, HTTP_SCHEMA({}))
 
-    if CONF_SERVER_HOST in conf:
-        if is_hassio(hass):
-            issue_id = "server_host_deprecated_hassio"
-            severity = ir.IssueSeverity.ERROR
-        else:
-            issue_id = "server_host_deprecated"
-            severity = ir.IssueSeverity.WARNING
+    if CONF_SERVER_HOST in conf and is_hassio(hass):
+        issue_id = "server_host_deprecated_hassio"
         ir.async_create_issue(
             hass,
             DOMAIN,
             issue_id,
             breaks_in_ha_version="2026.6.0",
             is_fixable=False,
-            severity=severity,
+            severity=ir.IssueSeverity.ERROR,
             translation_key=issue_id,
         )
 

homeassistant/components/http/strings.json

@@ -1,9 +1,5 @@
 {
   "issues": {
-    "server_host_deprecated": {
-      "description": "The `server_host` configuration option in the HTTP integration is deprecated and will be removed.\n\nIf you are using this option to bind Home Assistant to specific network interfaces, please remove it from your configuration. Home Assistant will automatically bind to all available interfaces by default.\n\nIf you have specific networking requirements, consider using firewall rules or other network configuration to control access to Home Assistant.",
-      "title": "The `server_host` HTTP configuration option is deprecated"
-    },
     "server_host_deprecated_hassio": {
       "description": "The deprecated `server_host` configuration option in the HTTP integration is prone to break the communication between Home Assistant Core and Supervisor, and will be removed.\n\nIf you are using this option to bind Home Assistant to specific network interfaces, please remove it from your configuration. Home Assistant will automatically bind to all available interfaces by default.\n\nIf you have specific networking requirements, consider using firewall rules or other network configuration to control access to Home Assistant.",
       "title": "The `server_host` HTTP configuration may break Home Assistant Core - Supervisor communication"

homeassistant/components/insteon/manifest.json

@@ -19,7 +19,7 @@
   "loggers": ["pyinsteon", "pypubsub"],
   "requirements": [
     "pyinsteon==1.6.4",
-    "insteon-frontend-home-assistant==0.6.0"
+    "insteon-frontend-home-assistant==0.6.1"
   ],
   "single_config_entry": true,
   "usb": [

homeassistant/components/iometer/sensor.py

@@ -73,7 +73,7 @@ SENSOR_TYPES: list[IOmeterEntityDescription] = [
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
         state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.status.device.core.battery_level,
+        value_fn=lambda data: int(round(data.status.device.core.battery_level)),
     ),
     IOmeterEntityDescription(
         key="pin_status",

homeassistant/components/microbees/__init__.py

@@ -2,6 +2,7 @@
 
 from dataclasses import dataclass
 from http import HTTPStatus
+import logging
 
 import aiohttp
 from microBeesPy import MicroBees
@@ -15,6 +16,8 @@ from homeassistant.helpers import config_entry_oauth2_flow
 from .const import DOMAIN, PLATFORMS
 from .coordinator import MicroBeesUpdateCoordinator
 
+_LOGGER = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True, kw_only=True)
 class HomeAssistantMicroBeesData:
@@ -25,6 +28,23 @@ class HomeAssistantMicroBeesData:
     session: config_entry_oauth2_flow.OAuth2Session
 
 
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate entry."""
+    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
+
+    if entry.version == 1:
+        # 1 -> 1.2: Unique ID from integer to string
+        if entry.minor_version == 1:
+            minor_version = 2
+            hass.config_entries.async_update_entry(
+                entry, unique_id=str(entry.unique_id), minor_version=minor_version
+            )
+
+    _LOGGER.debug("Migration successful")
+
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up microBees from a config entry."""
     implementation = (

homeassistant/components/microbees/config_flow.py

@@ -19,6 +19,8 @@ class OAuth2FlowHandler(
     """Handle a config flow for microBees."""
 
     DOMAIN = DOMAIN
+    VERSION = 1
+    MINOR_VERSION = 2
 
     @property
     def logger(self) -> logging.Logger:
@@ -47,7 +49,7 @@ class OAuth2FlowHandler(
             self.logger.exception("Unexpected error")
             return self.async_abort(reason="unknown")
 
-        await self.async_set_unique_id(current_user.id)
+        await self.async_set_unique_id(str(current_user.id))
         if self.source != SOURCE_REAUTH:
             self._abort_if_unique_id_configured()
             return self.async_create_entry(

homeassistant/components/monzo/__init__.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import logging
+
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -15,9 +17,28 @@ from .api import AuthenticatedMonzoAPI
 from .const import DOMAIN
 from .coordinator import MonzoCoordinator
 
+_LOGGER = logging.getLogger(__name__)
+
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate entry."""
+    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
+
+    if entry.version == 1:
+        # 1 -> 1.2: Unique ID from integer to string
+        if entry.minor_version == 1:
+            minor_version = 2
+            hass.config_entries.async_update_entry(
+                entry, unique_id=str(entry.unique_id), minor_version=minor_version
+            )
+
+    _LOGGER.debug("Migration successful")
+
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Monzo from a config entry."""
     implementation = await async_get_config_entry_implementation(hass, entry)

homeassistant/components/monzo/config_flow.py

@@ -21,6 +21,8 @@ class MonzoFlowHandler(
     """Handle a config flow."""
 
     DOMAIN = DOMAIN
+    VERSION = 1
+    MINOR_VERSION = 2
 
     oauth_data: dict[str, Any]
 
@@ -51,7 +53,7 @@ class MonzoFlowHandler(
         """Create an entry for the flow."""
         self.oauth_data = data
         user_id = data[CONF_TOKEN]["user_id"]
-        await self.async_set_unique_id(user_id)
+        await self.async_set_unique_id(str(user_id))
         if self.source != SOURCE_REAUTH:
             self._abort_if_unique_id_configured()
         else:

homeassistant/components/music_assistant/const.py

@@ -51,6 +51,7 @@ ATTR_ALBUM = "album"
 ATTR_URL = "url"
 ATTR_USE_PRE_ANNOUNCE = "use_pre_announce"
 ATTR_ANNOUNCE_VOLUME = "announce_volume"
+ATTR_PRE_ANNOUNCE_URL = "pre_announce_url"
 ATTR_SOURCE_PLAYER = "source_player"
 ATTR_AUTO_PLAY = "auto_play"
 ATTR_QUEUE_ID = "queue_id"

homeassistant/components/music_assistant/manifest.json

@@ -10,6 +10,6 @@
   "iot_class": "local_push",
   "loggers": ["music_assistant"],
   "quality_scale": "bronze",
-  "requirements": ["music-assistant-client==1.3.2"],
+  "requirements": ["music-assistant-client==1.3.3"],
   "zeroconf": ["_mass._tcp.local."]
 }

homeassistant/components/music_assistant/media_player.py

@@ -356,6 +356,7 @@ class MusicAssistantPlayer(MusicAssistantEntity, MediaPlayerEntity):
             await self._async_handle_play_announcement(
                 media_id,
                 use_pre_announce=kwargs[ATTR_MEDIA_EXTRA].get("use_pre_announce"),
+                pre_announce_url=kwargs[ATTR_MEDIA_EXTRA].get("pre_announce_url"),
                 announce_volume=kwargs[ATTR_MEDIA_EXTRA].get("announce_volume"),
             )
             return
@@ -464,11 +465,16 @@ class MusicAssistantPlayer(MusicAssistantEntity, MediaPlayerEntity):
         self,
         url: str,
         use_pre_announce: bool | None = None,
+        pre_announce_url: str | None = None,
         announce_volume: int | None = None,
     ) -> None:
         """Send the play_announcement command to the media player."""
         await self.mass.players.play_announcement(
-            self.player_id, url, use_pre_announce, announce_volume
+            self.player_id,
+            url,
+            pre_announce=use_pre_announce,
+            pre_announce_url=pre_announce_url,
+            volume_level=announce_volume,
         )
 
     @catch_musicassistant_error

homeassistant/components/music_assistant/services.py

@@ -42,6 +42,7 @@ from .const import (
     ATTR_ORDER_BY,
     ATTR_PLAYLISTS,
     ATTR_PODCASTS,
+    ATTR_PRE_ANNOUNCE_URL,
     ATTR_RADIO,
     ATTR_RADIO_MODE,
     ATTR_SEARCH,
@@ -150,6 +151,7 @@ def register_actions(hass: HomeAssistant) -> None:
         schema={
             vol.Required(ATTR_URL): cv.string,
             vol.Optional(ATTR_USE_PRE_ANNOUNCE): vol.Coerce(bool),
+            vol.Optional(ATTR_PRE_ANNOUNCE_URL): cv.string,
             vol.Optional(ATTR_ANNOUNCE_VOLUME): vol.Coerce(int),
         },
         func="_async_handle_play_announcement",

homeassistant/components/music_assistant/services.yaml

@@ -68,6 +68,10 @@ play_announcement:
       example: "true"
       selector:
         boolean:
+    pre_announce_url:
+      example: "http://someremotesite.com/chime.mp3"
+      selector:
+        text:
     announce_volume:
       example: 75
       selector:

homeassistant/components/music_assistant/strings.json

@@ -169,6 +169,10 @@
           "description": "Use a forced volume level for the announcement. Omit to use player default.",
           "name": "Announce volume"
         },
+        "pre_announce_url": {
+          "description": "URL to the pre-announcement sound.",
+          "name": "Pre-announce URL"
+        },
         "url": {
           "description": "URL to the notification sound.",
           "name": "URL"

homeassistant/components/number/const.py

@@ -253,7 +253,7 @@ class NumberDeviceClass(StrEnum):
     NITROGEN_MONOXIDE = "nitrogen_monoxide"
     """Amount of NO.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion), `μg/m³`
     """
 
     NITROUS_OXIDE = "nitrous_oxide"
@@ -521,7 +521,10 @@ DEVICE_CLASS_UNITS: dict[NumberDeviceClass, set[type[StrEnum] | str | None]] = {
         CONCENTRATION_PARTS_PER_BILLION,
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     },
-    NumberDeviceClass.NITROGEN_MONOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    NumberDeviceClass.NITROGEN_MONOXIDE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     NumberDeviceClass.NITROUS_OXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     NumberDeviceClass.OZONE: {
         CONCENTRATION_PARTS_PER_BILLION,

homeassistant/components/opower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
   "quality_scale": "bronze",
-  "requirements": ["opower==0.16.4"]
+  "requirements": ["opower==0.16.5"]
 }

homeassistant/components/playstation_network/strings.json

@@ -24,7 +24,7 @@
         "data_description": {
           "npsso": "[%key:component::playstation_network::config::step::user::data_description::npsso%]"
         },
-        "description": "The NPSSO token for **{name}** has expired. To obtain a new one, log in to your [PlayStation account]({psn_link}) first. Then [click here]({npsso_link}) to retrieve the token.",
+        "description": "The NPSSO token for **{name}** has expired. To obtain a new one, log in to your [PlayStation account]({psn_link}) first. Then [click here]({npsso_link}) to retrieve the token.\n\nNote: After obtaining the NPSSO token, do not log out of your PlayStation account, as this will invalidate the token.",
         "title": "Re-authenticate {name} with PlayStation Network"
       },
       "reconfigure": {
@@ -44,7 +44,7 @@
         "data_description": {
           "npsso": "The NPSSO token is generated upon successful login of your PlayStation Network account and is used to authenticate your requests within Home Assistant."
         },
-        "description": "To obtain your NPSSO token, log in to your [PlayStation account]({psn_link}) first. Then [click here]({npsso_link}) to retrieve the token."
+        "description": "To obtain your NPSSO token, log in to your [PlayStation account]({psn_link}) first. Then [click here]({npsso_link}) to retrieve the token.\n\nNote: Do not log out of your PlayStation account after obtaining the NPSSO token."
       }
     }
   },

homeassistant/components/rachio/manifest.json

@@ -23,6 +23,7 @@
   "homekit": {
     "models": ["Rachio"]
   },
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["rachiopy"],
   "requirements": ["RachioPy==1.1.0"],

homeassistant/components/rainforest_eagle/manifest.json

@@ -9,6 +9,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/rainforest_eagle",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["aioeagle", "eagle100"],
   "requirements": ["aioeagle==1.1.0", "eagle100==0.1.1"]

homeassistant/components/recorder/statistics.py

@@ -60,6 +60,7 @@ from homeassistant.util.unit_conversion import (
     MassConverter,
     MassVolumeConcentrationConverter,
     NitrogenDioxideConcentrationConverter,
+    NitrogenMonoxideConcentrationConverter,
     OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
@@ -228,6 +229,7 @@ _PRIMARY_UNIT_CONVERTERS: list[type[BaseUnitConverter]] = [
 _SECONDARY_UNIT_CONVERTERS: list[type[BaseUnitConverter]] = [
     CarbonMonoxideConcentrationConverter,
     NitrogenDioxideConcentrationConverter,
+    NitrogenMonoxideConcentrationConverter,
     OzoneConcentrationConverter,
     SulphurDioxideConcentrationConverter,
     TemperatureDeltaConverter,

homeassistant/components/recorder/websocket_api.py

@@ -34,6 +34,7 @@ from homeassistant.util.unit_conversion import (
     MassConverter,
     MassVolumeConcentrationConverter,
     NitrogenDioxideConcentrationConverter,
+    NitrogenMonoxideConcentrationConverter,
     OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
@@ -94,6 +95,9 @@ UNIT_SCHEMA = vol.Schema(
         vol.Optional("nitrogen_dioxide"): vol.In(
             NitrogenDioxideConcentrationConverter.VALID_UNITS
         ),
+        vol.Optional("nitrogen_monoxide"): vol.In(
+            NitrogenMonoxideConcentrationConverter.VALID_UNITS
+        ),
         vol.Optional("ozone"): vol.In(OzoneConcentrationConverter.VALID_UNITS),
         vol.Optional("power"): vol.In(PowerConverter.VALID_UNITS),
         vol.Optional("pressure"): vol.In(PressureConverter.VALID_UNITS),

homeassistant/components/screenlogic/manifest.json

@@ -13,6 +13,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/screenlogic",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["screenlogicpy"],
   "requirements": ["screenlogicpy==0.10.2"]

homeassistant/components/sensor/const.py

@@ -64,6 +64,7 @@ from homeassistant.util.unit_conversion import (
     MassConverter,
     MassVolumeConcentrationConverter,
     NitrogenDioxideConcentrationConverter,
+    NitrogenMonoxideConcentrationConverter,
     OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
@@ -291,7 +292,7 @@ class SensorDeviceClass(StrEnum):
     NITROGEN_MONOXIDE = "nitrogen_monoxide"
     """Amount of NO.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion), `μg/m³`
     """
 
     NITROUS_OXIDE = "nitrous_oxide"
@@ -566,6 +567,7 @@ UNIT_CONVERTERS: dict[SensorDeviceClass | str | None, type[BaseUnitConverter]] =
     SensorDeviceClass.ENERGY_STORAGE: EnergyConverter,
     SensorDeviceClass.GAS: VolumeConverter,
     SensorDeviceClass.NITROGEN_DIOXIDE: NitrogenDioxideConcentrationConverter,
+    SensorDeviceClass.NITROGEN_MONOXIDE: NitrogenMonoxideConcentrationConverter,
     SensorDeviceClass.OZONE: OzoneConcentrationConverter,
     SensorDeviceClass.POWER: PowerConverter,
     SensorDeviceClass.POWER_FACTOR: UnitlessRatioConverter,
@@ -639,7 +641,10 @@ DEVICE_CLASS_UNITS: dict[SensorDeviceClass, set[type[StrEnum] | str | None]] = {
         CONCENTRATION_PARTS_PER_BILLION,
         CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     },
-    SensorDeviceClass.NITROGEN_MONOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    SensorDeviceClass.NITROGEN_MONOXIDE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     SensorDeviceClass.NITROUS_OXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     SensorDeviceClass.OZONE: {
         CONCENTRATION_PARTS_PER_BILLION,

homeassistant/components/template/alarm_control_panel.py

@@ -355,16 +355,3 @@ class TriggerAlarmControlPanelEntity(TriggerEntity, AbstractTemplateAlarmControl
         """Restore last state."""
         await super().async_added_to_hass()
         await self._async_handle_restored_state()
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle update of the data."""
-        self._process_data()
-
-        if not self.available:
-            self.async_write_ha_state()
-            return
-
-        if self.handle_rendered_result(CONF_STATE):
-            self.async_set_context(self.coordinator.data["context"])
-            self.async_write_ha_state()

homeassistant/components/template/binary_sensor.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from abc import abstractmethod
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from functools import partial
@@ -183,8 +184,32 @@ class AbstractTemplateBinarySensor(
 
         self._attr_device_class = config.get(CONF_DEVICE_CLASS)
         self._template: template.Template = config[CONF_STATE]
+        self._delay_on = None
+        self._delay_off = None
         self._delay_cancel: CALLBACK_TYPE | None = None
 
+        self.setup_state_template(
+            CONF_STATE,
+            "_attr_is_on",
+            on_update=self._update_state,
+        )
+        self._delay_on = None
+        try:
+            self._delay_on = cv.positive_time_period(config.get(CONF_DELAY_ON))
+        except vol.Invalid:
+            self.setup_template(CONF_DELAY_ON, "_delay_on", cv.positive_time_period)
+
+        self._delay_off = None
+        try:
+            self._delay_off = cv.positive_time_period(config.get(CONF_DELAY_OFF))
+        except vol.Invalid:
+            self.setup_template(CONF_DELAY_OFF, "_delay_off", cv.positive_time_period)
+
+    @callback
+    @abstractmethod
+    def _update_state(self, result: Any) -> None:
+        """Update the state."""
+
 
 class StateBinarySensorEntity(TemplateEntity, AbstractTemplateBinarySensor):
     """A virtual binary sensor that triggers from another sensor."""
@@ -200,17 +225,15 @@ class StateBinarySensorEntity(TemplateEntity, AbstractTemplateBinarySensor):
         """Initialize the Template binary sensor."""
         TemplateEntity.__init__(self, hass, config, unique_id)
         AbstractTemplateBinarySensor.__init__(self, config)
-        self._delay_on = None
-        self._delay_on_template = config.get(CONF_DELAY_ON)
-        self._delay_off = None
-        self._delay_off_template = config.get(CONF_DELAY_OFF)
 
     async def async_added_to_hass(self) -> None:
         """Restore state."""
         if (
             (
-                self._delay_on_template is not None
-                or self._delay_off_template is not None
+                CONF_DELAY_ON in self._templates
+                or CONF_DELAY_OFF in self._templates
+                or self._delay_on is not None
+                or self._delay_off is not None
             )
             and (last_state := await self.async_get_last_state()) is not None
             and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
@@ -218,29 +241,6 @@ class StateBinarySensorEntity(TemplateEntity, AbstractTemplateBinarySensor):
             self._attr_is_on = last_state.state == STATE_ON
         await super().async_added_to_hass()
 
-    @callback
-    def _async_setup_templates(self) -> None:
-        """Set up templates."""
-        self.add_template_attribute("_state", self._template, None, self._update_state)
-
-        if self._delay_on_template is not None:
-            try:
-                self._delay_on = cv.positive_time_period(self._delay_on_template)
-            except vol.Invalid:
-                self.add_template_attribute(
-                    "_delay_on", self._delay_on_template, cv.positive_time_period
-                )
-
-        if self._delay_off_template is not None:
-            try:
-                self._delay_off = cv.positive_time_period(self._delay_off_template)
-            except vol.Invalid:
-                self.add_template_attribute(
-                    "_delay_off", self._delay_off_template, cv.positive_time_period
-                )
-
-        super()._async_setup_templates()
-
     @callback
     def _update_state(self, result):
         super()._update_state(result)
@@ -291,15 +291,11 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
         TriggerEntity.__init__(self, hass, coordinator, config)
         AbstractTemplateBinarySensor.__init__(self, config)
 
-        for key in (CONF_STATE, CONF_DELAY_ON, CONF_DELAY_OFF, CONF_AUTO_OFF):
-            if isinstance(config.get(key), template.Template):
-                self._to_render_simple.append(key)
-                self._parse_result.add(key)
-
         self._last_delay_from: bool | None = None
         self._last_delay_to: bool | None = None
         self._auto_off_cancel: CALLBACK_TYPE | None = None
         self._auto_off_time: datetime | None = None
+        self.setup_template(CONF_AUTO_OFF, "_auto_off_time", cv.positive_time_period)
 
     async def async_added_to_hass(self) -> None:
         """Restore last state."""
@@ -329,26 +325,7 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
                 self._set_auto_off(auto_off_time)
 
     @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle update of the data."""
-        self._process_data()
-
-        raw = self._rendered.get(CONF_STATE)
-        state: bool | None = None
-        if raw is not None:
-            state = template.result_as_boolean(raw)
-
-        key = CONF_DELAY_ON if state else CONF_DELAY_OFF
-        delay = self._rendered.get(key) or self._config.get(key)
-
-        if (
-            self._delay_cancel
-            and delay
-            and self._attr_is_on == self._last_delay_from
-            and state == self._last_delay_to
-        ):
-            return
-
+    def _cancel_delays(self):
         if self._delay_cancel:
             self._delay_cancel()
             self._delay_cancel = None
@@ -358,10 +335,27 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
             self._auto_off_cancel = None
             self._auto_off_time = None
 
-        if not self.available:
-            self.async_write_ha_state()
+    @callback
+    def _update_state(self, result):
+        state: bool | None = None
+        if result is not None:
+            state = template.result_as_boolean(result)
+
+        if state:
+            delay = self._rendered.get(CONF_DELAY_ON) or self._delay_on
+        else:
+            delay = self._rendered.get(CONF_DELAY_OFF) or self._delay_off
+
+        if (
+            self._delay_cancel
+            and delay
+            and self._attr_is_on == self._last_delay_from
+            and state == self._last_delay_to
+        ):
             return
 
+        self._cancel_delays()
+
         # state without delay.
         if self._attr_is_on == state or delay is None:
             self._set_state(state)
@@ -371,6 +365,7 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
             try:
                 delay = cv.positive_time_period(delay)
             except vol.Invalid as err:
+                key = CONF_DELAY_ON if state else CONF_DELAY_OFF
                 logging.getLogger(__name__).warning(
                     "Error rendering %s template: %s", key, err
                 )
@@ -412,6 +407,14 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
         auto_off_time = dt_util.utcnow() + auto_off_delay
         self._set_auto_off(auto_off_time)
 
+    def _render_availability_template(self, variables):
+        available = super()._render_availability_template(variables)
+        if not available:
+            # Cancel any delay_on, delay_off, or auto_off when
+            # the entity goes unavailable
+            self._cancel_delays()
+        return available
+
     def _set_auto_off(self, auto_off_time: datetime) -> None:
         @callback
         def _auto_off(_):

homeassistant/components/template/cover.py

@@ -500,7 +500,6 @@ class TriggerCoverEntity(TriggerEntity, AbstractTemplateCover):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/entity.py

@@ -96,6 +96,30 @@ class AbstractTemplateEntity(Entity):
     ) -> None:
         """Set up a template that manages the main state of the entity."""
 
+    @abstractmethod
+    def setup_template(
+        self,
+        option: str,
+        attribute: str,
+        validator: Callable[[Any], Any] | None = None,
+        on_update: Callable[[Any], None] | None = None,
+    ) -> None:
+        """Set up a template that manages any property or attribute of the entity.
+
+        Parameters
+        ----------
+        option
+            The configuration key provided by ConfigFlow or the yaml option
+        attribute
+            The name of the attribute to link to. This attribute must exist
+            unless a custom on_update method is supplied.
+        validator:
+            Optional function that validates the rendered result.
+        on_update:
+            Called to store the template result rather than storing it
+            the supplied attribute. Passed the result of the validator.
+        """
+
     def add_template(
         self,
         option: str,
@@ -109,7 +133,11 @@ class AbstractTemplateEntity(Entity):
         if (template := self._config.get(option)) and isinstance(template, Template):
             if add_if_static or (not template.is_static):
                 self._templates[option] = EntityTemplate(
-                    attribute, template, validator, on_update, none_on_template_error
+                    attribute,
+                    template,
+                    validator,
+                    on_update,
+                    none_on_template_error,
                 )
             return template
 

homeassistant/components/template/event.py

@@ -224,7 +224,6 @@ class TriggerEventEntity(TriggerEntity, AbstractTemplateEvent, RestoreEntity):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         for key, updater in (

homeassistant/components/template/fan.py

@@ -552,7 +552,6 @@ class TriggerFanEntity(TriggerEntity, AbstractTemplateFan):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/image.py

@@ -180,3 +180,4 @@ class TriggerImageEntity(TriggerEntity, AbstractTemplateImage):
         """Process new data."""
         super()._process_data()
         self._handle_state(self._rendered.get(CONF_URL))
+        self.async_write_ha_state()

homeassistant/components/template/light.py

@@ -1123,7 +1123,6 @@ class TriggerLightEntity(TriggerEntity, AbstractTemplateLight):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/lock.py

@@ -377,7 +377,6 @@ class TriggerLockEntity(TriggerEntity, AbstractTemplateLock):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/number.py

@@ -236,7 +236,6 @@ class TriggerNumberEntity(TriggerEntity, AbstractTemplateNumber):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/select.py

@@ -209,7 +209,6 @@ class TriggerSelectEntity(TriggerEntity, AbstractTemplateSelect):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/sensor.py

@@ -323,3 +323,4 @@ class TriggerSensorEntity(TriggerEntity, AbstractTemplateSensor):
 
         rendered = self._rendered.get(CONF_STATE)
         self._handle_state(rendered)
+        self.async_write_ha_state()

homeassistant/components/template/switch.py

@@ -281,7 +281,6 @@ class TriggerSwitchEntity(TriggerEntity, AbstractTemplateSwitch):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/template_entity.py

@@ -303,6 +303,30 @@ class TemplateEntity(AbstractTemplateEntity):
 
         self.add_template(option, attribute, on_update=_update_state)
 
+    def setup_template(
+        self,
+        option: str,
+        attribute: str,
+        validator: Callable[[Any], Any] | None = None,
+        on_update: Callable[[Any], None] | None = None,
+    ):
+        """Set up a template that manages any property or attribute of the entity.
+
+        Parameters
+        ----------
+        option
+            The configuration key provided by ConfigFlow or the yaml option
+        attribute
+            The name of the attribute to link to. This attribute must exist
+            unless a custom on_update method is supplied.
+        validator:
+            Optional function that validates the rendered result.
+        on_update:
+            Called to store the template result rather than storing it
+            the supplied attribute. Passed the result of the validator.
+        """
+        self.add_template(option, attribute, validator, on_update, True)
+
     def add_template_attribute(
         self,
         attribute: str,

homeassistant/components/template/trigger_entity.py

@@ -59,10 +59,33 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
         on_update: Callable[[Any], None] | None = None,
     ) -> None:
         """Set up a template that manages the main state of the entity."""
-        if self._config.get(option):
-            self._to_render_simple.append(CONF_STATE)
-            self._parse_result.add(CONF_STATE)
-            self.add_template(option, attribute, validator, on_update)
+        if self.add_template(option, attribute, validator, on_update):
+            self._to_render_simple.append(option)
+            self._parse_result.add(option)
+
+    def setup_template(
+        self,
+        option: str,
+        attribute: str,
+        validator: Callable[[Any], Any] | None = None,
+        on_update: Callable[[Any], None] | None = None,
+    ) -> None:
+        """Set up a template that manages any property or attribute of the entity.
+
+        Parameters
+        ----------
+        option
+            The configuration key provided by ConfigFlow or the yaml option
+        attribute
+            The name of the attribute to link to. This attribute must exist
+            unless a custom on_update method is supplied.
+        validator:
+            Optional function that validates the rendered result.
+        on_update:
+            Called to store the template result rather than storing it
+            the supplied attribute. Passed the result of the validator.
+        """
+        self.setup_state_template(option, attribute, validator, on_update)
 
     @property
     def referenced_blueprint(self) -> str | None:
@@ -103,21 +126,35 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
         self._render_attributes(rendered, variables)
         self._rendered = rendered
 
-    def handle_rendered_result(self, key: str) -> bool:
+    def _handle_rendered_results(self) -> bool:
         """Get a rendered result and return the value."""
-        if (rendered := self._rendered.get(key)) is not None:
-            if (entity_template := self._templates.get(key)) is not None:
+        # Handle any templates.
+        for option, entity_template in self._templates.items():
+            value = _SENTINEL
+            if (rendered := self._rendered.get(option)) is not None:
                 value = rendered
-                if entity_template.validator:
-                    value = entity_template.validator(rendered)
 
-                if entity_template.on_update:
-                    entity_template.on_update(value)
-                else:
-                    setattr(self, entity_template.attribute, value)
+            if entity_template.validator:
+                value = entity_template.validator(rendered)
 
+            # Capture templates that did not render a result due to an exception and
+            # ensure the state object updates. _SENTINEL is used to differentiate
+            # templates that render None.
+            if value is _SENTINEL:
                 return True
 
+            if entity_template.on_update:
+                entity_template.on_update(value)
+            else:
+                setattr(self, entity_template.attribute, value)
+            return True
+
+        if len(self._rendered) > 0:
+            # In some cases, the entity may be state optimistic or
+            # attribute optimistic, in these scenarios the state needs
+            # to update.
+            return True
+
         return False
 
     @callback
@@ -136,13 +173,35 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
         else:
             self._rendered_entity_variables = coordinator_variables
         variables = self._template_variables(self._rendered_entity_variables)
+
+        self.async_set_context(self.coordinator.data["context"])
         if self._render_availability_template(variables):
             self._render_templates(variables)
 
-        self.async_set_context(self.coordinator.data["context"])
+            write_state = False
+            # While transitioning platforms to the new framework, this
+            # if-statement is necessary for backward compatibility with existing
+            # trigger based platforms.
+            if self._templates:
+                # Handle any results that were rendered.
+                write_state = self._handle_rendered_results()
+
+            # Check availability after rendering the results because the state
+            # template could render the entity unavailable
+            if not self.available:
+                write_state = True
+
+            if write_state:
+                self.async_write_ha_state()
+        else:
+            self.async_write_ha_state()
 
     @callback
     def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
+        """Handle updated data from the coordinator.
+
+        While transitioning platforms to the new framework, this
+        function is necessary for backward compatibility with existing
+        trigger based platforms.
+        """
         self._process_data()
-        self.async_write_ha_state()

homeassistant/components/template/update.py

@@ -438,7 +438,6 @@ class TriggerUpdateEntity(TriggerEntity, AbstractTemplateUpdate):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/vacuum.py

@@ -489,7 +489,6 @@ class TriggerVacuumEntity(TriggerEntity, AbstractTemplateVacuum):
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/template/weather.py

@@ -747,7 +747,6 @@ class TriggerWeatherEntity(TriggerEntity, AbstractTemplateWeather, RestoreEntity
         self._process_data()
 
         if not self.available:
-            self.async_write_ha_state()
             return
 
         write_ha_state = False

homeassistant/components/toon/__init__.py

@@ -83,6 +83,14 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         )
         return False
 
+    if entry.version == 2:
+        # 2 -> 2.2: Unique ID from integer to string
+        if entry.minor_version == 1:
+            minor_version = 2
+            hass.config_entries.async_update_entry(
+                entry, unique_id=str(entry.unique_id), minor_version=minor_version
+            )
+
     return True
 
 

homeassistant/components/toon/config_flow.py

@@ -20,6 +20,7 @@ class ToonFlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
 
     DOMAIN = DOMAIN
     VERSION = 2
+    MINOR_VERSION = 2
 
     agreements: list[Agreement]
     data: dict[str, Any]
@@ -92,7 +93,7 @@ class ToonFlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
         if self.migrate_entry:
             await self.hass.config_entries.async_remove(self.migrate_entry)
 
-        await self.async_set_unique_id(agreement.agreement_id)
+        await self.async_set_unique_id(str(agreement.agreement_id))
         self._abort_if_unique_id_configured()
 
         self.data[CONF_AGREEMENT_ID] = agreement.agreement_id

homeassistant/components/tuya/binary_sensor.py

@@ -107,6 +107,11 @@ BINARY_SENSORS: dict[DeviceCategory, tuple[TuyaBinarySensorEntityDescription, ..
             translation_key="feeding",
             on_value="feeding",
         ),
+        TuyaBinarySensorEntityDescription(
+            key=DPCode.CHARGE_STATE,
+            device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
+            entity_category=EntityCategory.DIAGNOSTIC,
+        ),
     ),
     DeviceCategory.DGNBJ: (
         TuyaBinarySensorEntityDescription(