@@ -9,6 +9,12 @@ the GitHub release body should be rendered from the matching version section her
 
 ### Added
 
+- PI30 devices without model-specific charge-current controls can expose
+  **Max Total Charge Current** and **Max Utility Charge Current** in Full
+  Control, using only the selectable values read from that inverter (#58).
+  These writes remain untested. Two bounded read-only queries enrich detection;
+  normal polling and existing model-specific controls are unchanged.
+
 - Anenji GES48120M250-500P auto-binds through exact Sumry/GES identity anchors
   (model 45, product class 10, protocol raw 220) and exposes the existing
   nine-field read-only 0x7530 subset (#49, #55). Broader telemetry, derived
@@ -81,6 +87,14 @@ the GitHub release body should be rendered from the matching version section her
 
 ### Fixed
 
+- An initially silent collector that reveals a short framed heartbeat can
+  confirm its full PN through FC2 on the same socket instead of being closed
+  and retried with another dialect (#23). A short PN alone still cannot claim
+  a device; foreign identities, deadlines and cancellation remain guarded.
+- Enum controls discovered after HA platform setup are added without an entry
+  reload. Updated device-specific choices replace stale options, and controls
+  become unavailable when their live capability is withdrawn.
+
 - Framed collector connections accept AT metadata replies preceded by CR/LF
   without treating them as oversized binary frames and disconnecting. Binary
   transaction IDs and payloads remain intact; this does not change inverter
 
@@ -9,6 +9,8 @@
 normal callback attempt may try the alternate dialect.  This prevents an AT
 query from following a framed query (or vice versa) on one stream while keeping
 the established one-``set>server``-per-attempt contract intact.
+A short heartbeat learned during FC1 permits a bounded FC2 identity upgrade on
+that now-known framed socket; it does not permit claiming the short identity.
 """
 
 from __future__ import annotations
@@ -25,6 +27,7 @@
 from .identity_probe import (
     PROBE_AT_DTUPN,
     PROBE_FRAMED_FC1,
+    PROBE_FRAMED_FC2,
     silent_probe_kind_for_protocol,
 )
 from .silent_session_probe import SessionObservation
@@ -281,6 +284,48 @@ async def async_negotiate(
                 session_protocol=protocol,
                 identity_probe_kind=probe_kind,
             )
+            post = next(
+                (observation for observation in channel.snapshot_session_observations()
+                 if observation.session_id == selected.session_id),
+                selected,
+            )
+            if (
+                not identity_source_is_strong(post.identity_source)
+                and unknown_wire
+                and protocol == "eybond_framed"
+                and post.identity_source == "framed_heartbeat"
+                and validated_collector_pn(post.collector_pn)
+                and post.state not in _TERMINAL_STATES
+                and not post.state.startswith("closed")
+            ):
+                # FC1 can reveal only a short PN on an initially silent socket.
+                # This proves the framed dialect, NOT ownership. Upgrade that
+                # exact stream with FC2, rather than discarding the observation
+                # and trying AT on the next connection. Never mix dialects or
+                # extend the caller's deadline; a failed upgrade stays weak.
+                unknown_wire = False
+                if not pn_is_same_identity(durable_pn, post.collector_pn):
+                    return ExactSessionIdentityResult(
+                        NEGOTIATION_FOREIGN_IDENTITY,
+                        session_id=selected.session_id,
+                        collector_pn=post.collector_pn,
+                        session_protocol=protocol,
+                        identity_source=post.identity_source,
+                    )
+                remaining = deadline - loop.time()
+                if remaining > 0:
+                    probe_kind = PROBE_FRAMED_FC2
+                    try:
+                        identified_pn = await asyncio.wait_for(
+                            channel.async_identify_exact_session(
+                                selected.session_id,
+                                session_protocol=protocol,
+                                identity_probe_kind=probe_kind,
+                            ),
+                            timeout=remaining,
+                        )
+                    except asyncio.TimeoutError:
+                        identified_pn = ""
         except asyncio.CancelledError as original_cancel:
             if unknown_wire:
                 try:
@@ -292,7 +337,17 @@ async def async_negotiate(
                     pass
             raise original_cancel
 
-        strong_pn = validated_collector_pn(identified_pn)
+        post = next(
+            (observation for observation in channel.snapshot_session_observations()
+             if observation.session_id == selected.session_id),
+            selected,
+        )
+        strong_pn = (
+            validated_collector_pn(post.collector_pn)
+            if identity_source_is_strong(post.identity_source)
+            and pn_is_same_identity(identified_pn, post.collector_pn)
+            else ""
+        )
         if strong_pn:
             if not pn_is_same_identity(durable_pn, strong_pn):
                 return ExactSessionIdentityResult(
@@ -302,14 +357,6 @@ async def async_negotiate(
                     session_protocol=protocol,
                     probe_kind=probe_kind,
                 )
-            post = next(
-                (
-                    observation
-                    for observation in channel.snapshot_session_observations()
-                    if observation.session_id == selected.session_id
-                ),
-                selected,
-            )
             self._reset_unknown_candidate()
             return ExactSessionIdentityResult(
                 NEGOTIATION_IDENTIFIED,
@@ -337,7 +384,7 @@ async def async_negotiate(
             NEGOTIATION_PROBE_FAILED,
             session_id=selected.session_id,
             session_protocol=protocol,
-            identity_source=selected.identity_source,
+            identity_source=post.identity_source,
             probe_kind=probe_kind,
         )
 
 
@@ -66,6 +66,7 @@
     unsupported_commands as _unsupported_commands,
 )
 from .read_result import DriverReadMode, DriverReadResult
+from .pi30_controls import async_enrich_charge_current_controls
 from .support_probe import SupportProbeRequest
 
 
@@ -270,6 +271,7 @@ async def async_probe_signature(self, transport, target: ProbeTarget) -> bool:
         )
 
     async def async_probe(self, transport, target: ProbeTarget) -> DetectedInverter | None:
+        started = time.monotonic()
         session = self._session(transport, target)
         try:
             probe = await async_probe_ascii_catalog(
@@ -315,6 +317,12 @@ async def async_probe(self, transport, target: ProbeTarget) -> DetectedInverter
         config_values.update(serial_identity.as_details())
 
         capabilities = _build_pi30_capabilities(config_values, profile.capabilities)
+        # Enrichment must not extend the existing driver probe window or make
+        # unsupported optional queries a reason to lose positive PI30 identity.
+        capabilities = await async_enrich_charge_current_controls(
+            session, config_values, capabilities,
+            timeout=min(3.0, max(0.0, self.probe_timeout - (time.monotonic() - started) - 0.1)),
+        )
         _translate_capability_enum_values(config_values, capabilities)
 
         return DetectedInverter(
 
@@ -0,0 +1,73 @@
+"""Device-advertised PI30 charge-current controls, not a retail model guess.
+
+PI30 Communication Protocol 2015-09-24, sections 2.16/2.17 and 3.3/3.5,
+defines selectable-value queries and the corresponding three-digit writes.
+Only missing controls are enriched after positive protocol identification.
+Existing model-specific controls (including their tested status) are preserved.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+from ..models import CapabilityChoice, WriteCapability
+from ..payload.pi30 import Pi30Error
+
+
+_CONTROLS = (
+    ("max_charging_current", "QMCHGCR", "MCHGC", "Max Total Charge Current"),
+    ("max_ac_charging_current", "QMUCHGCR", "MUCHGC", "Max Utility Charge Current"),
+)
+
+
+def parse_charge_current_choices(payload: str) -> tuple[int, ...]:
+    """Accept a bounded list of distinct three-digit positive ampere values."""
+
+    if not isinstance(payload, str) or not re.fullmatch(r"[0-9]{3}(?: [0-9]{3}){0,63}", payload):
+        raise Pi30Error("invalid_charge_current_choices")
+    values = tuple(int(field) for field in payload.split(" "))
+    if 0 in values or len(set(values)) != len(values):
+        raise Pi30Error("invalid_charge_current_choices")
+    return values
+
+
+async def async_enrich_charge_current_controls(
+    session, values: dict, capabilities: tuple[WriteCapability, ...], *, timeout: float,
+) -> tuple[WriteCapability, ...]:
+    """Read at most two missing lists within a shared optional time budget.
+
+    A timeout/NAK/malformed list never invalidates an already detected inverter.
+    This is not part of the signature scan or regular polling. Writes remain
+    untested/Full-Control-only and accept only the device's advertised values.
+    """
+
+    result = list(capabilities)
+    existing = {cap.key for cap in capabilities}
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + max(0.0, timeout)
+    for index, (key, query, command, title) in enumerate(_CONTROLS):
+        current = values.get(key)
+        if key in existing or type(current) is not int or current <= 0:
+            continue
+        remaining = deadline - loop.time()
+        if remaining <= 0:
+            break
+        try:
+            payload = await asyncio.wait_for(session.request(query), timeout=min(1.5, remaining))
+            choices = parse_charge_current_choices(payload)
+        except Exception:  # Optional query/parser failure; cancellation is BaseException.
+            continue
+        if current not in choices:
+            continue
+        result.append(WriteCapability(
+            key=key, register=0, value_kind="enum", command=command, command_width=3,
+            note=f"PI30 {query} advertised these values on this device; local writes are untested.",
+            tested=False, provenance="doc_backed", support_tier="conditional",
+            title=title, group="battery", order=260 + 10 * index, unit="A",
+            enabled_default=True, requires_confirm=True,
+            change_summary="Limits battery charging current to a value advertised by this inverter.",
+            choices=tuple(CapabilityChoice(value=value, label=f"{value} A", order=order)
+                          for order, value in enumerate(choices)),
+        ))
+    return tuple(result)
@@ -122,6 +122,28 @@ async def async_setup_entry(
             ],
         ]
     )
+    # Some protocol controls are qualified from device-advertised choices only
+    # after the startup snapshot has built the platforms. Add newly confirmed
+    # enum surfaces without reloading the entry (which would lose that live
+    # evidence and recreate the same startup gap). Stable IDs remain unchanged.
+    added_keys = {capability.key for capability in exposable_capabilities}
+
+    def add_live_capabilities() -> None:
+        inverter = coordinator.identified_inverter
+        if inverter is None:
+            return
+        additions = [
+            capability for capability in inverter.capabilities
+            if capability.key not in added_keys
+            and capability.value_kind == "enum" and capability.enum_value_map
+            and coordinator.can_expose_capability(capability)
+        ]
+        if additions:
+            added_keys.update(capability.key for capability in additions)
+            async_add_entities([EybondCapabilitySelect(coordinator, cap) for cap in additions])
+
+    entry.async_on_unload(coordinator.async_add_listener(add_live_capabilities))
+    add_live_capabilities()
 
 
 class EybondRuntimeSettingSelect(CoordinatorEntity[EybondLocalCoordinator], SelectEntity):
@@ -203,6 +225,15 @@ def __init__(
     def device_info(self):
         return self.coordinator.inverter_device_info()
 
+    def _handle_coordinator_update(self) -> None:
+        inverter = self.coordinator.data.inverter
+        if inverter is not None:
+            current = next((cap for cap in inverter.capabilities if cap.key == self._capability.key), None)
+            if current is not None and current.value_kind == "enum":
+                self._capability = current
+                self._attr_options = current.enum_options
+        super()._handle_coordinator_update()
+
     @property
     def available(self) -> bool:
         snapshot = self.coordinator.data
@@ -211,6 +242,8 @@ def available(self) -> bool:
             return False
         if not any(cap.key == self._capability.key for cap in inverter.capabilities):
             return False
+        if not self.coordinator.can_expose_capability(self._capability):
+            return False
         return self._capability.runtime_state(snapshot.runtime_values()).visible
 
     @property
 
@@ -200,6 +200,13 @@ wire from the *observed* session, not from a persisted `collector_session_protoc
 hint. Untrusted states (`route_identity_mismatch`, `waiting_for_route_identity`,
 `parked_*`, `closed_*`) can never override a claimed, routed session.
 
+If a first-contact FC1 probe on an initially silent socket reveals only a
+short framed heartbeat, the exact-session negotiator may send one FC2 PN query
+on that same now-observed framed stream, within the caller's remaining deadline.
+This is a same-dialect identity upgrade, not an AT fallback or permission to
+claim the weak PN. Failure preserves the known framed candidate for a later
+normal attempt; only a still-unknown dialect is retired before trying another.
+
 The framed runtime reader is fail-closed at the physical socket boundary. An
 idle socket may remain silent indefinitely, but once the first byte of a frame
 arrives, header and payload completion are bounded and the decoded local-runtime
 
@@ -99,6 +99,21 @@ Persistent failures still need investigation: create a Support Archive while
 the problem is present. It includes failed command names and the age of the
 last confirmed basic readings. Retained values are not new measurements.
 
+### PI30: charge-current settings
+
+In **Full Control**, compatible PI30 inverters can show **Max Total Charge
+Current** and **Max Utility Charge Current**. The first limits total battery
+charging current; the second limits charging from the grid. They are dropdowns,
+not unrestricted number inputs: available values come from the inverter itself.
+
+For devices without an existing model-specific control map, these controls are
+marked **untested** until local writes are confirmed. Enabling Full Control does
+not change any inverter setting. If the inverter cannot supply a valid list of
+choices, the corresponding new control is not offered. Existing model-specific
+controls are unchanged. A readable buzzer/backlight state does not guarantee
+that the inverter accepts its enable/disable command; a `NAK` is a rejection,
+not a successful change.
+
 ## MUST PV/PH18 power and energy corrections
 
 The unreleased test build corrects several readings in the MUST PV/PH18 map: