Feature/favorites view, grid view changes, panel-offline

.gitignore

@@ -32,6 +32,7 @@ docs/agile-readme.md
 .claude/
 .superpowers/
 docs/superpowers/
+.mcp.json
 
 # Docker dev environment
 ha-config/

CHANGELOG.md

@@ -15,12 +15,18 @@ All notable changes to this project will be documented in this file.
   - By Activity: circuits sorted by power consumption with expandable graphs and search filtering
   - By Area: circuits grouped by Home Assistant area with live area registry updates
   - Shared tab bar across panel and card with configurable text/icon style
+- **Cross-panel Favorites view** (span-card 0.9.4) — A synthetic "Favorites" entry in the dashboard panel dropdown aggregates favorited circuits and sub-devices
+  (BESS, EVSE) across every configured SPAN panel into a single workspace. Heart toggles in the Graph Settings and per-circuit / per-sub-device side panels
+  persist favorites and the view to the integration storage so the Favorites view is reconstituted on restart. See the Favorites explanation in the frontend
+  dashboard link via the README.md.
 
 ### Fixed
 
 - **Dashboard goes blank after idle** — Panel and card migrated to LitElement and refresh after losing focus (span-card 0.9.1)
 - **Dashboard graph fidelity** — Circuit charts now use step interpolation instead of linear, eliminating misleading diagonal ramps between data points.
   Continuous signals (PV solar output, BESS SoC/SoE) retain linear interpolation to faithfully represent their gradual behavior.
+- **Panel status showing "Connected" while the panel is offline** — the panel status sensor now reflects the true connection state and updates within a second
+  of the panel going offline or coming back online (including the bump to span-panel-api v2.6.1)
 
 ## [2.0.5] - 4/2026
 

custom_components/span_panel/__init__.py

@@ -27,7 +27,7 @@
 from span_panel_api.mqtt.models import MqttClientConfig
 
 # Import config flow to ensure it's registered
-from . import config_flow  # noqa: F401  # type: ignore[misc]
+from . import config_flow  # noqa: F401
 from .const import (
     CONF_API_VERSION,
     CONF_EBUS_BROKER_HOST,
@@ -45,14 +45,15 @@
     PANEL_FRONTEND_DIR as PANEL_FRONTEND_DIR,
     PANEL_URL as PANEL_URL,
     _async_ensure_lovelace_resource as _async_ensure_lovelace_resource,
-    async_apply_panel_registration,
+    async_apply_panel_registration as async_apply_panel_registration,
     async_load_panel_settings as async_load_panel_settings,
     async_save_panel_settings as async_save_panel_settings,
 )
 from .graph_horizon import GraphHorizonManager
 from .migrations import CURRENT_CONFIG_VERSION, async_migrate_entry  # noqa: F401
 from .options import SNAPSHOT_UPDATE_INTERVAL
 from .services import (  # noqa: F401
+    _async_register_favorites_services,
     _async_register_graph_horizon_services,
     _async_register_monitoring_services,
     _async_register_services,
@@ -93,6 +94,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     _async_register_services(hass)
     _async_register_monitoring_services(hass)
     _async_register_graph_horizon_services(hass)
+    _async_register_favorites_services(hass)
 
     await async_apply_panel_registration(hass)
 
@@ -246,15 +248,25 @@ async def async_setup_entry(hass: HomeAssistant, entry: SpanPanelConfigEntry) ->
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: SpanPanelConfigEntry) -> bool:
-    """Unload a config entry."""
+    """Unload a config entry.
+
+    Unload the platforms first; only tear the coordinator down if that
+    succeeded. If a platform raises during unload, HA retries with the
+    coordinator still alive — shutting it down first would leave
+    entities pointing at a closed MQTT client.
+    """
     _LOGGER.debug("Unloading SPAN Panel integration")
 
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if not unload_ok:
+        return False
+
     if hasattr(entry, "runtime_data") and entry.runtime_data is not None:
         if entry.runtime_data.coordinator.current_monitor is not None:
             entry.runtime_data.coordinator.current_monitor.async_stop()
         await entry.runtime_data.coordinator.async_shutdown()
 
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    return True
 
 
 async def async_remove_config_entry_device(

custom_components/span_panel/alert_dispatcher.py

@@ -164,7 +164,8 @@ def dispatch_alert(
     over_threshold_since: str | None = None,
 ) -> None:
     """Dispatch alert through all enabled notification channels."""
-    local_time = dt_util.now().strftime("%-I:%M %p")
+    # `%-I` is glibc-only; strip any leading zero ourselves for portability.
+    local_time = dt_util.now().strftime("%I:%M %p").lstrip("0")
 
     event_data: dict[str, Any] = {
         "alert_source": alert_source,
@@ -249,7 +250,8 @@ def dispatch_test_alert(
     utilization_pct = 91.5
     panel_serial = "TEST"
     window_duration_s = 300
-    local_time = dt_util.now().strftime("%-I:%M %p")
+    # `%-I` is glibc-only; strip any leading zero ourselves for portability.
+    local_time = dt_util.now().strftime("%I:%M %p").lstrip("0")
 
     raw_targets = settings.get(NOTIFY_TARGETS, "")
     if isinstance(raw_targets, str):

custom_components/span_panel/binary_sensor.py

@@ -13,7 +13,7 @@
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity import EntityCategory  # type: ignore[attr-defined]
+from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from span_panel_api import SpanEvseSnapshot, SpanPanelSnapshot
 

custom_components/span_panel/config_flow.py

@@ -10,7 +10,6 @@
 
 from homeassistant import config_entries
 from homeassistant.config_entries import (
-    ConfigEntry,
     ConfigFlowContext,
     ConfigFlowResult,
 )
@@ -634,7 +633,7 @@ def create_new_entry(
 
     def _update_v2_entry(self, entry_id: str) -> ConfigFlowResult:
         """Update an existing config entry with new v2 MQTT credentials."""
-        entry: ConfigEntry[Any] | None = self.hass.config_entries.async_get_entry(entry_id)
+        entry: SpanPanelConfigEntry | None = self.hass.config_entries.async_get_entry(entry_id)
         if entry is None:
             _LOGGER.error("Config entry %s does not exist during v2 reauth", entry_id)
             return self.async_abort(reason="reauth_failed")

custom_components/span_panel/config_flow_options.py

@@ -72,7 +72,7 @@ def get_general_options_defaults(
         ),
         ENERGY_REPORTING_GRACE_PERIOD: config_entry.options.get(ENERGY_REPORTING_GRACE_PERIOD, 15),
         ENABLE_ENERGY_DIP_COMPENSATION: config_entry.options.get(
-            ENABLE_ENERGY_DIP_COMPENSATION, False
+            ENABLE_ENERGY_DIP_COMPENSATION, True
         ),
     }
 

custom_components/span_panel/coordinator.py

@@ -6,14 +6,14 @@
 from datetime import timedelta
 import logging
 from time import time as _epoch_time
-from typing import TYPE_CHECKING, Any, Protocol
+from typing import TYPE_CHECKING, Protocol
 
 if TYPE_CHECKING:
+    from . import SpanPanelConfigEntry
     from .current_monitor import CurrentMonitor
     from .graph_horizon import GraphHorizonManager
 
 from homeassistant.components.persistent_notification import async_create
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
@@ -23,11 +23,10 @@
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from span_panel_api import SpanMqttClient, SpanPanelSnapshot
-from span_panel_api.exceptions import SpanPanelAuthError
+from span_panel_api.exceptions import SpanPanelAuthError, SpanPanelStaleDataError
 
 from .const import DOMAIN
 from .id_builder import build_circuit_unique_id
-from .options import ENERGY_REPORTING_GRACE_PERIOD
 from .schema_validation import collect_sensor_definitions, validate_field_metadata
 
 
@@ -37,6 +36,7 @@ class SpanCircuitEnergySensorProtocol(Protocol):
     @property
     def energy_offset(self) -> float:
         """Cumulative dip compensation offset."""
+        ...
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,22 +66,21 @@ def __init__(
         self,
         hass: HomeAssistant,
         client: SpanMqttClient,
-        config_entry: ConfigEntry,
+        config_entry: SpanPanelConfigEntry,
     ) -> None:
         """Initialize the coordinator."""
         self._client = client
-        self.config_entry: ConfigEntry[Any] = config_entry
+        self.config_entry: SpanPanelConfigEntry = config_entry
         # Track last tick for visibility into cadence
         self._last_tick_epoch: float | None = None
         # Flag to track if a reload was requested
         self._reload_requested = False
         # Flag to track if panel is offline/unreachable
         self._panel_offline = False
-        # Track last grace period value for comparison
-        self._last_grace_period = config_entry.options.get(ENERGY_REPORTING_GRACE_PERIOD, 15)
 
         # Streaming state
         self._unregister_streaming: Callable[[], None] | None = None
+        self._unregister_connection: Callable[[], None] | None = None
 
         # Hardware capability tracking — detect when BESS/PV are commissioned
         # and trigger a reload so the factory creates the appropriate sensors.
@@ -142,13 +141,19 @@ def _mark_panel_online(self) -> None:
             _LOGGER.info("%s is back online", self.config_entry.title or "SPAN Panel")
         self._panel_offline = False
 
-    def _mark_panel_offline(self, err: Exception) -> None:
-        """Mark the panel offline and log the transition once."""
+    def _mark_panel_offline(self, reason: Exception | str) -> None:
+        """Mark the panel offline and log the transition once.
+
+        `reason` is rendered with %s — both Exception and str format
+        correctly. The broker-disconnect path (from the MQTT client
+        connection callback) passes a short string; the snapshot-poll
+        path passes a SpanPanelStaleDataError or unexpected Exception.
+        """
         if not self._panel_offline:
             _LOGGER.info(
                 "%s is unavailable: %s",
                 self.config_entry.title or "SPAN Panel",
-                err,
+                reason,
             )
         self._panel_offline = True
 
@@ -209,11 +214,34 @@ async def _fire_dip_notification(self) -> None:
     # --- Streaming ---
 
     async def async_setup_streaming(self) -> None:
-        """Set up push streaming."""
+        """Set up push streaming and broker-connection state listening."""
+        self._unregister_connection = self._client.register_connection_callback(
+            self._on_connection_change
+        )
         self._unregister_streaming = self._client.register_snapshot_callback(self._on_snapshot_push)
         await self._client.start_streaming()
         _LOGGER.info("MQTT push streaming started")
 
+    def _on_connection_change(self, connected: bool) -> None:
+        """Handle a broker connection state edge from the MQTT client.
+
+        Called on the event loop when the bridge transitions between
+        connected and disconnected. Flips the panel-offline flag and
+        pushes an immediate listener update so sensors enter or exit
+        grace-period logic without waiting for the 60 s fallback poll.
+
+        Listener fan-out is guarded by a real state change so a misbehaving
+        or future-version library that re-emits the same edge does not
+        trigger spurious entity re-renders.
+        """
+        was_offline = self._panel_offline
+        if connected:
+            self._mark_panel_online()
+        else:
+            self._mark_panel_offline("MQTT broker disconnected")
+        if self._panel_offline != was_offline:
+            self.async_update_listeners()
+
     async def _on_snapshot_push(self, snapshot: SpanPanelSnapshot) -> None:
         """Handle a pushed snapshot from MQTT streaming."""
         self._mark_panel_online()
@@ -223,6 +251,10 @@ async def _on_snapshot_push(self, snapshot: SpanPanelSnapshot) -> None:
 
     async def async_shutdown(self) -> None:
         """Shut down the coordinator and release resources."""
+        if self._unregister_connection is not None:
+            self._unregister_connection()
+            self._unregister_connection = None
+
         if self._unregister_streaming is not None:
             self._unregister_streaming()
             self._unregister_streaming = None
@@ -466,12 +498,20 @@ async def _async_update_data(self) -> SpanPanelSnapshot:
         except ConfigEntryAuthFailed:
             raise
 
-        except Exception as err:
+        except SpanPanelStaleDataError as err:
+            # Expected offline path — the library signals the client
+            # isn't live. Same handling as other offline errors.
             self._mark_panel_offline(err)
+            if self.data is not None:
+                return self.data
+            raise
 
-            # Return last known data to keep coordinator updating for grace period logic.
-            # On first refresh (self.data is None), re-raise so async_config_entry_first_refresh
-            # surfaces the error properly.
+        except Exception as err:
+            # Unexpected error — log the transition but keep the
+            # coordinator ticking on last-known data for grace-period logic.
+            # On first refresh (self.data is None), re-raise so
+            # async_config_entry_first_refresh surfaces the error properly.
+            self._mark_panel_offline(err)
             if self.data is not None:
                 return self.data
             raise