@@ -1188,15 +1188,21 @@ def slot_current_limits(self, inverter_sn, include_probed=True):
 
         The cap starts from the battery limit register (CID 7224 charge, 7226 discharge - read as is,
         not multiplied by the pack count, and SOLIS_SLOT_CURRENT_DEFAULT_AMPS when it has not been
-        read), is lowered to the smallest sysCommand max SolisCloud advertises across the six slot
-        CIDs - slot 1 advertising more than the others is not accepted - and then to the rated current
-        (issue #5187). Returns a dict: for each of "charge" and "discharge", "<direction>_register"
-        (the raw register value, None when not read), "<direction>_base" (the starting point),
-        "<direction>_metadata" (the smallest advertised max, None when none was returned) and
-        "<direction>" (the cap); plus "rated" (None when the size is unknown) and "rated_capped".
-        Finally each direction is held to the ceiling learned by ensure_slot_current_probed(), which
-        "<direction>_probed" reports (None when not probed); include_probed=False leaves it out,
-        which is what the probe itself starts from.
+        read) and is lowered to the smallest sysCommand max SolisCloud advertises across the six slot
+        CIDs - slot 1 advertising more than the others is not accepted. That is the battery-side cap.
+
+        Then, once ensure_slot_current_probed() has measured what the slots really accept, the cap is
+        held to that ceiling. Until then it is held to the rated current instead - an estimate that
+        can be too high (a 3.6kW inverter rated for 75A keeps only 60A, issue #5187) or too low (an
+        8kW hybrid rated for 156A takes 180A, charging from PV), so a measured ceiling replaces it.
+
+        Returns a dict: for each of "charge" and "discharge", "<direction>_register" (the raw register
+        value, None when not read), "<direction>_base" (the starting point), "<direction>_metadata"
+        (the smallest advertised max, None when none was returned), "<direction>_battery" (the
+        battery-side cap), "<direction>_probed" (the measured ceiling, None when not probed) and
+        "<direction>" (the cap); plus "rated" (None when the size is unknown) and "rated_capped"
+        (whether the rated current lowered a cap). include_probed=False leaves the measured ceiling
+        out, which is what the probe itself starts from.
         """
         values = self.cached_values.get(inverter_sn, {})
         infos = self.cached_infos.get(inverter_sn, {})
@@ -1213,20 +1219,24 @@ def slot_current_limits(self, inverter_sn, include_probed=True):
             limits[direction + "_register"] = values.get(register_cid)
             limits[direction + "_base"] = base
             limits[direction + "_metadata"] = min(advertised) if advertised else None
+            limits[direction + "_battery"] = cap
             limits[direction] = cap
 
         rated = self.get_rated_current(inverter_sn)
         limits["rated"] = rated
-        limits["rated_capped"] = rated is not None and rated < max(limits["charge"], limits["discharge"])
-        if limits["rated_capped"]:
-            limits["charge"] = min(limits["charge"], rated)
-            limits["discharge"] = min(limits["discharge"], rated)
-
         probed = self.slot_current_probed.get(inverter_sn, {}) if include_probed else {}
         for direction in ("charge", "discharge"):
             limits[direction + "_probed"] = probed.get(direction)
-            if probed.get(direction) is not None:
-                limits[direction] = min(limits[direction], probed[direction])
+        if limits["charge_probed"] is not None and limits["discharge_probed"] is not None:
+            # Measured, so the rated estimate no longer applies
+            limits["rated_capped"] = False
+            for direction in ("charge", "discharge"):
+                limits[direction] = min(limits[direction], limits[direction + "_probed"])
+        else:
+            limits["rated_capped"] = rated is not None and rated < max(limits["charge"], limits["discharge"])
+            if limits["rated_capped"]:
+                limits["charge"] = min(limits["charge"], rated)
+                limits["discharge"] = min(limits["discharge"], rated)
         return limits
 
     def describe_slot_current_limits(self, inverter_sn, limits):
@@ -1253,7 +1263,8 @@ def describe_slot_current_limits(self, inverter_sn, limits):
                 inputs.append(f"probed max {probed}A")
             parts.append(f"{direction} {cap}A from the {source} ({', '.join(inputs)})")
         if limits["rated"] is not None:
-            rated_text = f"rated {limits['rated']}A from {detail.get('power')}{detail.get('powerStr') or 'kW'} at {self.get_nominal_voltage(inverter_sn)}V"
+            superseded = ", not used once probed" if limits.get("charge_probed") is not None and limits.get("discharge_probed") is not None else ""
+            rated_text = f"rated {limits['rated']}A from {detail.get('power')}{detail.get('powerStr') or 'kW'} at {self.get_nominal_voltage(inverter_sn)}V{superseded}"
         else:
             rated_text = "rated current unknown"
         return f"Solis API: Slot current limits for {inverter_sn}: {', '.join(parts)}; {rated_text}"
@@ -1364,14 +1375,16 @@ async def probe_slot_write(self, inverter_sn, cid, value, field_description):
             self.log(f"Warn: Solis API: Probe of CID {cid} on {inverter_sn} got no answer: {e}")
             return None
 
-    async def probe_slot_current_ceiling(self, inverter_sn, direction, slot, expected):
+    async def probe_slot_current_ceiling(self, inverter_sn, direction, slot, start, upper):
         """Find the most one direction's slot current may be set to, on a disabled slot, then restore it.
 
-        Writes the expected maximum first; if it is refused, steps down SOLIS_SLOT_PROBE_STEP_DOWN_AMPS
-        at a time until one is kept, then up 1A at a time until one is refused, so the result is the
-        exact ceiling in whole amps. Returns None - nothing learned - if any write gets no verdict,
-        or if every current down to SOLIS_SLOT_PROBE_MIN_AMPS is refused, which is not a ceiling
-        any real inverter has.
+        Writes start first - the battery-side cap on a first probe, the known ceiling on a re-check.
+        If it is refused, steps down SOLIS_SLOT_PROBE_STEP_DOWN_AMPS at a time until one is kept;
+        then steps up 1A at a time until one is refused or upper (the battery-side cap, never
+        exceeded) is reached, so the result is the exact ceiling in whole amps. A first probe whose
+        start is kept is done in one write, and a re-check that finds the ceiling unchanged in two.
+        Returns None - nothing learned - if any write gets no verdict, or if every current down to
+        SOLIS_SLOT_PROBE_MIN_AMPS is refused, which is not a ceiling any real inverter has.
         """
         cid = (SOLIS_CID_CHARGE_CURRENT if direction == "charge" else SOLIS_CID_DISCHARGE_CURRENT)[slot - 1]
         try:
@@ -1385,14 +1398,16 @@ async def attempt(amps):
             return await self.probe_slot_write(inverter_sn, cid, amps, f"probe {direction} slot {slot} current {amps}A")
 
         try:
-            amps = int(expected)
+            upper = int(upper)
+            amps = min(int(start), upper)
             verdict = await attempt(amps)
             if verdict is None:
                 return None
             if verdict:
-                return float(amps)
-            refused = amps
-            while True:
+                refused = upper + 1  # Nothing above the battery-side cap is tried
+            else:
+                refused = amps
+            while not verdict:
                 amps -= SOLIS_SLOT_PROBE_STEP_DOWN_AMPS
                 if amps < SOLIS_SLOT_PROBE_MIN_AMPS:
                     self.log(f"Warn: Solis API: {inverter_sn} refused every {direction} slot current down to {amps + SOLIS_SLOT_PROBE_STEP_DOWN_AMPS}A - not a real ceiling, nothing learned")
@@ -1433,18 +1448,23 @@ async def ensure_slot_current_probed(self, inverter_sn):
             return
         limits = self.slot_current_limits(inverter_sn, include_probed=False)
         if limits["charge_register"] is None or limits["discharge_register"] is None:
-            return  # The expected maximum starts from the registers, so wait until they have been read
+            return  # The probe starts from the registers, so wait until they have been read
         slot = self.find_probe_slot(inverter_sn)
         if slot is None:
             if inverter_sn not in self.slot_probe_no_slot_logged:
                 self.slot_probe_no_slot_logged.add(inverter_sn)
                 self.log(f"Solis API: No disabled slot on {inverter_sn} to probe the slot current ceiling on, keeping the {limits['charge']}A/{limits['discharge']}A caps")
             return
 
-        self.log(f"Solis API: Probing the slot current ceiling on {inverter_sn} using disabled slot {slot}, expecting charge {limits['charge']}A and discharge {limits['discharge']}A")
+        # A first probe starts at the battery-side cap, not the rated estimate, which can be below
+        # what the inverter really takes; a re-check starts at the known ceiling, so an unchanged
+        # one costs two writes rather than a fresh search
+        known = self.slot_current_probed.get(inverter_sn) or {}
+        starts = {direction: known.get(direction, limits[direction + "_battery"]) for direction in ("charge", "discharge")}
+        self.log(f"Solis API: {'Re-checking' if known else 'Probing'} the slot current ceiling on {inverter_sn} using disabled slot {slot}, starting at charge {starts['charge']}A and discharge {starts['discharge']}A (battery limits {limits['charge_battery']}A/{limits['discharge_battery']}A)")
         probed = {}
         for direction in ("charge", "discharge"):
-            ceiling = await self.probe_slot_current_ceiling(inverter_sn, direction, slot, limits[direction])
+            ceiling = await self.probe_slot_current_ceiling(inverter_sn, direction, slot, starts[direction], limits[direction + "_battery"])
             if ceiling is None:
                 kept = self.slot_current_probed.get(inverter_sn)
                 keeping = f", keeping charge {kept['charge']}A, discharge {kept['discharge']}A" if kept else ""
 
@@ -6747,6 +6747,11 @@ def published():
     assert published() == {"slot_charge_power_max": 2880, "slot_discharge_power_max": 2880, "battery_rate_max": 2880, "max_charge_power": 4800}, f"after the probe 60A should apply, got {published()}"
     slider = api.dashboard_items[f"number.{prefix}_solis_{lower}_discharge_slot1_power"]["attributes"]["max"]
     assert slider == 2880, f"the slot power slider should stop at what the slot accepts, got {slider}"
+
+    # A measured ceiling above the rated estimate is what gets planned with
+    api.slot_current_probed[sn] = {"charge": 100.0, "discharge": 90.0, "probed_at": "2026-09-29T20:00:00+00:00"}
+    await api.publish_entities()
+    assert published() == {"slot_charge_power_max": 4800, "slot_discharge_power_max": 4320, "battery_rate_max": 4800, "max_charge_power": 4800}, f"a probed ceiling above the rated 75A should be used, got {published()}"
     print("PASSED: published slot power limits follow the slot current cap")
     return False
 
@@ -6826,7 +6831,7 @@ async def test_slot_probe_finds_exact_ceiling():
     assert probed == {"charge": 60.0, "discharge": 60.0} and probed_at, f"expected 60A both ways with a probe time, got {api.slot_current_probed.get(sn)}"
     discharge_cid = SOLIS_CID_DISCHARGE_CURRENT[5]
     discharge_writes = [value for cid, value in inverter.writes if cid == discharge_cid]
-    assert discharge_writes == ["75", "70", "65", "60", "61", "50"], f"expected 75 (rated), down 5 to 60, up to 61, then restore 50; got {discharge_writes}"
+    assert discharge_writes == ["100", "95", "90", "85", "80", "75", "70", "65", "60", "61", "50"], f"expected 100 (the battery limit), down 5 to 60, up to 61, then restore 50; got {discharge_writes}"
     assert {cid for cid, _ in inverter.writes} == {SOLIS_CID_CHARGE_CURRENT[5], discharge_cid}, f"only disabled slot 6 may be written, got {inverter.writes}"
     assert inverter.registers[discharge_cid] == "50" and inverter.registers[SOLIS_CID_CHARGE_CURRENT[5]] == "50", "slot 6 must be restored in both directions"
     assert storage.contents.get(("solis", "slot_current_limits")) == {sn: {"charge": 60.0, "discharge": 60.0, "probed_at": probed_at}}, f"the ceiling should be saved, got {storage.contents}"
@@ -6836,22 +6841,30 @@ async def test_slot_probe_finds_exact_ceiling():
     assert (limits["charge"], limits["discharge"]) == (60.0, 60.0), f"slot writes should be capped at 60A, got {limits}"
     text = api.describe_slot_current_limits(sn, limits)
     assert "charge 60.0A from the probed ceiling (register 100A, no slot metadata max, probed max 60.0A)" in text, f"the limits line should say the probed ceiling set the cap: {text}"
-    assert "from the rated current" not in text, f"the rated 75A must not read as the cap once the probe has lowered it: {text}"
+    assert "from the rated current" not in text and "not used once probed" in text, f"the rated 75A must not read as the cap once probed: {text}"
     assert any("probe discharge slot 6 current 61A on SN0PROBE: refused, still 60" in m for m in api.log_messages), "each refusal should be logged with the value kept"
     assert any("probe discharge slot 6 current 60A on SN0PROBE: kept" in m for m in api.log_messages), "each accepted value should be logged"
     print("PASSED: slot probe finds the exact ceiling")
     return False
 
 
 async def test_slot_probe_expected_maximum_accepted():
-    """When the inverter keeps the expected maximum, that is the ceiling - one write each way plus the restore."""
-    print("\n=== Test: slot probe keeps an accepted expected maximum ===")
+    """When the inverter keeps its battery limit, that is the ceiling - and it replaces a lower rated estimate.
+
+    An 8kW hybrid reading 180A is rated for only 156A at 51.2V, yet takes 180A (charging from PV
+    above the AC rating); the rated estimate must not hold it below what was measured. One write
+    each way plus the restore.
+    """
+    print("\n=== Test: slot probe keeps an accepted battery limit ===")
     api, sn = _probe_api(storage=_FakeStorage())
     inverter = _ProbeInverter(api, ceiling=100)
+    assert api.slot_current_limits(sn)["discharge"] == 75.0, "before probing, the 75A rated estimate should apply"
     await api.ensure_slot_current_probed(sn)
-    assert (api.slot_current_probed[sn]["charge"], api.slot_current_probed[sn]["discharge"]) == (75.0, 75.0), f"expected the 75A rated cap to stand, got {api.slot_current_probed.get(sn)}"
+    assert (api.slot_current_probed[sn]["charge"], api.slot_current_probed[sn]["discharge"]) == (100.0, 100.0), f"expected the 100A battery limit to be kept, got {api.slot_current_probed.get(sn)}"
     assert len(inverter.writes) == 4, f"expected one probe write and one restore per direction, got {inverter.writes}"
-    print("PASSED: slot probe keeps an accepted expected maximum")
+    limits = api.slot_current_limits(sn)
+    assert (limits["charge"], limits["discharge"]) == (100.0, 100.0) and not limits["rated_capped"], f"a measured ceiling above the rated estimate should replace it, got {limits}"
+    print("PASSED: slot probe keeps an accepted battery limit")
     return False
 
 
@@ -6903,6 +6916,17 @@ async def test_slot_probe_reloaded_not_repeated():
     limits = api.slot_current_limits(sn)
     assert (limits["charge"], limits["discharge"]) == (60.0, 58.0), f"the saved ceilings should cap the slots, got {limits}"
 
+    # A day old with the ceiling unchanged: the re-check starts at the known ceiling, so it costs two writes and the restore
+    unchanged = {"SN0PROBE": {"charge": 60, "discharge": 60, "probed_at": (now - timedelta(hours=25)).isoformat()}}
+    api, sn = _probe_api(storage=_FakeStorage({("solis", "slot_current_limits"): unchanged}))
+    api._test_now_utc_exact = now
+    inverter = _ProbeInverter(api, ceiling=60)
+    await api.load_slot_current_probes()
+    await api.ensure_slot_current_probed(sn)
+    discharge_writes = [value for cid, value in inverter.writes if cid == SOLIS_CID_DISCHARGE_CURRENT[5]]
+    assert discharge_writes == ["60", "61", "50"], f"an unchanged re-check should write the ceiling, one above, then restore; got {discharge_writes}"
+    assert api.slot_current_probed[sn]["probed_at"] == now.isoformat(), "the re-check should refresh the probe time"
+
     # A day old: checked again, and the fresh result replaces it
     stale = {"SN0PROBE": {"charge": 60, "discharge": 58, "probed_at": (now - timedelta(hours=25)).isoformat()}}
     storage = _FakeStorage({("solis", "slot_current_limits"): stale})
 
@@ -845,7 +845,7 @@ When `automatic: true` (recommended), Predbat will automatically create and conf
 
 No manual entity configuration is required when using automatic mode.
 
-Automatic mode plans each direction at the most a charge or discharge slot can actually be set to. That is the lowest of the inverter's maximum charge or discharge current, the current it can deliver at its rated power, and a ceiling Predbat measures itself. Some inverters refuse slot currents well below the maximum current they report, with no way to read the real limit. For example, a 3.6kW inverter reports 100A but only accepts 60A. When Predbat first sees an inverter, it measures this ceiling by writing test currents to one of slots 2-6 that is not in use, and puts back the value that slot held. It saves the result, and checks it again at most once a day. Predbat only uses slot 1 itself, so the test does not touch the schedule. The results are published as `sensor.predbat_solis_<serial>_slot_charge_power_max` and `..._slot_discharge_power_max`, and used for `inverter_limit_charge` and `inverter_limit_discharge`. `battery_rate_max` is set to the larger of the two, so a battery allowed to discharge faster than it charges is planned at both rates. An `inverter_limit_charge` or `inverter_limit_discharge` you set in `apps.yaml` takes precedence - use it to state a lower limit such as your inverter's AC rating.
+Automatic mode plans each direction at the most a charge or discharge slot can actually be set to. Some inverters refuse slot currents well below the maximum current they report, with no way to read the real limit. For example, a 3.6kW inverter reports 100A but only accepts 60A. So when Predbat first sees an inverter, it measures the ceiling itself. It writes test currents to one of slots 2-6 that is not in use: first the inverter's reported maximum charge or discharge current, then lower values until one is accepted. It then puts back the value that slot held. It saves the result, and checks it again at most once a day, starting from the saved value. Until an inverter has been measured, the current it can deliver at its rated power is used as an estimate. Once measured, the measured ceiling replaces that estimate, so a hybrid that can charge from PV above its AC rating is not held back. Predbat only uses slot 1 itself, so the test does not touch the schedule. The results are published as `sensor.predbat_solis_<serial>_slot_charge_power_max` and `..._slot_discharge_power_max`, and used for `inverter_limit_charge` and `inverter_limit_discharge`. `battery_rate_max` is set to the larger of the two, so a battery allowed to discharge faster than it charges is planned at both rates. An `inverter_limit_charge` or `inverter_limit_discharge` you set in `apps.yaml` takes precedence - use it to state a lower limit such as your inverter's AC rating.
 
 #### Manual configuration (solis_automatic: false)