feat: implement thread events, webhooks, voice management, and entity selects

- Inbound thread events: ThreadCreated/Updated/Deleted/MemberAdd/MemberRemove
  published via 5 new bridge methods + 4 serenity EventHandler impls
- Outbound commands: CreateWebhookCommand, ExecuteWebhookCommand,
  DeleteWebhookCommand, VoiceMoveCommand, VoiceDisconnectCommand
- ActionRowComponent: UserSelect, RoleSelect, ChannelSelect variants
  with full serenity CreateSelectMenuKind wiring in build_action_rows
- 10 new NATS subjects (bot::thread_* + agent::webhook_* / agent::voice_*)
- 280 tests passing

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jramirezhdez02

rsworkspace/crates/discord-bot/src/bridge.rs

@@ -977,6 +977,117 @@ impl DiscordBridge {
         debug!("Published bot_ready to {}", subject);
         Ok(())
     }
+
+    pub async fn publish_thread_created(&self, thread: &GuildChannel) -> Result<()> {
+        let meta = EventMetadata::new(
+            format!("dc-guild-{}", thread.guild_id.get()),
+            self.next_sequence(),
+        );
+        let tm = thread.thread_metadata.as_ref();
+        let ev = ThreadCreatedEvent {
+            metadata: meta,
+            thread_id: thread.id.get(),
+            guild_id: thread.guild_id.get(),
+            parent_id: thread.parent_id.map(|id| id.get()).unwrap_or(0),
+            name: thread.name.clone(),
+            archived: tm.map(|m| m.archived).unwrap_or(false),
+            locked: tm.map(|m| m.locked).unwrap_or(false),
+            auto_archive_duration: tm
+                .map(|m| u16::from(m.auto_archive_duration) as u64)
+                .unwrap_or(0),
+        };
+        let subject = subjects::bot::thread_created(self.prefix());
+        self.publisher.publish(&subject, &ev).await?;
+        debug!("Published thread_created to {}", subject);
+        Ok(())
+    }
+
+    pub async fn publish_thread_updated(&self, thread: &GuildChannel) -> Result<()> {
+        let meta = EventMetadata::new(
+            format!("dc-guild-{}", thread.guild_id.get()),
+            self.next_sequence(),
+        );
+        let tm = thread.thread_metadata.as_ref();
+        let ev = ThreadUpdatedEvent {
+            metadata: meta,
+            thread_id: thread.id.get(),
+            guild_id: thread.guild_id.get(),
+            parent_id: thread.parent_id.map(|id| id.get()).unwrap_or(0),
+            name: thread.name.clone(),
+            archived: tm.map(|m| m.archived).unwrap_or(false),
+            locked: tm.map(|m| m.locked).unwrap_or(false),
+        };
+        let subject = subjects::bot::thread_updated(self.prefix());
+        self.publisher.publish(&subject, &ev).await?;
+        debug!("Published thread_updated to {}", subject);
+        Ok(())
+    }
+
+    pub async fn publish_thread_deleted(
+        &self,
+        thread_id: u64,
+        guild_id: u64,
+        parent_id: Option<u64>,
+    ) -> Result<()> {
+        let meta = EventMetadata::new(
+            format!("dc-guild-{}", guild_id),
+            self.next_sequence(),
+        );
+        let ev = ThreadDeletedEvent {
+            metadata: meta,
+            thread_id,
+            guild_id,
+            parent_id,
+        };
+        let subject = subjects::bot::thread_deleted(self.prefix());
+        self.publisher.publish(&subject, &ev).await?;
+        debug!("Published thread_deleted to {}", subject);
+        Ok(())
+    }
+
+    pub async fn publish_thread_member_add(
+        &self,
+        thread_id: u64,
+        guild_id: u64,
+        user_ids: Vec<u64>,
+    ) -> Result<()> {
+        let meta = EventMetadata::new(
+            format!("dc-guild-{}", guild_id),
+            self.next_sequence(),
+        );
+        let ev = ThreadMemberAddEvent {
+            metadata: meta,
+            thread_id,
+            guild_id,
+            user_ids,
+        };
+        let subject = subjects::bot::thread_member_add(self.prefix());
+        self.publisher.publish(&subject, &ev).await?;
+        debug!("Published thread_member_add to {}", subject);
+        Ok(())
+    }
+
+    pub async fn publish_thread_member_remove(
+        &self,
+        thread_id: u64,
+        guild_id: u64,
+        user_ids: Vec<u64>,
+    ) -> Result<()> {
+        let meta = EventMetadata::new(
+            format!("dc-guild-{}", guild_id),
+            self.next_sequence(),
+        );
+        let ev = ThreadMemberRemoveEvent {
+            metadata: meta,
+            thread_id,
+            guild_id,
+            user_ids,
+        };
+        let subject = subjects::bot::thread_member_remove(self.prefix());
+        self.publisher.publish(&subject, &ev).await?;
+        debug!("Published thread_member_remove to {}", subject);
+        Ok(())
+    }
 }
 
 fn convert_reaction_type(reaction: &ReactionType) -> Emoji {

rsworkspace/crates/discord-bot/src/handlers/mod.rs

@@ -618,4 +618,107 @@ impl EventHandler for Handler {
             error!("failed to publish guild_member_update: {e}");
         }
     }
+
+    async fn thread_create(&self, ctx: Context, thread: GuildChannel) {
+        let bridge = {
+            let data = ctx.data.read().await;
+            match data.get::<DiscordBridge>() {
+                Some(b) => b.clone(),
+                None => return,
+            }
+        };
+        if !bridge.check_guild_access(thread.guild_id.get()) {
+            return;
+        }
+        if let Err(e) = bridge.publish_thread_created(&thread).await {
+            error!("Failed to publish thread_created: {}", e);
+        }
+    }
+
+    async fn thread_update(&self, ctx: Context, _old: Option<GuildChannel>, new: GuildChannel) {
+        let bridge = {
+            let data = ctx.data.read().await;
+            match data.get::<DiscordBridge>() {
+                Some(b) => b.clone(),
+                None => return,
+            }
+        };
+        if !bridge.check_guild_access(new.guild_id.get()) {
+            return;
+        }
+        if let Err(e) = bridge.publish_thread_updated(&new).await {
+            error!("Failed to publish thread_updated: {}", e);
+        }
+    }
+
+    async fn thread_delete(
+        &self,
+        ctx: Context,
+        thread: serenity::model::channel::PartialGuildChannel,
+        _full: Option<GuildChannel>,
+    ) {
+        let bridge = {
+            let data = ctx.data.read().await;
+            match data.get::<DiscordBridge>() {
+                Some(b) => b.clone(),
+                None => return,
+            }
+        };
+        let guild_id = thread.guild_id.get();
+        if !bridge.check_guild_access(guild_id) {
+            return;
+        }
+        let parent_id = Some(thread.parent_id.get());
+        if let Err(e) = bridge
+            .publish_thread_deleted(thread.id.get(), guild_id, parent_id)
+            .await
+        {
+            error!("Failed to publish thread_deleted: {}", e);
+        }
+    }
+
+    async fn thread_members_update(
+        &self,
+        ctx: Context,
+        event: serenity::model::event::ThreadMembersUpdateEvent,
+    ) {
+        let bridge = {
+            let data = ctx.data.read().await;
+            match data.get::<DiscordBridge>() {
+                Some(b) => b.clone(),
+                None => return,
+            }
+        };
+        let guild_id = event.guild_id.get();
+        if !bridge.check_guild_access(guild_id) {
+            return;
+        }
+        let thread_id = event.id.get();
+
+        // Publish member additions
+        let added: Vec<u64> = event
+            .added_members
+            .iter()
+            .map(|m| m.user_id.get())
+            .collect();
+        if !added.is_empty() {
+            if let Err(e) = bridge
+                .publish_thread_member_add(thread_id, guild_id, added)
+                .await
+            {
+                error!("Failed to publish thread_member_add: {}", e);
+            }
+        }
+
+        // Publish member removals
+        let removed: Vec<u64> = event.removed_member_ids.iter().map(|id| id.get()).collect();
+        if !removed.is_empty() {
+            if let Err(e) = bridge
+                .publish_thread_member_remove(thread_id, guild_id, removed)
+                .await
+            {
+                error!("Failed to publish thread_member_remove: {}", e);
+            }
+        }
+    }
 }