Host._send_command does not release command_semaphore on timeout, causing subsequent commands to hang

Start at Host._send_command and run the reproduction script from the issue to observe the timeout and the subsequent command hang. Trace the finally-block semaphore handling, then add or update coverage for a timed-out command followed by another command. Done means the second command no longer blocks indefinitely after the first timeout.

When Host._send_command times out waiting for an HCI response, the command_semaphore is never released. Every subsequent call to _send_command then blocks indefinitely at await self.command_semaphore.acquire(), making the host permanently unresponsive with no error or exception.

The release in the finally block is gated on response is not None. On a timeout, response remains None, so the semaphore is never released:

response = None
try:
    ...
    response = await asyncio.wait_for(self.pending_response, timeout=response_timeout)
    return response
finally:
    if (
        response is not None          # <-- None on timeout
        and response.num_hci_command_packets
        and self.command_semaphore.locked()
    ):
        self.command_semaphore.release()  # <-- never reached

I'm wondering if this is intentional, to perhaps indicate that the controller is unresponsive/pending? The controller I'm using definitely isn't the most reliable (Raspberry Pi 3B+), but I'm not sure how to detect / recover from this, other than wrapping all bumble calls in a timeout.

There was about 3 minutes between when I issued the command that timed out (!!! Command HCI_LE_CLEAR_FILTER_ACCEPT_LIST_COMMAND timed out) to when I tried issuing the next command.

I haven't been able to capture any proper logs of this happening on real hardware, but this script reproduces what I've seen (reproduction code generated with Claude).

import asyncio

from bumble import hci
from bumble.controller import Controller
from bumble.device import Device
from bumble.host import Host
from bumble.link import LocalLink
from bumble.transport.common import AsyncPipeSink

def make_device() -> Device:
    link = LocalLink()
    controller = Controller("test-controller", link=link)
    device = Device(host=Host())
    device.host.set_packet_sink(controller)
    controller.host = AsyncPipeSink(device.host)
    return device

async def main():
    device = make_device()
    await device.power_on()

    print("Step 1: Send a command with a near-zero timeout to force a timeout...")
    try:
        await device.host._send_command(
            hci.HCI_LE_Clear_Filter_Accept_List_Command(),
            response_timeout=0.00001,
        )
    except TimeoutError:
        print("  -> Timed out as expected.")

    print("Step 2: Send a normal command — hangs forever if semaphore was leaked...")
    try:
        await asyncio.wait_for(
            device.host._send_command(
                hci.HCI_LE_Clear_Filter_Accept_List_Command(),
            ),
            timeout=3.0,
        )
        print("  -> Completed (bug is fixed).")
    except asyncio.TimeoutError:
        print(
            "  -> HUNG for 3 seconds and timed out: semaphore was leaked. Bug confirmed."
        )

asyncio.run(main())