refactor: prefix private data members with m_

Rename all trailing-underscore private data members to the m_ prefix
required by AGENTS.md, across the auth, crypto, gip, mt76, and usb
transport classes plus the app session classes. Pure rename; no
behavior change. Full build and test suite pass.

Co-Authored-By: qwen3.8-27b@q3_k_xl: renamed members to m_ prefix

include/auth/auth.hpp

@@ -79,15 +79,15 @@ private:
     auto handle_pubkey(std::span<u8 const> data) -> int;
     auto get_transcript() -> std::array<u8, k_transcript_len>;
 
-    auth_sink& sink_;
-    sha256 transcript_;
-    u8 last_sent_command_ = 0;
+    auth_sink& m_sink;
+    sha256 m_transcript;
+    u8 m_last_sent_command = 0;
 
-    std::array<u8, k_random_len> random_host_{};
-    std::array<u8, k_random_len> random_client_{};
-    std::array<u8, k_pubkey_len> pubkey_client_{};
-    std::array<u8, k_pubkey2_len> pubkey_client2_{};
-    std::array<u8, k_secret_len> master_secret_{};
+    std::array<u8, k_random_len> m_random_host{};
+    std::array<u8, k_random_len> m_random_client{};
+    std::array<u8, k_pubkey_len> m_pubkey_client{};
+    std::array<u8, k_pubkey2_len> m_pubkey_client2{};
+    std::array<u8, k_secret_len> m_master_secret{};
 
     enum class deferred_action {
         none,
@@ -95,7 +95,7 @@ private:
         exchange_ecdh,
         complete,
     };
-    deferred_action deferred_action_ = deferred_action::none;
+    deferred_action m_deferred_action = deferred_action::none;
 };
 
 } // namespace xone::auth

include/auth/crypto.hpp

@@ -48,7 +48,7 @@ public:
     auto finalize(std::array<u8, k_sha256_len>& out) -> void;
 
 private:
-    CC_SHA256_CTX ctx_;
+    CC_SHA256_CTX m_ctx;
 };
 
 // --------------------------------------------------------------------------
@@ -62,8 +62,8 @@ public:
     auto finalize(std::array<u8, k_sha256_len>& out) -> void;
 
 private:
-    sha256 inner_;
-    sha256 outer_;
+    sha256 m_inner;
+    sha256 m_outer;
 };
 
 // --------------------------------------------------------------------------

include/gip/protocol.hpp

@@ -164,11 +164,11 @@ class client : public xone::auth::auth_sink {
 public:
     client(adapter& adapter, u8 id);
 
-    auto id() const -> u8 { return id_; }
-    auto hardware() const -> gip_hardware const& { return hardware_; }
-    auto audio_config_in() const -> gip_audio_config const& { return audio_config_in_; }
-    auto audio_config_out() const -> gip_audio_config const& { return audio_config_out_; }
-    auto classes() const -> std::vector<std::string> const& { return classes_; }
+    auto id() const -> u8 { return m_id; }
+    auto hardware() const -> gip_hardware const& { return m_hardware; }
+    auto audio_config_in() const -> gip_audio_config const& { return m_audio_config_in; }
+    auto audio_config_out() const -> gip_audio_config const& { return m_audio_config_out; }
+    auto classes() const -> std::vector<std::string> const& { return m_classes; }
 
     auto has_interface(xone::guid_t const& guid) const -> bool;
 
@@ -187,35 +187,35 @@ public:
     auto send(std::span<u8 const> pkt, bool acknowledge) -> int override;
     auto set_encryption_key(std::span<u8 const> key) -> int override;
 
-    auto start_auth() -> int { return auth_.start(); }
+    auto start_auth() -> int { return m_auth.start(); }
     auto process_auth(std::span<u8 const> data) -> int
     {
-        return auth_.process_pkt(data);
+        return m_auth.process_pkt(data);
     }
 
 private:
     friend class adapter;
 
-    adapter& adapter_;
-    u8 id_;
-    gip_hardware hardware_{};
+    adapter& m_adapter;
+    u8 m_id;
+    gip_hardware m_hardware{};
 
     struct info_element {
         u8 count = 0;
         std::vector<u8> data;
     };
 
-    std::unique_ptr<info_element> client_commands_;
-    std::unique_ptr<info_element> firmware_versions_;
-    std::unique_ptr<info_element> audio_formats_;
-    std::unique_ptr<info_element> capabilities_out_;
-    std::unique_ptr<info_element> capabilities_in_;
-    std::vector<std::string> classes_;
-    std::unique_ptr<info_element> interfaces_;
-    std::unique_ptr<info_element> hid_descriptor_;
+    std::unique_ptr<info_element> m_client_commands;
+    std::unique_ptr<info_element> m_firmware_versions;
+    std::unique_ptr<info_element> m_audio_formats;
+    std::unique_ptr<info_element> m_capabilities_out;
+    std::unique_ptr<info_element> m_capabilities_in;
+    std::vector<std::string> m_classes;
+    std::unique_ptr<info_element> m_interfaces;
+    std::unique_ptr<info_element> m_hid_descriptor;
 
-    gip_audio_config audio_config_in_;
-    gip_audio_config audio_config_out_;
+    gip_audio_config m_audio_config_in;
+    gip_audio_config m_audio_config_out;
 
     // Chunk reassembly buffers (large packets are split into chunks).
     struct chunk_buffer {
@@ -223,10 +223,10 @@ private:
         u32 length = 0;
         std::vector<u8> data;
     };
-    std::unique_ptr<chunk_buffer> chunk_buf_out_;
-    std::unique_ptr<chunk_buffer> chunk_buf_in_;
+    std::unique_ptr<chunk_buffer> m_chunk_buf_out;
+    std::unique_ptr<chunk_buffer> m_chunk_buf_in;
 
-    xone::auth::auth auth_{*this};
+    xone::auth::auth m_auth{*this};
 };
 
 class adapter {
@@ -288,13 +288,13 @@ private:
     auto parse_hid_descriptor(client& c, u16 const offsets[8],
                               std::span<u8 const> data) -> int;
 
-    transport& transport_;
-    client_listener& listener_;
-    int audio_packet_count_;
+    transport& m_transport;
+    client_listener& m_listener;
+    int m_audio_packet_count;
 
-    std::array<std::unique_ptr<client>, k_max_clients> clients_;
-    u8 data_sequence_ = 0;
-    u8 audio_sequence_ = 0;
+    std::array<std::unique_ptr<client>, k_max_clients> m_clients;
+    u8 m_data_sequence = 0;
+    u8 m_audio_sequence = 0;
 };
 
 } // namespace xone::gip

include/mt76/mt76.hpp

@@ -137,10 +137,10 @@ private:
     auto write_beacon(bool pair) -> int;
     auto set_channel_candidates() -> int;
 
-    usb::transport &transport_;
+    usb::transport &m_transport;
     char build_time_[17] = {};
-    std::array<channel, num_channels> channels_{};
-    channel current_channel_{};
+    std::array<channel, num_channels> m_channels{};
+    channel m_current_channel{};
 };
 
 } // namespace xone::mt76

include/usb/usb_transport.hpp

@@ -125,7 +125,7 @@ private:
     static void on_read_completion(void *refcon, std::int32_t result, void *arg0);
     static void on_dongle_terminated(void *refcon, std::uint32_t iter);
 
-    std::unique_ptr<state> state_;
+    std::unique_ptr<state> m_state;
 };
 
 // TRUE if an Xbox Wireless Dongle is connected (any supported PID).