@@ -169,6 +169,7 @@ eauth
 echargingpile
 Eddi
 eddis
+efgh
 elif
 elinter
 eload
@@ -495,6 +496,10 @@ preseed
 preseeded
 prevs
 protobuf
+pseudonymisation
+pseudonymise
+pseudonymised
+pseudonymises
 psum
 pthread
 pvbat
@@ -700,6 +705,7 @@ varh
 venv
 Victron
 visibilitychange
+vvwwxxabcdefyyzzuu
 waf
 waitpid
 Wallbox
@@ -712,13 +718,15 @@ WNOHANG
 workmode
 writeonly
 wrongsha
+wwxxabcdefyyzz
 xaxis
 xaxistooltip
 xlabel
 xlim
 xload
 xrtkq
 xticks
+xxabcdefyy
 yaxis
 yaxistooltip
 yday
 
@@ -53,8 +53,18 @@ class ComponentBase(ABC):
         api_started: Flag indicating whether the component has successfully started
         api_stop: Flag to signal the component to stop
         last_success_timestamp: Timestamp of the last successful operation
+        component_name: Registry key this component is filed under (e.g. "givtcp"), set by
+            Components.initialize(); falls back to the class name for a component built outside
+            the registry (the standalone CLI harnesses), so report_discovery() always has a name.
     """
 
+    # Declared on the class, not only assigned in __init__, so they exist even on a component built
+    # without it - the test harnesses construct components with Cls.__new__(Cls) to exercise one
+    # method in isolation. refresh_discovery() must not be able to raise on such an instance: an
+    # AttributeError escaping run() is exactly the degradation an observer is forbidden to cause.
+    component_name = None
+    _discovery_report = None
+
     def __init__(self, base, **kwargs):
         """
         Initialise the component base.
@@ -72,6 +82,10 @@ def __init__(self, base, **kwargs):
         self.args = base.args
         self.count_errors = 0
         self.run_timeout = 60 * 60  # Default run time in seconds, can be overridden by subclasses
+        # Overridden with the registry key by Components.initialize() once this component is
+        # constructed through the registry; a component built directly (the standalone CLI
+        # harnesses) keeps this class-name fallback instead.
+        self.component_name = self.__class__.__name__
         self.initialize(**kwargs)
 
     @abstractmethod
@@ -146,6 +160,74 @@ def update_success_timestamp(self):
         """Update the last success timestamp to the current time"""
         self.last_success_timestamp = datetime.now(timezone.utc)
 
+    def report_discovery(self, report):
+        """Report what this component discovered to the discovery catalogue.
+
+        Silently does nothing when there is no coordinator - the standalone CLI harnesses run a
+        component against a MockBase with no registry at all.
+        """
+        components = getattr(self.base, "components", None)
+        coordinator = getattr(components, "coordinator", None) if components else None
+        if coordinator:
+            coordinator.report(self.component_name or type(self).__name__, report)
+
+    def refresh_discovery(self):
+        """Rebuild this component's discovery report and file it if it has moved on.
+
+        Call unconditionally once per run() cycle. A component opts in by defining
+        build_discovery(), returning the report dict, or None when it has not discovered enough to
+        describe yet (no serial, no account) - a component with no build_discovery() is a no-op.
+
+        This is the whole reporting loop, so that a reporter only has to write the part that is
+        actually its own. Three rules the reporters are otherwise each expected to remember are
+        structural here instead:
+
+        - The report is rebuilt and compared IN FULL on every call, never keyed on a hand-maintained
+          snapshot of whatever build_discovery() happens to read. A key has to be kept in step with
+          the build by hand, and when it drifts the symptom is a report frozen in its first,
+          incomplete state for the life of the process - the endpoint that had not yet decoded its
+          serial, the entity Home Assistant had not published yet. Comparing the built report cannot
+          drift, and needs no completeness check either: a report that fills in later simply differs
+          from the stored one and replaces it. Builds are dict work over data already in hand and
+          run() is called about once a minute, so rebuilding to compare costs nothing measurable,
+          and report() is still only reached when something actually moved.
+        - The marker advances only after the report has been filed, and never on the failure path,
+          so a transient failure is retried on the next cycle instead of being lost. This is why the
+          call belongs OUTSIDE any one-shot "if first:" gate: "first" is a start()-local that flips
+          to False forever the instant run() returns True, so a single failed cycle inside it can
+          never be retried.
+        - A failure is caught and logged here, never raised. An observer must not be able to degrade
+          the health of the component it observes: an exception escaping run() withholds
+          update_success_timestamp() and eventually pushes a healthy component toward unhealthy.
+          Logged only, never non_fatal_error_occurred(): that sets base.had_errors, which makes
+          update_pred() skip record_status() and suppress the run notification, so a purely
+          observational side channel would be changing Predbat's user-visible status (see solis.py's
+          own comment on the same trap).
+        """
+        build = getattr(self, "build_discovery", None)
+        if build is None:
+            return
+        try:
+            report = build()
+            if report is None or report == self._discovery_report:
+                return
+            self.report_discovery(report)
+            self._discovery_report = report
+        except Exception as e:
+            self.log("Warn: {}: failed to report discovery for the catalogue: {}".format(self.component_name or type(self).__name__, e))
+
+    def discovery_entities(self, descriptors):
+        """Keep only the entity descriptors Home Assistant has actually seen.
+
+        `descriptors` maps a Predbat standard control name to its descriptor dict, each carrying at
+        least an "entity_id". An entity spec describes what a component CAN publish, not what it HAS
+        published on this install with this firmware - most reporters publish a good part of theirs
+        conditionally - so the catalogue must never claim an entity exists that Home Assistant has
+        never seen. Checking the state store is also what keeps this true across a restart
+        mid-cycle, where a spec would still claim everything.
+        """
+        return {name: descriptor for name, descriptor in descriptors.items() if self.get_state_wrapper(descriptor["entity_id"]) is not None}
+
     @property
     def currency_symbols(self):
         """Get the currency symbols from the base system"""
 
@@ -38,6 +38,8 @@
 import asyncio
 import os
 
+from coordinator import Coordinator
+
 
 def load_component_class(component_info):
     """Import a registry entry's module and return its component class.
@@ -749,6 +751,14 @@ class Components:
     """
 
     def __init__(self, base):
+        """Create the registry, with an empty component set and its own discovery coordinator.
+
+        The coordinator lives here - never as a PredBat attribute - because create_debug_yaml()
+        dumps every non-excluded member of PredBat.__dict__, and the coordinator holds the raw
+        unredacted reports plus the pseudonym salt. "components" is in DEBUG_EXCLUDE_LIST (as is
+        "coordinator", defensively), so nothing under self.components is dumped automatically at
+        all; create_debug_yaml() instead adds a plain redacted dict via coordinator.catalogue().
+        """
         self.components = {}
         self.component_tasks = {}
         # Why a configured component could not be loaded or constructed, by name. Such a component
@@ -757,6 +767,7 @@ def __init__(self, base):
         self.component_errors = {}
         self.base = base
         self.log = base.log
+        self.coordinator = Coordinator(base)
 
     def initialize(self, only=None, phase=0):
         """Initialise components without starting them"""
@@ -804,6 +815,9 @@ def initialize(self, only=None, phase=0):
                     component_class = load_component_class(component_info)
                     self.log(f"Initialising {component_info['name']} interface")
                     self.components[component_name] = component_class(self.base, **arg_dict)
+                    # Overrides the class-name fallback ComponentBase.__init__ set, with the
+                    # registry key report_discovery() should file this component's reports under.
+                    self.components[component_name].component_name = component_name
                 except Exception as e:
                     # A component that will not import (a missing package, a syntax error) or
                     # construct must not take Predbat down with it: record why, leave it inactive