In `@backends/advanced/src/advanced_omi_backend/client.py`:
- Around line 54-55: The timeout path can race with websocket_controller
finalization because start_new_conversation() is scheduled via
asyncio.create_task() and close_current_conversation() is legacy and doesn't
clear markers; update start_new_conversation() to explicitly clear markers
before resetting conversation state (call self.markers.clear() or
client_state.markers.clear() as appropriate) so any leftover markers from the
previous conversation are removed even if websocket_controller finalization
hasn't run, leaving the rest of the reset (current_audio_uuid, conversation IDs,
etc.) unchanged.

In `@backends/advanced/src/advanced_omi_backend/workers/conversation_jobs.py`:
- Around line 307-316: The block reading markers uses session_key before it's
defined, causing a NameError; move or compute session_key =
f"audio:session:{session_id}" so it is defined before the
redis_client.hget(session_key, "markers") call (session_id is the identifier to
use), then assign conversation.markers from json.loads(markers_data) and save as
before; also narrow the except to catch json.JSONDecodeError and
UnicodeDecodeError (instead of broad Exception) around the json.loads/decoding
step to avoid swallowing unrelated errors.

In `@extras/friend-lite-sdk/friend_lite/bluetooth.py`:
- Around line 28-39: The connect method assigns self._client before awaiting
self._client.connect(), so if BleakClient.connect() raises the instance is left
with a non-None _client and future connect() calls are blocked; update
OmiConnection.connect to catch exceptions from await self._client.connect(), and
on any failure reset self._client to None (and optionally clear/set any related
state like self._disconnected) before re-raising the exception so the instance
can retry connecting later; look for the connect function, the _on_disconnect
callback, and usages of self._client / BleakClient to implement this change.

In `@extras/friend-lite-sdk/friend_lite/discover_characteristics.py`:
- Line 19: The module currently calls asyncio.run(main()) at import time which
triggers BLE connection; wrap that call in a standard module guard so that
main() only runs when executed as a script. Locate the top-level
asyncio.run(main()) invocation (and the async def main function) and move or
replace the bare call with a guarded call using if __name__ == "__main__": so
importing friend_lite.discover_characteristics no longer executes the BLE logic.
- Line 4: The file currently hardcodes a device MAC in the constant OMI_MAC;
remove that literal and change the script in discover_characteristics.py to
accept the device address via a CLI argument (e.g., argparse) or an environment
variable (e.g., FRIEND_DEVICE_MAC) with the CLI taking precedence, validate the
address format before use, and update any calls/usage/help text to reflect the
new parameter so no real device identifiers remain in source.

In `@extras/friend-lite-sdk/friend_lite/transcribe.py`:
- Around line 153-157: The logger.debug call uses an unnecessary f-string prefix
in the block that sends AudioStop when segment_has_audio is true; remove the
extra "f" so the call is logger.debug("Wyoming: Sending AudioStop...") in the
same conditional where AudioStop().event() is written to the client (see
references: segment_has_audio, logger.debug, client.write_event,
AudioStop().event()).
- Around line 96-100: The connection creation and connect call are outside the
try so connection failures bypass error handling and cleanup; move the
AsyncClient.from_uri(wyoming_url) and await client.connect() into the existing
try block that contains the subsequent logic (the try that currently starts
before the main processing and has the except handlers and finally cleanup),
ensuring any exceptions from AsyncClient.from_uri or client.connect are caught
by the existing except clauses and that the finally block still runs to
close/cleanup the client and call logger as appropriate.

In `@extras/local-omi-bt/connect-omi.py`:
- Around line 212-219: The async with OmiConnection(...) block never exits
because asyncio.gather(conn.wait_until_disconnected(), process_audio(),
backend_stream_wrapper()) never completes, preventing OmiConnection.__aexit__ /
disconnect() from running; fix by creating separate tasks for process_audio()
and backend_stream_wrapper() (e.g., via asyncio.create_task), await
conn.wait_until_disconnected(), then cancel and await those background tasks
before leaving the async with so that __aexit__/disconnect() runs and resources
are cleaned up; reference OmiConnection, wait_until_disconnected, process_audio,
backend_stream_wrapper, handle_ble_data, handle_button_event, __aexit__, and
disconnect when making the changes.
- Around line 74-78: The fire-and-forget call to
loop.create_task(send_button_event(state.name)) loses exceptions; change the
block to capture the created Task (e.g., task = loop.create_task(...)) and
attach a done callback that logs exceptions from task.exception() using the
existing logger so errors are not silently dropped; keep the RuntimeError except
handling for no running loop and ensure the callback checks for cancelled/None
exceptions before logging.
- Around line 215-219: Gathering wait_until_disconnected(), process_audio(), and
backend_stream_wrapper() with asyncio.gather hangs because the latter two are
infinite queue.get() loops; change to explicit task management: create tasks for
process_audio() and backend_stream_wrapper() via asyncio.create_task, await
conn.wait_until_disconnected(), then cancel the remaining tasks (task.cancel()),
and await them with return_exceptions=True while handling asyncio.CancelledError
inside those coroutines (or catching it when awaiting) to ensure clean shutdown;
update the block referencing wait_until_disconnected, process_audio, and
backend_stream_wrapper to use try/finally to perform cancellations and cleanup.

In `@extras/local-omi-bt/send_to_adv.py`:
- Around line 39-55: The send_button_event function can raise an unhandled
ConnectionClosed if _active_websocket closes after the None check; wrap the
await _active_websocket.send(...) call in a try/except that catches the
websocket connection closed error (e.g., websockets.exceptions.ConnectionClosed
or the relevant library exception) inside send_button_event, log the failure
with logger.debug/logger.info including the button_state and the exception, and
return gracefully so the exception doesn't propagate to callers.