fix: repair unidentified collectors and classify live measurements

Reuse explicit session-bound identity probes for in-place reconfigure, preserve verified route settings, and cover repair through real HA lifecycle tests. Keep SMG live measurements outside diagnostics without changing entity identity or enablement. Clarify short-ASCII reference voltage and temperature units. Refs #18, #26, #38, #46.

Author: Maksym Shtembuliak

CHANGELOG.md

@@ -28,6 +28,17 @@ the GitHub release body should be rendered from the matching version section her
 
 ### Fixed
 
+- Older entries without a confirmed collector identity can now use the same
+  explicit read-only framed/AT identity check as manual setup. Successful repair
+  updates the existing entry and its selected connection settings in place;
+  failed checks preserve it. Runtime timeout diagnostics no longer imply that
+  no TCP connection arrived when identity was not confirmed (#18, #46).
+
+- SMG live voltage, current, frequency, power and temperature measurements are
+  ordinary sensors instead of diagnostics, including inherited model profiles
+  and OP2 apparent power. Entity IDs, units and default enablement are unchanged;
+  settings, protocol information and fault details remain diagnostic (#38).
+
 - Support archives preserve numeric-looking hex sequences in explicitly typed
   wire-evidence fields instead of replacing their bytes with identifier masks.
   Embedded ASCII identifiers remain masked. Short-ASCII archive creation and

custom_components/eybond_local/config_entry.py

@@ -26,6 +26,7 @@
 from .connection.admission_transaction import (
     CollectorAdmissionTransaction,
 )
+from .connection.callback_identity import OnboardingWireProbeIntent
 from .connection.connection_policy import (
     collector_identity_binding_required,
     resolve_connection_strategy,
@@ -55,6 +56,7 @@
     CONF_DETECTED_SERIAL,
     CONF_DETECTION_CONFIDENCE,
     CONF_DISCOVERY_TARGET,
+    CONF_DRIVER_HINT,
     CONF_DRIVER_DETECTION_STRATEGY,
     CONF_POLL_INTERVAL,
     CONF_POLL_MODE,
@@ -133,6 +135,8 @@ async def async_step_reconfigure(
 
         self._repair_entry_id = entry.entry_id
         await self._async_ensure_network_defaults()
+        if not self._manual_config:
+            self._manual_defaults = {**entry.data, **entry.options}
 
         # A PN-less entry has no prior identity to match -> bind ANY freshly
         # triggered strong session. An entry that still carries a (short) PN must
@@ -152,24 +156,60 @@ async def async_step_reconfigure(
             )
             if not errors:
                 self._manual_config = dict(flat_input)
-                # Repair is an active callback attempt too: same shared lifecycle
-                # (fresh baseline + ledger generation + probe + matcher + claim),
-                # so a repeated repair can never reuse a previous attempt's proof.
-                verification_error = await self._async_run_manual_callback_attempt(
-                    flat_input
-                )
-                if verification_error:
-                    errors["base"] = verification_error
-                else:
-                    applied = self._async_apply_reconfigure(entry)
-                    if applied is not None:
-                        return applied
-                    # No durable strong PN was bound: refuse to "repair" into
-                    # another doomed PN-less entry; re-prompt.
-                    errors["base"] = "callback_identity_unverified"
+                return await self._async_reconfigure_retry()
 
         return self._async_show_reconfigure_form(user_input, errors)
 
+    async def async_step_reconfigure_confirm(
+        self, user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Serve repair results with the shared explicit identity actions."""
+
+        del user_input
+        if not self._repair_entry_id:
+            return await self.async_step_reconfigure()
+        return await self.async_step_manual_confirm()
+
+    async def _async_reconfigure_retry(
+        self, protocol: str | None = None,
+    ) -> ConfigFlowResult:
+        """Retry identity repair; never enter new-entry save or reboot recovery."""
+
+        entry = self._reconfigure_target_entry()
+        if entry is None or not collector_identity_binding_required(
+            entry.data, entry.options,
+        ):
+            self._replace_manual_callback_continuation()
+            return self.async_abort(reason=(
+                "reconfigure_entry_missing" if entry is None else "reconfigure_not_required"
+            ))
+        if not self._manual_config:
+            return await self.async_step_reconfigure()
+        intent = None
+        if protocol is not None:
+            offer = self._callback_continuation.silent_bootstrap_offer
+            if offer is None:
+                return await self.async_step_manual_confirm()
+            intent = OnboardingWireProbeIntent.for_offer(offer, protocol=protocol)
+        error = await self._async_run_manual_callback_attempt(
+            self._manual_config, bootstrap_probe=intent,
+        )
+        if not error:
+            # Re-check after the await: removal or another repair may have won.
+            current = self._reconfigure_target_entry()
+            if current is None or not collector_identity_binding_required(
+                current.data, current.options,
+            ):
+                self._replace_manual_callback_continuation()
+                return self.async_abort(reason=(
+                    "reconfigure_entry_missing" if current is None else "reconfigure_not_required"
+                ))
+            applied = self._async_apply_reconfigure(current)
+            if applied is not None:
+                return applied
+            error = "callback_identity_unverified"
+        return await self._async_route_after_manual_callback_failure(error)
+
     def _async_show_reconfigure_form(
         self,
         user_input: dict[str, Any] | None,
@@ -236,8 +276,22 @@ def _async_apply_reconfigure(self, entry: ConfigEntry) -> ConfigFlowResult | Non
                 return self.async_abort(reason="already_configured")
 
         new_data = dict(entry.data)
+        new_options = dict(entry.options)
+        # Retain the verified route, including an explicitly corrected listener
+        # port. An old option override must not silently restore the broken route
+        # after reload. Identity repair does not change driver/control policy.
+        for key, value in build_manual_entry_settings(
+            self._current_connection_type(), self._manual_config,
+        ).items():
+            if key == CONF_DRIVER_HINT:
+                continue
+            new_data[key] = value
+            if key in new_options:
+                new_options[key] = value
         new_data[CONF_COLLECTOR_PN] = verified_full_pn
         new_data[CONF_COLLECTOR_IP] = collector_ip
+        if CONF_COLLECTOR_IP in new_options:
+            new_options[CONF_COLLECTOR_IP] = collector_ip
         # Identity repair re-binds the durable PN; it does NOT re-decide how the
         # collector connects. The entry's canonical strategy (the user's choice)
         # is preserved untouched. Only an entry from before the canonical axis
@@ -275,6 +329,7 @@ def _async_apply_reconfigure(self, entry: ConfigEntry) -> ConfigFlowResult | Non
                 entry,
                 unique_id=f"collector:{verified_full_pn}",
                 data=new_data,
+                options=new_options,
             ),
             recovery=self._callback_continuation.terminal_input,
         )

custom_components/eybond_local/flows/config/manual.py

@@ -322,8 +322,8 @@ async def _async_route_after_manual_callback_failure(
         cleared here as an additional terminal-path guard. The flow remains open
         with retry/edit actions; no PN-less entry is persisted.
 
-        Reconfigure does not call this helper and remains fail-closed on its own
-        form.
+        Identity repair shares this presentation, but keeps its own in-place
+        commit/retry boundary and can never offer new-entry save or recovery.
         """
 
         reason = str(verification_error or "callback_timeout").strip()
@@ -569,7 +569,8 @@ async def async_step_manual_confirm(
         ):
             # Advanced recovery for a genuinely SILENT device: the user (and
             # only the user) may pick the bootstrap protocol for exactly one
-            # read-only identity query on the next attempt's new session.
+            # read-only identity query on the exact offered session. A stale
+            # offer must be renewed, never applied to a replacement socket.
             menu_options.append("manual_bootstrap_framed")
             menu_options.append("manual_bootstrap_at")
         menu_options.extend(
@@ -578,6 +579,16 @@ async def async_step_manual_confirm(
                 MANUAL_CONFIRM_ACTION_EDIT_SETTINGS,
             ]
         )
+        if self._repair_entry_id:
+            return self.async_show_menu(
+                step_id="reconfigure_confirm",
+                menu_options=menu_options,
+                description_placeholders={
+                    "failure_explanation": _shared_recovery_failure_explanation(
+                        self._tr, last_error,
+                    ),
+                },
+            )
         if self._can_offer_smartess_cloud_assist(self._manual_result):
             menu_options.append("manual_smartess_cloud_assist")
         if self._manual_entry_ready_to_save():
@@ -610,6 +621,8 @@ async def async_step_manual_probe_again(
         user_input: dict[str, Any] | None = None,
     ) -> ConfigFlowResult:
         del user_input
+        if self._repair_entry_id:
+            return await self._async_reconfigure_retry()
         if not self._manual_config:
             return await self.async_step_manual()
 
@@ -657,6 +670,8 @@ async def _async_manual_bootstrap_retry(self, protocol: str) -> ConfigFlowResult
         reader, prepared handoff) is the one shared identity transaction.
         """
 
+        if self._repair_entry_id:
+            return await self._async_reconfigure_retry(protocol)
         if not self._manual_config:
             return await self.async_step_manual()
         offer = self._callback_continuation.silent_bootstrap_offer
@@ -685,6 +700,8 @@ async def async_step_manual_edit_settings(
         self._callback_continuation.release_terminal_owner()
         self._manual_defaults = dict(self._manual_config)
         self._manual_result = None
+        if self._repair_entry_id:
+            return await self.async_step_reconfigure()
         return await self.async_step_manual()
 
     async def async_step_manual_save(
@@ -694,6 +711,8 @@ async def async_step_manual_save(
         """Create a normal collector entry only after durable identity proof."""
 
         del user_input
+        if self._repair_entry_id:
+            return await self.async_step_reconfigure_confirm()
         if not self._manual_config:
             return await self.async_step_manual()
         if not self._manual_entry_ready_to_save():