fix: auto-backup silently skipped capture on several write paths

The pre-write auto-backup (#1288) silently skipped a snapshot whenever the
id handed to a domain's fetch handler could not be resolved to the existing
entity: the fetch returns None and maybe_snapshot skips with no error. Each
affected path is fixed so the realistic caller id form resolves.

- automation: automation_backup_target stripped the "automation." prefix,
  yielding a bare slug that _resolve_automation_id mis-treats as a numeric
  unique_id -> GET 404. The recommended python_transform edit path hit this
  on every UI-created automation. Pass the identifier unchanged so the
  resolver maps it to the real unique_id (also fixes a latent wrong-target
  restore the strip would have caused).
- todo_item: _fetch_todo_item matched only on uid, but set/remove pass the
  item summary (the documented form). Match uid OR summary.
- dashboard: _fetch_dashboard did not lazy-resolve HA's internal
  (underscored) dashboard id, so that form 404'd. Pre-resolve to the
  canonical url_path like the set/delete tools already do.
- helper: _fetch_helper missed storage helpers after an entity_id rename
  (object_id != collection id). Fall back to the registry unique_id.

Coverage gaps closed (the feature promises a snapshot before destructive
writes, so the absence was a bug):
- ha_remove_entity had no @with_auto_backup -> snapshot entity state before
  the registry delete.
- ha_set_device / ha_remove_device had no coverage -> add a device
  DomainHandler (capture + restore of name_by_user/area_id/disabled_by/
  labels) and decorate both tools.

Regression tests added for every fetch path (todo summary-match, helper
rename fallback, device fetch/restore, dashboard internal-id resolve,
automation target prefix preservation, device handler registration).

Author: kingpanther13

src/ha_mcp/backup_manager.py

@@ -735,19 +735,46 @@ async def _fetch_dashboard(client: Any, entity_id: str) -> Any:
     """
     from fastmcp.exceptions import ToolError
 
-    from .tools.tools_config_dashboards import _get_dashboard_config_internal
+    from .tools.tools_config_dashboards import (
+        _get_dashboard_config_internal,
+        _resolve_dashboard,
+    )
+
+    # The set/delete tools accept BOTH the canonical hyphenated url_path
+    # AND HA's internal (underscored) dashboard id, eagerly resolving the
+    # latter before writing. ``_get_dashboard_config_internal`` does NOT
+    # lazy-resolve, so an internal-id identifier 404s with "Unknown config
+    # specified" and the pre-write snapshot is silently skipped. Pre-resolve
+    # to the canonical url_path so capture works for whichever form the
+    # caller passed (matching the form the write tool ultimately targets).
+    fetch_path = entity_id
+    try:
+        match, _ = await _resolve_dashboard(client, entity_id)
+        if match and match.get("url_path"):
+            fetch_path = match["url_path"]
+    except (HomeAssistantError, ToolError) as err:
+        # Resolver failure (transport/shape) — fall through with the
+        # original identifier; the canonical form is often already correct.
+        logger.debug(
+            "Auto-backup: dashboard resolve failed for %r: %s — using as-is",
+            entity_id,
+            err,
+        )
 
     try:
-        config, _config_hash = await _get_dashboard_config_internal(client, entity_id)
+        config, _config_hash = await _get_dashboard_config_internal(client, fetch_path)
     except ToolError as err:
-        # ToolError carries the structured failure payload; treat
-        # missing-dashboard responses as "entity doesn't exist yet".
+        # ToolError carries the structured failure payload; treat a
+        # missing/unknown dashboard as "nothing to back up" (also covers a
+        # brand-new dashboard on the create path). "Unknown config
+        # specified" is HA's message for an unresolved url_path.
         msg = str(err).lower()
-        if "not_found" in msg or "config_not_found" in msg:
+        if "not_found" in msg or "config_not_found" in msg or "unknown config" in msg:
             return None
         raise
     except HomeAssistantError as err:
-        if "not_found" in str(err).lower() or "config_not_found" in str(err).lower():
+        msg = str(err).lower()
+        if "not_found" in msg or "config_not_found" in msg or "unknown config" in msg:
             return None
         raise
     return config
@@ -1009,8 +1036,11 @@ async def _restore_area_or_floor(client: Any, entity_id: str, config: Any) -> An
 
 
 async def _fetch_todo_item(client: Any, entity_id: str) -> Any:
-    cal, _, uid = entity_id.partition("::")
-    if not cal or not uid:
+    # The second segment is whatever the tool's ``item`` param carried.
+    # ha_set_todo_item / ha_remove_todo_item accept EITHER the item uid OR
+    # its exact summary/name, so this can be either form.
+    cal, _, item_ref = entity_id.partition("::")
+    if not cal or not item_ref:
         return None
     payload = {
         "type": "execute_script",
@@ -1037,7 +1067,11 @@ async def _fetch_todo_item(client: Any, entity_id: str) -> Any:
         return None
     items = result.get("response", {}).get("items", {}).get(cal, {}).get("items", [])
     for item in items:
-        if item.get("uid") == uid:
+        # Match either form. Matching only on uid silently skipped the
+        # snapshot whenever the caller passed the human-readable summary
+        # (the documented/common case, e.g. ha_remove_todo_item(list, "Buy
+        # milk")) — uid != summary, so the loop found nothing -> None.
+        if item.get("uid") == item_ref or item.get("summary") == item_ref:
             return {"todo_entity_id": cal, **item}
     return None
 
@@ -1071,6 +1105,42 @@ async def _restore_entity_state(client: Any, entity_id: str, config: Any) -> Any
     return await _rest_post(client, f"states/{entity_id}", payload)
 
 
+# Devices — config/device_registry/{list,update}. ``ha_set_device`` mutates
+# the user-editable registry fields (name_by_user / area_id / disabled_by /
+# labels); restore re-applies exactly those. A device deleted by
+# ``ha_remove_device`` cannot be recreated through the registry, so for that
+# path the snapshot is an informational pre-delete record and restore is
+# best-effort.
+
+
+async def _fetch_device(client: Any, entity_id: str) -> Any:
+    items = await _ws_send(client, {"type": "config/device_registry/list"})
+    if not isinstance(items, list):
+        return None
+    for item in items:
+        if item.get("id") == entity_id:
+            return item
+    return None
+
+
+async def _restore_device(client: Any, entity_id: str, config: Any) -> Any:
+    # Re-apply the captured registry state. Uses the same field NAMES as
+    # ``_update_device_internal`` but, unlike that partial-update path, always
+    # sends all four — restore reverts the device to the snapshot, so a
+    # captured ``None`` area/name is intentionally re-applied (cleared).
+    return await _ws_send(
+        client,
+        {
+            "type": "config/device_registry/update",
+            "device_id": entity_id,
+            "name_by_user": config.get("name_by_user"),
+            "area_id": config.get("area_id"),
+            "disabled_by": config.get("disabled_by"),
+            "labels": config.get("labels", []),
+        },
+    )
+
+
 # Integration enable/disable — restore re-applies the disabled flag.
 
 
@@ -1140,6 +1210,34 @@ async def _fetch_helper(client: Any, entity_id: str, helper_type: str) -> Any:
     for item in items:
         if item.get("id") == object_id or item.get("id") == entity_id:
             return item
+    # Fallback for renamed helpers: after an entity_id rename the object_id
+    # no longer equals the storage collection id (which stays the original
+    # create-time id == the registry unique_id), so the direct match above
+    # misses and the snapshot was silently skipped. Resolve the unique_id
+    # via the entity registry and match on that — the same key the helper
+    # update tool itself resolves to.
+    eid = entity_id if "." in entity_id else f"{helper_type}.{entity_id}"
+    try:
+        entry = await _ws_send(
+            client, {"type": "config/entity_registry/get", "entity_id": eid}
+        )
+    except HomeAssistantError as err:
+        # Only a genuine "entity not found" means there's nothing to back up;
+        # transport/auth/5xx errors must propagate so maybe_snapshot logs a
+        # WARNING rather than silently skipping. Same POLICY as _fetch_automation,
+        # but matched on the message substring because config/entity_registry/get
+        # failures arrive as a WS command error with no status_code to switch on.
+        # Best-effort: if HA's not-found wording ever changes, a real miss
+        # degrades to a WARNING + skip (never a swallowed fatal error).
+        msg = str(err).lower()
+        if "not_found" in msg or "not found" in msg:
+            return None
+        raise
+    unique_id = entry.get("unique_id") if isinstance(entry, dict) else None
+    if unique_id:
+        for item in items:
+            if str(item.get("id")) == str(unique_id):
+                return item
     return None
 
 
@@ -1210,6 +1308,7 @@ def register_default_handlers(mgr: BackupManager, _client: Any) -> None:
     )
     mgr.register(DomainHandler("todo_item", _fetch_todo_item, _restore_todo_item))
     mgr.register(DomainHandler("entity", _fetch_entity_state, _restore_entity_state))
+    mgr.register(DomainHandler("device", _fetch_device, _restore_device))
     mgr.register(DomainHandler("integration", _fetch_integration, _restore_integration))
     for helper_type in _KNOWN_HELPER_TYPES:
         mgr.register(_make_helper_handler(helper_type))

src/ha_mcp/tools/auto_backup.py

@@ -75,17 +75,20 @@ def automation_backup_target(kw: dict[str, Any]) -> str:
         config_id = config.get("id")
         if config_id:
             return str(config_id)
-    identifier = _resolve_str(kw.get("identifier"))
-    # Strip the leading ``automation.`` prefix when the caller passed an
-    # entity_id form (typical for ``python_transform`` calls that don't
-    # carry a config body). Without this, snapshot files duplicate the
-    # domain segment as ``automation.automation.<slug>.<ts>.yaml`` — the
-    # body's entity_id keeps the prefix, only the filename / list key
-    # tighten up. HA's automation upsert accepts either form for the
-    # ``identifier`` param, so restore is unaffected.
-    if identifier.startswith("automation."):
-        identifier = identifier[len("automation.") :]
-    return identifier
+    # Return the identifier 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
+    # ``unique_id`` via a state lookup ONLY when the prefix is present;
+    # otherwise it assumes the string already IS a unique_id. Stripping the
+    # prefix produced a bare object_id slug that the resolver mis-treats as
+    # a unique_id -> GET /config/automation/config/<slug> 404s -> the
+    # pre-write snapshot is silently skipped (and, had it resolved, restore
+    # 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"))
 
 
 def with_auto_backup(

src/ha_mcp/tools/tools_entities.py

@@ -1316,6 +1316,7 @@ async def _fetch_entity(eid: str) -> dict[str, Any]:
             "title": "Remove Entity",
         },
     )
+    @with_auto_backup(domain="entity", id_param="entity_id", client=client)
     @log_tool_usage
     async def ha_remove_entity(
         entity_id: Annotated[

src/ha_mcp/tools/tools_registry.py

@@ -14,6 +14,7 @@
 
 from ..client.rest_client import HomeAssistantAPIError, HomeAssistantConnectionError
 from ..errors import ErrorCode, create_error_response
+from .auto_backup import with_auto_backup
 from .helpers import (
     exception_to_structured_error,
     log_tool_usage,
@@ -599,6 +600,7 @@ def get_device_info(device: dict[str, Any]) -> dict[str, Any]:
         tags={"Device Registry"},
         annotations={"destructiveHint": True, "title": "Set Device"},
     )
+    @with_auto_backup(domain="device", id_param="device_id", client=client)
     @log_tool_usage
     async def ha_set_device(
         device_id: Annotated[
@@ -700,6 +702,7 @@ async def ha_set_device(
             "title": "Remove Device",
         },
     )
+    @with_auto_backup(domain="device", id_param="device_id", client=client)
     @log_tool_usage
     async def ha_remove_device(
         device_id: Annotated[