Rename skill reference files to uppercase

Create a Claude Code skill for developing Home Assistant integrations with
separate reference files for each platform and component:

- SKILL.md: Main skill entry point with quick reference table
- config-flow.md: Configuration flow patterns
- coordinator.md: Data update coordinator patterns
- entity.md: Base entity development patterns
- sensor.md: Sensor platform reference
- binary-sensor.md: Binary sensor platform reference
- switch.md: Switch platform reference
- number.md: Number platform reference
- select.md: Select platform reference
- button.md: Button platform reference
- device.md: Device management patterns
- diagnostics.md: Diagnostics implementation
- services.md: Service registration patterns
- testing.md: Testing patterns and fixtures

This skill extracts best practices from CLAUDE.md into a reusable
format that can be invoked via /ha-integration.

.agent/skills

@@ -1 +0,0 @@
-../.claude/skills/

.claude/agents/raise-pull-request.md

@@ -1,225 +0,0 @@
----
-name: raise-pull-request
-description: |
-  Use this agent when creating a pull request for the Home Assistant core repository after completing implementation work. This agent automates the PR creation process including running tests, formatting checks, and proper checkbox handling.
-model: inherit
-color: green
-tools: Read, Bash, Grep, Glob
----
-
-You are an expert at creating pull requests for the Home Assistant core repository. You will automate the PR creation process with proper verification, formatting, testing, and checkbox handling.
-
-**Execute each step in order. Do not skip steps.**
-
-## Step 1: Gather Information
-
-Run these commands in parallel to analyze the changes:
-
-```bash
-# Get current branch and remote
-git branch --show-current
-git remote -v | grep push
-
-# Determine the best available dev reference
-if git rev-parse --verify --quiet upstream/dev >/dev/null; then
-  BASE_REF="upstream/dev"
-elif git rev-parse --verify --quiet origin/dev >/dev/null; then
-  BASE_REF="origin/dev"
-elif git rev-parse --verify --quiet dev >/dev/null; then
-  BASE_REF="dev"
-else
-  echo "Could not find upstream/dev, origin/dev, or local dev"
-  exit 1
-fi
-
-BASE_SHA="$(git merge-base "$BASE_REF" HEAD)"
-echo "BASE_REF=$BASE_REF"
-echo "BASE_SHA=$BASE_SHA"
-
-# Get commit info for this branch vs dev
-git log "${BASE_SHA}..HEAD" --oneline
-
-# Check what files changed
-git diff "${BASE_SHA}..HEAD" --name-only
-
-# Check if test files were added/modified
-git diff "${BASE_SHA}..HEAD" --name-only | grep -E "^tests/.*\.py$" || echo "NO_TESTS_CHANGED"
-
-# Check if manifest.json changed
-git diff "${BASE_SHA}..HEAD" --name-only | grep "manifest.json" || echo "NO_MANIFEST_CHANGED"
-```
-
-From the file paths, extract the **integration domain** from `homeassistant/components/{integration}/` or `tests/components/{integration}/`.
-
-**Track results:**
-- `BASE_REF`: the dev reference used for comparison
-- `BASE_SHA`: the merge-base commit used for diff-based checks
-- `TESTS_CHANGED`: true if test files were added or modified
-- `MANIFEST_CHANGED`: true if manifest.json was modified
-
-**If no suitable dev reference is available, STOP and tell the user to fetch `upstream/dev`, `origin/dev`, or a local `dev` branch before continuing.**
-
-## Step 2: Run Code Quality Checks
-
-Run `prek` to perform code quality checks (formatting, linting, hassfest, etc.) on the files changed since `BASE_SHA`:
-
-```bash
-prek run --from-ref "$BASE_SHA" --to-ref HEAD
-```
-
-**Track results:**
-- `PREK_PASSED`: true if `prek run` exits with code 0
-
-**If `prek` fails or is not available, STOP and report the failure to the user. Do not proceed with PR creation. If the failure appears to be an environment setup issue (e.g., missing tools, command not found, venv not activated), also point the user to https://developers.home-assistant.io/docs/development_environment.**
-
-## Step 3: Stage Any Changes from Checks
-
-If `prek` made any formatting or generated file changes, stage and commit them as a separate commit:
-
-```bash
-git status --porcelain
-# If changes exist:
-git add -A
-git commit -m "Apply prek formatting and generated file updates"
-```
-
-## Step 4: Run Tests
-
-Run pytest for the specific integration:
-
-```bash
-pytest tests/components/{integration} \
-  --timeout=60 \
-  --durations-min=1 \
-  --durations=0 \
-  -q
-```
-
-**Track results:**
-- `TESTS_PASSED`: true if pytest exits with code 0
-
-**If tests fail, STOP and report the failures to the user. Do not proceed with PR creation.**
-
-## Step 5: Identify PR Metadata
-
-Write a release-note-style PR title summarizing the change. The title becomes the release notes entry, so it should be a complete sentence fragment describing what changed in imperative mood.
-
-**PR Title Examples by Type:**
-| Type | Example titles |
-|------|----------------|
-| Bugfix | `Fix Hikvision NVR binary sensors not being detected` |
-| | `Fix JSON serialization of time objects in anthropic tool results` |
-| | `Fix config flow bug in Tesla Fleet` |
-| Dependency | `Bump eheimdigital to 1.5.0` |
-| | `Bump python-otbr-api to 2.7.1` |
-| New feature | `Add asyncio-level timeout to Backblaze B2 uploads` |
-| | `Add Nettleie optimization option` |
-| Code quality | `Add exception translations to Teslemetry` |
-| | `Improve test coverage of Tesla Fleet` |
-| | `Refactor adguard tests to use proper fixtures for mocking` |
-| | `Simplify entity init in Proxmox` |
-
-## Step 6: Verify Development Checklist
-
-Check each item from the [development checklist](https://developers.home-assistant.io/docs/development_checklist/):
-
-| Item | How to verify |
-|------|---------------|
-| External libraries on PyPI | Check manifest.json requirements - all should be PyPI packages |
-| Dependencies in requirements_all.txt | Only if dependency declarations changed (the `requirements` field in `manifest.json` or `requirements_all.txt`), run `python -m script.gen_requirements_all` |
-| Codeowners updated | If this is a new integration, ensure its `manifest.json` includes a `codeowners` field with one or more GitHub usernames |
-| No commented out code | Visually scan the diff for blocks of commented-out code |
-
-**Track results:**
-- `NO_COMMENTED_CODE`: true if no blocks of commented-out code found in the diff
-- `DEPENDENCIES_CHANGED`: true if the diff changes the `requirements` field in `manifest.json` or changes `requirements_all.txt`
-- `REQUIREMENTS_UPDATED`: true if `DEPENDENCIES_CHANGED` is true and requirements_all.txt was regenerated successfully; not applicable if `DEPENDENCIES_CHANGED` is false
-- `CHECKLIST_PASSED`: true if all items above pass
-
-## Step 7: Determine Type of Change
-
-Select exactly ONE based on the changes. Mark the selected type with `[x]` and all others with `[ ]` (space):
-
-| Type | Condition |
-|------|-----------|
-| Dependency upgrade | Only manifest.json/requirements changes |
-| Bugfix | Fixes broken behavior, no new features |
-| New integration | New folder in components/ |
-| New feature | Adds capability to existing integration |
-| Deprecation | Adds deprecation warnings for future breaking change |
-| Breaking change | Removes or changes existing functionality |
-| Code quality | Only refactoring or test additions, no functional change |
-
-**Track results:**
-- `CHANGE_TYPE`: the selected type (e.g., "Bugfix", "New feature", "Code quality", etc.)
-
-**Important:** All seven type options must remain in the PR body. Only the selected type gets `[x]`, all others get `[ ]`.
-
-## Step 8: Determine Checkbox States
-
-Based on the verification steps above, determine checkbox states:
-
-| Checkbox | Condition to tick |
-|----------|-------------------|
-| The code change is tested and works locally | Leave unchecked for the contributor to verify manually (this refers to manual testing, not unit tests) |
-| Local tests pass | Tick only if `TESTS_PASSED` is true |
-| I understand the code I am submitting and can explain how it works | Leave unchecked for the contributor to review and set manually |
-| There is no commented out code | Tick only if `NO_COMMENTED_CODE` is true |
-| Development checklist | Tick only if `CHECKLIST_PASSED` is true |
-| Perfect PR recommendations | Tick only if the PR affects a single integration or closely related modules, represents one primary type of change, and has a clear, self-contained scope |
-| Formatted using Ruff | Tick only if `PREK_PASSED` is true |
-| Tests have been added | Tick only if `TESTS_CHANGED` is true AND the changes exercise new or changed functionality (not only cosmetic test changes) |
-| Documentation added/updated | Tick if documentation PR created (or not applicable) |
-| Manifest file fields filled out | Tick if `PREK_PASSED` is true (or not applicable) |
-| Dependencies in requirements_all.txt | Tick only if `DEPENDENCIES_CHANGED` is false, or if `DEPENDENCIES_CHANGED` is true and `REQUIREMENTS_UPDATED` is true |
-| Dependency changelog linked | Tick if dependency changelog linked in PR description (or not applicable) |
-| Any generated code has been carefully reviewed | Leave unchecked for the contributor to review and set manually |
-
-## Step 9: Breaking Change Section
-
-**If `CHANGE_TYPE` is NOT "Breaking change" or "Deprecation": REMOVE the entire "## Breaking change" section from the PR body (including the heading).**
-
-If `CHANGE_TYPE` IS "Breaking change" or "Deprecation", keep the `## Breaking change` section and describe:
-- What breaks
-- How users can fix it
-- Why it was necessary
-
-## Step 10: Push Branch and Create PR
-
-Push the branch with upstream tracking, and create a PR against `home-assistant/core` with the generated title and body:
-
-```bash
-# Create PR (gh pr create pushes the branch automatically)
-gh pr create --repo home-assistant/core --base dev \
-  --draft \
-  --title "TITLE_HERE" \
-  --body "$(cat <<'EOF'
-BODY_HERE
-EOF
-)"
-```
-
-### PR Body Template
-
-Read the PR template from `.github/PULL_REQUEST_TEMPLATE.md` and use it as the basis for the PR body. **Do not hardcode the template — always read it from the file to stay in sync with upstream changes.**
-
-Use any HTML comments (`<!-- ... -->`) in the template as guidance to understand what to fill in. For the final PR body sent to GitHub, keep the template text intact — do not delete any text from the template unless it explicitly instructs removal (e.g., the breaking change section when not applicable). Then fill in the sections:
-
-1. **Breaking change section**: If the type is NOT "Breaking change" or "Deprecation", remove the entire `## Breaking change` section (heading and body). Otherwise, describe what breaks, how users can fix it, and why.
-2. **Proposed change section**: Fill in a description of the change extracted from commit messages.
-3. **Type of change**: Check exactly ONE checkbox matching the determined type from Step 7. Leave all others unchecked.
-4. **Additional information**: Fill in any related issue numbers if known.
-5. **Checklist**: Check boxes based on the conditions in Step 8. Leave manual-verification boxes unchecked for the contributor.
-
-**Important:** Preserve all template structure, options, and link references exactly as they appear in the file — only modify checkbox states and fill in content sections.
-
-## Step 11: Report Result
-
-Provide the user with:
-1. **PR URL** - The created pull request link
-2. **Verification Summary** - Which checks passed/failed
-3. **Unchecked Items** - List any checkboxes left unchecked and why
-4. **User Action Required** - Remind user to:
-   - Review and set manual-verification checkboxes ("I understand the code..." and "Any generated code...") as applicable
-   - Consider reviewing two other open PRs
-   - Add any related issue numbers if applicable

.claude/skills/github-pr-reviewer/SKILL.md

@@ -1,38 +0,0 @@
----
-name: github-pr-reviewer
-description: Reviews GitHub pull requests and provides feedback comments. This is the top skill to use for reviewing Pull Requests from GitHub.
----
-
-# Review GitHub Pull Request
-
-## Follow these steps:
-1. Use 'gh pr view' to get the PR details and description.
-2. Use 'gh pr diff' to see all the changes in the PR.
-3. Analyze the code changes for:
-   - Code quality and style consistency
-   - Potential bugs or issues
-   - Performance implications
-   - Security concerns
-   - Test coverage
-   - Documentation updates if needed
-4. Ensure any existing review comments have been addressed.
-5. Generate constructive review comments in the CONSOLE. DO NOT POST TO GITHUB YOURSELF.
-
-## IMPORTANT:
-- Just review. DO NOT make any changes
-- Be constructive and specific in your comments
-- Suggest improvements where appropriate
-- Only provide review feedback in the CONSOLE. DO NOT ACT ON GITHUB.
-- No need to run tests or linters, just review the code changes.
-- No need to highlight things that are already good.
-
-## Output format:
-- List specific comments for each file/line that needs attention
-- In the end, summarize with an overall assessment (approve, request changes, or comment) and bullet point list of changes suggested, if any.
-  - Example output:
-    ```
-    Overall assessment: request changes.
-    - [CRITICAL] Memory leak in homeassistant/components/sensor/my_sensor.py:143
-    - [PROBLEM] Inefficient algorithm in homeassistant/helpers/data_processing.py:87
-    - [SUGGESTION] Improve variable naming in homeassistant/helpers/config_validation.py:45
-    ```

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

@@ -0,0 +1,238 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,254 @@
+# 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

@@ -0,0 +1,239 @@
+# 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

@@ -0,0 +1,248 @@
+# 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

@@ -0,0 +1,278 @@
+# 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

@@ -0,0 +1,286 @@
+# 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

@@ -0,0 +1,229 @@
+# 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

@@ -0,0 +1,252 @@
+# 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

@@ -0,0 +1,271 @@
+# 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

@@ -0,0 +1,335 @@
+# 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

@@ -0,0 +1,165 @@
+---
+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

@@ -0,0 +1,236 @@
+# 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

@@ -0,0 +1,396 @@
+# 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

@@ -1,42 +0,0 @@
----
-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>/`
-
-## General guidelines
-
-- When looking for examples, prefer integrations with the platinum or gold quality scale level first.
-- Polling intervals are NOT user-configurable. Never add scan_interval, update_interval, or polling frequency options to config flows or config entries.
-- 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.
-- For entity actions and entity services, avoid requesting redundant defensive checks for fields already enforced by Home Assistant validation schemas and entity filters; only request extra guards when values bypass validation or are transformed unsafely.
-- When validation guarantees a key is present, prefer direct dictionary indexing (`data["key"]`) over `.get("key")` so invalid assumptions fail fast.
-
-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
-
-
-## Integration Quality Scale
-
-- When validating the quality scale rules, check them at https://developers.home-assistant.io/docs/core/integration-quality-scale/rules
-- When implementing or reviewing an integration, always consider the quality scale rules, since they promote best practices.
-
-Template scale file: `./script/scaffold/templates/integration/integration/quality_scale.yaml`
-
-### 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
-
-
-## Testing Requirements
-
-- Tests should avoid interacting or mocking internal integration details. For more info, see https://developers.home-assistant.io/docs/development_testing/#writing-tests-for-integrations

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

@@ -1,6 +0,0 @@
-# Integration Diagnostics
-
-Platform exists as `homeassistant/components/<domain>/diagnostics.py`.
-
-- **Required**: Implement diagnostic data collection
-- **Security**: Never expose passwords, tokens, or sensitive coordinates

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

@@ -1,21 +0,0 @@
-# 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.)
-- **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
-- Only create issues for problems users can potentially resolve

.core_files.yaml

@@ -22,7 +22,6 @@ base_platforms: &base_platforms
   - homeassistant/components/calendar/**
   - homeassistant/components/camera/**
   - homeassistant/components/climate/**
-  - homeassistant/components/conversation/**
   - homeassistant/components/cover/**
   - homeassistant/components/date/**
   - homeassistant/components/datetime/**
@@ -34,7 +33,6 @@ base_platforms: &base_platforms
   - homeassistant/components/humidifier/**
   - homeassistant/components/image/**
   - homeassistant/components/image_processing/**
-  - homeassistant/components/infrared/**
   - homeassistant/components/lawn_mower/**
   - homeassistant/components/light/**
   - homeassistant/components/lock/**
@@ -55,7 +53,6 @@ base_platforms: &base_platforms
   - homeassistant/components/update/**
   - homeassistant/components/vacuum/**
   - homeassistant/components/valve/**
-  - homeassistant/components/wake_word/**
   - homeassistant/components/water_heater/**
   - homeassistant/components/weather/**
 
@@ -73,6 +70,7 @@ components: &components
   - homeassistant/components/cloud/**
   - homeassistant/components/config/**
   - homeassistant/components/configurator/**
+  - homeassistant/components/conversation/**
   - homeassistant/components/demo/**
   - homeassistant/components/device_automation/**
   - homeassistant/components/dhcp/**

.devcontainer/devcontainer.json

@@ -8,6 +8,9 @@
     "PYTHONASYNCIODEBUG": "1"
   },
   "features": {
+    // Node feature required for Claude Code until fixed https://github.com/anthropics/devcontainer-features/issues/28
+    "ghcr.io/devcontainers/features/node:1": {},
+    "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
   // Port 5683 udp is used by Shelly integration
@@ -60,13 +63,7 @@
         "[python]": {
           "editor.defaultFormatter": "charliermarsh.ruff"
         },
-        "[json]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[jsonc]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[yaml]": {
+        "[json][jsonc][yaml]": {
           "editor.defaultFormatter": "esbenp.prettier-vscode"
         },
         "json.schemas": [

.gemini/skills

@@ -1 +0,0 @@
-../.claude/skills

.gitattributes

@@ -16,7 +16,6 @@ Dockerfile.dev linguist-language=Dockerfile
 CODEOWNERS linguist-generated=true
 Dockerfile linguist-generated=true
 homeassistant/generated/*.py linguist-generated=true
-machine/* linguist-generated=true
 mypy.ini linguist-generated=true
 requirements.txt linguist-generated=true
 requirements_all.txt linguist-generated=true

.github/PULL_REQUEST_TEMPLATE.md

@@ -80,7 +80,7 @@ If the code communicates with devices, web services, or third-party tools:
       Updated and included derived files by running: `python3 -m script.hassfest`.
 - [ ] New or updated dependencies have been added to `requirements_all.txt`.  
       Updated by running `python3 -m script.gen_requirements_all`.
-- [ ] For the updated dependencies a diff between library versions and ideally a link to the changelog/release notes is added to the PR description.
+- [ ] For the updated dependencies - a link to the changelog, or at minimum a diff between library versions is added to the PR description.
 
 <!--
   This project is very active and we have a high turnover of pull requests.

.github/dependabot.yml

@@ -9,5 +9,3 @@ updates:
     labels:
       - dependency
       - github_actions
-    cooldown:
-      default-days: 7

.github/renovate.json

@@ -1,216 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended"],
-
-  "enabledManagers": [
-    "pep621",
-    "pip_requirements",
-    "pre-commit",
-    "regex",
-    "homeassistant-manifest"
-  ],
-
-  "pre-commit": {
-    "enabled": true
-  },
-
-  "pip_requirements": {
-    "managerFilePatterns": [
-      "/(^|/)requirements[\\w_-]*\\.txt$/",
-      "/(^|/)homeassistant/package_constraints\\.txt$/"
-    ]
-  },
-
-  "homeassistant-manifest": {
-    "managerFilePatterns": [
-      "/^homeassistant/components/[^/]+/manifest\\.json$/"
-    ]
-  },
-
-  "regexManagers": [
-    {
-      "description": "Update ruff required-version in pyproject.toml",
-      "managerFilePatterns": ["/^pyproject\\.toml$/"],
-      "matchStrings": ["required-version = \">=(?<currentValue>[\\d.]+)\""],
-      "depNameTemplate": "ruff",
-      "datasourceTemplate": "pypi"
-    }
-  ],
-
-  "minimumReleaseAge": "7 days",
-  "prConcurrentLimit": 10,
-  "prHourlyLimit": 2,
-  "schedule": ["before 6am"],
-
-  "semanticCommits": "disabled",
-  "commitMessageAction": "Update",
-  "commitMessageTopic": "{{depName}}",
-  "commitMessageExtra": "to {{newVersion}}",
-
-  "automerge": false,
-
-  "vulnerabilityAlerts": {
-    "enabled": false
-  },
-
-  "packageRules": [
-    {
-      "description": "Deny all by default — allowlist below re-enables specific packages",
-      "matchPackageNames": ["*"],
-      "enabled": false
-    },
-    {
-      "description": "Core runtime dependencies (allowlisted)",
-      "matchPackageNames": [
-        "aiohttp",
-        "aiohttp-fast-zlib",
-        "aiohttp_cors",
-        "aiohttp-asyncmdnsresolver",
-        "yarl",
-        "httpx",
-        "requests",
-        "urllib3",
-        "certifi",
-        "orjson",
-        "PyYAML",
-        "Jinja2",
-        "cryptography",
-        "pyOpenSSL",
-        "PyJWT",
-        "SQLAlchemy",
-        "Pillow",
-        "attrs",
-        "uv",
-        "voluptuous",
-        "voluptuous-serialize",
-        "voluptuous-openapi",
-        "zeroconf"
-      ],
-      "enabled": true,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Common Python utilities (allowlisted)",
-      "matchPackageNames": [
-        "astral",
-        "atomicwrites-homeassistant",
-        "audioop-lts",
-        "awesomeversion",
-        "bcrypt",
-        "ciso8601",
-        "cronsim",
-        "defusedxml",
-        "fnv-hash-fast",
-        "getmac",
-        "ical",
-        "ifaddr",
-        "lru-dict",
-        "mutagen",
-        "propcache",
-        "pyserial",
-        "python-slugify",
-        "PyTurboJPEG",
-        "securetar",
-        "standard-aifc",
-        "standard-telnetlib",
-        "ulid-transform",
-        "url-normalize",
-        "xmltodict"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Home Assistant ecosystem packages (core-maintained, no cooldown)",
-      "matchPackageNames": [
-        "hassil",
-        "home-assistant-bluetooth",
-        "home-assistant-frontend",
-        "home-assistant-intents",
-        "infrared-protocols"
-      ],
-      "enabled": true,
-      "minimumReleaseAge": null,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Test dependencies (allowlisted)",
-      "matchPackageNames": [
-        "pytest",
-        "pytest-asyncio",
-        "pytest-aiohttp",
-        "pytest-cov",
-        "pytest-freezer",
-        "pytest-github-actions-annotate-failures",
-        "pytest-socket",
-        "pytest-sugar",
-        "pytest-timeout",
-        "pytest-unordered",
-        "pytest-picked",
-        "pytest-xdist",
-        "pylint",
-        "pylint-per-file-ignores",
-        "astroid",
-        "coverage",
-        "freezegun",
-        "syrupy",
-        "respx",
-        "requests-mock",
-        "ruff",
-        "codespell",
-        "yamllint",
-        "zizmor"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "For types-* stubs, only allow patch updates. Major/minor bumps track the upstream runtime package version and must be manually coordinated with the corresponding pin.",
-      "matchPackageNames": ["/^types-/"],
-      "matchUpdateTypes": ["patch"],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Pre-commit hook repos (allowlisted, matched by owner/repo)",
-      "matchPackageNames": [
-        "astral-sh/ruff-pre-commit",
-        "codespell-project/codespell",
-        "adrienverge/yamllint",
-        "zizmorcore/zizmor-pre-commit"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Group ruff pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["astral-sh/ruff-pre-commit", "ruff"],
-      "groupName": "ruff",
-      "groupSlug": "ruff"
-    },
-    {
-      "description": "Group codespell pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["codespell-project/codespell", "codespell"],
-      "groupName": "codespell",
-      "groupSlug": "codespell"
-    },
-    {
-      "description": "Group yamllint pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["adrienverge/yamllint", "yamllint"],
-      "groupName": "yamllint",
-      "groupSlug": "yamllint"
-    },
-    {
-      "description": "Group zizmor pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["zizmorcore/zizmor-pre-commit", "zizmor"],
-      "groupName": "zizmor",
-      "groupSlug": "zizmor"
-    },
-    {
-      "description": "Group pylint with astroid (their versions are linked and must move together)",
-      "matchPackageNames": ["pylint", "astroid"],
-      "groupName": "pylint",
-      "groupSlug": "pylint"
-    }
-  ]
-}

.github/workflows/builder.yml

@@ -10,51 +10,45 @@ on:
 
 env:
   BUILD_TYPE: core
+  DEFAULT_PYTHON: "3.13"
   PIP_TIMEOUT: 60
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
   # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2026.01.0"
+  BASE_IMAGE_VERSION: "2025.12.0"
   ARCHITECTURES: '["amd64", "aarch64"]'
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
 jobs:
   init:
     name: Initialize build
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
-    permissions:
-      contents: read # To check out the repository
     outputs:
       version: ${{ steps.version.outputs.version }}
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
       architectures: ${{ env.ARCHITECTURES }}
-      base_image_version: ${{ env.BASE_IMAGE_VERSION }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
-          python-version-file: ".python-version"
+          python-version: ${{ env.DEFAULT_PYTHON }}
+
+      - name: Get information
+        id: info
+        uses: home-assistant/actions/helpers/info@master
 
       - name: Get version
         id: version
-        uses: home-assistant/actions/helpers/version@master # zizmor: ignore[unpinned-uses]
+        uses: home-assistant/actions/helpers/version@master
         with:
           type: ${{ env.BUILD_TYPE }}
 
       - name: Verify version
-        uses: home-assistant/actions/helpers/verify-version@master # zizmor: ignore[unpinned-uses]
+        uses: home-assistant/actions/helpers/verify-version@master
         with:
           ignore-dev: true
 
@@ -69,14 +63,14 @@ jobs:
       - name: Download Translations
         run: python3 -m script.translations download
         env:
-          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
 
       - name: Archive translations
         shell: bash
         run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
 
       - name: Upload translations
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: translations
           path: translations.tar.gz
@@ -88,27 +82,25 @@ jobs:
     needs: init
     runs-on: ${{ matrix.os }}
     permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      id-token: write # For cosign signing
+      contents: read
+      packages: write
+      id-token: write
     strategy:
       fail-fast: false
       matrix:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
         include:
           - arch: amd64
-            os: ubuntu-24.04
+            os: ubuntu-latest
           - arch: aarch64
             os: ubuntu-24.04-arm
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -119,7 +111,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -128,23 +120,22 @@ jobs:
           workflow_conclusion: success
           name: package
 
-      - name: Set up Python
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
-          python-version-file: ".python-version"
+          python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Adjust nightly version
         if: needs.init.outputs.channel == 'dev'
         shell: bash
         env:
           UV_PRERELEASE: allow
-          VERSION: ${{ needs.init.outputs.version }}
         run: |
           python3 -m pip install "$(grep '^uv' < requirements.txt)"
           uv pip install packaging tomli
           uv pip install .
-          python3 script/version_bump.py nightly --set-nightly-version "${VERSION}"
+          python3 script/version_bump.py nightly --set-nightly-version "${{ needs.init.outputs.version }}"
 
           if [[ "$(ls home_assistant_frontend*.whl)" =~ ^home_assistant_frontend-(.*)-py3-none-any.whl$ ]]; then
             echo "Found frontend wheel, setting version to: ${BASH_REMATCH[1]}"
@@ -174,11 +165,11 @@ jobs:
             sed -i "s|home-assistant-intents==.*|home-assistant-intents==${BASH_REMATCH[1]}|" \
               homeassistant/package_constraints.txt
 
-            sed -i "s|home-assistant-intents==.*||" requirements_all.txt requirements.txt
+            sed -i "s|home-assistant-intents==.*||" requirements_all.txt
           fi
 
       - name: Download translations
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: translations
 
@@ -190,36 +181,84 @@ jobs:
       - name: Write meta info file
         shell: bash
         run: |
-          echo "${GITHUB_SHA};${GITHUB_REF};${GITHUB_EVENT_NAME};${GITHUB_ACTOR}" > rootfs/OFFICIAL_IMAGE
+          echo "${{ github.sha }};${{ github.ref }};${{ github.event_name }};${{ github.actor }}" > rootfs/OFFICIAL_IMAGE
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - &install_cosign
+        name: Install Cosign
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
+        with:
+          cosign-release: "v2.5.3"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+
+      - name: Build variables
+        id: vars
+        shell: bash
+        run: |
+          echo "base_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ env.BASE_IMAGE_VERSION }}" >> "$GITHUB_OUTPUT"
+          echo "cache_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:latest" >> "$GITHUB_OUTPUT"
+          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
+
+      - name: Verify base image signature
+        run: |
+          cosign verify \
+            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
+            "${{ steps.vars.outputs.base_image }}"
+
+      - name: Verify cache image signature
+        id: cache
+        continue-on-error: true
+        run: |
+          cosign verify \
+            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
+            "${{ steps.vars.outputs.cache_image }}"
 
       - name: Build base image
-        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
+        id: build
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
-          arch: ${{ matrix.arch }}
-          build-args: |
-            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
-          cache-gha: false
-          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
-          cosign-base-identity: "https://github.com/home-assistant/docker/.*"
-          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
-          image: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant
-          image-tags: ${{ needs.init.outputs.version }}
+          context: .
+          file: ./Dockerfile
+          platforms: ${{ steps.vars.outputs.platform }}
           push: true
-          version: ${{ needs.init.outputs.version }}
+          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
+          build-args: |
+            BUILD_FROM=${{ steps.vars.outputs.base_image }}
+          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          labels: |
+            io.hass.arch=${{ matrix.arch }}
+            io.hass.version=${{ needs.init.outputs.version }}
+            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
+            org.opencontainers.image.version=${{ needs.init.outputs.version }}
+
+      - name: Sign image
+        run: |
+          cosign sign --yes "ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}@${{ steps.build.outputs.digest }}"
 
   build_machine:
     name: Build ${{ matrix.machine }} machine core image
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]
-    runs-on: ${{ matrix.runs-on }}
+    runs-on: ubuntu-latest
     permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      id-token: write # For cosign signing
+      contents: read
+      packages: write
+      id-token: write
     strategy:
       matrix:
         machine:
           - generic-x86-64
+          - intel-nuc
           - khadas-vim3
           - odroid-c2
           - odroid-c4
@@ -232,55 +271,37 @@ jobs:
           - raspberrypi5-64
           - yellow
           - green
-        include:
-          # Default: aarch64 on native ARM runner
-          - arch: aarch64
-            runs-on: ubuntu-24.04-arm
-          # Overrides for amd64 machines
-          - machine: generic-x86-64
-            arch: amd64
-            runs-on: ubuntu-24.04
-          - machine: qemux86-64
-            arch: amd64
-            runs-on: ubuntu-24.04
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Compute extra tags
-        id: tags
-        shell: bash
-        env:
-          VERSION: ${{ needs.init.outputs.version }}
+      - name: Set build additional args
         run: |
-          if [[ "${VERSION}" =~ d ]]; then
-            echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
-          elif [[ "${VERSION}" =~ b ]]; then
-            echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
+          # Create general tags
+          if [[ "${{ needs.init.outputs.version }}" =~ d ]]; then
+            echo "BUILD_ARGS=--additional-tag dev" >> $GITHUB_ENV
+          elif [[ "${{ needs.init.outputs.version }}" =~ b ]]; then
+            echo "BUILD_ARGS=--additional-tag beta" >> $GITHUB_ENV
           else
-            echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
+            echo "BUILD_ARGS=--additional-tag stable" >> $GITHUB_ENV
           fi
 
-      - name: Build machine image
-        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
-          arch: ${{ matrix.arch }}
-          build-args: |
-            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          cache-gha: false
-          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
-          context: machine/
-          cosign-base-identity: "https://github.com/home-assistant/core/.*"
-          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          file: machine/${{ matrix.machine }}
-          image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
-          image-tags: |
-            ${{ needs.init.outputs.version }}
-            ${{ steps.tags.outputs.extra_tags }}
-          push: true
-          version: ${{ needs.init.outputs.version }}
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # home-assistant/builder doesn't support sha pinning
+      - name: Build base image
+        uses: home-assistant/builder@2025.11.0
+        with:
+          args: |
+            $BUILD_ARGS \
+            --target /data/machine \
+            --cosign \
+            --machine "${{ needs.init.outputs.version }}=${{ matrix.machine }}"
 
   publish_ha:
     name: Publish version files
@@ -288,23 +309,19 @@ jobs:
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_machine"]
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize git
-        uses: home-assistant/actions/helpers/git-init@master # zizmor: ignore[unpinned-uses]
+        uses: home-assistant/actions/helpers/git-init@master
         with:
           name: ${{ secrets.GIT_NAME }}
           email: ${{ secrets.GIT_EMAIL }}
           token: ${{ secrets.GIT_TOKEN }}
 
       - name: Update version file
-        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
+        uses: home-assistant/actions/helpers/version-push@master
         with:
           key: "homeassistant[]"
           key-description: "Home Assistant Core"
@@ -314,7 +331,7 @@ jobs:
 
       - name: Update version file (stable -> beta)
         if: needs.init.outputs.channel == 'stable'
-        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
+        uses: home-assistant/actions/helpers/version-push@master
         with:
           key: "homeassistant[]"
           key-description: "Home Assistant Core"
@@ -329,28 +346,25 @@ jobs:
     needs: ["init", "build_base"]
     runs-on: ubuntu-latest
     permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      id-token: write # For cosign signing
+      contents: read
+      packages: write
+      id-token: write
     strategy:
       fail-fast: false
       matrix:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
-        with:
-          cosign-release: "v2.5.3"
+      - *install_cosign
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -358,17 +372,14 @@ jobs:
 
       - name: Verify architecture image signatures
         shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          VERSION: ${{ needs.init.outputs.version }}
         run: |
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
           for arch in $ARCHS; do
             echo "Verifying ${arch} image signature..."
             cosign verify \
               --certificate-oidc-issuer https://token.actions.githubusercontent.com \
               --certificate-identity-regexp https://github.com/home-assistant/core/.* \
-              "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"
+              "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
           done
           echo "✓ All images verified successfully"
 
@@ -380,7 +391,7 @@ jobs:
       #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
       - name: Generate Docker metadata
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
         with:
           images: ${{ matrix.registry }}/home-assistant
           sep-tags: ","
@@ -394,24 +405,21 @@ jobs:
             type=semver,pattern={{major}}.{{minor}},value=${{ needs.init.outputs.version }},enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v3.7.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
 
       - name: Copy architecture images to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
         shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          VERSION: ${{ needs.init.outputs.version }}
         run: |
           # Use imagetools to copy image blobs directly between registries
           # This preserves provenance/attestations and seems to be much faster than pull/push
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
           for arch in $ARCHS; do
             echo "Copying ${arch} image to DockerHub..."
             for attempt in 1 2 3; do
               if docker buildx imagetools create \
-                --tag "docker.io/homeassistant/${arch}-homeassistant:${VERSION}" \
-                "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"; then
+                --tag "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}" \
+                "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"; then
                 break
               fi
               echo "Attempt ${attempt} failed, retrying in 10 seconds..."
@@ -421,28 +429,23 @@ jobs:
                 exit 1
               fi
             done
-            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${VERSION}"
+            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
           done
 
       - name: Create and push multi-arch manifests
         shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          REGISTRY: ${{ matrix.registry }}
-          VERSION: ${{ needs.init.outputs.version }}
-          META_TAGS: ${{ steps.meta.outputs.tags }}
         run: |
           # Build list of architecture images dynamically
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
           ARCH_IMAGES=()
           for arch in $ARCHS; do
-            ARCH_IMAGES+=("${REGISTRY}/${arch}-homeassistant:${VERSION}")
+            ARCH_IMAGES+=("${{ matrix.registry }}/${arch}-homeassistant:${{ needs.init.outputs.version }}")
           done
 
           # Build list of all tags for single manifest creation
           # Note: Using sep-tags=',' in metadata-action for easier parsing
           TAG_ARGS=()
-          IFS=',' read -ra TAGS <<< "${META_TAGS}"
+          IFS=',' read -ra TAGS <<< "${{ steps.meta.outputs.tags }}"
           for tag in "${TAGS[@]}"; do
             TAG_ARGS+=("--tag" "${tag}")
           done
@@ -466,22 +469,20 @@ jobs:
     needs: ["init", "build_base"]
     runs-on: ubuntu-latest
     permissions:
-      contents: read # To check out the repository
-      id-token: write # For PyPI trusted publishing
+      contents: read
+      id-token: write
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
-          python-version-file: ".python-version"
+          python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Download translations
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: translations
 
@@ -499,7 +500,7 @@ jobs:
           python -m build
 
       - name: Upload package to PyPI
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
         with:
           skip-existing: true
 
@@ -507,10 +508,10 @@ jobs:
     name: Build and test hassfest image
     runs-on: ubuntu-latest
     permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      attestations: write # For build provenance attestation
-      id-token: write # For build provenance attestation
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
     needs: ["init"]
     if: github.repository_owner == 'home-assistant'
     env:
@@ -518,19 +519,17 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build Docker image
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -538,12 +537,12 @@ jobs:
           tags: ${{ env.HASSFEST_IMAGE_TAG }}
 
       - name: Run hassfest against core
-        run: docker run --rm -v "${GITHUB_WORKSPACE}":/github/workspace "${HASSFEST_IMAGE_TAG}" --core-path=/github/workspace
+        run: docker run --rm -v ${{ github.workspace }}:/github/workspace ${{ env.HASSFEST_IMAGE_TAG }} --core-path=/github/workspace
 
       - name: Push Docker image
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
         id: push
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -552,7 +551,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest@59d89421af93a897026c735860bf21b6eb4f7b26 # v4.1.0
+        uses: actions/attest-build-provenance@00014ed6ed5efc5b1ab7f7f34a39eb55d41aa4f8 # v3.1.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/codeql.yml

@@ -5,8 +5,6 @@ on:
   schedule:
     - cron: "30 18 * * 4"
 
-permissions: {}
-
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
@@ -17,22 +15,20 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 360
     permissions:
-      actions: read # To read workflow information for CodeQL
-      contents: read # To check out the repository
-      security-events: write # To upload CodeQL results
+      actions: read
+      contents: read
+      security-events: write
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
+        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
+        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           category: "/language:python"

.github/workflows/detect-duplicate-issues.yml

@@ -5,23 +5,18 @@ on:
   issues:
     types: [labeled]
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+permissions:
+  issues: write
+  models: read
 
 jobs:
   detect-duplicates:
-    name: Detect duplicate issues
     runs-on: ubuntu-latest
-    permissions:
-      issues: write # To comment on and label issues
-      models: read # For AI-based duplicate detection
 
     steps:
       - name: Check if integration label was added and extract details
         id: extract
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             // Debug: Log the event payload
@@ -118,7 +113,7 @@ jobs:
       - name: Fetch similar issues
         id: fetch_similar
         if: steps.extract.outputs.should_continue == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           INTEGRATION_LABELS: ${{ steps.extract.outputs.integration_labels }}
           CURRENT_NUMBER: ${{ steps.extract.outputs.current_number }}
@@ -236,7 +231,7 @@ jobs:
       - name: Detect duplicates using AI
         id: ai_detection
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@e09e65981758de8b2fdab13c2bfb7c7d5493b0b6 # v2.0.7
+        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
         with:
           model: openai/gpt-4o
           system-prompt: |
@@ -285,7 +280,7 @@ jobs:
       - name: Post duplicate detection results
         id: post_results
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           AI_RESPONSE: ${{ steps.ai_detection.outputs.response }}
           SIMILAR_ISSUES: ${{ steps.fetch_similar.outputs.similar_issues }}

.github/workflows/detect-non-english-issues.yml

@@ -5,23 +5,18 @@ on:
   issues:
     types: [opened]
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+permissions:
+  issues: write
+  models: read
 
 jobs:
   detect-language:
-    name: Detect non-English issues
     runs-on: ubuntu-latest
-    permissions:
-      issues: write # To comment on, label, and close issues
-      models: read # For AI-based language detection
 
     steps:
       - name: Check issue language
         id: detect_language
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           ISSUE_NUMBER: ${{ github.event.issue.number }}
           ISSUE_TITLE: ${{ github.event.issue.title }}
@@ -62,7 +57,7 @@ jobs:
       - name: Detect language using AI
         id: ai_language_detection
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@e09e65981758de8b2fdab13c2bfb7c7d5493b0b6 # v2.0.7
+        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
         with:
           model: openai/gpt-4o-mini
           system-prompt: |
@@ -95,7 +90,7 @@ jobs:
 
       - name: Process non-English issues
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           AI_RESPONSE: ${{ steps.ai_language_detection.outputs.response }}
           ISSUE_NUMBER: ${{ steps.detect_language.outputs.issue_number }}

.github/workflows/lock.yml

@@ -5,20 +5,10 @@ on:
   schedule:
     - cron: "0 * * * *"
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
-
 jobs:
   lock:
-    name: Lock inactive threads
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
-    permissions:
-      issues: write # To lock issues
-      pull-requests: write # To lock pull requests
     steps:
       - uses: dessant/lock-threads@7266a7ce5c1df01b1c6db85bf8cd86c737dadbe7 # v6.0.0
         with:

.github/workflows/restrict-task-creation.yml

@@ -5,44 +5,14 @@ on:
   issues:
     types: [opened]
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
-
 jobs:
-  add-no-stale:
-    name: Add no-stale label
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write # To add labels to issues
-    if: >-
-      github.event.issue.type.name == 'Task'
-      || github.event.issue.type.name == 'Epic'
-      || github.event.issue.type.name == 'Opportunity'
-    steps:
-      - name: Add no-stale label
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
-        with:
-          script: |
-            await github.rest.issues.addLabels({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              labels: ['no-stale']
-            });
-
   check-authorization:
-    name: Check authorization
     runs-on: ubuntu-latest
-    permissions:
-      contents: read # To read CODEOWNERS file
-      issues: write # To comment on, label, and close issues
     # Only run if this is a Task issue type (from the issue form)
     if: github.event.issue.type.name == 'Task'
     steps:
       - name: Check if user is authorized
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             const issueAuthor = context.payload.issue.user.login;

.github/workflows/stale.yml

@@ -6,20 +6,10 @@ on:
     - cron: "0 * * * *"
   workflow_dispatch:
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
-
 jobs:
   stale:
-    name: Mark stale issues and PRs
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
-    permissions:
-      issues: write # To label and close stale issues
-      pull-requests: write # To label and close stale PRs
     steps:
       # The 60 day stale policy for PRs
       # Used for:
@@ -27,7 +17,7 @@ jobs:
       # - No PRs marked as no-stale
       # - No issues (-1)
       - name: 60 days stale PRs policy
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 60
@@ -58,8 +48,8 @@ jobs:
         # v1.7.0
         uses: tibdex/github-app-token@3beb63f4bd073e61482598c45c71c1019b59b73a
         with:
-          app_id: ${{ secrets.ISSUE_TRIAGE_APP_ID }} # zizmor: ignore[secrets-outside-env]
-          private_key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }} # zizmor: ignore[secrets-outside-env]
+          app_id: ${{ secrets.ISSUE_TRIAGE_APP_ID }}
+          private_key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }}
 
       # The 90 day stale policy for issues
       # Used for:
@@ -67,7 +57,7 @@ jobs:
       # - No issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: 90 days stale issues
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ steps.token.outputs.token }}
           days-before-stale: 90
@@ -97,7 +87,7 @@ jobs:
       # - No Issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: Needs more information stale issues policy
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ steps.token.outputs.token }}
           only-labels: "needs-more-information"

.github/workflows/translations.yml

@@ -9,11 +9,8 @@ on:
     paths:
       - "**strings.json"
 
-permissions: {}
-
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
+env:
+  DEFAULT_PYTHON: "3.13"
 
 jobs:
   upload:
@@ -22,17 +19,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
-          python-version-file: ".python-version"
+          python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Upload Translations
-        env:
-          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }} # zizmor: ignore[secrets-outside-env]
         run: |
+          export LOKALISE_TOKEN="${{ secrets.LOKALISE_TOKEN }}"
           python3 -m script.translations upload

.github/workflows/wheels.yml

@@ -16,7 +16,8 @@ on:
       - "requirements.txt"
       - "script/gen_requirements_all.py"
 
-permissions: {}
+env:
+  DEFAULT_PYTHON: "3.13"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name}}
@@ -28,16 +29,15 @@ jobs:
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - &checkout
+        name: Checkout the repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Set up Python
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
-          python-version-file: ".python-version"
+          python-version: ${{ env.DEFAULT_PYTHON }}
           check-latest: true
 
       - name: Create Python virtual environment
@@ -50,7 +50,7 @@ jobs:
 
       - name: Create requirements_diff file
         run: |
-          if [[ "${GITHUB_EVENT_NAME}" =~ (schedule|workflow_dispatch) ]]; then
+          if [[ ${{ github.event_name }} =~ (schedule|workflow_dispatch) ]]; then
             touch requirements_diff.txt
           else
             curl -s -o requirements_diff.txt https://raw.githubusercontent.com/home-assistant/core/master/requirements.txt
@@ -74,7 +74,7 @@ jobs:
           ) > .env_file
 
       - name: Upload env_file
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: &actions-upload-artifact actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: env_file
           path: ./.env_file
@@ -82,7 +82,7 @@ jobs:
           overwrite: true
 
       - name: Upload requirements_diff
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: *actions-upload-artifact
         with:
           name: requirements_diff
           path: ./requirements_diff.txt
@@ -94,7 +94,7 @@ jobs:
           python -m script.gen_requirements_all ci
 
       - name: Upload requirements_all_wheels
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: *actions-upload-artifact
         with:
           name: requirements_all_wheels
           path: ./requirements_all_wheels_*.txt
@@ -106,8 +106,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
-      matrix:
-        abi: ["cp314"]
+      matrix: &matrix-build
+        abi: ["cp313", "cp314"]
         arch: ["amd64", "aarch64"]
         include:
           - arch: amd64
@@ -115,18 +115,17 @@ jobs:
           - arch: aarch64
             os: ubuntu-24.04-arm
     steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - *checkout
 
-      - name: Download env_file
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+      - &download-env-file
+        name: Download env_file
+        uses: &actions-download-artifact actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
           name: env_file
 
-      - name: Download requirements_diff
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+      - &download-requirements-diff
+        name: Download requirements_diff
+        uses: *actions-download-artifact
         with:
           name: requirements_diff
 
@@ -137,12 +136,12 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: &home-assistant-wheels home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
-          wheels-key: ${{ secrets.WHEELS_KEY }} # zizmor: ignore[secrets-outside-env]
+          wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
           apk: "libffi-dev;openssl-dev;yaml-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;multidict;propcache;yarl;SQLAlchemy
@@ -157,32 +156,16 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
-      matrix:
-        abi: ["cp314"]
-        arch: ["amd64", "aarch64"]
-        include:
-          - arch: amd64
-            os: ubuntu-latest
-          - arch: aarch64
-            os: ubuntu-24.04-arm
+      matrix: *matrix-build
     steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
+      - *checkout
 
-      - name: Download env_file
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: env_file
+      - *download-env-file
 
-      - name: Download requirements_diff
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: requirements_diff
+      - *download-requirements-diff
 
       - name: Download requirements_all_wheels
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: *actions-download-artifact
         with:
           name: requirements_all_wheels
 
@@ -195,15 +178,15 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: *home-assistant-wheels
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
-          wheels-key: ${{ secrets.WHEELS_KEY }} # zizmor: ignore[secrets-outside-env]
+          wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
           apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all_wheels_${{ matrix.arch }}.txt"
+          requirements: "requirements_all.txt"

.gitignore

@@ -142,6 +142,5 @@ pytest_buckets.txt
 
 # AI tooling
 .claude/settings.local.json
-.claude/worktrees/
 .serena/
 

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.10
+    rev: v0.14.13
     hooks:
       - id: ruff-check
         args:
@@ -8,7 +8,7 @@ repos:
       - id: ruff-format
         files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
     hooks:
       - id: codespell
         args:
@@ -17,12 +17,6 @@ repos:
           - --quiet-level=2
         exclude_types: [csv, json, html]
         exclude: ^tests/fixtures/|homeassistant/generated/|tests/components/.*/snapshots/
-  - repo: https://github.com/zizmorcore/zizmor-pre-commit
-    rev: v1.24.0
-    hooks:
-      - id: zizmor
-        args:
-          - --pedantic
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v6.0.0
     hooks:
@@ -36,7 +30,7 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
     hooks:
       - id: yamllint
   - repo: https://github.com/rbubley/mirrors-prettier
@@ -87,13 +81,6 @@ repos:
         language: script
         types: [text]
         files: ^(homeassistant/.+/manifest\.json|homeassistant/brands/.+\.json|pyproject\.toml|\.pre-commit-config\.yaml|script/gen_requirements_all\.py)$
-      - id: gen_copilot_instructions
-        name: gen_copilot_instructions
-        entry: script/run-in-env.sh python3 -m script.gen_copilot_instructions
-        pass_filenames: false
-        language: script
-        types: [text]
-        files: ^(AGENTS\.md|\.claude/skills/(?!github-pr-reviewer/).+/SKILL\.md|\.github/copilot-instructions\.md|script/gen_copilot_instructions\.py)$
       - id: hassfest
         name: hassfest
         entry: script/run-in-env.sh python3 -m script.hassfest

.python-version

@@ -1 +1 @@
-3.14.2
+3.13

.strict-typing

@@ -46,16 +46,13 @@ homeassistant.components.accuweather.*
 homeassistant.components.acer_projector.*
 homeassistant.components.acmeda.*
 homeassistant.components.actiontec.*
-homeassistant.components.actron_air.*
 homeassistant.components.adax.*
 homeassistant.components.adguard.*
 homeassistant.components.aftership.*
-homeassistant.components.ai_task.*
 homeassistant.components.air_quality.*
 homeassistant.components.airgradient.*
 homeassistant.components.airly.*
 homeassistant.components.airnow.*
-homeassistant.components.airobot.*
 homeassistant.components.airos.*
 homeassistant.components.airq.*
 homeassistant.components.airthings.*
@@ -86,7 +83,6 @@ homeassistant.components.androidtv_remote.*
 homeassistant.components.anel_pwrctrl.*
 homeassistant.components.anova.*
 homeassistant.components.anthemav.*
-homeassistant.components.anthropic.*
 homeassistant.components.apache_kafka.*
 homeassistant.components.apcupsd.*
 homeassistant.components.api.*
@@ -124,6 +120,7 @@ homeassistant.components.blueprint.*
 homeassistant.components.bluesound.*
 homeassistant.components.bluetooth.*
 homeassistant.components.bluetooth_adapters.*
+homeassistant.components.bmw_connected_drive.*
 homeassistant.components.bond.*
 homeassistant.components.bosch_alarm.*
 homeassistant.components.braviatv.*
@@ -131,14 +128,12 @@ homeassistant.components.bring.*
 homeassistant.components.brother.*
 homeassistant.components.browser.*
 homeassistant.components.bryant_evolution.*
-homeassistant.components.bsblan.*
 homeassistant.components.bthome.*
 homeassistant.components.button.*
 homeassistant.components.calendar.*
 homeassistant.components.cambridge_audio.*
 homeassistant.components.camera.*
 homeassistant.components.canary.*
-homeassistant.components.casper_glow.*
 homeassistant.components.cert_expiry.*
 homeassistant.components.clickatell.*
 homeassistant.components.clicksend.*
@@ -175,11 +170,9 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
-homeassistant.components.dropbox.*
 homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*
-homeassistant.components.duco.*
 homeassistant.components.dunehd.*
 homeassistant.components.duotecno.*
 homeassistant.components.easyenergy.*
@@ -214,9 +207,7 @@ homeassistant.components.firefly_iii.*
 homeassistant.components.fitbit.*
 homeassistant.components.flexit_bacnet.*
 homeassistant.components.flux_led.*
-homeassistant.components.folder_watcher.*
 homeassistant.components.forecast_solar.*
-homeassistant.components.freshr.*
 homeassistant.components.fritz.*
 homeassistant.components.fritzbox.*
 homeassistant.components.fritzbox_callmonitor.*
@@ -224,13 +215,11 @@ homeassistant.components.fronius.*
 homeassistant.components.frontend.*
 homeassistant.components.fujitsu_fglair.*
 homeassistant.components.fully_kiosk.*
-homeassistant.components.fumis.*
 homeassistant.components.fyta.*
 homeassistant.components.generic_hygrostat.*
 homeassistant.components.generic_thermostat.*
 homeassistant.components.geo_location.*
 homeassistant.components.geocaching.*
-homeassistant.components.ghost.*
 homeassistant.components.gios.*
 homeassistant.components.github.*
 homeassistant.components.glances.*
@@ -251,7 +240,6 @@ homeassistant.components.guardian.*
 homeassistant.components.habitica.*
 homeassistant.components.hardkernel.*
 homeassistant.components.hardware.*
-homeassistant.components.hdfury.*
 homeassistant.components.heos.*
 homeassistant.components.here_travel_time.*
 homeassistant.components.history.*
@@ -277,15 +265,12 @@ homeassistant.components.homekit_controller.storage
 homeassistant.components.homekit_controller.utils
 homeassistant.components.homewizard.*
 homeassistant.components.homeworks.*
-homeassistant.components.hr_energy_qube.*
 homeassistant.components.http.*
 homeassistant.components.huawei_lte.*
 homeassistant.components.humidifier.*
 homeassistant.components.husqvarna_automower.*
-homeassistant.components.huum.*
 homeassistant.components.hydrawise.*
 homeassistant.components.hyperion.*
-homeassistant.components.hypontech.*
 homeassistant.components.ibeacon.*
 homeassistant.components.idasen_desk.*
 homeassistant.components.image.*
@@ -296,12 +281,10 @@ homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.inels.*
-homeassistant.components.infrared.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*
 homeassistant.components.integration.*
-homeassistant.components.intelliclima.*
 homeassistant.components.intent.*
 homeassistant.components.intent_script.*
 homeassistant.components.ios.*
@@ -309,7 +292,6 @@ homeassistant.components.iotty.*
 homeassistant.components.ipp.*
 homeassistant.components.iqvia.*
 homeassistant.components.iron_os.*
-homeassistant.components.isal.*
 homeassistant.components.islamic_prayer_times.*
 homeassistant.components.isy994.*
 homeassistant.components.jellyfin.*
@@ -320,7 +302,6 @@ homeassistant.components.knocki.*
 homeassistant.components.knx.*
 homeassistant.components.kraken.*
 homeassistant.components.kulersky.*
-homeassistant.components.labs.*
 homeassistant.components.lacrosse.*
 homeassistant.components.lacrosse_view.*
 homeassistant.components.lamarzocco.*
@@ -332,10 +313,8 @@ homeassistant.components.ld2410_ble.*
 homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
-homeassistant.components.lg_infrared.*
 homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
-homeassistant.components.liebherr.*
 homeassistant.components.lifx.*
 homeassistant.components.light.*
 homeassistant.components.linkplay.*
@@ -351,7 +330,6 @@ homeassistant.components.lookin.*
 homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
 homeassistant.components.lunatone.*
-homeassistant.components.lutron.*
 homeassistant.components.madvr.*
 homeassistant.components.manual.*
 homeassistant.components.mastodon.*
@@ -383,7 +361,7 @@ homeassistant.components.my.*
 homeassistant.components.mysensors.*
 homeassistant.components.myuplink.*
 homeassistant.components.nam.*
-homeassistant.components.namecheapdns.*
+homeassistant.components.nanoleaf.*
 homeassistant.components.nasweb.*
 homeassistant.components.neato.*
 homeassistant.components.nest.*
@@ -397,7 +375,6 @@ homeassistant.components.no_ip.*
 homeassistant.components.nordpool.*
 homeassistant.components.notify.*
 homeassistant.components.notion.*
-homeassistant.components.nrgkick.*
 homeassistant.components.ntfy.*
 homeassistant.components.number.*
 homeassistant.components.nut.*
@@ -405,13 +382,11 @@ homeassistant.components.ohme.*
 homeassistant.components.onboarding.*
 homeassistant.components.oncue.*
 homeassistant.components.onedrive.*
-homeassistant.components.onedrive_for_business.*
 homeassistant.components.onewire.*
 homeassistant.components.onkyo.*
 homeassistant.components.open_meteo.*
 homeassistant.components.open_router.*
 homeassistant.components.openai_conversation.*
-homeassistant.components.openevse.*
 homeassistant.components.openexchangerates.*
 homeassistant.components.opensky.*
 homeassistant.components.openuv.*
@@ -419,7 +394,6 @@ homeassistant.components.opnsense.*
 homeassistant.components.opower.*
 homeassistant.components.oralb.*
 homeassistant.components.otbr.*
-homeassistant.components.otp.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
 homeassistant.components.p1_monitor.*
@@ -436,7 +410,6 @@ homeassistant.components.plugwise.*
 homeassistant.components.pooldose.*
 homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
-homeassistant.components.powerfox_local.*
 homeassistant.components.powerwall.*
 homeassistant.components.private_ble_device.*
 homeassistant.components.prometheus.*
@@ -455,13 +428,10 @@ homeassistant.components.radarr.*
 homeassistant.components.radio_browser.*
 homeassistant.components.rainforest_raven.*
 homeassistant.components.rainmachine.*
-homeassistant.components.random.*
 homeassistant.components.raspberry_pi.*
 homeassistant.components.rdw.*
 homeassistant.components.recollect_waste.*
 homeassistant.components.recorder.*
-homeassistant.components.recovery_mode.*
-homeassistant.components.redgtech.*
 homeassistant.components.remember_the_milk.*
 homeassistant.components.remote.*
 homeassistant.components.remote_calendar.*
@@ -492,7 +462,6 @@ homeassistant.components.schlage.*
 homeassistant.components.scrape.*
 homeassistant.components.script.*
 homeassistant.components.search.*
-homeassistant.components.season.*
 homeassistant.components.select.*
 homeassistant.components.sensibo.*
 homeassistant.components.sensirion_ble.*
@@ -519,7 +488,6 @@ homeassistant.components.smtp.*
 homeassistant.components.snooz.*
 homeassistant.components.solarlog.*
 homeassistant.components.sonarr.*
-homeassistant.components.spaceapi.*
 homeassistant.components.speedtestdotnet.*
 homeassistant.components.spotify.*
 homeassistant.components.sql.*
@@ -544,7 +512,6 @@ homeassistant.components.synology_dsm.*
 homeassistant.components.system_health.*
 homeassistant.components.system_log.*
 homeassistant.components.systemmonitor.*
-homeassistant.components.systemnexa2.*
 homeassistant.components.tag.*
 homeassistant.components.tailscale.*
 homeassistant.components.tailwind.*
@@ -555,8 +522,6 @@ homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
-homeassistant.components.teleinfo.*
-homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
 homeassistant.components.threshold.*
@@ -580,25 +545,21 @@ homeassistant.components.trafikverket_train.*
 homeassistant.components.trafikverket_weatherstation.*
 homeassistant.components.transmission.*
 homeassistant.components.trend.*
-homeassistant.components.trmnl.*
 homeassistant.components.tts.*
 homeassistant.components.twentemilieu.*
 homeassistant.components.unifi.*
-homeassistant.components.unifi_access.*
 homeassistant.components.unifiprotect.*
 homeassistant.components.upcloud.*
 homeassistant.components.update.*
 homeassistant.components.uptime.*
 homeassistant.components.uptime_kuma.*
 homeassistant.components.uptimerobot.*
-homeassistant.components.usage_prediction.*
 homeassistant.components.usb.*
 homeassistant.components.uvc.*
 homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
-homeassistant.components.velux.*
 homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*
@@ -611,7 +572,6 @@ homeassistant.components.water_heater.*
 homeassistant.components.watts.*
 homeassistant.components.watttime.*
 homeassistant.components.weather.*
-homeassistant.components.web_rtc.*
 homeassistant.components.webhook.*
 homeassistant.components.webostv.*
 homeassistant.components.websocket_api.*
@@ -628,7 +588,6 @@ homeassistant.components.yale_smart_alarm.*
 homeassistant.components.yalexs_ble.*
 homeassistant.components.youtube.*
 homeassistant.components.zeroconf.*
-homeassistant.components.zinvolt.*
 homeassistant.components.zodiac.*
 homeassistant.components.zone.*
 homeassistant.components.zwave_js.*

AGENTS.md

@@ -1,27 +0,0 @@
-# GitHub Copilot & Claude Code Instructions
-
-This repository contains the core of Home Assistant, a Python 3 based home automation application.
-
-## Git Commit Guidelines
-
-- **Do NOT amend, squash, or rebase commits that have already been pushed to the PR branch after the PR is opened** - Reviewers need to follow the commit history, as well as see what changed since their last review
-
-## Development Commands
-
-.vscode/tasks.json contains useful commands used for development.
-
-## Python Syntax Notes
-
-- Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses.
-
-## Testing
-
-When writing or modifying tests, ensure all test function parameters have type annotations.
-Prefer concrete types (for example, `HomeAssistant`, `MockConfigEntry`, etc.) over `Any`.
-
-## Good practices
-
-Integrations with Platinum or Gold level in the Integration Quality Scale reflect a high standard of code quality and maintainability. When looking for examples of something, these are good places to start. The level is indicated in the manifest.json of the integration.
-
-When reviewing entity actions, do not suggest extra defensive checks for input fields that are already validated by Home Assistant's service/action schemas and entity selection filters. Suggest additional guards only when data bypasses those validators or is transformed into a less-safe form.
-When validation guarantees a dict key exists, prefer direct key access (`data["key"]`) instead of `.get("key")` so contract violations are surfaced instead of silently masked.

AGENTS.md

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

CLAUDE.md

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

CODEOWNERS

@@ -15,7 +15,7 @@
 .yamllint @home-assistant/core
 pyproject.toml @home-assistant/core
 requirements_test.txt @home-assistant/core
-/.devcontainer/ @home-assistant/core @edenhaus
+/.devcontainer/ @home-assistant/core
 /.github/ @home-assistant/core
 /.vscode/ @home-assistant/core
 /homeassistant/*.py @home-assistant/core
@@ -37,13 +37,6 @@ build.json @home-assistant/supervisor
 # Other code
 /homeassistant/scripts/check_config.py @kellerza
 
-# Agent Configurations
-AGENTS.md @home-assistant/core
-CLAUDE.md @home-assistant/core
-/.agent/ @home-assistant/core
-/.claude/ @home-assistant/core
-/.gemini/ @home-assistant/core
-
 # Integrations
 /homeassistant/components/abode/ @shred86
 /tests/components/abode/ @shred86
@@ -193,8 +186,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/auth/ @home-assistant/core
 /homeassistant/components/automation/ @home-assistant/core
 /tests/components/automation/ @home-assistant/core
-/homeassistant/components/autoskope/ @mcisk
-/tests/components/autoskope/ @mcisk
 /homeassistant/components/avea/ @pattyland
 /homeassistant/components/awair/ @ahayworth @ricohageman
 /tests/components/awair/ @ahayworth @ricohageman
@@ -221,16 +212,14 @@ CLAUDE.md @home-assistant/core
 /tests/components/balboa/ @garbled1 @natekspencer
 /homeassistant/components/bang_olufsen/ @mj23000
 /tests/components/bang_olufsen/ @mj23000
-/homeassistant/components/battery/ @home-assistant/core
-/tests/components/battery/ @home-assistant/core
 /homeassistant/components/bayesian/ @HarvsG
 /tests/components/bayesian/ @HarvsG
 /homeassistant/components/beewi_smartclim/ @alemuro
 /homeassistant/components/binary_sensor/ @home-assistant/core
 /tests/components/binary_sensor/ @home-assistant/core
 /homeassistant/components/bizkaibus/ @UgaitzEtxebarria
-/homeassistant/components/blebox/ @bbx-a @swistakm @bkobus-bbx
-/tests/components/blebox/ @bbx-a @swistakm @bkobus-bbx
+/homeassistant/components/blebox/ @bbx-a @swistakm
+/tests/components/blebox/ @bbx-a @swistakm
 /homeassistant/components/blink/ @fronzbot
 /tests/components/blink/ @fronzbot
 /homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
@@ -245,14 +234,14 @@ CLAUDE.md @home-assistant/core
 /tests/components/bluetooth/ @bdraco
 /homeassistant/components/bluetooth_adapters/ @bdraco
 /tests/components/bluetooth_adapters/ @bdraco
+/homeassistant/components/bmw_connected_drive/ @gerard33 @rikroe
+/tests/components/bmw_connected_drive/ @gerard33 @rikroe
 /homeassistant/components/bond/ @bdraco @prystupa @joshs85 @marciogranzotto
 /tests/components/bond/ @bdraco @prystupa @joshs85 @marciogranzotto
 /homeassistant/components/bosch_alarm/ @mag1024 @sanjay900
 /tests/components/bosch_alarm/ @mag1024 @sanjay900
 /homeassistant/components/bosch_shc/ @tschamm
 /tests/components/bosch_shc/ @tschamm
-/homeassistant/components/brands/ @home-assistant/core
-/tests/components/brands/ @home-assistant/core
 /homeassistant/components/braviatv/ @bieniu @Drafteed
 /tests/components/braviatv/ @bieniu @Drafteed
 /homeassistant/components/bring/ @miaucl @tr4nt0r
@@ -282,8 +271,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/cambridge_audio/ @noahhusby
 /homeassistant/components/camera/ @home-assistant/core
 /tests/components/camera/ @home-assistant/core
-/homeassistant/components/casper_glow/ @mikeodr
-/tests/components/casper_glow/ @mikeodr
 /homeassistant/components/cast/ @emontnemery
 /tests/components/cast/ @emontnemery
 /homeassistant/components/ccm15/ @ocalvo
@@ -292,8 +279,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/cert_expiry/ @jjlawren
 /homeassistant/components/chacon_dio/ @cnico
 /tests/components/chacon_dio/ @cnico
-/homeassistant/components/chess_com/ @joostlek
-/tests/components/chess_com/ @joostlek
 /homeassistant/components/cisco_ios/ @fbradyirl
 /homeassistant/components/cisco_mobility_express/ @fbradyirl
 /homeassistant/components/cisco_webex_teams/ @fbradyirl
@@ -303,8 +288,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/cloud/ @home-assistant/cloud
 /homeassistant/components/cloudflare/ @ludeeus @ctalkington
 /tests/components/cloudflare/ @ludeeus @ctalkington
-/homeassistant/components/cloudflare_r2/ @corrreia
-/tests/components/cloudflare_r2/ @corrreia
 /homeassistant/components/co2signal/ @jpbede @VIKTORVAV99
 /tests/components/co2signal/ @jpbede @VIKTORVAV99
 /homeassistant/components/coinbase/ @tombrien
@@ -362,8 +345,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/deluge/ @tkdrob
 /homeassistant/components/demo/ @home-assistant/core
 /tests/components/demo/ @home-assistant/core
-/homeassistant/components/denon_rs232/ @balloob
-/tests/components/denon_rs232/ @balloob
 /homeassistant/components/denonavr/ @ol-iver @starkillerOG
 /tests/components/denonavr/ @ol-iver @starkillerOG
 /homeassistant/components/derivative/ @afaucogney @karwosts
@@ -398,8 +379,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dlna_dms/ @chishm
 /homeassistant/components/dnsip/ @gjohansson-ST
 /tests/components/dnsip/ @gjohansson-ST
-/homeassistant/components/door/ @home-assistant/core
-/tests/components/door/ @home-assistant/core
 /homeassistant/components/doorbird/ @oblogic7 @bdraco @flacjacket
 /tests/components/doorbird/ @oblogic7 @bdraco @flacjacket
 /homeassistant/components/dormakaba_dkey/ @emontnemery
@@ -410,8 +389,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dremel_3d_printer/ @tkdrob
 /homeassistant/components/drop_connect/ @ChandlerSystems @pfrazer
 /tests/components/drop_connect/ @ChandlerSystems @pfrazer
-/homeassistant/components/dropbox/ @bdr99
-/tests/components/dropbox/ @bdr99
 /homeassistant/components/droplet/ @sarahseidman
 /tests/components/droplet/ @sarahseidman
 /homeassistant/components/dsmr/ @Robbie1221
@@ -420,18 +397,16 @@ CLAUDE.md @home-assistant/core
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /homeassistant/components/duckdns/ @tr4nt0r
 /tests/components/duckdns/ @tr4nt0r
-/homeassistant/components/duco/ @ronaldvdmeer
-/tests/components/duco/ @ronaldvdmeer
+/homeassistant/components/duke_energy/ @hunterjm
+/tests/components/duke_energy/ @hunterjm
 /homeassistant/components/duotecno/ @cereal2nd
 /tests/components/duotecno/ @cereal2nd
-/homeassistant/components/dwd_weather_warnings/ @runningman84 @stephan192
-/tests/components/dwd_weather_warnings/ @runningman84 @stephan192
+/homeassistant/components/dwd_weather_warnings/ @runningman84 @stephan192 @andarotajo
+/tests/components/dwd_weather_warnings/ @runningman84 @stephan192 @andarotajo
 /homeassistant/components/dynalite/ @ziv1234
 /tests/components/dynalite/ @ziv1234
 /homeassistant/components/eafm/ @Jc2k
 /tests/components/eafm/ @Jc2k
-/homeassistant/components/earn_e_p1/ @Miggets7
-/tests/components/earn_e_p1/ @Miggets7
 /homeassistant/components/easyenergy/ @klaasnicolaas
 /tests/components/easyenergy/ @klaasnicolaas
 /homeassistant/components/ecoforest/ @pjanuario
@@ -493,8 +468,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
-/homeassistant/components/epic_games_store/ @Quentame
-/tests/components/epic_games_store/ @Quentame
+/homeassistant/components/epic_games_store/ @hacf-fr @Quentame
+/tests/components/epic_games_store/ @hacf-fr @Quentame
 /homeassistant/components/epion/ @lhgravendeel
 /tests/components/epion/ @lhgravendeel
 /homeassistant/components/epson/ @pszafer
@@ -509,8 +484,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/essent/ @jaapp
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
-/homeassistant/components/eurotronic_cometblue/ @rikroe
-/tests/components/eurotronic_cometblue/ @rikroe
 /homeassistant/components/event/ @home-assistant/core
 /tests/components/event/ @home-assistant/core
 /homeassistant/components/evohome/ @zxdavb
@@ -570,18 +543,18 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/fortios/ @kimfrellsen
 /homeassistant/components/foscam/ @Foscam-wangzhengyu
 /tests/components/foscam/ @Foscam-wangzhengyu
-/homeassistant/components/freebox/ @hacf-fr/reviewers @Quentame
-/tests/components/freebox/ @hacf-fr/reviewers @Quentame
+/homeassistant/components/freebox/ @hacf-fr @Quentame
+/tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
-/homeassistant/components/freshr/ @SierraNL
-/tests/components/freshr/ @SierraNL
 /homeassistant/components/fressnapf_tracker/ @eifinger
 /tests/components/fressnapf_tracker/ @eifinger
 /homeassistant/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
 /tests/components/fritzbox/ @mib1185 @flabbamann
+/homeassistant/components/fritzbox_callmonitor/ @cdce8p
+/tests/components/fritzbox_callmonitor/ @cdce8p
 /homeassistant/components/fronius/ @farmio
 /tests/components/fronius/ @farmio
 /homeassistant/components/frontend/ @home-assistant/frontend
@@ -592,18 +565,12 @@ CLAUDE.md @home-assistant/core
 /tests/components/fujitsu_fglair/ @crevetor
 /homeassistant/components/fully_kiosk/ @cgarwood
 /tests/components/fully_kiosk/ @cgarwood
-/homeassistant/components/fumis/ @frenck
-/tests/components/fumis/ @frenck
 /homeassistant/components/fyta/ @dontinelli
 /tests/components/fyta/ @dontinelli
-/homeassistant/components/garage_door/ @home-assistant/core
-/tests/components/garage_door/ @home-assistant/core
 /homeassistant/components/garages_amsterdam/ @klaasnicolaas
 /tests/components/garages_amsterdam/ @klaasnicolaas
 /homeassistant/components/gardena_bluetooth/ @elupus
 /tests/components/gardena_bluetooth/ @elupus
-/homeassistant/components/gate/ @home-assistant/core
-/tests/components/gate/ @home-assistant/core
 /homeassistant/components/gdacs/ @exxamalte
 /tests/components/gdacs/ @exxamalte
 /homeassistant/components/generic/ @davet2001
@@ -626,8 +593,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/geonetnz_quakes/ @exxamalte
 /homeassistant/components/geonetnz_volcano/ @exxamalte
 /tests/components/geonetnz_volcano/ @exxamalte
-/homeassistant/components/ghost/ @johnonolan
-/tests/components/ghost/ @johnonolan
 /homeassistant/components/gios/ @bieniu
 /tests/components/gios/ @bieniu
 /homeassistant/components/github/ @timmo001 @ludeeus
@@ -676,8 +641,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/gpsd/ @fabaff @jrieger
 /homeassistant/components/gree/ @cmroche
 /tests/components/gree/ @cmroche
-/homeassistant/components/green_planet_energy/ @petschni
-/tests/components/green_planet_energy/ @petschni
 /homeassistant/components/greeneye_monitor/ @jkeljo
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
@@ -703,8 +666,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
-/homeassistant/components/hegel/ @boazca
-/tests/components/hegel/ @boazca
 /homeassistant/components/heos/ @andrewsayre
 /tests/components/heos/ @andrewsayre
 /homeassistant/components/here_travel_time/ @eifinger
@@ -748,18 +709,14 @@ CLAUDE.md @home-assistant/core
 /tests/components/homekit_controller/ @Jc2k @bdraco
 /homeassistant/components/homematic/ @pvizeli
 /tests/components/homematic/ @pvizeli
-/homeassistant/components/homematicip_cloud/ @hahn-th @lackas
-/tests/components/homematicip_cloud/ @hahn-th @lackas
-/homeassistant/components/homevolt/ @danielhiversen @liudger
-/tests/components/homevolt/ @danielhiversen @liudger
+/homeassistant/components/homematicip_cloud/ @hahn-th
+/tests/components/homematicip_cloud/ @hahn-th
 /homeassistant/components/homewizard/ @DCSBL
 /tests/components/homewizard/ @DCSBL
 /homeassistant/components/honeywell/ @rdfurman @mkmer
 /tests/components/honeywell/ @rdfurman @mkmer
-/homeassistant/components/hr_energy_qube/ @MattieGit
-/tests/components/hr_energy_qube/ @MattieGit
-/homeassistant/components/html5/ @alexyao2015 @tr4nt0r
-/tests/components/html5/ @alexyao2015 @tr4nt0r
+/homeassistant/components/html5/ @alexyao2015
+/tests/components/html5/ @alexyao2015
 /homeassistant/components/http/ @home-assistant/core
 /tests/components/http/ @home-assistant/core
 /homeassistant/components/huawei_lte/ @scop @fphammerle
@@ -772,8 +729,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/huisbaasje/ @dennisschroer
 /homeassistant/components/humidifier/ @home-assistant/core @Shulyaka
 /tests/components/humidifier/ @home-assistant/core @Shulyaka
-/homeassistant/components/humidity/ @home-assistant/core
-/tests/components/humidity/ @home-assistant/core
 /homeassistant/components/hunterdouglas_powerview/ @bdraco @kingy444 @trullock
 /tests/components/hunterdouglas_powerview/ @bdraco @kingy444 @trullock
 /homeassistant/components/husqvarna_automower/ @Thomas55555
@@ -788,8 +743,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/hydrawise/ @dknowles2 @thomaskistler @ptcryan
 /homeassistant/components/hyperion/ @dermotduffy
 /tests/components/hyperion/ @dermotduffy
-/homeassistant/components/hypontech/ @jcisio
-/tests/components/hypontech/ @jcisio
 /homeassistant/components/ialarm/ @RyuzakiKK
 /tests/components/ialarm/ @RyuzakiKK
 /homeassistant/components/iammeter/ @lewei50
@@ -799,14 +752,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/icloud/ @Quentame @nzapponi
 /homeassistant/components/idasen_desk/ @abmantis
 /tests/components/idasen_desk/ @abmantis
-/homeassistant/components/idrive_e2/ @patrickvorgers
-/tests/components/idrive_e2/ @patrickvorgers
 /homeassistant/components/igloohome/ @keithle888
 /tests/components/igloohome/ @keithle888
 /homeassistant/components/ign_sismologia/ @exxamalte
 /tests/components/ign_sismologia/ @exxamalte
-/homeassistant/components/illuminance/ @home-assistant/core
-/tests/components/illuminance/ @home-assistant/core
 /homeassistant/components/image/ @home-assistant/core
 /tests/components/image/ @home-assistant/core
 /homeassistant/components/image_processing/ @home-assistant/core
@@ -825,14 +774,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/improv_ble/ @emontnemery
 /homeassistant/components/incomfort/ @jbouwh
 /tests/components/incomfort/ @jbouwh
-/homeassistant/components/indevolt/ @xirt
-/tests/components/indevolt/ @xirt
 /homeassistant/components/inels/ @epdevlab
 /tests/components/inels/ @epdevlab
-/homeassistant/components/influxdb/ @mdegat01 @Robbie1221
-/tests/components/influxdb/ @mdegat01 @Robbie1221
-/homeassistant/components/infrared/ @home-assistant/core
-/tests/components/infrared/ @home-assistant/core
+/homeassistant/components/influxdb/ @mdegat01
+/tests/components/influxdb/ @mdegat01
 /homeassistant/components/inkbird/ @bdraco
 /tests/components/inkbird/ @bdraco
 /homeassistant/components/input_boolean/ @home-assistant/core
@@ -851,8 +796,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/insteon/ @teharris1
 /homeassistant/components/integration/ @dgomes
 /tests/components/integration/ @dgomes
-/homeassistant/components/intelliclima/ @dvdinth
-/tests/components/intelliclima/ @dvdinth
 /homeassistant/components/intellifire/ @jeeftor
 /tests/components/intellifire/ @jeeftor
 /homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
@@ -904,8 +847,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/jewish_calendar/ @tsvi
 /homeassistant/components/justnimbus/ @kvanzuijlen
 /tests/components/justnimbus/ @kvanzuijlen
-/homeassistant/components/jvc_projector/ @SteveEasley
-/tests/components/jvc_projector/ @SteveEasley
+/homeassistant/components/jvc_projector/ @SteveEasley @msavazzi
+/tests/components/jvc_projector/ @SteveEasley @msavazzi
 /homeassistant/components/kaiterra/ @Michsior14
 /homeassistant/components/kaleidescape/ @SteveEasley
 /tests/components/kaleidescape/ @SteveEasley
@@ -918,8 +861,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/keyboard_remote/ @bendavid @lanrat
 /homeassistant/components/keymitt_ble/ @spycle
 /tests/components/keymitt_ble/ @spycle
-/homeassistant/components/kiosker/ @Claeysson
-/tests/components/kiosker/ @Claeysson
 /homeassistant/components/kitchen_sink/ @home-assistant/core
 /tests/components/kitchen_sink/ @home-assistant/core
 /homeassistant/components/kmtronic/ @dgomes
@@ -968,20 +909,14 @@ CLAUDE.md @home-assistant/core
 /tests/components/lektrico/ @lektrico
 /homeassistant/components/letpot/ @jpelgrom
 /tests/components/letpot/ @jpelgrom
-/homeassistant/components/lg_infrared/ @home-assistant/core
-/tests/components/lg_infrared/ @home-assistant/core
 /homeassistant/components/lg_netcast/ @Drafteed @splinter98
 /tests/components/lg_netcast/ @Drafteed @splinter98
 /homeassistant/components/lg_thinq/ @LG-ThinQ-Integration
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
 /homeassistant/components/libre_hardware_monitor/ @Sab44
 /tests/components/libre_hardware_monitor/ @Sab44
-/homeassistant/components/lichess/ @aryanhasgithub
-/tests/components/lichess/ @aryanhasgithub
 /homeassistant/components/lidarr/ @tkdrob
 /tests/components/lidarr/ @tkdrob
-/homeassistant/components/liebherr/ @mettolen
-/tests/components/liebherr/ @mettolen
 /homeassistant/components/lifx/ @Djelibeybi
 /tests/components/lifx/ @Djelibeybi
 /homeassistant/components/light/ @home-assistant/core
@@ -1007,8 +942,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/logbook/ @home-assistant/core
 /homeassistant/components/logger/ @home-assistant/core
 /tests/components/logger/ @home-assistant/core
-/homeassistant/components/lojack/ @devinslick
-/tests/components/lojack/ @devinslick
 /homeassistant/components/london_underground/ @jpbede
 /tests/components/london_underground/ @jpbede
 /homeassistant/components/lookin/ @ANMalko @bdraco
@@ -1065,8 +998,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/met/ @danielhiversen
 /homeassistant/components/met_eireann/ @DylanGore
 /tests/components/met_eireann/ @DylanGore
-/homeassistant/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
-/tests/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
+/homeassistant/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
+/tests/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
 /homeassistant/components/meteo_lt/ @xE1H
 /tests/components/meteo_lt/ @xE1H
 /homeassistant/components/meteoalarm/ @rolfberkenbosch
@@ -1098,8 +1031,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/modern_forms/ @wonderslug
 /homeassistant/components/moehlenhoff_alpha2/ @j-a-n
 /tests/components/moehlenhoff_alpha2/ @j-a-n
-/homeassistant/components/moisture/ @home-assistant/core
-/tests/components/moisture/ @home-assistant/core
 /homeassistant/components/monarch_money/ @jeeftor
 /tests/components/monarch_money/ @jeeftor
 /homeassistant/components/monoprice/ @etsinko @OnFreund
@@ -1110,8 +1041,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/moon/ @fabaff @frenck
 /homeassistant/components/mopeka/ @bdraco
 /tests/components/mopeka/ @bdraco
-/homeassistant/components/motion/ @home-assistant/core
-/tests/components/motion/ @home-assistant/core
 /homeassistant/components/motion_blinds/ @starkillerOG
 /tests/components/motion_blinds/ @starkillerOG
 /homeassistant/components/motionblinds_ble/ @LennP @jerrybboy
@@ -1123,8 +1052,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/mqtt/ @emontnemery @jbouwh @bdraco
 /tests/components/mqtt/ @emontnemery @jbouwh @bdraco
 /homeassistant/components/msteams/ @peroyvind
-/homeassistant/components/mta/ @OnFreund
-/tests/components/mta/ @OnFreund
 /homeassistant/components/mullvad/ @meichthys
 /tests/components/mullvad/ @meichthys
 /homeassistant/components/music_assistant/ @music-assistant @arturpragacz
@@ -1133,8 +1060,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core
 /tests/components/my/ @home-assistant/core
-/homeassistant/components/myneomitis/ @l-pr
-/tests/components/myneomitis/ @l-pr
 /homeassistant/components/mysensors/ @MartinHjelmare @functionpointer
 /tests/components/mysensors/ @MartinHjelmare @functionpointer
 /homeassistant/components/mystrom/ @fabaff
@@ -1145,21 +1070,21 @@ CLAUDE.md @home-assistant/core
 /tests/components/nam/ @bieniu
 /homeassistant/components/namecheapdns/ @tr4nt0r
 /tests/components/namecheapdns/ @tr4nt0r
-/homeassistant/components/nanoleaf/ @milanmeu @joostlek @loebi-ch @JaspervRijbroek @jonathanrobichaud4
-/tests/components/nanoleaf/ @milanmeu @joostlek @loebi-ch @JaspervRijbroek @jonathanrobichaud4
+/homeassistant/components/nanoleaf/ @milanmeu @joostlek
+/tests/components/nanoleaf/ @milanmeu @joostlek
 /homeassistant/components/nasweb/ @nasWebio
 /tests/components/nasweb/ @nasWebio
 /homeassistant/components/nederlandse_spoorwegen/ @YarmoM @heindrichpaul
 /tests/components/nederlandse_spoorwegen/ @YarmoM @heindrichpaul
-/homeassistant/components/ness_alarm/ @nickw444 @poshy163
-/tests/components/ness_alarm/ @nickw444 @poshy163
+/homeassistant/components/ness_alarm/ @nickw444
+/tests/components/ness_alarm/ @nickw444
 /homeassistant/components/nest/ @allenporter
 /tests/components/nest/ @allenporter
 /homeassistant/components/netatmo/ @cgtobi
 /tests/components/netatmo/ @cgtobi
 /homeassistant/components/netdata/ @fabaff
-/homeassistant/components/netgear/ @Quentame @starkillerOG
-/tests/components/netgear/ @Quentame @starkillerOG
+/homeassistant/components/netgear/ @hacf-fr @Quentame @starkillerOG
+/tests/components/netgear/ @hacf-fr @Quentame @starkillerOG
 /homeassistant/components/netgear_lte/ @tkdrob
 /tests/components/netgear_lte/ @tkdrob
 /homeassistant/components/network/ @home-assistant/core
@@ -1199,8 +1124,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/notify_events/ @matrozov @papajojo
 /homeassistant/components/notion/ @bachya
 /tests/components/notion/ @bachya
-/homeassistant/components/nrgkick/ @andijakl
-/tests/components/nrgkick/ @andijakl
 /homeassistant/components/nsw_fuel_station/ @nickw444
 /tests/components/nsw_fuel_station/ @nickw444
 /homeassistant/components/nsw_rural_fire_service_feed/ @exxamalte
@@ -1225,8 +1148,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/nzbget/ @chriscla
 /homeassistant/components/obihai/ @dshokouhi @ejpenney
 /tests/components/obihai/ @dshokouhi @ejpenney
-/homeassistant/components/occupancy/ @home-assistant/core
-/tests/components/occupancy/ @home-assistant/core
 /homeassistant/components/octoprint/ @rfleming71
 /tests/components/octoprint/ @rfleming71
 /homeassistant/components/ohmconnect/ @robbiet480
@@ -1241,20 +1162,16 @@ CLAUDE.md @home-assistant/core
 /tests/components/ondilo_ico/ @JeromeHXP
 /homeassistant/components/onedrive/ @zweckj
 /tests/components/onedrive/ @zweckj
-/homeassistant/components/onedrive_for_business/ @zweckj
-/tests/components/onedrive_for_business/ @zweckj
 /homeassistant/components/onewire/ @garbled1 @epenet
 /tests/components/onewire/ @garbled1 @epenet
 /homeassistant/components/onkyo/ @arturpragacz @eclair4151
 /tests/components/onkyo/ @arturpragacz @eclair4151
-/homeassistant/components/onvif/ @jterrace
-/tests/components/onvif/ @jterrace
+/homeassistant/components/onvif/ @hunterjm @jterrace
+/tests/components/onvif/ @hunterjm @jterrace
 /homeassistant/components/open_meteo/ @frenck
 /tests/components/open_meteo/ @frenck
-/homeassistant/components/open_router/ @joostlek @ab3lson
-/tests/components/open_router/ @joostlek @ab3lson
-/homeassistant/components/opendisplay/ @g4bri3lDev
-/tests/components/opendisplay/ @g4bri3lDev
+/homeassistant/components/open_router/ @joostlek
+/tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
 /homeassistant/components/openevse/ @c00w @firstof9
@@ -1275,8 +1192,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/openuv/ @bachya
 /homeassistant/components/openweathermap/ @fabaff @freekode @nzapponi @wittypluck
 /tests/components/openweathermap/ @fabaff @freekode @nzapponi @wittypluck
-/homeassistant/components/opnsense/ @HarlemSquirrel @Snuffy2
-/tests/components/opnsense/ @HarlemSquirrel @Snuffy2
+/homeassistant/components/opnsense/ @mtreinish
+/tests/components/opnsense/ @mtreinish
 /homeassistant/components/opower/ @tronikos
 /tests/components/opower/ @tronikos
 /homeassistant/components/oralb/ @bdraco @Lash-L
@@ -1320,8 +1237,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/pi_hole/ @shenxn
 /homeassistant/components/picnic/ @corneyl @codesalatdev
 /tests/components/picnic/ @corneyl @codesalatdev
-/homeassistant/components/picotts/ @rooggiieerr
-/tests/components/picotts/ @rooggiieerr
 /homeassistant/components/ping/ @jpbede
 /tests/components/ping/ @jpbede
 /homeassistant/components/plaato/ @JohNan
@@ -1340,16 +1255,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/poolsense/ @haemishkyd
 /homeassistant/components/portainer/ @erwindouna
 /tests/components/portainer/ @erwindouna
-/homeassistant/components/power/ @home-assistant/core
-/tests/components/power/ @home-assistant/core
 /homeassistant/components/powerfox/ @klaasnicolaas
 /tests/components/powerfox/ @klaasnicolaas
-/homeassistant/components/powerfox_local/ @klaasnicolaas
-/tests/components/powerfox_local/ @klaasnicolaas
 /homeassistant/components/powerwall/ @bdraco @jrester @daniel-simpson
 /tests/components/powerwall/ @bdraco @jrester @daniel-simpson
-/homeassistant/components/prana/ @prana-dev-official
-/tests/components/prana/ @prana-dev-official
 /homeassistant/components/private_ble_device/ @Jc2k
 /tests/components/private_ble_device/ @Jc2k
 /homeassistant/components/probe_plus/ @pantherale0
@@ -1364,8 +1273,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/prosegur/ @dgomes
 /homeassistant/components/proximity/ @mib1185
 /tests/components/proximity/ @mib1185
-/homeassistant/components/proxmoxve/ @Corbeno @erwindouna @CoMPaTech
-/tests/components/proxmoxve/ @Corbeno @erwindouna @CoMPaTech
+/homeassistant/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
+/tests/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
 /homeassistant/components/ps4/ @ktnrg45
 /tests/components/ps4/ @ktnrg45
 /homeassistant/components/pterodactyl/ @elmurato
@@ -1436,8 +1345,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/recorder/ @home-assistant/core
 /homeassistant/components/recovery_mode/ @home-assistant/core
 /tests/components/recovery_mode/ @home-assistant/core
-/homeassistant/components/redgtech/ @jonhsady @luan-nvg
-/tests/components/redgtech/ @jonhsady @luan-nvg
 /homeassistant/components/refoss/ @ashionky
 /tests/components/refoss/ @ashionky
 /homeassistant/components/rehlko/ @bdraco @peterager
@@ -1600,8 +1507,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/sma/ @kellerza @rklomp @erwindouna
 /homeassistant/components/smappee/ @bsmappee
 /tests/components/smappee/ @bsmappee
-/homeassistant/components/smarla/ @explicatis @johannes-exp
-/tests/components/smarla/ @explicatis @johannes-exp
+/homeassistant/components/smarla/ @explicatis @rlint-explicatis
+/tests/components/smarla/ @explicatis @rlint-explicatis
 /homeassistant/components/smart_meter_texas/ @grahamwetzler
 /tests/components/smart_meter_texas/ @grahamwetzler
 /homeassistant/components/smartthings/ @joostlek
@@ -1627,8 +1534,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/solaredge_local/ @drobtravels @scheric
 /homeassistant/components/solarlog/ @Ernst79 @dontinelli
 /tests/components/solarlog/ @Ernst79 @dontinelli
-/homeassistant/components/solarman/ @solarmanpv
-/tests/components/solarman/ @solarmanpv
 /homeassistant/components/solax/ @squishykid @Darsstar
 /tests/components/solax/ @squishykid @Darsstar
 /homeassistant/components/soma/ @ratsept
@@ -1646,7 +1551,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/speedtestdotnet/ @rohankapoorcom @engrbm87
 /tests/components/speedtestdotnet/ @rohankapoorcom @engrbm87
 /homeassistant/components/splunk/ @Bre77
-/tests/components/splunk/ @Bre77
 /homeassistant/components/spotify/ @frenck @joostlek
 /tests/components/spotify/ @frenck @joostlek
 /homeassistant/components/sql/ @gjohansson-ST @dougiteixeira
@@ -1657,6 +1561,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/srp_energy/ @briglx
 /homeassistant/components/starline/ @anonym-tsk
 /tests/components/starline/ @anonym-tsk
+/homeassistant/components/starlink/ @boswelja
+/tests/components/starlink/ @boswelja
 /homeassistant/components/statistics/ @ThomDietrich @gjohansson-ST
 /tests/components/statistics/ @ThomDietrich @gjohansson-ST
 /homeassistant/components/steam_online/ @tkdrob
@@ -1702,15 +1608,13 @@ CLAUDE.md @home-assistant/core
 /tests/components/syncthing/ @zhulik
 /homeassistant/components/syncthru/ @nielstron
 /tests/components/syncthru/ @nielstron
-/homeassistant/components/synology_dsm/ @Quentame @mib1185
-/tests/components/synology_dsm/ @Quentame @mib1185
+/homeassistant/components/synology_dsm/ @hacf-fr @Quentame @mib1185
+/tests/components/synology_dsm/ @hacf-fr @Quentame @mib1185
 /homeassistant/components/synology_srm/ @aerialls
 /homeassistant/components/system_bridge/ @timmo001
 /tests/components/system_bridge/ @timmo001
 /homeassistant/components/systemmonitor/ @gjohansson-ST
 /tests/components/systemmonitor/ @gjohansson-ST
-/homeassistant/components/systemnexa2/ @konsulten
-/tests/components/systemnexa2/ @konsulten
 /homeassistant/components/tado/ @erwindouna
 /tests/components/tado/ @erwindouna
 /homeassistant/components/tag/ @home-assistant/core
@@ -1734,14 +1638,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/tedee/ @patrickhilker @zweckj
 /homeassistant/components/telegram_bot/ @hanwg
 /tests/components/telegram_bot/ @hanwg
-/homeassistant/components/teleinfo/ @esciara
-/tests/components/teleinfo/ @esciara
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
-/homeassistant/components/teltonika/ @karlbeecken
-/tests/components/teltonika/ @karlbeecken
-/homeassistant/components/temperature/ @home-assistant/core
-/tests/components/temperature/ @home-assistant/core
 /homeassistant/components/template/ @Petro31 @home-assistant/core
 /tests/components/template/ @Petro31 @home-assistant/core
 /homeassistant/components/tesla_fleet/ @Bre77
@@ -1754,6 +1652,7 @@ CLAUDE.md @home-assistant/core
 /tests/components/tessie/ @Bre77
 /homeassistant/components/text/ @home-assistant/core
 /tests/components/text/ @home-assistant/core
+/homeassistant/components/tfiac/ @fredrike @mellado
 /homeassistant/components/thermobeacon/ @bdraco
 /tests/components/thermobeacon/ @bdraco
 /homeassistant/components/thermopro/ @bdraco @h3ss
@@ -1787,8 +1686,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/tomorrowio/ @raman325 @lymanepp
 /homeassistant/components/totalconnect/ @austinmroczek
 /tests/components/totalconnect/ @austinmroczek
-/homeassistant/components/touchline/ @mnordseth
-/tests/components/touchline/ @mnordseth
 /homeassistant/components/touchline_sl/ @jnsgruk
 /tests/components/touchline_sl/ @jnsgruk
 /homeassistant/components/tplink/ @rytilahti @bdraco @sdb9696
@@ -1809,16 +1706,12 @@ CLAUDE.md @home-assistant/core
 /tests/components/trafikverket_train/ @gjohansson-ST
 /homeassistant/components/trafikverket_weatherstation/ @gjohansson-ST
 /tests/components/trafikverket_weatherstation/ @gjohansson-ST
-/homeassistant/components/trane/ @bdraco
-/tests/components/trane/ @bdraco
 /homeassistant/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
 /tests/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
 /homeassistant/components/trend/ @jpbede
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey
 /tests/components/triggercmd/ @rvmey
-/homeassistant/components/trmnl/ @joostlek
-/tests/components/trmnl/ @joostlek
 /homeassistant/components/tts/ @home-assistant/core
 /tests/components/tts/ @home-assistant/core
 /homeassistant/components/tuya/ @Tuya @zlinoliver
@@ -1829,17 +1722,11 @@ CLAUDE.md @home-assistant/core
 /tests/components/twinkly/ @dr1rrb @Robbie1221 @Olen
 /homeassistant/components/twitch/ @joostlek
 /tests/components/twitch/ @joostlek
-/homeassistant/components/uhoo/ @getuhoo @joshsmonta
-/tests/components/uhoo/ @getuhoo @joshsmonta
 /homeassistant/components/ukraine_alarm/ @PaulAnnekov
 /tests/components/ukraine_alarm/ @PaulAnnekov
 /homeassistant/components/unifi/ @Kane610
 /tests/components/unifi/ @Kane610
-/homeassistant/components/unifi_access/ @imhotep @RaHehl
-/tests/components/unifi_access/ @imhotep @RaHehl
 /homeassistant/components/unifi_direct/ @tofuSCHNITZEL
-/homeassistant/components/unifi_discovery/ @RaHehl
-/tests/components/unifi_discovery/ @RaHehl
 /homeassistant/components/unifiled/ @florisvdk
 /homeassistant/components/unifiprotect/ @RaHehl
 /tests/components/unifiprotect/ @RaHehl
@@ -1878,8 +1765,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/vegehub/ @thulrus
 /homeassistant/components/velbus/ @Cereal2nd @brefra
 /tests/components/velbus/ @Cereal2nd @brefra
-/homeassistant/components/velux/ @Julius2342 @pawlizio @wollew
-/tests/components/velux/ @Julius2342 @pawlizio @wollew
+/homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
+/tests/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
 /homeassistant/components/venstar/ @garbled1 @jhollowe
 /tests/components/venstar/ @garbled1 @jhollowe
 /homeassistant/components/versasense/ @imstevenxyz
@@ -1887,12 +1774,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/version/ @ludeeus
 /homeassistant/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
-/homeassistant/components/vicare/ @CFenner @lackas
-/tests/components/vicare/ @CFenner @lackas
+/homeassistant/components/vicare/ @CFenner
+/tests/components/vicare/ @CFenner
 /homeassistant/components/victron_ble/ @rajlaud
 /tests/components/victron_ble/ @rajlaud
-/homeassistant/components/victron_gx/ @tomer-w
-/tests/components/victron_gx/ @tomer-w
 /homeassistant/components/victron_remote_monitoring/ @AndyTempel
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
@@ -1924,7 +1809,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
 /homeassistant/components/waterfurnace/ @sdague @masterkoppa
-/tests/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai
@@ -1954,8 +1838,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/webostv/ @thecode
 /homeassistant/components/websocket_api/ @home-assistant/core
 /tests/components/websocket_api/ @home-assistant/core
-/homeassistant/components/weheat/ @barryvdh
-/tests/components/weheat/ @barryvdh
+/homeassistant/components/weheat/ @jesperraemaekers
+/tests/components/weheat/ @jesperraemaekers
 /homeassistant/components/wemo/ @esev
 /tests/components/wemo/ @esev
 /homeassistant/components/whirlpool/ @abmantis @mkmer
@@ -1964,19 +1848,15 @@ CLAUDE.md @home-assistant/core
 /tests/components/whois/ @frenck
 /homeassistant/components/wiffi/ @mampfes
 /tests/components/wiffi/ @mampfes
-/homeassistant/components/wiim/ @Linkplay2020
-/tests/components/wiim/ @Linkplay2020
 /homeassistant/components/wilight/ @leofig-rj
 /tests/components/wilight/ @leofig-rj
-/homeassistant/components/window/ @home-assistant/core
-/tests/components/window/ @home-assistant/core
 /homeassistant/components/wirelesstag/ @sergeymaysak
 /homeassistant/components/withings/ @joostlek
 /tests/components/withings/ @joostlek
 /homeassistant/components/wiz/ @sbidy @arturpragacz
 /tests/components/wiz/ @sbidy @arturpragacz
-/homeassistant/components/wled/ @frenck @mik-laj
-/tests/components/wled/ @frenck @mik-laj
+/homeassistant/components/wled/ @frenck
+/tests/components/wled/ @frenck
 /homeassistant/components/wmspro/ @mback2k
 /tests/components/wmspro/ @mback2k
 /homeassistant/components/wolflink/ @adamkrol93 @mtielen
@@ -1987,12 +1867,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/worldclock/ @fabaff
 /homeassistant/components/ws66i/ @ssaenger
 /tests/components/ws66i/ @ssaenger
-/homeassistant/components/wsdot/ @ucodery
-/tests/components/wsdot/ @ucodery
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
-/homeassistant/components/xbox/ @tr4nt0r
-/tests/components/xbox/ @tr4nt0r
+/homeassistant/components/xbox/ @hunterjm @tr4nt0r
+/tests/components/xbox/ @hunterjm @tr4nt0r
 /homeassistant/components/xiaomi_aqara/ @danielhiversen @syssi
 /tests/components/xiaomi_aqara/ @danielhiversen @syssi
 /homeassistant/components/xiaomi_ble/ @Jc2k @Ernst79
@@ -2037,14 +1915,11 @@ CLAUDE.md @home-assistant/core
 /tests/components/zha/ @dmulcahey @adminiuga @puddly @TheJulianJES
 /homeassistant/components/zimi/ @markhannon
 /tests/components/zimi/ @markhannon
-/homeassistant/components/zinvolt/ @joostlek
-/tests/components/zinvolt/ @joostlek
 /homeassistant/components/zodiac/ @JulienTant
 /tests/components/zodiac/ @JulienTant
 /homeassistant/components/zone/ @home-assistant/core
 /tests/components/zone/ @home-assistant/core
 /homeassistant/components/zoneminder/ @rohankapoorcom @nabbi
-/tests/components/zoneminder/ @rohankapoorcom @nabbi
 /homeassistant/components/zwave_js/ @home-assistant/z-wave
 /tests/components/zwave_js/ @home-assistant/z-wave
 /homeassistant/components/zwave_me/ @lawfulchaos @Z-Wave-Me @PoltoS

Dockerfile

@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile@sha256:2780b5c3bab67f1f76c781860de469442999ed1a0d7992a5efdf2cffc0e3d769
 # Automatically generated by hassfest.
 #
 # To update, run python3 -m script.hassfest -p docker
@@ -11,6 +10,7 @@ LABEL \
     org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
     org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
     org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.source="https://github.com/home-assistant/core" \
     org.opencontainers.image.title="Home Assistant" \
     org.opencontainers.image.url="https://www.home-assistant.io/"
 
@@ -20,22 +20,25 @@ ENV \
     UV_SYSTEM_PYTHON=true \
     UV_NO_CACHE=true
 
-WORKDIR /usr/src
-
 # Home Assistant S6-Overlay
 COPY rootfs /
 
 # Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc
+COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
 
-## Setup Home Assistant Core dependencies
-COPY --parents requirements.txt homeassistant/package_constraints.txt homeassistant/
 RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
-    # Install uv at the version pinned in the requirements file
-    && pip3 install --no-cache-dir "uv==$(awk -F'==' '/^uv==/{print $2}' homeassistant/requirements.txt)" \
-    && uv pip install \
+    # Install uv
+    && pip3 install uv==0.9.17
+
+WORKDIR /usr/src
+
+## Setup Home Assistant Core dependencies
+COPY requirements.txt homeassistant/
+COPY homeassistant/package_constraints.txt homeassistant/homeassistant/
+RUN \
+    uv pip install \
         --no-build \
         -r homeassistant/requirements.txt
 
@@ -49,7 +52,7 @@ RUN \
         -r homeassistant/requirements_all.txt
 
 ## Setup Home Assistant Core
-COPY --parents LICENSE* README* homeassistant/ pyproject.toml homeassistant/
+COPY . homeassistant/
 RUN \
     uv pip install \
         -e ./homeassistant \

Dockerfile.dev

@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile@sha256:2780b5c3bab67f1f76c781860de469442999ed1a0d7992a5efdf2cffc0e3d769
 FROM mcr.microsoft.com/vscode/devcontainers/base:debian
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
@@ -53,9 +52,6 @@ RUN --mount=type=bind,source=requirements.txt,target=requirements.txt \
     --mount=type=bind,source=requirements_test_pre_commit.txt,target=requirements_test_pre_commit.txt \
     uv pip install -r requirements.txt -r requirements_test.txt
 
-# Claude Code native install
-RUN curl -fsSL https://claude.ai/install.sh | bash
-
 WORKDIR /workspaces
 
 # Set the default shell to bash instead of sh

codecov.yml

@@ -10,7 +10,6 @@ coverage:
         target: auto
         threshold: 1
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py
@@ -29,7 +28,6 @@ coverage:
         target: 100
         threshold: 0
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py

homeassistant/auth/jwt_wrapper.py

@@ -7,31 +7,23 @@ to speed up the process.
 
 from __future__ import annotations
 
-from collections.abc import Container, Iterable, Sequence
 from datetime import timedelta
-from functools import lru_cache
-from typing import Any, override
+from functools import lru_cache, partial
+from typing import Any
 
-from jwt import DecodeError, PyJWK, PyJWS, PyJWT
-from jwt.algorithms import AllowedPublicKeys
-from jwt.types import Options
+from jwt import DecodeError, PyJWS, PyJWT
 
 from homeassistant.util.json import json_loads
 
 JWT_TOKEN_CACHE_SIZE = 16
 MAX_TOKEN_SIZE = 8192
 
-_NO_VERIFY_OPTIONS = Options(
-    verify_signature=False,
-    verify_exp=False,
-    verify_nbf=False,
-    verify_iat=False,
-    verify_aud=False,
-    verify_iss=False,
-    verify_sub=False,
-    verify_jti=False,
-    require=[],
-)
+_VERIFY_KEYS = ("signature", "exp", "nbf", "iat", "aud", "iss", "sub", "jti")
+
+_VERIFY_OPTIONS: dict[str, Any] = {f"verify_{key}": True for key in _VERIFY_KEYS} | {
+    "require": []
+}
+_NO_VERIFY_OPTIONS = {f"verify_{key}": False for key in _VERIFY_KEYS}
 
 
 class _PyJWSWithLoadCache(PyJWS):
@@ -46,6 +38,9 @@ class _PyJWSWithLoadCache(PyJWS):
         return super()._load(jwt)
 
 
+_jws = _PyJWSWithLoadCache()
+
+
 @lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
 def _decode_payload(json_payload: str) -> dict[str, Any]:
     """Decode the payload from a JWS dictionary."""
@@ -61,12 +56,21 @@ def _decode_payload(json_payload: str) -> dict[str, Any]:
 class _PyJWTWithVerify(PyJWT):
     """PyJWT with a fast decode implementation."""
 
-    def __init__(self) -> None:
-        """Initialize the PyJWT instance."""
-        # We require exp and iat claims to be present
-        super().__init__(Options(require=["exp", "iat"]))
-        # Override the _jws instance with our cached version
-        self._jws = _PyJWSWithLoadCache()
+    def decode_payload(
+        self, jwt: str, key: str, options: dict[str, Any], algorithms: list[str]
+    ) -> dict[str, Any]:
+        """Decode a JWT's payload."""
+        if len(jwt) > MAX_TOKEN_SIZE:
+            # Avoid caching impossible tokens
+            raise DecodeError("Token too large")
+        return _decode_payload(
+            _jws.decode_complete(
+                jwt=jwt,
+                key=key,
+                algorithms=algorithms,
+                options=options,
+            )["payload"]
+        )
 
     def verify_and_decode(
         self,
@@ -75,70 +79,37 @@ class _PyJWTWithVerify(PyJWT):
         algorithms: list[str],
         issuer: str | None = None,
         leeway: float | timedelta = 0,
-        options: Options | None = None,
+        options: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Verify a JWT's signature and claims."""
-        return self.decode(
+        merged_options = {**_VERIFY_OPTIONS, **(options or {})}
+        payload = self.decode_payload(
             jwt=jwt,
             key=key,
+            options=merged_options,
             algorithms=algorithms,
+        )
+        # These should never be missing since we verify them
+        # but this is an additional safeguard to make sure
+        # nothing slips through.
+        assert "exp" in payload, "exp claim is required"
+        assert "iat" in payload, "iat claim is required"
+        self._validate_claims(
+            payload=payload,
+            options=merged_options,
             issuer=issuer,
             leeway=leeway,
-            options=options,
         )
-
-    @override
-    def decode(
-        self,
-        jwt: str | bytes,
-        key: AllowedPublicKeys | PyJWK | str | bytes = "",
-        algorithms: Sequence[str] | None = None,
-        options: Options | None = None,
-        verify: bool | None = None,
-        detached_payload: bytes | None = None,
-        audience: str | Iterable[str] | None = None,
-        subject: str | None = None,
-        issuer: str | Container[str] | None = None,
-        leeway: float | timedelta = 0,
-        **kwargs: Any,
-    ) -> dict[str, Any]:
-        """Decode a JWT, verifying the signature and claims."""
-        if len(jwt) > MAX_TOKEN_SIZE:
-            # Avoid caching impossible tokens
-            raise DecodeError("Token too large")
-        return super().decode(
-            jwt=jwt,
-            key=key,
-            algorithms=algorithms,
-            options=options,
-            verify=verify,
-            detached_payload=detached_payload,
-            audience=audience,
-            subject=subject,
-            issuer=issuer,
-            leeway=leeway,
-            **kwargs,
-        )
-
-    @override
-    def _decode_payload(self, decoded: dict[str, Any]) -> dict[str, Any]:
-        return _decode_payload(decoded["payload"])
+        return payload
 
 
 _jwt = _PyJWTWithVerify()
 verify_and_decode = _jwt.verify_and_decode
-
-
-@lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
-def unverified_hs256_token_decode(jwt: str) -> dict[str, Any]:
-    """Decode a JWT without verifying the signature."""
-    return _jwt.decode(
-        jwt=jwt,
-        key="",
-        algorithms=["HS256"],
-        options=_NO_VERIFY_OPTIONS,
+unverified_hs256_token_decode = lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)(
+    partial(
+        _jwt.decode_payload, key="", algorithms=["HS256"], options=_NO_VERIFY_OPTIONS
     )
-
+)
 
 __all__ = [
     "unverified_hs256_token_decode",

homeassistant/backup_restore.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 from dataclasses import dataclass
+import hashlib
 import json
 import logging
 from pathlib import Path
@@ -39,6 +40,17 @@ class RestoreBackupFileContent:
     restore_homeassistant: bool
 
 
+def password_to_key(password: str) -> bytes:
+    """Generate a AES Key from password.
+
+    Matches the implementation in supervisor.backups.utils.password_to_key.
+    """
+    key: bytes = password.encode()
+    for _ in range(100):
+        key = hashlib.sha256(key).digest()
+    return key[:16]
+
+
 def restore_backup_file_content(config_dir: Path) -> RestoreBackupFileContent | None:
     """Return the contents of the restore backup file."""
     instruction_path = config_dir.joinpath(RESTORE_BACKUP_FILE)
@@ -84,14 +96,15 @@ def _extract_backup(
     """Extract the backup file to the config directory."""
     with (
         TemporaryDirectory() as tempdir,
-        securetar.SecureTarArchive(
+        securetar.SecureTarFile(
             restore_content.backup_file_path,
+            gzip=False,
             mode="r",
         ) as ostf,
     ):
-        ostf.tar.extractall(
+        ostf.extractall(
             path=Path(tempdir, "extracted"),
-            members=securetar.secure_path(ostf.tar),
+            members=securetar.secure_path(ostf),
             filter="fully_trusted",
         )
         backup_meta_file = Path(tempdir, "extracted", "backup.json")
@@ -113,7 +126,10 @@ def _extract_backup(
                 f"homeassistant.tar{'.gz' if backup_meta['compressed'] else ''}",
             ),
             gzip=backup_meta["compressed"],
-            password=restore_content.password,
+            key=password_to_key(restore_content.password)
+            if restore_content.password is not None
+            else None,
+            mode="r",
         ) as istf:
             istf.extractall(
                 path=Path(tempdir, "homeassistant"),

homeassistant/bootstrap.py

@@ -67,10 +67,12 @@ 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
-from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
+from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
     category_registry,
@@ -210,7 +212,6 @@ DEFAULT_INTEGRATIONS = {
     "analytics",  # Needed for onboarding
     "application_credentials",
     "backup",
-    "brands",
     "frontend",
     "hardware",
     "labs",
@@ -236,31 +237,9 @@ DEFAULT_INTEGRATIONS = {
     "input_text",
     "schedule",
     "timer",
-    #
-    # Base platforms:
-    # Note: Calendar and todo are not included to prevent them from registering
-    # their frontend panels when there are no calendar or todo integrations.
-    *(BASE_PLATFORMS - {"calendar", "todo"}),
-    #
-    # Integrations providing triggers and conditions for base platforms:
-    "air_quality",
-    "battery",
-    "door",
-    "garage_door",
-    "gate",
-    "humidity",
-    "illuminance",
-    "moisture",
-    "motion",
-    "occupancy",
-    "power",
-    "temperature",
-    "window",
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.
-    "backup",
-    "cloud",
     "frontend",
 }
 DEFAULT_INTEGRATIONS_SUPERVISOR = {
@@ -455,57 +434,32 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
-    """Load the registries and modules that will do blocking I/O.
-
-    Return whether loading succeeded.
-    """
+async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
+    """Load the registries and modules that will do blocking I/O."""
     if DATA_REGISTRIES_LOADED in hass.data:
-        return True
-
+        return
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-
-    recovery = hass.config.recovery_mode
-    device_registry.async_setup(hass)
-    try:
-        await asyncio.gather(
-            create_eager_task(get_internal_store_manager(hass).async_initialize()),
-            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
-            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-            create_eager_task(template.async_load_custom_templates(hass)),
-            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
-            create_eager_task(hass.config_entries.async_initialize()),
-            create_eager_task(async_get_system_info(hass)),
-            create_eager_task(condition.async_setup(hass)),
-            create_eager_task(trigger.async_setup(hass)),
-        )
-    except UnsupportedStorageVersionError as err:
-        # If we're already in recovery mode, we don't want to handle the exception
-        # and activate recovery mode again, as that would lead to an infinite loop.
-        if recovery:
-            raise
-
-        _LOGGER.error(
-            "Storage file %s was created by a newer version of Home Assistant"
-            " (storage version %s > %s); activating recovery mode; on-disk data"
-            " is preserved; upgrade Home Assistant or restore from a backup",
-            err.storage_key,
-            err.found_version,
-            err.max_supported_version,
-        )
-        return False
-
-    return True
+    await asyncio.gather(
+        create_eager_task(get_internal_store_manager(hass).async_initialize()),
+        create_eager_task(area_registry.async_load(hass)),
+        create_eager_task(category_registry.async_load(hass)),
+        create_eager_task(device_registry.async_load(hass)),
+        create_eager_task(entity_registry.async_load(hass)),
+        create_eager_task(floor_registry.async_load(hass)),
+        create_eager_task(issue_registry.async_load(hass)),
+        create_eager_task(label_registry.async_load(hass)),
+        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+        create_eager_task(template.async_load_custom_templates(hass)),
+        create_eager_task(restore_state.async_load(hass)),
+        create_eager_task(hass.config_entries.async_initialize()),
+        create_eager_task(async_get_system_info(hass)),
+        create_eager_task(condition.async_setup(hass)),
+        create_eager_task(trigger.async_setup(hass)),
+    )
 
 
 async def async_from_config_dict(
@@ -522,9 +476,7 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-
-    if not await async_load_base_functionality(hass):
-        return None
+    await async_load_base_functionality(hass)
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)
@@ -564,6 +516,38 @@ 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/brands/american_standard.json

@@ -1,5 +0,0 @@
-{
-  "domain": "american_standard",
-  "name": "American Standard",
-  "integrations": ["nexia", "trane"]
-}

homeassistant/brands/bega.json

@@ -1,5 +0,0 @@
-{
-  "domain": "bega",
-  "name": "BEGA",
-  "iot_standards": ["zigbee"]
-}

homeassistant/brands/cloudflare.json

@@ -1,5 +0,0 @@
-{
-  "domain": "cloudflare",
-  "name": "Cloudflare",
-  "integrations": ["cloudflare", "cloudflare_r2"]
-}

homeassistant/brands/denon.json

@@ -1,5 +1,5 @@
 {
   "domain": "denon",
   "name": "Denon",
-  "integrations": ["denon", "denonavr", "denon_rs232", "heos"]
+  "integrations": ["denon", "denonavr", "heos"]
 }

homeassistant/brands/heatit.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heatit",
-  "name": "Heatit",
-  "iot_standards": ["zwave"]
-}

homeassistant/brands/heiman.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heiman",
-  "name": "Heiman",
-  "iot_standards": ["matter", "zigbee"]
-}

homeassistant/brands/leviton.json

@@ -1,6 +1,5 @@
 {
   "domain": "leviton",
   "name": "Leviton",
-  "integrations": ["decora_wifi"],
   "iot_standards": ["zwave"]
 }

homeassistant/brands/lg.json

@@ -1,11 +1,5 @@
 {
   "domain": "lg",
   "name": "LG",
-  "integrations": [
-    "lg_infrared",
-    "lg_netcast",
-    "lg_soundbar",
-    "lg_thinq",
-    "webostv"
-  ]
+  "integrations": ["lg_netcast", "lg_soundbar", "lg_thinq", "webostv"]
 }

homeassistant/brands/microsoft.json

@@ -13,7 +13,6 @@
     "microsoft",
     "msteams",
     "onedrive",
-    "onedrive_for_business",
     "xbox"
   ]
 }

homeassistant/brands/powerfox.json

@@ -1,5 +0,0 @@
-{
-  "domain": "powerfox",
-  "name": "Powerfox",
-  "integrations": ["powerfox", "powerfox_local"]
-}

homeassistant/brands/trane.json

@@ -1,5 +0,0 @@
-{
-  "domain": "trane",
-  "name": "Trane",
-  "integrations": ["nexia", "trane"]
-}

homeassistant/brands/ubiquiti.json

@@ -1,13 +1,5 @@
 {
   "domain": "ubiquiti",
   "name": "Ubiquiti",
-  "integrations": [
-    "airos",
-    "unifi",
-    "unifi_access",
-    "unifi_direct",
-    "unifi_discovery",
-    "unifiled",
-    "unifiprotect"
-  ]
+  "integrations": ["airos", "unifi", "unifi_direct", "unifiled", "unifiprotect"]
 }

homeassistant/brands/ubisys.json

@@ -1,5 +0,0 @@
-{
-  "domain": "ubisys",
-  "name": "Ubisys",
-  "iot_standards": ["zigbee"]
-}

homeassistant/brands/victron.json

@@ -1,5 +1,5 @@
 {
   "domain": "victron",
   "name": "Victron",
-  "integrations": ["victron_gx", "victron_ble", "victron_remote_monitoring"]
+  "integrations": ["victron_ble", "victron_remote_monitoring"]
 }

homeassistant/components/abode/__init__.py

@@ -30,7 +30,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_POLLING, DOMAIN, DOMAIN_DATA, LOGGER
+from .const import CONF_POLLING, DOMAIN, LOGGER
 from .services import async_setup_services
 
 ATTR_DEVICE_NAME = "device_name"
@@ -99,7 +99,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     except (AbodeException, ConnectTimeout, HTTPError) as ex:
         raise ConfigEntryNotReady(f"Unable to connect to Abode: {ex}") from ex
 
-    hass.data[DOMAIN_DATA] = AbodeSystem(abode, polling)
+    hass.data[DOMAIN] = AbodeSystem(abode, polling)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -113,12 +113,11 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
-    await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.events.stop)
-    await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.logout)
+    await hass.async_add_executor_job(hass.data[DOMAIN].abode.events.stop)
+    await hass.async_add_executor_job(hass.data[DOMAIN].abode.logout)
 
-    if logout_listener := hass.data[DOMAIN_DATA].logout_listener:
-        logout_listener()
-    hass.data.pop(DOMAIN_DATA)
+    hass.data[DOMAIN].logout_listener()
+    hass.data.pop(DOMAIN)
 
     return unload_ok
 
@@ -128,16 +127,16 @@ async def setup_hass_events(hass: HomeAssistant) -> None:
 
     def logout(event: Event) -> None:
         """Logout of Abode."""
-        if not hass.data[DOMAIN_DATA].polling:
-            hass.data[DOMAIN_DATA].abode.events.stop()
+        if not hass.data[DOMAIN].polling:
+            hass.data[DOMAIN].abode.events.stop()
 
-        hass.data[DOMAIN_DATA].abode.logout()
+        hass.data[DOMAIN].abode.logout()
         LOGGER.info("Logged out of Abode")
 
-    if not hass.data[DOMAIN_DATA].polling:
-        await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.events.start)
+    if not hass.data[DOMAIN].polling:
+        await hass.async_add_executor_job(hass.data[DOMAIN].abode.events.start)
 
-    hass.data[DOMAIN_DATA].logout_listener = hass.bus.async_listen_once(
+    hass.data[DOMAIN].logout_listener = hass.bus.async_listen_once(
         EVENT_HOMEASSISTANT_STOP, logout
     )
 
@@ -179,6 +178,6 @@ def setup_abode_events(hass: HomeAssistant) -> None:
     ]
 
     for event in events:
-        hass.data[DOMAIN_DATA].abode.events.add_event_callback(
+        hass.data[DOMAIN].abode.events.add_event_callback(
             event, partial(event_callback, event)
         )

homeassistant/components/abode/alarm_control_panel.py

@@ -13,7 +13,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 
@@ -23,7 +24,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode alarm control panel device."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
     async_add_entities(
         [AbodeAlarm(data, await hass.async_add_executor_job(data.abode.get_alarm))]
     )

homeassistant/components/abode/binary_sensor.py

@@ -15,7 +15,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.enum import try_parse_enum
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 
@@ -25,7 +26,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode binary sensor devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     device_types = [
         "connectivity",

homeassistant/components/abode/camera.py

@@ -19,7 +19,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import Throttle
 
 from . import AbodeSystem
-from .const import DOMAIN_DATA, LOGGER
+from .const import DOMAIN, LOGGER
 from .entity import AbodeDevice
 
 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
@@ -31,7 +31,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode camera devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     async_add_entities(
         AbodeCamera(data, device, timeline.CAPTURE_IMAGE)

homeassistant/components/abode/config_flow.py

@@ -64,7 +64,7 @@ class AbodeFlowHandler(ConfigFlow, domain=DOMAIN):
             else:
                 errors = {"base": "cannot_connect"}
 
-        except ConnectTimeout, HTTPError:
+        except (ConnectTimeout, HTTPError):
             errors = {"base": "cannot_connect"}
 
         if errors:

homeassistant/components/abode/const.py

@@ -1,19 +1,10 @@
 """Constants for the Abode Security System component."""
 
-from __future__ import annotations
-
 import logging
-from typing import TYPE_CHECKING
-
-from homeassistant.util.hass_dict import HassKey
-
-if TYPE_CHECKING:
-    from . import AbodeSystem
 
 LOGGER = logging.getLogger(__package__)
 
 DOMAIN = "abode"
-DOMAIN_DATA: HassKey[AbodeSystem] = HassKey(DOMAIN)
 ATTRIBUTION = "Data provided by goabode.com"
 
 CONF_POLLING = "polling"

homeassistant/components/abode/cover.py

@@ -9,7 +9,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 
@@ -19,7 +20,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode cover devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     async_add_entities(
         AbodeCover(data, device)

homeassistant/components/abode/entity.py

@@ -7,7 +7,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
 from . import AbodeSystem
-from .const import ATTRIBUTION, DOMAIN, DOMAIN_DATA
+from .const import ATTRIBUTION, DOMAIN
 
 
 class AbodeEntity(Entity):
@@ -29,7 +29,7 @@ class AbodeEntity(Entity):
             self._update_connection_status,
         )
 
-        self.hass.data[DOMAIN_DATA].entity_ids.add(self.entity_id)
+        self.hass.data[DOMAIN].entity_ids.add(self.entity_id)
 
     async def async_will_remove_from_hass(self) -> None:
         """Unsubscribe from Abode connection status updates."""

homeassistant/components/abode/light.py

@@ -20,7 +20,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 
@@ -30,7 +31,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode light devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     async_add_entities(
         AbodeLight(data, device)
@@ -99,7 +100,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return _hs
 
     @property
-    def color_mode(self) -> ColorMode:
+    def color_mode(self) -> str | None:
         """Return the color mode of the light."""
         if self._device.is_dimmable and self._device.is_color_capable:
             if self.hs_color is not None:
@@ -110,7 +111,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return ColorMode.ONOFF
 
     @property
-    def supported_color_modes(self) -> set[ColorMode]:
+    def supported_color_modes(self) -> set[str] | None:
         """Flag supported color modes."""
         if self._device.is_dimmable and self._device.is_color_capable:
             return {ColorMode.COLOR_TEMP, ColorMode.HS}

homeassistant/components/abode/lock.py

@@ -9,7 +9,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 
@@ -19,7 +20,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode lock devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     async_add_entities(
         AbodeLock(data, device)

homeassistant/components/abode/manifest.json

@@ -9,6 +9,6 @@
   },
   "iot_class": "cloud_push",
   "loggers": ["jaraco.abode", "lomond"],
-  "requirements": ["jaraco.abode==6.4.0"],
+  "requirements": ["jaraco.abode==6.2.1"],
   "single_config_entry": true
 }

homeassistant/components/abode/sensor.py

@@ -12,7 +12,6 @@ from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
-    SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import LIGHT_LUX, PERCENTAGE, UnitOfTemperature
@@ -20,7 +19,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AbodeSystem
-from .const import DOMAIN_DATA
+from .const import DOMAIN
 from .entity import AbodeDevice
 
 ABODE_TEMPERATURE_UNIT_HA_UNIT = {
@@ -41,7 +40,6 @@ SENSOR_TYPES: tuple[AbodeSensorDescription, ...] = (
     AbodeSensorDescription(
         key="temperature",
         device_class=SensorDeviceClass.TEMPERATURE,
-        state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement_fn=lambda device: ABODE_TEMPERATURE_UNIT_HA_UNIT[
             device.temp_unit
         ],
@@ -50,14 +48,12 @@ SENSOR_TYPES: tuple[AbodeSensorDescription, ...] = (
     AbodeSensorDescription(
         key="humidity",
         device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement_fn=lambda _: PERCENTAGE,
         value_fn=lambda device: cast(float, device.humidity),
     ),
     AbodeSensorDescription(
         key="lux",
         device_class=SensorDeviceClass.ILLUMINANCE,
-        state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement_fn=lambda _: LIGHT_LUX,
         value_fn=lambda device: cast(float, device.lux),
     ),
@@ -70,7 +66,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode sensor devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     async_add_entities(
         AbodeSensor(data, device, description)

homeassistant/components/abode/services.py

@@ -10,7 +10,11 @@ from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import dispatcher_send
 
-from .const import DOMAIN, DOMAIN_DATA, LOGGER
+from .const import DOMAIN, LOGGER
+
+SERVICE_SETTINGS = "change_setting"
+SERVICE_CAPTURE_IMAGE = "capture_image"
+SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
 
 ATTR_SETTING = "setting"
 ATTR_VALUE = "value"
@@ -31,7 +35,7 @@ def _change_setting(call: ServiceCall) -> None:
     value = call.data[ATTR_VALUE]
 
     try:
-        call.hass.data[DOMAIN_DATA].abode.set_setting(setting, value)
+        call.hass.data[DOMAIN].abode.set_setting(setting, value)
     except AbodeException as ex:
         LOGGER.warning(ex)
 
@@ -42,7 +46,7 @@ def _capture_image(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
+        for entity_id in call.hass.data[DOMAIN].entity_ids
         if entity_id in entity_ids
     ]
 
@@ -57,7 +61,7 @@ def _trigger_automation(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
+        for entity_id in call.hass.data[DOMAIN].entity_ids
         if entity_id in entity_ids
     ]
 
@@ -71,13 +75,16 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Home Assistant services."""
 
     hass.services.async_register(
-        DOMAIN, "change_setting", _change_setting, schema=CHANGE_SETTING_SCHEMA
+        DOMAIN, SERVICE_SETTINGS, _change_setting, schema=CHANGE_SETTING_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "capture_image", _capture_image, schema=CAPTURE_IMAGE_SCHEMA
+        DOMAIN, SERVICE_CAPTURE_IMAGE, _capture_image, schema=CAPTURE_IMAGE_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "trigger_automation", _trigger_automation, schema=AUTOMATION_SCHEMA
+        DOMAIN,
+        SERVICE_TRIGGER_AUTOMATION,
+        _trigger_automation,
+        schema=AUTOMATION_SCHEMA,
     )

homeassistant/components/abode/switch.py

@@ -12,7 +12,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN_DATA
+from . import AbodeSystem
+from .const import DOMAIN
 from .entity import AbodeAutomation, AbodeDevice
 
 DEVICE_TYPES = ["switch", "valve"]
@@ -24,7 +25,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode switch devices."""
-    data = hass.data[DOMAIN_DATA]
+    data: AbodeSystem = hass.data[DOMAIN]
 
     entities: list[SwitchEntity] = [
         AbodeSwitch(data, device)

homeassistant/components/accuweather/__init__.py

@@ -7,7 +7,7 @@ import logging
 
 from accuweather import AccuWeather
 
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.components.sensor import DOMAIN as SENSOR_PLATFORM
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -72,7 +72,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: AccuWeatherConfigEntry)
     ent_reg = er.async_get(hass)
     for day in range(5):
         unique_id = f"{location_key}-ozone-{day}"
-        if entity_id := ent_reg.async_get_entity_id(SENSOR_DOMAIN, DOMAIN, unique_id):
+        if entity_id := ent_reg.async_get_entity_id(SENSOR_PLATFORM, DOMAIN, unique_id):
             _LOGGER.debug("Removing ozone sensor entity %s", entity_id)
             ent_reg.async_remove(entity_id)
 

homeassistant/components/accuweather/config_flow.py

@@ -43,7 +43,7 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                         longitude=user_input[CONF_LONGITUDE],
                     )
                     await accuweather.async_get_location()
-            except ApiError, ClientConnectorError, TimeoutError, ClientError:
+            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
                 errors["base"] = "cannot_connect"
             except InvalidApiKeyError:
                 errors[CONF_API_KEY] = "invalid_api_key"
@@ -104,7 +104,7 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                         longitude=self._longitude,
                     )
                     await accuweather.async_get_location()
-            except ApiError, ClientConnectorError, TimeoutError, ClientError:
+            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
                 errors["base"] = "cannot_connect"
             except InvalidApiKeyError:
                 errors["base"] = "invalid_api_key"

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.1.0"]
+  "requirements": ["accuweather==5.0.0"]
 }

homeassistant/components/accuweather/system_health.py

@@ -30,8 +30,6 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     return {
-        "can_reach_server": system_health.async_check_can_reach_url(
-            hass, str(ENDPOINT)
-        ),
+        "can_reach_server": system_health.async_check_can_reach_url(hass, ENDPOINT),
         "remaining_requests": remaining_requests,
     }

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/acer_projector/const.py

@@ -6,11 +6,10 @@ from typing import Final
 
 from homeassistant.const import STATE_OFF, STATE_ON
 
-CONF_READ_TIMEOUT: Final = "timeout"
 CONF_WRITE_TIMEOUT: Final = "write_timeout"
 
 DEFAULT_NAME: Final = "Acer Projector"
-DEFAULT_READ_TIMEOUT: Final = 1
+DEFAULT_TIMEOUT: Final = 1
 DEFAULT_WRITE_TIMEOUT: Final = 1
 
 ECO_MODE: Final = "ECO Mode"

homeassistant/components/acer_projector/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/acer_projector",
   "iot_class": "local_polling",
   "quality_scale": "legacy",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["pyserial==3.5"]
 }

homeassistant/components/acer_projector/switch.py

@@ -6,7 +6,7 @@ import logging
 import re
 from typing import Any
 
-from serialx import Serial, SerialException
+import serial
 import voluptuous as vol
 
 from homeassistant.components.switch import (
@@ -16,22 +16,21 @@ from homeassistant.components.switch import (
 from homeassistant.const import (
     CONF_FILENAME,
     CONF_NAME,
+    CONF_TIMEOUT,
     STATE_OFF,
     STATE_ON,
     STATE_UNKNOWN,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
     CMD_DICT,
-    CONF_READ_TIMEOUT,
     CONF_WRITE_TIMEOUT,
     DEFAULT_NAME,
-    DEFAULT_READ_TIMEOUT,
+    DEFAULT_TIMEOUT,
     DEFAULT_WRITE_TIMEOUT,
     ECO_MODE,
     ICON,
@@ -46,7 +45,7 @@ PLATFORM_SCHEMA = SWITCH_PLATFORM_SCHEMA.extend(
     {
         vol.Required(CONF_FILENAME): cv.isdevice,
         vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-        vol.Optional(CONF_READ_TIMEOUT, default=DEFAULT_READ_TIMEOUT): cv.positive_int,
+        vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
         vol.Optional(
             CONF_WRITE_TIMEOUT, default=DEFAULT_WRITE_TIMEOUT
         ): cv.positive_int,
@@ -63,10 +62,10 @@ def setup_platform(
     """Connect with serial port and return Acer Projector."""
     serial_port = config[CONF_FILENAME]
     name = config[CONF_NAME]
-    read_timeout = config[CONF_READ_TIMEOUT]
+    timeout = config[CONF_TIMEOUT]
     write_timeout = config[CONF_WRITE_TIMEOUT]
 
-    add_entities([AcerSwitch(serial_port, name, read_timeout, write_timeout)], True)
+    add_entities([AcerSwitch(serial_port, name, timeout, write_timeout)], True)
 
 
 class AcerSwitch(SwitchEntity):
@@ -78,14 +77,14 @@ class AcerSwitch(SwitchEntity):
         self,
         serial_port: str,
         name: str,
-        read_timeout: int,
+        timeout: int,
         write_timeout: int,
     ) -> None:
         """Init of the Acer projector."""
+        self.serial = serial.Serial(
+            port=serial_port, timeout=timeout, write_timeout=write_timeout
+        )
         self._serial_port = serial_port
-        self._read_timeout = read_timeout
-        self._write_timeout = write_timeout
-
         self._attr_name = name
         self._attributes = {
             LAMP_HOURS: STATE_UNKNOWN,
@@ -95,26 +94,22 @@ class AcerSwitch(SwitchEntity):
 
     def _write_read(self, msg: str) -> str:
         """Write to the projector and read the return."""
-
+        ret = ""
         # Sometimes the projector won't answer for no reason or the projector
         # was disconnected during runtime.
         # This way the projector can be reconnected and will still work
         try:
-            with Serial.from_url(
-                self._serial_port,
-                read_timeout=self._read_timeout,
-                write_timeout=self._write_timeout,
-            ) as serial:
-                serial.write(msg.encode("utf-8"))
-
-                # Size is an experience value there is no real limit.
-                # AFAIK there is no limit and no end character so we will usually
-                # need to wait for timeout
-                return serial.read_until(size=20).decode("utf-8")
-        except (OSError, SerialException, TimeoutError) as exc:
-            raise HomeAssistantError(
-                f"Problem communicating with {self._serial_port}"
-            ) from exc
+            if not self.serial.is_open:
+                self.serial.open()
+            self.serial.write(msg.encode("utf-8"))
+            # Size is an experience value there is no real limit.
+            # AFAIK there is no limit and no end character so we will usually
+            # need to wait for timeout
+            ret = self.serial.read_until(size=20).decode("utf-8")
+        except serial.SerialException:
+            _LOGGER.error("Problem communicating with %s", self._serial_port)
+        self.serial.close()
+        return ret
 
     def _write_read_format(self, msg: str) -> str:
         """Write msg, obtain answer and format output."""

homeassistant/components/actiontec/__init__.py

@@ -1 +1 @@
-"""The Actiontec integration."""
+"""The actiontec component."""

homeassistant/components/actron_air/__init__.py

@@ -1,7 +1,11 @@
 """The Actron Air integration."""
 
-from actron_neo_api import ActronAirAPI, ActronAirAPIError, ActronAirAuthError
-from actron_neo_api.models.system import ActronAirSystemInfo
+from actron_neo_api import (
+    ActronAirACSystem,
+    ActronAirAPI,
+    ActronAirAPIError,
+    ActronAirAuthError,
+)
 
 from homeassistant.const import CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
@@ -21,7 +25,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
     """Set up Actron Air integration from a config entry."""
 
     api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirSystemInfo] = []
+    systems: list[ActronAirACSystem] = []
 
     try:
         systems = await api.get_ac_systems()
@@ -32,17 +36,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
             translation_key="auth_error",
         ) from err
     except ActronAirAPIError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="setup_connection_error",
-        ) from err
+        raise ConfigEntryNotReady from err
 
     system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
     for system in systems:
         coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
-        _LOGGER.debug("Setting up coordinator for system: %s", system.serial)
+        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
         await coordinator.async_config_entry_first_refresh()
-        system_coordinators[system.serial] = coordinator
+        system_coordinators[system["serial"]] = coordinator
 
     entry.runtime_data = ActronAirRuntimeData(
         api=api,

homeassistant/components/actron_air/climate.py

@@ -15,12 +15,10 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, ActronAirZoneEntity, actron_air_command
+from .entity import ActronAirAcEntity, ActronAirZoneEntity
 
 PARALLEL_UPDATES = 0
 
@@ -138,27 +136,20 @@ class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
         """Return the target temperature."""
         return self._status.user_aircon_settings.temperature_setpoint_cool_c
 
-    @actron_air_command
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR[fan_mode]
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode)
         await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
 
-    @actron_air_command
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set the HVAC mode."""
-        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR[hvac_mode]
+        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
         await self._status.ac_system.set_system_mode(ac_mode)
 
-    @actron_air_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="temperature_missing",
-            )
-        await self._status.user_aircon_settings.set_temperature(temperature=temperature)
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        await self._status.user_aircon_settings.set_temperature(temperature=temp)
 
 
 class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
@@ -218,18 +209,11 @@ class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
         """Return the target temperature."""
         return self._zone.temperature_setpoint_cool_c
 
-    @actron_air_command
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set the HVAC mode."""
         is_enabled = hvac_mode != HVACMode.OFF
         await self._zone.enable(is_enabled)
 
-    @actron_air_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="temperature_missing",
-            )
-        await self._zone.set_temperature(temperature=temperature)
+        await self._zone.set_temperature(temperature=kwargs.get(ATTR_TEMPERATURE))

homeassistant/components/actron_air/config_flow.py

@@ -23,7 +23,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
         self._user_code: str = ""
         self._verification_uri: str = ""
         self._expires_minutes: str = "30"
-        self.login_task: asyncio.Task[None] | None = None
+        self.login_task: asyncio.Task | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -38,10 +38,10 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
                 _LOGGER.error("OAuth2 flow failed: %s", err)
                 return self.async_abort(reason="oauth2_error")
 
-            self._device_code = device_code_response.device_code
-            self._user_code = device_code_response.user_code
-            self._verification_uri = device_code_response.verification_uri_complete
-            self._expires_minutes = str(device_code_response.expires_in // 60)
+            self._device_code = device_code_response["device_code"]
+            self._user_code = device_code_response["user_code"]
+            self._verification_uri = device_code_response["verification_uri_complete"]
+            self._expires_minutes = str(device_code_response["expires_in"] // 60)
 
         async def _wait_for_authorization() -> None:
             """Wait for the user to authorize the device."""
@@ -94,7 +94,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.error("Error getting user info: %s", err)
             return self.async_abort(reason="oauth2_error")
 
-        unique_id = user_data.sub
+        unique_id = str(user_data["id"])
         await self.async_set_unique_id(unique_id)
 
         # Check if this is a reauth flow
@@ -107,7 +107,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
 
         self._abort_if_unique_id_configured()
         return self.async_create_entry(
-            title=user_data.email,
+            title=user_data["email"],
             data={CONF_API_TOKEN: self._api.refresh_token_value},
         )
 
@@ -120,7 +120,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="timeout",
             )
-        self.login_task = None
+        del self.login_task
         return await self.async_step_user()
 
     async def async_step_reauth(

homeassistant/components/actron_air/coordinator.py

@@ -6,12 +6,12 @@ from dataclasses import dataclass
 from datetime import timedelta
 
 from actron_neo_api import (
+    ActronAirACSystem,
     ActronAirAPI,
     ActronAirAPIError,
     ActronAirAuthError,
     ActronAirStatus,
 )
-from actron_neo_api.models.system import ActronAirSystemInfo
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -38,7 +38,7 @@ class ActronAirRuntimeData:
 type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
 
 
-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
     """System coordinator for Actron Air integration."""
 
     def __init__(
@@ -46,7 +46,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
         hass: HomeAssistant,
         entry: ActronAirConfigEntry,
         api: ActronAirAPI,
-        system: ActronAirSystemInfo,
+        system: ActronAirACSystem,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(
@@ -57,7 +57,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
             config_entry=entry,
         )
         self.system = system
-        self.serial_number = system.serial
+        self.serial_number = system["serial"]
         self.api = api
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
@@ -78,14 +78,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
                 translation_placeholders={"error": repr(err)},
             ) from err
 
-        status = self.api.state_manager.get_status(self.serial_number)
-        if status is None:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_error",
-                translation_placeholders={"error": "Status not available"},
-            )
-        self.status = status
+        self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
         return self.status
 

homeassistant/components/actron_air/diagnostics.py

@@ -1,35 +0,0 @@
-"""Diagnostics support for Actron Air."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_API_TOKEN
-from homeassistant.core import HomeAssistant
-
-from .coordinator import ActronAirConfigEntry
-
-TO_REDACT = {CONF_API_TOKEN, "master_serial", "serial_number", "serial"}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant,
-    entry: ActronAirConfigEntry,
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinators: dict[int, Any] = {}
-    for idx, coordinator in enumerate(entry.runtime_data.system_coordinators.values()):
-        coordinators[idx] = {
-            "system": async_redact_data(
-                coordinator.system.model_dump(mode="json"), TO_REDACT
-            ),
-            "status": async_redact_data(
-                coordinator.data.model_dump(mode="json", exclude={"last_known_state"}),
-                TO_REDACT,
-            ),
-        }
-    return {
-        "entry_data": async_redact_data(entry.data, TO_REDACT),
-        "coordinators": coordinators,
-    }

homeassistant/components/actron_air/entity.py

@@ -1,12 +1,7 @@
 """Base entity classes for Actron Air integration."""
 
-from collections.abc import Callable, Coroutine
-from functools import wraps
-from typing import Any, Concatenate
+from actron_neo_api import ActronAirZone
 
-from actron_neo_api import ActronAirAPIError, ActronAirZone
-
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -14,31 +9,6 @@ from .const import DOMAIN
 from .coordinator import ActronAirSystemCoordinator
 
 
-def actron_air_command[_EntityT: ActronAirEntity, **_P](
-    func: Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, Any]],
-) -> Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, None]]:
-    """Decorator for Actron Air API calls.
-
-    Handles ActronAirAPIError exceptions, and requests a coordinator update
-    to update the status of the devices as soon as possible.
-    """
-
-    @wraps(func)
-    async def wrapper(self: _EntityT, /, *args: _P.args, **kwargs: _P.kwargs) -> None:
-        """Wrap API calls with exception handling."""
-        try:
-            await func(self, *args, **kwargs)
-        except ActronAirAPIError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="api_error",
-                translation_placeholders={"error": str(err)},
-            ) from err
-        self.coordinator.async_set_updated_data(self.coordinator.data)
-
-    return wrapper
-
-
 class ActronAirEntity(CoordinatorEntity[ActronAirSystemCoordinator]):
     """Base class for Actron Air entities."""
 

homeassistant/components/actron_air/manifest.json

@@ -12,6 +12,6 @@
   "documentation": "https://www.home-assistant.io/integrations/actron_air",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "quality_scale": "silver",
-  "requirements": ["actron-neo-api==0.5.3"]
+  "quality_scale": "bronze",
+  "requirements": ["actron-neo-api==0.4.1"]
 }

homeassistant/components/actron_air/quality_scale.yaml

@@ -26,7 +26,7 @@ rules:
   unique-config-entry: done
 
   # Silver
-  action-exceptions: done
+  action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
     status: exempt
@@ -37,11 +37,11 @@ rules:
   log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: done
-  test-coverage: done
+  test-coverage: todo
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: exempt
     comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
@@ -54,12 +54,18 @@ rules:
   docs-troubleshooting: done
   docs-use-cases: done
   dynamic-devices: todo
-  entity-category: done
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
+  entity-category:
+    status: exempt
+    comment: This integration does not use entity categories.
+  entity-device-class:
+    status: exempt
+    comment: This integration does not use entity device classes.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Not required for this integration at this stage.
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
   reconfiguration-flow: todo
   repair-issues:
     status: exempt
@@ -69,4 +75,4 @@ rules:
   # Platinum
   async-dependency: done
   inject-websession: todo
-  strict-typing: done
+  strict-typing: todo

homeassistant/components/actron_air/strings.json

@@ -49,18 +49,9 @@
     }
   },
   "exceptions": {
-    "api_error": {
-      "message": "Failed to communicate with Actron Air device: {error}"
-    },
     "auth_error": {
       "message": "Authentication failed, please reauthenticate"
     },
-    "setup_connection_error": {
-      "message": "Failed to connect to the Actron Air API"
-    },
-    "temperature_missing": {
-      "message": "Provide a temperature value when adjusting the climate entity."
-    },
     "update_error": {
       "message": "An error occurred while retrieving data from the Actron Air API: {error}"
     }

homeassistant/components/actron_air/switch.py

@@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, actron_air_command
+from .entity import ActronAirAcEntity
 
 PARALLEL_UPDATES = 0
 
@@ -29,42 +29,30 @@ SWITCHES: tuple[ActronAirSwitchEntityDescription, ...] = (
         key="away_mode",
         translation_key="away_mode",
         is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.away_mode,
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_away_mode(enabled)
-        ),
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_away_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="continuous_fan",
         translation_key="continuous_fan",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.continuous_fan_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_continuous_mode(enabled)
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.continuous_fan_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_continuous_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="quiet_mode",
         translation_key="quiet_mode",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.quiet_mode_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_quiet_mode(enabled)
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.quiet_mode_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_quiet_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="turbo_mode",
         translation_key="turbo_mode",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.turbo_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_turbo_mode(enabled)
-        ),
-        is_supported_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.turbo_supported
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_turbo_mode(enabled),
+        is_supported_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_supported,
     ),
 )
 
@@ -105,12 +93,10 @@ class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
         """Return true if the switch is on."""
         return self.entity_description.is_on_fn(self.coordinator)
 
-    @actron_air_command
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""
         await self.entity_description.set_fn(self.coordinator, True)
 
-    @actron_air_command
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the switch off."""
         await self.entity_description.set_fn(self.coordinator, False)

homeassistant/components/adax/climate.py

@@ -168,57 +168,29 @@ class LocalAdaxDevice(CoordinatorEntity[AdaxLocalCoordinator], ClimateEntity):
         if hvac_mode == HVACMode.HEAT:
             temperature = self._attr_target_temperature or self._attr_min_temp
             await self._adax_data_handler.set_target_temperature(temperature)
-            self._attr_target_temperature = temperature
-            self._attr_icon = "mdi:radiator"
         elif hvac_mode == HVACMode.OFF:
             await self._adax_data_handler.set_target_temperature(0)
-            self._attr_icon = "mdi:radiator-off"
-        else:
-            # Ignore unsupported HVAC modes to avoid desynchronizing entity state
-            # from the physical device.
-            return
-
-        self._attr_hvac_mode = hvac_mode
-        self.async_write_ha_state()
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
             return
-        if self._attr_hvac_mode == HVACMode.HEAT:
-            await self._adax_data_handler.set_target_temperature(temperature)
+        await self._adax_data_handler.set_target_temperature(temperature)
 
-        self._attr_target_temperature = temperature
-        self.async_write_ha_state()
-
-    def _update_hvac_attributes(self) -> None:
-        """Update hvac mode and temperatures from coordinator data.
-
-        The coordinator reports a target temperature of 0 when the heater is
-        turned off. In that case, only the hvac mode and icon are updated and
-        the previous non-zero target temperature is preserved. When the
-        reported target temperature is non-zero, the stored target temperature
-        is updated to match the coordinator value.
-        """
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
         if data := self.coordinator.data:
             self._attr_current_temperature = data["current_temperature"]
+            self._attr_available = self._attr_current_temperature is not None
             if (target_temp := data["target_temperature"]) == 0:
                 self._attr_hvac_mode = HVACMode.OFF
                 self._attr_icon = "mdi:radiator-off"
-                if self._attr_target_temperature is None:
+                if target_temp == 0:
                     self._attr_target_temperature = self._attr_min_temp
             else:
                 self._attr_hvac_mode = HVACMode.HEAT
                 self._attr_icon = "mdi:radiator"
                 self._attr_target_temperature = target_temp
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        self._update_hvac_attributes()
         super()._handle_coordinator_update()
-
-    async def async_added_to_hass(self) -> None:
-        """When entity is added to hass."""
-        await super().async_added_to_hass()
-        self._update_hvac_attributes()