Server-side trails: the current run and one previous

The integration now records the path itself (trails.py): it watches the
source entity's state changes, so recording needs no open card, has no
multi-tab write races, and every screen sees the same line — reloads
included, which retires the localStorage snapshot after one day of
life. Stored per marker: the current run plus exactly one previous
(owner call — users want cleaned-vs-uncleaned at a glance). The
previous run renders at 40% opacity; the current one still trims its
live tail so it never outruns the puck. Runs rotate on start or map
switch, points cap at 2000 with decimation, store writes debounce 10 s,
and houseplan_trail_updated pushes live cards. TrailBook is pure under
5 backend tests; the WS command degrades silently on older backends.

custom_components/houseplan/__init__.py

@@ -50,6 +50,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) ->
         raise ConfigEntryNotReady(f"House Plan storage is not readable: {err}") from err
     entry.runtime_data = data
 
+    # server-side vacuum trails: the integration records the path itself
+    from .trails import TrailRecorder
+    recorder = TrailRecorder(hass, data)
+    await recorder.async_setup()
+    hass.data[DOMAIN]["trail_recorder"] = recorder
+
     card_path = Path(__file__).parent / "frontend" / "houseplan-card.js"
     plans_path = Path(hass.config.path(PLANS_DIR))
     files_path = Path(hass.config.path(FILES_DIR))
@@ -194,6 +200,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) ->
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: HouseplanConfigEntry) -> bool:
+    rec = hass.data.get(DOMAIN, {}).pop("trail_recorder", None)
+    if rec:
+        rec.teardown()
     """Unload the entry.
 
     WS commands and the HTTP view are global (async_setup) and stay registered —

custom_components/houseplan/trails.py

@@ -0,0 +1,170 @@
+"""Server-side vacuum trails.
+
+The integration records the robot's path ITSELF by watching the source
+entity's state changes — no card involvement. This removes every client-side
+race (N open tabs would fight over writes), survives page reloads by
+construction, and keeps recording while no card is open at all. Stored: the
+current run and one previous run per marker (owner call 2026-07-31 — users
+want to see where the cleanup has already been).
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.event import async_call_later, async_track_state_change_event
+from homeassistant.helpers.storage import Store
+
+from .const import DOMAIN
+
+TRAIL_CAP = 2000          # raw points per run before decimation
+SAVE_DELAY_S = 10         # debounce store writes — flash wear over precision
+FIRE_THROTTLE_S = 2.0     # event-bus updates for live cards
+MOVING_STATES = {"cleaning", "returning", "on"}
+
+
+class TrailBook:
+    """Pure run bookkeeping: {marker: {current: run, previous: run}}.
+
+    A run is {"map_id", "started", "ended", "points": [[x, y], …]} in RAW
+    robot coordinates — recalibration never invalidates a stored trail.
+    """
+
+    def __init__(self, data: dict[str, Any] | None = None) -> None:
+        self.data: dict[str, Any] = data if isinstance(data, dict) else {}
+
+    def on_point(self, marker: str, map_id: str, x: float, y: float, now: float) -> bool:
+        rec = self.data.setdefault(marker, {})
+        cur = rec.get("current")
+        if not cur or cur.get("ended") or cur.get("map_id") != map_id:
+            # a new run begins: the old one becomes "previous" (and the one
+            # before it is forgotten — we keep exactly two, per the owner)
+            if cur:
+                rec["previous"] = cur
+            cur = {"map_id": map_id, "started": now, "ended": None, "points": []}
+            rec["current"] = cur
+        pts: list[list[float]] = cur["points"]
+        if pts and pts[-1][0] == x and pts[-1][1] == y:
+            return False
+        pts.append([x, y])
+        if len(pts) > TRAIL_CAP:
+            # decimate by two but never lose the freshest point
+            half = pts[0::2]
+            if half[-1] != pts[-1]:
+                half.append(pts[-1])
+            cur["points"] = half
+        return True
+
+    def end_run(self, marker: str, now: float) -> bool:
+        cur = (self.data.get(marker) or {}).get("current")
+        if cur and not cur.get("ended"):
+            cur["ended"] = now
+            return True
+        return False
+
+
+class TrailRecorder:
+    """HA wiring: watch the tracked entities, feed the book, persist, notify."""
+
+    def __init__(self, hass: HomeAssistant, rt: Any) -> None:
+        self.hass = hass
+        self.rt = rt
+        self.store = Store(hass, 1, f"{DOMAIN}.trails")
+        self.book = TrailBook()
+        self.pairs: dict[str, tuple[str, str]] = {}  # source → (marker, vacuum)
+        self._unsub_track = None
+        self._unsub_save = None
+        self._last_fire = 0.0
+
+    async def async_setup(self) -> None:
+        self.book = TrailBook(await self.store.async_load() or {})
+        await self.async_refresh()
+
+    async def async_refresh(self) -> None:
+        """(Re)subscribe after any config change — markers may come and go."""
+        if self._unsub_track:
+            self._unsub_track()
+            self._unsub_track = None
+        stored = await self.rt.config_store.async_load() or {}
+        cfg = stored.get("config") or {}
+        self.pairs = {}
+        for m in cfg.get("markers") or []:
+            v = m.get("vacuum") or {}
+            src = v.get("source")
+            if not src or v.get("live") is False:
+                continue
+            vac = self._vacuum_entity(m)
+            if vac:
+                self.pairs[src] = (str(m.get("id")), vac)
+        ents = set(self.pairs) | {vac for _, vac in self.pairs.values()}
+        if ents:
+            self._unsub_track = async_track_state_change_event(
+                self.hass, sorted(ents), self._on_state
+            )
+
+    def teardown(self) -> None:
+        if self._unsub_track:
+            self._unsub_track()
+            self._unsub_track = None
+        if self._unsub_save:
+            self._unsub_save()
+            self._unsub_save = None
+
+    def _vacuum_entity(self, m: dict[str, Any]) -> str | None:
+        b = str(m.get("binding") or "")
+        if b.startswith("entity:vacuum."):
+            return b[len("entity:"):]
+        if b.startswith("device:"):
+            reg = er.async_get(self.hass)
+            for e in er.async_entries_for_device(reg, b[len("device:"):]):
+                if e.entity_id.startswith("vacuum."):
+                    return e.entity_id
+        return None
+
+    @callback
+    def _on_state(self, event: Any) -> None:
+        eid = event.data.get("entity_id")
+        now = time.time()
+        changed = False
+        for src, (marker, vac) in self.pairs.items():
+            if eid not in (src, vac):
+                continue
+            st_vac = self.hass.states.get(vac)
+            moving = bool(st_vac and st_vac.state in MOVING_STATES)
+            if not moving:
+                changed |= self.book.end_run(marker, now)
+                continue
+            st_src = self.hass.states.get(src)
+            attrs = st_src.attributes if st_src else {}
+            pos = attrs.get("vacuum_position") or attrs.get("robot_position")
+            if not isinstance(pos, dict):
+                continue
+            try:
+                x, y = float(pos["x"]), float(pos["y"])
+            except (KeyError, TypeError, ValueError):
+                continue
+            map_id = str(
+                attrs.get("map_name")
+                or attrs.get("current_map")
+                or attrs.get("map_index")
+                or (st_vac.attributes.get("selected_map") if st_vac else None)
+                or "default"
+            )
+            changed |= self.book.on_point(marker, map_id, x, y, now)
+        if changed:
+            self._schedule_save()
+            if now - self._last_fire >= FIRE_THROTTLE_S:
+                self._last_fire = now
+                self.hass.bus.async_fire("houseplan_trail_updated", {})
+
+    def _schedule_save(self) -> None:
+        if self._unsub_save:
+            return
+
+        async def _save(_now: Any) -> None:
+            self._unsub_save = None
+            await self.store.async_save(self.book.data)
+
+        self._unsub_save = async_call_later(self.hass, SAVE_DELAY_S, _save)

custom_components/houseplan/websocket_api.py

@@ -40,6 +40,7 @@ _LOGGER = logging.getLogger(__name__)
 def async_register(hass: HomeAssistant) -> None:
     """Register the WS commands."""
     websocket_api.async_register_command(hass, ws_layout_get)
+    websocket_api.async_register_command(hass, ws_trail_get)
     websocket_api.async_register_command(hass, ws_layout_set)
     websocket_api.async_register_command(hass, ws_geometry_repair)
     websocket_api.async_register_command(hass, ws_layout_update)
@@ -692,6 +693,7 @@ async def ws_config_set(hass: HomeAssistant, connection, msg: dict[str, Any]) ->
         except Exception:  # noqa: BLE001 — see above: the commit stands regardless
             _LOGGER.exception("House Plan: collecting superseded files failed")
     hass.bus.async_fire("houseplan_config_updated", {"rev": new_rev})
+    _refresh_trail_recorder(hass)
     # refresh repair issues (broken plan references) without waiting for a restart
     entry = get_entry(hass)
     if entry is not None:
@@ -767,3 +769,18 @@ async def ws_plan_set(hass: HomeAssistant, connection, msg: dict[str, Any]) -> N
             connection.send_error(msg["id"], err.reason, err.detail)
             return
     connection.send_result(msg["id"], {"ok": True, "url": f"{CONTENT_URL}/plans/_/{name}"})
+
+
+def _refresh_trail_recorder(hass: HomeAssistant) -> None:
+    """Markers changed — the trail recorder must re-resolve what it watches."""
+    rec = hass.data.get(DOMAIN, {}).get("trail_recorder")
+    if rec:
+        hass.async_create_task(rec.async_refresh())
+
+
+@websocket_api.websocket_command({vol.Required("type"): "houseplan/trail/get"})
+@websocket_api.async_response
+async def ws_trail_get(hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict) -> None:
+    """Current + previous cleanup runs per marker, raw robot coordinates."""
+    rec = hass.data.get(DOMAIN, {}).get("trail_recorder")
+    connection.send_result(msg["id"], {"trails": rec.book.data if rec else {}})