ha-mcp-dev 8.6.0.dev2973__tar.gz → 8.6.0.dev2977__tar.gz

{ha_mcp_dev-8.6.0.dev2973 → ha_mcp_dev-8.6.0.dev2977}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.6.0.dev2973
+Version: 8.6.0.dev2977
 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-8.6.0.dev2973 → ha_mcp_dev-8.6.0.dev2977}/pyproject.toml

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

{ha_mcp_dev-8.6.0.dev2973 → ha_mcp_dev-8.6.0.dev2977}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.6.0.dev2973"
+version = "8.6.0.dev2977"
 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-8.6.0.dev2977/src/ha_mcp/tools/core_contract.py

@@ -0,0 +1,129 @@
+"""Optional access to the running Core's request contracts, never local replicas."""
+
+import logging
+from typing import Any
+
+from ha_mcp._vendor.fastmcp.exceptions import ToolError
+
+from ..client.websocket_client import get_websocket_client
+from ..errors import ErrorCode, create_error_response
+from .component_api import (
+    component_supports,
+    get_component_caps,
+    invalidate_caps,
+    is_unknown_command,
+)
+from .helpers import raise_tool_error
+
+logger = logging.getLogger(__name__)
+
+
+async def include_core_contract(
+    client: Any, result: dict[str, Any], command: str
+) -> None:
+    """Attach optional discovery without discarding an otherwise successful read."""
+    try:
+        contract = dict(await core_contract(client, command))
+    except ToolError:
+        logger.warning("Optional Core schema discovery failed", exc_info=True)
+        contract = {
+            "status": "unavailable",
+            "reason": "Core schema discovery failed; the read result is preserved.",
+        }
+    warnings = contract.pop("warnings", [])
+    if contract.get("status") == "unavailable":
+        warnings.append(contract["reason"])
+    if warnings:
+        result.setdefault("warnings", []).extend(warnings)
+    result["core_contract"] = contract
+
+
+async def core_contract(
+    client: Any, command: str, payload: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Describe or validate without dispatching; absence is explicitly unvalidated."""
+    unavailable = {
+        "status": "unavailable",
+        "reason": "The installed component does not expose Core contract discovery/validation. Core still validates actual requests.",
+    }
+    try:
+        caps = await get_component_caps(client, strict=True)
+        if not component_supports(caps, "core_contract"):
+            return unavailable
+        ws = await get_websocket_client(
+            url=client.base_url,
+            token=client.token,
+            verify_ssl=getattr(client, "verify_ssl", None),
+        )
+        params: dict[str, Any] = {"command": command}
+        if payload is not None:
+            params["payload"] = payload
+        response = await ws.send_command("ha_mcp_tools/core_contract", **params)
+        result = response.get("result")
+        if isinstance(result, dict) and result.get("status") in {
+            "available",
+            "validated",
+            "unavailable",
+        }:
+            return result
+        raise ValueError("Malformed Core contract response")
+    except Exception as exc:
+        if is_unknown_command(exc):
+            invalidate_caps(client)
+            return unavailable
+        logger.warning("Core contract discovery failed", exc_info=True)
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                f"Could not obtain Core contract: {exc}",
+                context={"command": command},
+            )
+        )
+        return {}  # unreachable
+
+
+def command_payload(command: str, payload: dict[str, Any]) -> dict[str, Any]:
+    """Preserve every payload field while preventing command-envelope injection."""
+    if {"id", "type"} & payload.keys():
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_FAILED,
+                "id and type are reserved WebSocket transport fields",
+            )
+        )
+    return {"type": command, **payload}
+
+
+async def validate_energy_proposal(
+    client: Any, config: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate the whole submitted payload with the same schema Core will save."""
+    command_payload("energy/save_prefs", config)
+    result = await core_contract(client, "energy/save_prefs", config)
+    if result.get("status") == "validated" and result.get("valid") is not True:
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_FAILED,
+                "Home Assistant Core rejected the proposed energy preferences",
+                context={"proposal_validation": result},
+            )
+        )
+    return result
+
+
+def merge_core_options(
+    params: dict[str, Any], options: dict[str, Any] | None
+) -> dict[str, Any]:
+    """Pass native options through while retaining the tool's bounded query envelope."""
+    if not options:
+        return params
+    reserved = set(params) | {"id", "type"}
+    if overlap := reserved.intersection(options):
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_INVALID_PARAMETER,
+                "Use the tool parameters for protected query fields",
+                context={"protected_fields": sorted(overlap)},
+            )
+        )
+    return {**params, **options}

ha_mcp_dev-8.6.0.dev2973/src/ha_mcp/tools/energy_statistics.py → ha_mcp_dev-8.6.0.dev2977/src/ha_mcp/tools/energy_preferences.py

@@ -1,14 +1,18 @@
-"""Read the recorder statistics referenced by native Energy Dashboard preferences."""
+"""Read native Energy preferences, hash saved state and enrich statistic references."""
 
-from typing import Any, Literal
+import logging
+from typing import Any
 
 from ha_mcp._vendor.fastmcp.exceptions import ToolError
 
 from ..errors import ErrorCode, create_error_response
 from ..utils.config_hash import compute_config_hash
+from .core_contract import core_contract
 from .helpers import exception_to_structured_error, raise_tool_error
 from .statistics_helpers import fetch_statistics_metadata, statistics_unit
 
+logger = logging.getLogger(__name__)
+
 
 def _statistic_ids(value: Any) -> set[str]:
     """Collect statistic references across Core's source and device structures."""
@@ -52,46 +56,9 @@ async def include_energy_statistics(
     return result
 
 
-_PrefsKey = Literal["energy_sources", "device_consumption", "device_consumption_water"]
-_PREFS_TOP_LEVEL_KEYS: tuple[_PrefsKey, ...] = (
-    "energy_sources",
-    "device_consumption",
-    "device_consumption_water",
-)
-
-
-def _default_prefs() -> dict[str, Any]:
-    """Return the default empty prefs structure used by HA Core.
-
-    Mirrors ``EnergyManager.default_preferences()`` in
-    ``homeassistant/components/energy/data.py``. A Home Assistant instance
-    that has never had the Energy Dashboard configured returns
-    ``ERR_NOT_FOUND "No prefs"`` from ``energy/get_prefs``; this helper
-    provides the canonical empty structure so the tool can transparently
-    treat the two cases (never-configured vs. configured-but-empty) the
-    same way.
-    """
-    return {
-        "energy_sources": [],
-        "device_consumption": [],
-        "device_consumption_water": [],
-    }
-
-
-def _compute_per_key_hashes(prefs: dict[str, Any]) -> dict[_PrefsKey, str]:
-    """Per-top-level-key hashes for partial-update optimistic locking.
-
-    Each top-level key is wrapped in its own single-key dict before hashing,
-    so the per-key hash captures both the key name and its value — an agent
-    cannot accidentally use, say, an ``energy_sources`` hash to authorise a
-    ``device_consumption`` write. ``prefs.get(key, [])`` mirrors the
-    "missing top-level key = empty list" semantics codified by
-    ``_default_prefs``.
-    """
-    return {
-        key: compute_config_hash({key: prefs.get(key, [])})
-        for key in _PREFS_TOP_LEVEL_KEYS
-    }
+def compute_per_key_hashes(prefs: dict[str, Any]) -> dict[str, str]:
+    """Hash every native preference slot without an allowlist or invented defaults."""
+    return {key: compute_config_hash({key: value}) for key, value in prefs.items()}
 
 
 def _is_no_prefs_error(error_msg: str) -> bool:
@@ -119,16 +86,23 @@ async def get_energy_prefs(client: Any) -> dict[str, Any]:
                         context={"mode": "get"},
                     )
                 )
-            prefs = _default_prefs()
-            note = "Energy Dashboard has never been configured on this instance; returning empty default."
+            try:
+                contract = await core_contract(client, "energy/save_prefs")
+            except ToolError:
+                logger.warning("Energy defaults discovery failed", exc_info=True)
+                contract = {}
+            prefs = contract.get("default_preferences", {})
+            note = "Energy Dashboard has never been configured."
+            if "default_preferences" not in contract:
+                note += " Core defaults are unavailable; config is empty. Use the full config_hash for the initial save."
         else:
-            prefs = result.get("result") or _default_prefs()
+            prefs = result.get("result") or {}
         response = {
             "success": True,
             "mode": "get",
             "config": prefs,
             "config_hash": compute_config_hash(prefs),
-            "config_hash_per_key": _compute_per_key_hashes(prefs),
+            "config_hash_per_key": compute_per_key_hashes(prefs),
         }
         if note:
             response["note"] = note

ha_mcp_dev-8.6.0.dev2977/src/ha_mcp/tools/history_response.py

@@ -0,0 +1,70 @@
+"""Present recorder history with readable names and local event times."""
+
+from datetime import UTC, datetime, tzinfo
+from typing import Any
+
+from .response_helpers import resolve_local_timezone
+
+_FIELD_NAMES = {
+    "s": "state",
+    "a": "attributes",
+    "lu": "last_updated",
+    "lc": "last_changed",
+}
+
+
+def _local_timestamp(value: Any, timezone: tzinfo) -> Any:
+    """Format supported Core event times without discarding unfamiliar values."""
+    try:
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            parsed = datetime.fromtimestamp(value, UTC)
+        elif isinstance(value, str):
+            parsed = datetime.fromisoformat(value)
+            if parsed.tzinfo is None:
+                parsed = parsed.replace(tzinfo=UTC)
+        else:
+            return value
+        return parsed.astimezone(timezone).isoformat()
+    except (ValueError, OverflowError, OSError):
+        return value
+
+
+def _readable_row(row: dict[str, Any], timezone: tzinfo) -> dict[str, Any]:
+    """Expand known compact keys once; retain unknown fields and name collisions."""
+    result = {}
+    for key, value in row.items():
+        name = _FIELD_NAMES.get(key, key)
+        if name in row:
+            result[key] = value
+        else:
+            result[name] = (
+                _local_timestamp(value, timezone) if key in {"lu", "lc"} else value
+            )
+    # Match Core's fallback; omitted lc does not prove a state change at lu.
+    if "lc" not in row and "last_changed" not in row and "lu" in row:
+        result["last_changed"] = _local_timestamp(row["lu"], timezone)
+    return result
+
+
+def format_history_response(response: dict[str, Any]) -> dict[str, Any]:
+    """Localize only history event times, leaving attributes and query bounds intact."""
+    if response["data"].get("source") != "history":
+        return response
+    metadata = response["metadata"]
+    timezone, name = resolve_local_timezone(
+        metadata.get("home_assistant_timezone", "UTC")
+    )
+    for entity in response["data"].get("entities", []):
+        entity["states"] = [_readable_row(row, timezone) for row in entity["states"]]
+    metadata.update(
+        home_assistant_timezone=name,
+        timestamp_format=f"ISO 8601 ({name})",
+        note=(
+            f"History event times use {name}. When Core omits lc, last_changed "
+            "falls back to last_updated; it may not be the actual state-change time "
+            "with significant_changes_only or a window-start snapshot. "
+            "Attributes, unknown fields and query bounds are unchanged."
+            " UTC is used if HA's timezone is unavailable."
+        ),
+    )
+    return response

ha_mcp_dev-8.6.0.dev2977/src/ha_mcp/tools/recorder_errors.py

@@ -0,0 +1,53 @@
+"""Translate native recorder error codes without duplicating its request schemas."""
+
+from ..errors import ErrorCode, create_error_response
+from .helpers import raise_tool_error
+from .util_helpers import is_connection_error_message
+
+
+def raise_recorder_ws_failure(
+    kind: str,
+    error_msg: str,
+    entity_id_list: list[str],
+    suggestions: list[str],
+    error_code: str | None = None,
+) -> None:
+    """Raise the structured error for a failed recorder WS call.
+
+    The pooled ``send_websocket_message`` collapses transport failures into
+    ``{"success": False, "error": ...}`` — classify connection-shaped errors
+    as CONNECTION_FAILED (retry/connectivity guidance) instead of presenting
+    recorder-retention suggestions during an HA restart or WS outage.
+    """
+    if error_code == "invalid_format":
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_INVALID_PARAMETER,
+                f"Home Assistant rejected the {kind} parameters: {error_msg}",
+                context={"entity_ids": entity_id_list, "ha_error_code": error_code},
+                suggestions=[
+                    "Correct the parameter named in Home Assistant's validation message",
+                    "With the HA-MCP component installed and supporting schema discovery, use include_schema=True on a valid read to inspect the running Core schema",
+                ],
+            )
+        )
+    if is_connection_error_message(error_msg):
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.CONNECTION_FAILED,
+                f"Failed to retrieve {kind}: {error_msg}",
+                context={"entity_ids": entity_id_list},
+                suggestions=[
+                    "Home Assistant may be restarting or unreachable — retry shortly",
+                    "Check the connection to Home Assistant",
+                ],
+            )
+        )
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.SERVICE_CALL_FAILED,
+            f"Failed to retrieve {kind}: {error_msg}",
+            context={"entity_ids": entity_id_list},
+            suggestions=suggestions,
+        )
+    )

{ha_mcp_dev-8.6.0.dev2973 → ha_mcp_dev-8.6.0.dev2977}/src/ha_mcp/tools/response_helpers.py

@@ -390,7 +390,11 @@ def _convert_timestamp_fields(obj: Any, local_tz: _TZInfo) -> Any:
 
 
 async def add_timezone_metadata(
-    client: Any, data: dict[str, Any], include_metadata: bool = True
+    client: Any,
+    data: dict[str, Any],
+    include_metadata: bool = True,
+    *,
+    convert_timestamps: bool = True,
 ) -> dict[str, Any]:
     """Add Home Assistant timezone to tool responses and convert timestamps to local time.
 
@@ -404,6 +408,9 @@ async def add_timezone_metadata(
     Pass ``include_metadata=False`` to return *data* unchanged — the
     ``metadata`` wrapper is then omitted entirely.
 
+    Pass ``convert_timestamps=False`` to retain native values while still
+    including timezone context, without claiming that timestamps were converted.
+
     Conversion notes:
     - Offset-aware strings (``+00:00``) are converted directly.
     - Naive strings (no offset) are assumed to be UTC before conversion.
@@ -415,6 +422,22 @@ async def add_timezone_metadata(
 
     ha_timezone, fetch_failed = await fetch_ha_timezone(client)
 
+    if not convert_timestamps:
+        note = "Timestamp fields retain their native format; see the tool description for units."
+        result: dict[str, Any] = {
+            "data": data,
+            "metadata": {
+                "home_assistant_timezone": ha_timezone,
+                "timestamp_format": "native",
+                "note": note,
+            },
+        }
+        if fetch_failed:
+            result["warnings"] = [
+                "Could not fetch Home Assistant timezone; timezone context defaults to UTC."
+            ]
+        return result
+
     if fetch_failed:
         return {
             "data": data,

{ha_mcp_dev-8.6.0.dev2973 → ha_mcp_dev-8.6.0.dev2977}/src/ha_mcp/tools/statistics_helpers.py

@@ -3,6 +3,9 @@
 import logging
 from typing import Any
 
+from ..errors import ErrorCode, create_error_response
+from .coercion import parse_string_list_param
+from .helpers import raise_tool_error
 from .response_helpers import build_pagination_metadata
 
 logger = logging.getLogger(__name__)
@@ -55,8 +58,6 @@ def statistics_unit(
         return {**unknown, "unit_reason": "invalid_display_unit_metadata"}
     result = {"unit_of_measurement": unit, "unit_source": "recorder_metadata"}
     if unit is None:
-        if metadata.get("statistics_unit_of_measurement") is not None:
-            return {**unknown, "unit_reason": "display_unit_not_reported"}
         result["unit_reason"] = "statistics_are_unitless"
     return result
 
@@ -99,3 +100,97 @@ def statistics_warnings(entities: list[dict[str, Any]]) -> list[str]:
         for entity in entities
         if entity["unit_source"] == "unknown"
     ]
+
+
+async def resolve_requested_units(
+    client: Any, entities: list[dict[str, Any]], units: dict[str, Any]
+) -> dict[str, dict[str, Any]]:
+    """Resolve explicit units and default converters absent from recorder metadata."""
+    from ..client.websocket_client import get_websocket_client
+    from .component_api import (
+        component_supports,
+        get_component_caps,
+        invalidate_caps,
+        is_unknown_command,
+    )
+
+    if not units:
+        entities = [
+            entity
+            for entity in entities
+            if (record := entity.get("statistics_metadata"))
+            and record.get("unit_class") is None
+            and record.get("display_unit_of_measurement")
+            != record.get("statistics_unit_of_measurement")
+        ]
+    if not entities:
+        return {}
+    records: dict[str, dict[str, Any]] = {}
+    try:
+        caps = await get_component_caps(client)
+        if component_supports(caps, "core_contract"):
+            ws = await get_websocket_client(
+                url=client.base_url,
+                token=client.token,
+                verify_ssl=getattr(client, "verify_ssl", None),
+            )
+            response = await ws.send_command(
+                "ha_mcp_tools/statistics_units",
+                statistic_ids=[e["entity_id"] for e in entities],
+                units=units,
+            )
+            records = {r["statistic_id"]: r for r in response["result"]["records"]}
+    except Exception as exc:
+        if is_unknown_command(exc):
+            invalidate_caps(client)
+        logger.warning("Statistics converter resolution failed", exc_info=True)
+    if not units:
+        # Default labels already come from recorder metadata; this lookup only
+        # supplies converter classes needed to recover reset timestamps.
+        return records
+    for entity in entities:
+        record = records.get(entity["entity_id"])
+        if record is not None and "output_unit_of_measurement" in record:
+            entity["unit_of_measurement"] = record["output_unit_of_measurement"]
+            entity["unit_source"] = "core_converter"
+            entity.pop("unit_reason", None)
+        else:
+            unit_class = (entity.get("statistics_metadata") or {}).get("unit_class")
+            if isinstance(unit_class, str) and unit_class not in units:
+                continue
+            entity.update(
+                unit_of_measurement=None,
+                unit_source="unknown",
+                unit_reason="requested_unit_resolution_unavailable",
+            )
+    return records
+
+
+def _parse_statistic_types(
+    statistic_types: str | list[str] | None,
+) -> list[str] | None:
+    """Parse and validate the statistic_types param into a list (or None for all)."""
+    stat_types_list: list[str] | None = None
+    if statistic_types is not None:
+        if isinstance(statistic_types, str):
+            if statistic_types.startswith("["):
+                stat_types_list = parse_string_list_param(
+                    statistic_types, "statistic_types"
+                )
+            elif "," in statistic_types:
+                stat_types_list = [
+                    s.strip() for s in statistic_types.split(",") if s.strip()
+                ]
+            else:
+                stat_types_list = [statistic_types.strip()]
+        else:
+            stat_types_list = list(statistic_types)
+        if not stat_types_list:
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "statistic_types cannot be empty: this tool requires at least one value field. Omit it for Core's defaults.",
+                )
+            )
+
+    return stat_types_list

ha_mcp_dev-8.6.0.dev2977/src/ha_mcp/tools/statistics_resets.py

@@ -0,0 +1,113 @@
+"""Keep recorder reset timestamps independent of numeric unit conversion."""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _reset_groups(
+    rows_by_id: dict[str, Any],
+    metadata: dict[str, dict[str, Any]],
+    query: dict[str, Any],
+    resolved_units: dict[str, dict[str, Any]],
+) -> tuple[dict[tuple[str | None, str | None], list[str]], set[str]]:
+    groups: dict[tuple[str | None, str | None], list[str]] = {}
+    unresolved: set[str] = set()
+    for statistic_id, rows in rows_by_id.items():
+        if not any(row.get("last_reset") is not None for row in rows):
+            continue
+        record = resolved_units.get(statistic_id) or metadata.get(statistic_id, {})
+        stored = record.get("statistics_unit_of_measurement")
+        unit_class = record.get("unit_class")
+        resolved = resolved_units.get(statistic_id, {})
+        if "conversion_unit_class" in resolved:
+            if resolved["output_unit_of_measurement"] == stored:
+                continue
+            unit_class = resolved["conversion_unit_class"]
+        unchanged_default = (
+            "display_unit_of_measurement" in record
+            and "statistics_unit_of_measurement" in record
+            and record["display_unit_of_measurement"] == stored
+        )
+        if unchanged_default and (
+            not query.get("units")
+            or (isinstance(unit_class, str) and unit_class not in query["units"])
+        ):
+            continue
+        if isinstance(unit_class, str) and "statistics_unit_of_measurement" in record:
+            groups.setdefault((unit_class, stored), []).append(statistic_id)
+        elif unchanged_default:
+            # Core's default output is stored-unit data even when its converter
+            # class cannot be discovered. Clear explicit units on the reset query.
+            groups.setdefault((None, stored), []).append(statistic_id)
+        else:
+            unresolved.add(statistic_id)
+    return groups, unresolved
+
+
+def _replace_resets(
+    rows_by_id: dict[str, Any], result: dict[str, Any], ids: list[str]
+) -> set[str]:
+    unresolved = set()
+    for statistic_id in ids:
+        resets = {
+            row["start"]: row["last_reset"]
+            for row in result.get(statistic_id, [])
+            if "last_reset" in row
+        }
+        for row in rows_by_id[statistic_id]:
+            if "last_reset" not in row:
+                continue
+            if row["start"] not in resets:
+                unresolved.add(statistic_id)
+                break
+            row["last_reset"] = resets[row["start"]]
+    return unresolved
+
+
+async def restore_reset_timestamps(
+    client: Any,
+    rows_by_id: dict[str, Any],
+    metadata: dict[str, dict[str, Any]],
+    query: dict[str, Any],
+    resolved_units: dict[str, dict[str, Any]] | None = None,
+) -> list[str]:
+    """Read resets in their stored unit to avoid Core converting timestamps.
+
+    Core 2026.9's generic row converter also converts last_reset. A native
+    same-unit query avoids that bug without inverse arithmetic or a unit table,
+    and remains correct when Core fixes it. Group by native class/stored unit
+    because one query's unit option applies to every statistic in that class.
+    """
+    groups, unresolved = _reset_groups(
+        rows_by_id, metadata, query, resolved_units or {}
+    )
+    for (unit_class, stored), ids in groups.items():
+        try:
+            response = await client.send_websocket_message(
+                {
+                    **query,
+                    "type": "recorder/statistics_during_period",
+                    "statistic_ids": ids,
+                    "types": ["last_reset"],
+                    "units": {unit_class: stored} if unit_class else {},
+                }
+            )
+            result = response.get("result") if response.get("success") else None
+            if not isinstance(result, dict):
+                unresolved.update(ids)
+                continue
+            unresolved.update(_replace_resets(rows_by_id, result, ids))
+        except Exception:
+            logger.warning("Unconverted reset timestamp lookup failed", exc_info=True)
+            unresolved.update(ids)
+
+    for statistic_id in unresolved:
+        for row in rows_by_id[statistic_id]:
+            row.pop("last_reset", None)
+    return [
+        f"{statistic_id}: last_reset omitted because its unconverted timestamp "
+        "could not be read; Core may apply value-unit conversion to this field."
+        for statistic_id in sorted(unresolved)
+    ]