@@ -1975,7 +1975,7 @@ async def _send_control(self, entity_id, command, **kwargs):
             if not same:
                 entry = {"command_ids": [], "outcomes": {}, "command": command, "kwargs": dict(kwargs), "state": "sent", "sent_at": now, "resent": False, "cached": None, "cached_ids": [], "attempt_ids": [], "acks": 0}
                 self._pending_commands[entity_id] = entry
-            previous = {"command_ids": list(entry["command_ids"]), "attempt_ids": list(entry["attempt_ids"]), "outcomes": dict(entry["outcomes"]), "state": entry["state"], "sent_at": entry["sent_at"], "resent": entry["resent"], "cached": entry["cached"]}
+            previous = {"attempt_ids": list(entry["attempt_ids"]), "state": entry["state"], "sent_at": entry["sent_at"], "resent": entry["resent"], "cached": entry["cached"]}
             if entry["state"] != "sent":
                 # A fresh attempt after the previous one was answered. Earlier ids and their
                 # outcomes stay, so a late ack from another unit is still logged and acted on and
@@ -1985,10 +1985,10 @@ async def _send_control(self, entity_id, command, **kwargs):
                 entry["resent"] = True  # the one re-send after an unanswered window
             command_id = self._command_id = self._command_id + 1
             command_ref = f"PBAT{command_id}"
-            # Earlier ids of the same value stay matchable: an ack for any of them confirms it
-            entry["command_ids"] = entry["command_ids"][-(_COMMAND_ACK_IDS_KEPT - 1) :] + [command_ref]
-            entry["outcomes"] = {key: value for key, value in entry["outcomes"].items() if key in entry["command_ids"]}
-            entry["attempt_ids"] = [ref for ref in entry["attempt_ids"] if ref in entry["command_ids"]] + [command_ref]
+            # Earlier ids of the same value stay matchable: an ack for any of them confirms it.
+            # The oldest id is only pruned once this send has gone out (see below).
+            entry["command_ids"] = entry["command_ids"] + [command_ref]
+            entry["attempt_ids"] = entry["attempt_ids"] + [command_ref]
             entry["sent_at"] = now
             acks_before = entry["acks"]
 
@@ -2001,17 +2001,23 @@ async def _send_control(self, entity_id, command, **kwargs):
                 # An ack for this id may already have arrived while the publish was awaiting its
                 # broker confirmation: then the command did reach the hub, so keep it
                 if self._pending_commands.get(entity_id) is entry and command_ref in entry["command_ids"] and command_ref not in entry["outcomes"]:
-                    if not previous["command_ids"]:
+                    entry["command_ids"].remove(command_ref)
+                    entry["attempt_ids"].remove(command_ref)
+                    if not entry["command_ids"]:
                         del self._pending_commands[entity_id]
                     elif entry["acks"] == acks_before:
-                        # No ack arrived meanwhile: back to how the earlier attempt left it,
-                        # including any id pruned to make room for this one
+                        # No ack arrived meanwhile: back to how the earlier attempt left it
                         entry.update(previous)
-                    else:
-                        entry["command_ids"].remove(command_ref)
-                        entry["attempt_ids"].remove(command_ref)
             raise
 
+        with self._command_lock:
+            # Keep the id history bounded now that this send is out
+            if self._pending_commands.get(entity_id) is entry and len(entry["command_ids"]) > _COMMAND_ACK_IDS_KEPT:
+                entry["command_ids"] = entry["command_ids"][-_COMMAND_ACK_IDS_KEPT:]
+                entry["outcomes"] = {key: value for key, value in entry["outcomes"].items() if key in entry["command_ids"]}
+                entry["attempt_ids"] = [ref for ref in entry["attempt_ids"] if ref in entry["command_ids"]]
+                entry["cached_ids"] = [ref for ref in entry["cached_ids"] if ref in entry["command_ids"]]
+
     def _process_ack(self, data):
         """Handle a command ack from the hub.
 
 
@@ -5266,6 +5266,33 @@ async def refusal_then_fail(command, command_id=None, **kwargs):
             self._run(gw.number_event(self.CHARGE_RATE, 2000))
         assert len(gw._published) == 1
 
+    def test_full_history_failing_publish_with_concurrent_ack_keeps_all_earlier_ids(self):
+        """16 ids kept, a 17th send fails while an ack for PBAT2 arrives: PBAT1..PBAT16 all stay matchable."""
+        gw = self._make_gateway(acks_seen=False)
+        clock, patcher = self._clock()
+        with patcher:
+            for step in range(16):
+                clock["now"] = 1000.0 + step * 2
+                self._run(gw.number_event(self.CHARGE_RATE, 2000))
+
+            async def ack_other_then_fail(command, command_id=None, **kwargs):
+                self._ack(gw, "PBAT2", "set_charge_rate", ok=False, error="not_managed")
+                self._ack(gw, "PBAT1", "set_charge_rate", ok=False, error="modbus_write_failed")
+                raise RuntimeError("broker gone")
+
+            real_publish = gw.publish_command
+            gw.publish_command = ack_other_then_fail
+            clock["now"] = 1100.0
+            try:
+                self._run(gw.number_event(self.CHARGE_RATE, 2000))
+            except RuntimeError:
+                pass
+            gw.publish_command = real_publish
+        entry = gw._pending_commands[self.CHARGE_RATE]
+        assert entry["command_ids"] == [f"PBAT{n}" for n in range(1, 17)]
+        assert entry["outcomes"] == {"PBAT2": "refused", "PBAT1": "refused"}
+        assert self._logged(gw, "refused by hub: modbus_write_failed")
+
     def test_outcomes_do_not_grow_past_the_kept_ids(self):
         """Per-id outcomes are pruned with the ids, so a value re-sent for a long time does not grow the entry."""
         gw = self._make_gateway()