ha-mcp-dev 9.1.0.dev3285__tar.gz → 9.1.0.dev3289__tar.gz

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.1.0.dev3285
+Version: 9.1.0.dev3289
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.0.dev3285"
+version = "9.1.0.dev3289"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.0.dev3285"
+version = "9.1.0.dev3289"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/src/ha_mcp/backup_manager.py

@@ -2070,25 +2070,13 @@ async def _ws_send(client: Any, message: dict[str, Any]) -> Any:
 
 
 async def _fetch_automation(client: Any, entity_id: str) -> Any:
-    """Fetch an automation through the same path the get tool uses.
-
-    Applies ``_normalize_config_for_roundtrip`` so the snapshot matches
-    what ``ha_config_get_automation`` returns and round-trips cleanly
-    back through ``ha_config_set_automation`` on restore. Imported lazily
-    to keep the manager import-cycle-free.
-    """
-    # Lazy import to avoid backup_manager → tools → backup_manager cycle.
-    from .tools.tools_config_automations import _normalize_config_for_roundtrip
-
+    """Fetch the stored body verbatim."""
     try:
-        raw = await client.get_automation_config(entity_id)
+        return await client.get_automation_config(entity_id)
     except HomeAssistantError as err:
         if getattr(err, "status_code", None) == 404:
             return None
         raise
-    if not isinstance(raw, dict):
-        return raw
-    return _normalize_config_for_roundtrip(raw)
 
 
 async def _restore_automation(client: Any, entity_id: str, config: Any) -> Any:

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/src/ha_mcp/client/rest_client.py

@@ -1377,40 +1377,44 @@ class HomeAssistantClient:
     # Automation Configuration Management
 
     async def _resolve_automation_id(self, identifier: str) -> str:
-        """Convert entity_id to unique_id if needed, or return unique_id as-is.
+        """Return the config id of ``identifier`` (an entity_id or a config id).
 
-        Args:
-            identifier: Either entity_id (automation.xxx) or unique_id
-
-        Returns:
-            The unique_id for configuration API
+        An entity_id resolves through the entity registry first, so a disabled
+        automation (no state) resolves too; the state's ``id`` attribute is the
+        fallback when the registry does not answer with a ``unique_id``.
 
         Raises:
             HomeAssistantAPIError: 404 if not found; other read failures propagate
         """
-        if identifier.startswith("automation."):
-            try:
-                state = await self.get_entity_state(identifier)
-                unique_id = state.get("attributes", {}).get("id")
-                if not unique_id:
-                    raise HomeAssistantAPIError(
-                        f"Automation {identifier} has no unique_id attribute",
-                        status_code=404,
-                    )
-                logger.debug(
-                    f"Converted entity_id {identifier} to unique_id {unique_id}"
-                )
-                return str(unique_id)
-            except HomeAssistantAPIError as e:
-                if e.status_code != 404:  # a failed read is not a missing one
-                    raise
-                raise HomeAssistantAPIError(
-                    f"Failed to resolve automation {identifier}: {str(e)}",
-                    status_code=404,
-                ) from e
-        else:
-            # Assume it's already a unique_id
+        if not identifier.startswith("automation."):
             return identifier
+        try:
+            entry = await self.send_websocket_message(
+                {"type": "config/entity_registry/get", "entity_id": identifier}
+            )
+        except HomeAssistantConnectionError as e:
+            logger.debug(f"Registry lookup for {identifier} failed: {e}")
+            entry = {}
+        if entry.get("success"):
+            unique_id = (entry.get("result") or {}).get("unique_id")
+            if unique_id:
+                return str(unique_id)
+        try:
+            state = await self.get_entity_state(identifier)
+        except HomeAssistantAPIError as e:
+            if e.status_code != 404:  # a failed read is not a missing one
+                raise
+            raise HomeAssistantAPIError(
+                f"Failed to resolve automation {identifier}: {str(e)}",
+                status_code=404,
+            ) from e
+        unique_id = state.get("attributes", {}).get("id")
+        if not unique_id:
+            raise HomeAssistantAPIError(
+                f"Automation {identifier} has no unique_id attribute",
+                status_code=404,
+            )
+        return str(unique_id)
 
     async def get_automation_config(self, identifier: str) -> dict[str, Any]:
         """Get automation configuration by unique_id or entity_id.
@@ -1446,19 +1450,19 @@ class HomeAssistantClient:
         identifier: str | None = None,
         *,
         _resolved: bool = False,
+        wait_for_entity: bool = False,
     ) -> dict[str, Any]:
         """
         Create new automation or update existing one.
 
         Args:
-            config: Automation configuration dictionary
-            identifier: Optional automation entity_id or unique_id (None = create new)
-            _resolved: When True, ``identifier`` is already the resolved unique_id
-                (the caller ran ``_resolve_automation_id``), so the redundant
-                entity_id→unique_id lookup is skipped. Ignored on the create path
-                (``identifier is None``). The #1404 config-id mismatch guard below
-                is unaffected — it still compares ``config['id']`` to the resolved
-                unique_id.
+            config: Automation configuration dictionary, sent as given
+            identifier: Optional automation entity_id or config id (None = create new)
+            _resolved: When True, ``identifier`` is already the config id (the
+                caller resolved it), so the entity_id lookup is skipped. The
+                #1404 config-id mismatch guard below still applies.
+            wait_for_entity: Poll for the entity the write registers, as a
+                creation does, and report it as ``entity_id``.
 
         Returns:
             Result with automation unique_id and status
@@ -1466,19 +1470,14 @@ class HomeAssistantClient:
         Raises:
             HomeAssistantAPIError: If configuration invalid or API error
         """
-        # Generate unique_id for new automation if not provided
         if identifier is None:
             unique_id = str(int(time.time() * 1000))
-            operation = "created"
-            logger.debug(f"Creating new automation with unique_id: {unique_id}")
         else:
             unique_id = (
                 identifier
                 if _resolved
                 else await self._resolve_automation_id(identifier)
             )
-            operation = "updated"
-            logger.debug(f"Updating automation with unique_id: {unique_id}")
 
         # Reject mismatch between resolved storage key and inner ``config["id"]``.
         # HA stores by the inner id field even though the URL carries one too —
@@ -1491,20 +1490,20 @@ class HomeAssistantClient:
                     "Cannot create automation with explicit config['id']="
                     f"{config_id!r}: Home Assistant stores by the inner id, "
                     "which would silently overwrite an existing automation. "
-                    "Omit 'id' from config to auto-generate, or pass identifier "
+                    "Omit 'id' from config to auto-generate, or pass entity_id "
                     "to update an existing automation.",
                     status_code=400,
                 )
             raise HomeAssistantAPIError(
-                f"Mismatched automation id: identifier={identifier!r} resolves "
-                f"to unique_id={unique_id!r}, but config['id']={config_id!r}. "
+                f"Mismatched automation id: the target's config id is "
+                f"{unique_id!r}, but config['id']={config_id!r}. "
                 "Refusing to write to prevent overwriting the wrong automation. "
-                f"Remove 'id' from config or set it to the resolved unique_id "
+                f"Remove 'id' from config or set it to the target's config id "
                 f"({unique_id!r}).",
                 status_code=400,
             )
 
-        # Add unique_id to config for updates
+        # Core stores by the body's id, so it carries the target's.
         if unique_id and "id" not in config:
             config = {**config, "id": unique_id}
 
@@ -1513,10 +1512,9 @@ class HomeAssistantClient:
                 "POST", f"/config/automation/config/{unique_id}", json=config
             )
 
-            # For new automations, query Home Assistant to get the actual entity_id that was assigned
             actual_entity_id = None
             entity_not_verified = False
-            if operation == "created":
+            if wait_for_entity:
                 actual_entity_id = await self._poll_for_automation_entity(unique_id)
                 if not actual_entity_id:
                     entity_not_verified = True
@@ -1525,7 +1523,6 @@ class HomeAssistantClient:
                 "unique_id": unique_id,
                 "entity_id": actual_entity_id,
                 "result": response.get("result", "ok"),
-                "operation": operation,
             }
             if entity_not_verified:
                 result["entity_not_verified"] = True
@@ -1533,7 +1530,9 @@ class HomeAssistantClient:
         except HomeAssistantAPIError as e:
             if e.status_code == 400:
                 raise HomeAssistantAPIError(
-                    f"Invalid automation configuration: {str(e)}", status_code=400
+                    f"Invalid automation configuration: {str(e)}",
+                    status_code=400,
+                    response_data=e.response_data,
                 ) from e
             raise
 
@@ -1610,27 +1609,11 @@ class HomeAssistantClient:
                 "operation": "deleted",
             }
         except HomeAssistantAPIError as e:
-            if e.status_code == 404:
-                raise HomeAssistantAPIError(
-                    f"Automation not found: {identifier} (unique_id: {unique_id})",
-                    status_code=404,
-                ) from e
-            elif e.status_code == 405:
-                raise HomeAssistantAPIError(
-                    f"Cannot delete automation '{identifier}': The HTTP DELETE method is blocked. "
-                    f"This typically occurs when running ha-mcp as a Home Assistant add-on, because "
-                    f"the Supervisor ingress proxy only allows GET and POST requests. "
-                    f"WORKAROUNDS: "
-                    f"(1) Use ha-mcp via pip, Docker, or as an external MCP server instead of the add-on. "
-                    f"(2) Use a long-lived access token to connect directly to Home Assistant's API. "
-                    f"(3) As a fallback, disable the automation and rename it with a 'DELETE_' prefix "
-                    f"(e.g., 'DELETE_{identifier}') so you can identify and manually delete it later "
-                    f"via the Home Assistant UI (Settings > Automations & Scenes).",
-                    status_code=405,
-                ) from e
-            raise
-        except Exception as e:
-            if "404" in str(e):
+            # Core's DELETE answers a missing id with 400, not 404.
+            if (
+                e.status_code == 400
+                and (e.response_data or {}).get("message") == "Resource not found"
+            ):
                 raise HomeAssistantAPIError(
                     f"Automation not found: {identifier} (unique_id: {unique_id})",
                     status_code=404,

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/src/ha_mcp/server_tool_text.py

@@ -213,10 +213,10 @@ SEARCH_KEYWORDS: dict[str, str] = {
 LITE_DOCSTRINGS: dict[str, str] = {
     "ha_config_get_automation": (
         "Get a Home Assistant automation configuration by "
-        "entity_id or unique_id. Returns the full config "
-        "(trigger, condition, action, mode) plus a stable "
-        "config_hash for use with python_transform on "
-        "ha_config_set_automation.\n\n"
+        "entity_id or config id. Returns the stored config "
+        "plus a stable config_hash for use with python_transform on "
+        "ha_config_set_automation, the registry entry, and Home "
+        "Assistant's validation status.\n\n"
         "For schema and field-level details, see "
         "ha_get_skill_guide."
     ),
@@ -224,14 +224,14 @@ LITE_DOCSTRINGS: dict[str, str] = {
         "Create or update a Home Assistant automation.\n\n"
         "Supports three modes: full `config` replacement, surgical "
         "`python_transform` on an existing automation (requires "
-        "`identifier` and `config_hash` from "
+        "`entity_id` and `config_hash` from "
         "ha_config_get_automation), or `take_control_of_blueprint` "
         "to convert a blueprint-backed automation into an editable "
         "standalone one (the UI's Take control action). Omit "
-        "`identifier` to create a new automation. Reusing an identifier targets "
+        "`entity_id` to create a new automation. Reusing an entity_id targets "
         "the same automation; changing its alias requires config_hash from a prior read. "
         "`enabled` turns it on or off and `run_actions` runs it now, with a "
-        "write or alone with `identifier`.\n\n"
+        "write or alone with `entity_id`.\n\n"
         "For schema details, examples, and native-vs-template "
         "guidance, see ha_get_skill_guide or your locally "
         "installed skills."

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/src/ha_mcp/tools/auto_backup.py

@@ -108,13 +108,13 @@ def automation_backup_target(kw: dict[str, Any]) -> str:
     """Resolve the actual storage target for an automation write.
 
     HA's automation storage uses the body's ``id`` field as the primary
-    key (#1404). When the caller passes both ``identifier`` and a
+    key (#1404). When the caller passes both ``entity_id`` and a
     ``config.id`` that differ, HA writes to ``config.id`` — the
     snapshot must capture *that* entity, not the user-provided
-    ``identifier`` whose target is left untouched.
+    ``entity_id`` whose target is left untouched.
 
     Returns ``str(config["id"])`` when present, else
-    ``str(identifier or "")``. Empty string skips capture (matches the
+    ``str(entity_id or "")``. Empty string skips capture (matches the
     create path where there's nothing to back up yet).
 
     ``config`` accepts dict or JSON-string per the tool signature; both
@@ -130,7 +130,7 @@ def automation_backup_target(kw: dict[str, Any]) -> str:
         config_id = config.get("id")
         if config_id:
             return str(config_id)
-    # Return the identifier UNCHANGED — do NOT strip the ``automation.``
+    # Return the entity_id UNCHANGED — do NOT strip the ``automation.``
     # prefix. Capture and restore resolve the target through
     # ``client.get_automation_config`` -> ``_resolve_automation_id``, which
     # converts an entity_id ("automation.<slug>") to the real numeric
@@ -142,8 +142,8 @@ def automation_backup_target(kw: dict[str, Any]) -> str:
     # would POST to the wrong key and create a stray automation). The
     # doubled domain segment in the snapshot filename
     # ("automation.automation.<slug>.<ts>.yaml") is purely cosmetic and is
-    # exactly what the remove path (id_param="identifier") already produces.
-    return _resolve_str(kw.get("identifier"))
+    # exactly what the remove path (id_param="entity_id") already produces.
+    return _resolve_str(kw.get("entity_id"))
 
 
 def with_auto_backup(

ha_mcp_dev-9.1.0.dev3289/src/ha_mcp/tools/automation_errors.py

@@ -0,0 +1,206 @@
+"""Errors for an automation Home Assistant rejected.
+
+Core's own text leads every rejection, behind one fixed prefix; this module
+only names the section that failed and adds suggestions. Closest matches for
+an unknown trigger or condition key come from the platforms the running Core
+registered (the component's ``describe``, else the first event of Core's
+``trigger_platforms/subscribe`` / ``condition_platforms/subscribe``), never
+from a list kept here.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import difflib
+import logging
+import re
+from typing import Any, Literal, NoReturn, cast
+
+from ha_mcp._vendor.websockets.exceptions import ConnectionClosed
+
+from ..client.rest_client import HomeAssistantAPIError, HomeAssistantError
+from ..client.websocket_client import get_websocket_client
+from ..errors import ErrorCode, create_error_response
+from .component_automation import automation_describe
+from .helpers import raise_tool_error
+
+logger = logging.getLogger(__name__)
+
+REJECTION_PREFIX = "Home Assistant rejected the automation: "
+
+# Core raises both quote styles (the helpers/condition package uses each once).
+_INVALID_KEY = re.compile(r"Invalid (trigger|condition) ['\"]([^'\"]+)['\"] specified")
+
+# Bounds the wait for a platform subscription's first event, which Core sends
+# right after the subscription result.
+_DESCRIPTIONS_TIMEOUT_S = 5.0
+
+
+def section_from_status(status: str | None) -> str | None:
+    """The config section a component ``validate`` status names."""
+    return (
+        status.removeprefix("failed_")
+        if status and status.startswith("failed_")
+        else None
+    )
+
+
+def core_rejection_text(exc: HomeAssistantAPIError) -> str | None:
+    """Core's message for a 400 it answered, None for any other error."""
+    if exc.status_code != 400 or not isinstance(exc.response_data, dict):
+        return None
+    message = exc.response_data.get("message")
+    return message if isinstance(message, str) and message else None
+
+
+async def failed_section_from_core(client: Any, config: dict[str, Any]) -> str | None:
+    """Name the failed section with Core's ``validate_config``; best effort.
+
+    When every section Core checks is valid, the root schema (or the
+    blueprint) is what failed.
+    """
+    sections = {}
+    for plural, singular in (
+        ("triggers", "trigger"),
+        ("conditions", "condition"),
+        ("actions", "action"),
+    ):
+        value = config.get(plural, config.get(singular))
+        if value is not None:
+            sections[plural] = value
+    if sections:
+        try:
+            result = await client.send_websocket_message(
+                {"type": "validate_config", **sections}
+            )
+        except HomeAssistantError as exc:
+            logger.debug("validate_config got no answer: %s", exc)
+            return None
+        verdicts = result.get("result") if result.get("success") else None
+        if not isinstance(verdicts, dict):
+            return None
+        for section in sections:
+            if (verdicts.get(section) or {}).get("valid") is False:
+                return section
+    return "blueprint" if "use_blueprint" in config else "schema"
+
+
+async def _subscription_first_event(client: Any, command: str) -> dict[str, Any] | None:
+    try:
+        ws = await get_websocket_client(
+            url=client.base_url,
+            token=client.token,
+            verify_ssl=getattr(client, "verify_ssl", None),
+        )
+        sub_id, queue = await ws.subscribe_command(command)
+    except (HomeAssistantError, OSError, ConnectionClosed) as exc:
+        logger.debug("%s failed: %s", command, exc)
+        return None
+    try:
+        message = await asyncio.wait_for(queue.get(), timeout=_DESCRIPTIONS_TIMEOUT_S)
+    except TimeoutError:
+        return None
+    finally:
+        await ws.release_subscription(sub_id)
+    event = message.get("event") if isinstance(message, dict) else None
+    return event if isinstance(event, dict) else None
+
+
+async def platform_descriptions(
+    client: Any, kind: Literal["trigger", "condition"]
+) -> dict[str, Any] | None:
+    """Core's description of every registered trigger or condition, by key."""
+    descriptions = await automation_describe(client, kind)
+    if descriptions is not None:
+        return descriptions
+    return await _subscription_first_event(client, f"{kind}_platforms/subscribe")
+
+
+def closest_matches(key: str, candidates: list[str]) -> list[str]:
+    """Registered keys nearest to ``key``.
+
+    Searched within the key's domain when Core registers one: the domain is
+    the part a caller has right, and a renamed key's replacement lives there
+    (``schedule.turned_on`` is now ``schedule.block_started``, which no
+    lookalike from another domain would surface). Across every domain
+    otherwise, which also serves a misspelt domain. A key nothing comes close
+    to gets no hint: the domain's other keys are not corrections.
+    """
+    domain, dot, _ = key.partition(".")
+    if dot and (same := [c for c in candidates if c.startswith(f"{domain}.")]):
+        return difflib.get_close_matches(key, same, n=3, cutoff=0.5)
+    return difflib.get_close_matches(key, candidates, n=3, cutoff=0.5)
+
+
+def _platform_condition(config: dict[str, Any]) -> bool:
+    conditions = config.get("conditions", config.get("condition"))
+    items = conditions if isinstance(conditions, list) else [conditions]
+    return any(
+        isinstance(c, dict) and "platform" in c and "condition" not in c for c in items
+    )
+
+
+def _text_suggestions(core_text: str, config: dict[str, Any]) -> list[str]:
+    """Targeted hints for Core rejections agents commonly cause."""
+    lowered = core_text.lower()
+    suggestions = []
+    if "unexpected keyword argument" in lowered:
+        suggestions.append(
+            "A root-level field such as alias, triggers or conditions is inside "
+            "an action step."
+        )
+    elif "'variables'" in core_text and "dictionary" in core_text:
+        suggestions.append(
+            "variables must be a dict mapping names to values, "
+            'e.g. {"variables": {"my_var": 42}}'
+        )
+    if "unexpected value for condition" in lowered and _platform_condition(config):
+        suggestions.append(
+            "A condition uses 'platform' (trigger syntax); conditions use "
+            "'condition', e.g. {'condition': 'state', ...}."
+        )
+    return suggestions
+
+
+async def raise_core_rejection(
+    client: Any,
+    core_text: str,
+    config: dict[str, Any],
+    *,
+    failed_section: str | None,
+    context: dict[str, Any],
+    bp_warnings: list[str],
+) -> NoReturn:
+    """Raise VALIDATION_FAILED with Core's text and the hints it supports."""
+    error_context: dict[str, Any] = {**context, "failed_section": failed_section}
+    suggestions = _text_suggestions(core_text, config)
+    match = _INVALID_KEY.search(core_text)
+    if match:
+        kind = cast(Literal["trigger", "condition"], match.group(1))
+        key = match.group(2)
+        descriptions = await platform_descriptions(client, kind) or {}
+        matches = closest_matches(key, sorted(descriptions))
+        if matches:
+            error_context["closest_matches"] = matches
+            description = descriptions.get(matches[0])
+            if isinstance(description, dict):
+                error_context["platform_description"] = description
+            suggestions.insert(
+                0,
+                f"Home Assistant has no {kind} '{key}'. Registered {kind}s "
+                f"closest to it: {', '.join(matches)}.",
+            )
+    suggestions.append("Use ha_get_skill_guide for automation examples")
+    if bp_warnings:
+        suggestions.append(
+            "Config had best-practice issues that may be related: "
+            + "; ".join(bp_warnings)
+        )
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.VALIDATION_FAILED,
+            f"{REJECTION_PREFIX}{core_text}",
+            suggestions=suggestions,
+            context=error_context,
+        )
+    )

{ha_mcp_dev-9.1.0.dev3285 → ha_mcp_dev-9.1.0.dev3289}/src/ha_mcp/tools/best_practice_checker.py

@@ -145,22 +145,6 @@ _TARGET_FIELDS = ("entity_id", "device_id", "area_id", "floor_id", "label_id")
 # ``service:`` (legacy) and ``action:`` (modern, 2024+) for the same field.
 _SERVICE_KEYS = ("service", "action")
 
-# Purpose-specific trigger/condition keys renamed in HA 2026.7 — the old keys
-# no longer load (home-assistant/core#174463).
-_RENAMED_TRIGGER_KEYS = {
-    "battery.low": "battery.became_low",
-    "battery.not_low": "battery.no_longer_low",
-    "lawn_mower.docked": "lawn_mower.returned_to_dock",
-    "schedule.turned_on": "schedule.block_started",
-    "schedule.turned_off": "schedule.block_ended",
-    "timer.time_remaining": "timer.remaining_time_reached",
-    "update.update_became_available": "update.became_available",
-    "vacuum.docked": "vacuum.returned_to_dock",
-}
-_RENAMED_CONDITION_KEYS = {
-    "climate.target_temperature": "climate.is_target_temperature",
-    "climate.target_humidity": "climate.is_target_humidity",
-}
 # Trigger ``options.behavior`` values renamed in HA 2026.7: any→each,
 # last→all (home-assistant/core#173259). The old values still load but raise
 # an HA repair issue and face removal. Condition ``options.behavior`` keeps
@@ -202,10 +186,8 @@ def check_automation_config(
 
     warnings = BestPracticeCheckResult()
 
-    # Read the canonical 2024.10+ plural root keys, falling back to the singular
-    # aliases. The internal pipeline always pre-normalizes to plural, so the
-    # fallback is defensive for direct/public callers of check_automation_config
-    # (HA accepts both forms). Mirrors _check_triggers' platform/trigger tolerance.
+    # The config is checked as the caller wrote it, so either root form may
+    # carry the lists.
     # Condition templates
     _check_condition_templates(
         config.get("conditions", config.get("condition", [])), warnings, skill_prefix
@@ -267,23 +249,6 @@ def _check_condition_templates(
             # Shorthand template condition
             _check_template_string(cond, warnings, skill_prefix, "condition")
         elif isinstance(cond, dict):
-            # 2026.7 renamed purpose-specific condition keys — old keys no
-            # longer load.
-            condition_key = cond.get("condition")
-            renamed_condition = (
-                _RENAMED_CONDITION_KEYS.get(condition_key)
-                if isinstance(condition_key, str)
-                else None
-            )
-            if renamed_condition:
-                _emit(
-                    warnings,
-                    f"Condition key `{condition_key}` was renamed to "
-                    f"`{renamed_condition}` in HA 2026.7 and the old key no "
-                    f"longer loads — use `condition: {renamed_condition}`.",
-                    skill_prefix,
-                    "triggers-and-conditions.md#native-conditions",
-                )
             if cond.get("condition") == "template":
                 vt = cond.get("value_template", "")
                 if isinstance(vt, str):
@@ -690,10 +655,9 @@ def _check_triggers(
 ) -> None:
     """Check triggers for device_id and template anti-patterns.
 
-    Per-trigger detection is split into focused helpers (renamed-key check,
-    deprecated-behavior check, template-trigger check, numeric_state-trigger
-    check) purely to keep this function's complexity low. They run in the
-    same order as before.
+    Per-trigger detection is split into focused helpers (deprecated-behavior
+    check, template-trigger check, numeric_state-trigger check) purely to keep
+    this function's complexity low.
     """
     for trigger in _as_list(triggers):
         if not isinstance(trigger, dict):
@@ -701,7 +665,6 @@ def _check_triggers(
 
         platform = trigger.get("platform", trigger.get("trigger", ""))
 
-        _check_renamed_trigger_key(platform, warnings, skill_prefix)
         _check_deprecated_trigger_behavior(trigger, warnings, skill_prefix)
 
         # Device trigger → prefer entity_id-based triggers
@@ -727,24 +690,6 @@ def _check_triggers(
             _check_numeric_state_trigger(trigger, warnings, skill_prefix)
 
 
-def _check_renamed_trigger_key(
-    platform: Any, warnings: BestPracticeCheckResult, skill_prefix: str | None
-) -> None:
-    """Flag HA 2026.7 purpose-specific trigger key renames (old keys no longer load)."""
-    renamed_trigger = (
-        _RENAMED_TRIGGER_KEYS.get(platform) if isinstance(platform, str) else None
-    )
-    if renamed_trigger:
-        _emit(
-            warnings,
-            f"Trigger key `{platform}` was renamed to `{renamed_trigger}` "
-            "in HA 2026.7 and the old key no longer loads — use "
-            f"`trigger: {renamed_trigger}`.",
-            skill_prefix,
-            "triggers-and-conditions.md#trigger-types",
-        )
-
-
 def _check_deprecated_trigger_behavior(
     trigger: dict[str, Any], warnings: BestPracticeCheckResult, skill_prefix: str | None
 ) -> None: