fix(backup): unwrap WS send_command envelope in _ws_send

Root cause of every WS-backed auto-backup capture silently skipping:
``ws_client.send_command(...)`` returns the HA standard envelope
``{"success": True, "result": <inner>}``, not the bare ``<inner>``.
``_ws_send`` was returning that envelope, but every fetch handler
downstream did ``items = await _ws_send(...)`` followed by
``isinstance(items, list)`` — which is always False for the
``{"success": ..., "result": [...]}`` dict, so the handler returned
None, ``maybe_snapshot`` skipped silently, and the e2e log filled with
``Auto-backup: fetch returned None for <domain>:<id>`` lines.

Affected every fetch handler that hits a ``<type>/list`` style WS
endpoint: label, category, group, zone, area_or_floor, integration,
storage-backed helpers (input_boolean / input_text / input_number /
input_select / input_datetime / input_button / counter / timer /
schedule), and dashboard_resource. Automation / script / scene were
unaffected because they go through typed client helpers
(``get_automation_config`` etc.) that already unwrap.

Calendar and todo fetch handlers use ``execute_script`` which returns
a nested dict; they then do ``result.get("response", ...)``. Unwrapping
the envelope here is still correct for them — the inner ``result`` is
the ``execute_script`` response dict that already has the ``response``
key. No call-site behavior change needed.

Restore handlers that use ``_ws_send`` (dashboard, dashboard_resource,
label, category, zone, area_or_floor, integration, helpers) treat
the return as opaque (it's just embedded in ``ha_manage_backup``'s
``data.result``). Unwrapping affects what shows up there but doesn't
break anything — the inner result is more informative than the
envelope anyway.

Also demote the ``fetch returned None`` log from INFO back to DEBUG
now that the root cause is fixed (it was a one-iteration diagnostic).

Author: kingpanther13

src/ha_mcp/backup_manager.py

@@ -278,11 +278,7 @@ async def maybe_snapshot(
             if config is None:
                 # Entity didn't exist at fetch time (create operation, or
                 # already-deleted at remove time before our pre-fetch).
-                # Logged at INFO so e2e diagnostics surface the
-                # "entity-not-yet-indexed" case without polluting prod
-                # WARNING streams; downgrade to DEBUG later once #1288
-                # full-loop e2e coverage is stable.
-                logger.info(
+                logger.debug(
                     "Auto-backup: fetch returned None for %s — skipping snapshot",
                     key,
                 )
@@ -601,7 +597,7 @@ async def _ws_send(client: Any, message: dict[str, Any]) -> Any:
         raise RuntimeError(msg)
     try:
         cmd_type = message.pop("type")
-        result = await ws_client.send_command(cmd_type, **message)
+        envelope = await ws_client.send_command(cmd_type, **message)
     finally:
         # Best-effort close: narrow to transport/network errors; let
         # other exceptions propagate so they show up in logs rather
@@ -614,7 +610,17 @@ async def _ws_send(client: Any, message: dict[str, Any]) -> Any:
                 type(err).__name__,
                 err,
             )
-    return result
+    # ``send_command`` returns ``{"success": True, "result": <inner>}``
+    # — unwrap so every fetch / restore handler downstream sees the
+    # inner ``<inner>`` shape directly (list for ``<type>/list`` calls,
+    # dict for ``execute_script`` calls, etc.). Without this unwrap the
+    # ``isinstance(items, list)`` guards in every fetch handler return
+    # None silently, the snapshot is skipped, and the auto-backup loop
+    # never captures anything for WS-backed domains (#1288 full-loop
+    # e2e regression — only the REST-backed automation lane worked).
+    if isinstance(envelope, dict) and "result" in envelope:
+        return envelope["result"]
+    return envelope
 
 
 # Automation / Script / Scene — reuse the typed client helpers, which