refactor(bot_turns): extract TurnAction helper + fix MultibotMentions gating

Addresses PR openabdev#487 review comments:

1. (bug) src/slack.rs MultibotMentions arm did `if other_bot { continue; }`
   without checking `mentions_bot` — logic didn't match the 'requiring
   @mention' debug message and could diverge from Discord parity.

2. (nit) The ~50-line `match tracker.on_bot_message(..) { TurnResult::.. }`
   block was duplicated in src/discord.rs and src/slack.rs. Extracted into
   `BotTurnTracker::classify_bot_message` returning a new `TurnAction` enum
   so adapters collapse to a 4-arm match. Severity hint keeps info! (soft)
   vs warn! (hard) log levels at the call site. Added 4 unit tests for the
   new helper.

Author: dogzzdogzz

src/bot_turns.rs

@@ -60,6 +60,59 @@ impl BotTurnTracker {
             *hard = 0;
         }
     }
+
+    /// High-level decision for a bot message: increments the counter and
+    /// returns what the adapter should do. Collapses the warn-once semantics
+    /// and user-facing message formatting so Discord/Slack (and future adapters)
+    /// don't duplicate the match.
+    pub fn classify_bot_message(&mut self, thread_id: &str) -> TurnAction {
+        match self.on_bot_message(thread_id) {
+            TurnResult::Ok => TurnAction::Continue,
+            TurnResult::SoftLimit(n) => TurnAction::WarnAndStop {
+                severity: TurnSeverity::Soft,
+                user_message: format!(
+                    "⚠️ Bot turn limit reached ({n}/{soft}). \
+                     A human must reply in this thread to continue bot-to-bot conversation.",
+                    soft = self.soft_limit,
+                ),
+            },
+            TurnResult::HardLimit => TurnAction::WarnAndStop {
+                severity: TurnSeverity::Hard,
+                user_message: format!(
+                    "🛑 Hard bot turn limit reached ({HARD_BOT_TURN_LIMIT}). \
+                     A human must reply to continue."
+                ),
+            },
+            TurnResult::Throttled | TurnResult::Stopped => TurnAction::SilentStop,
+        }
+    }
+}
+
+/// Log severity hint for `TurnAction::WarnAndStop`.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum TurnSeverity {
+    /// Soft limit — typically logged at `info!`.
+    Soft,
+    /// Hard absolute cap — typically logged at `warn!`.
+    Hard,
+}
+
+/// High-level action for a bot message after calling
+/// [`BotTurnTracker::classify_bot_message`].
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum TurnAction {
+    /// Safe to continue processing this bot message.
+    Continue,
+    /// Stop processing; if the message did not come from our own bot, the
+    /// caller should post `user_message` to the thread so humans see why
+    /// the bot went quiet.
+    WarnAndStop {
+        severity: TurnSeverity,
+        user_message: String,
+    },
+    /// Stop processing silently — the warning was already sent on a previous
+    /// turn; further warnings would spam the thread.
+    SilentStop,
 }
 
 #[cfg(test)]
@@ -191,4 +244,52 @@ mod tests {
         assert_eq!(t.on_bot_message("t1"), TurnResult::Ok);
         assert_eq!(t.on_bot_message("t1"), TurnResult::SoftLimit(3));
     }
+
+    #[test]
+    fn classify_returns_continue_under_limits() {
+        let mut t = BotTurnTracker::new(5);
+        assert_eq!(t.classify_bot_message("t1"), TurnAction::Continue);
+    }
+
+    #[test]
+    fn classify_returns_warn_and_stop_on_soft_limit() {
+        let mut t = BotTurnTracker::new(3);
+        let _ = t.classify_bot_message("t1");
+        let _ = t.classify_bot_message("t1");
+        match t.classify_bot_message("t1") {
+            TurnAction::WarnAndStop { severity, user_message } => {
+                assert_eq!(severity, TurnSeverity::Soft);
+                assert!(user_message.contains("3/3"));
+                assert!(user_message.contains("⚠️"));
+            }
+            other => panic!("expected WarnAndStop(Soft), got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn classify_returns_silent_stop_past_soft_limit() {
+        let mut t = BotTurnTracker::new(2);
+        let _ = t.classify_bot_message("t1");
+        let _ = t.classify_bot_message("t1"); // soft limit
+        assert_eq!(t.classify_bot_message("t1"), TurnAction::SilentStop);
+        assert_eq!(t.classify_bot_message("t1"), TurnAction::SilentStop);
+    }
+
+    #[test]
+    fn classify_returns_warn_and_stop_on_hard_limit() {
+        let mut t = BotTurnTracker::new(HARD_BOT_TURN_LIMIT + 1);
+        for _ in 0..HARD_BOT_TURN_LIMIT - 1 {
+            let _ = t.classify_bot_message("t1");
+        }
+        match t.classify_bot_message("t1") {
+            TurnAction::WarnAndStop { severity, user_message } => {
+                assert_eq!(severity, TurnSeverity::Hard);
+                assert!(user_message.contains("🛑"));
+                assert!(user_message.contains(&HARD_BOT_TURN_LIMIT.to_string()));
+            }
+            other => panic!("expected WarnAndStop(Hard), got {other:?}"),
+        }
+        // Next call is silent (already warned).
+        assert_eq!(t.classify_bot_message("t1"), TurnAction::SilentStop);
+    }
 }

src/discord.rs

@@ -1,7 +1,7 @@
 use crate::acp::ContentBlock;
 use crate::acp::protocol::ConfigOption;
 use crate::adapter::{AdapterRouter, ChatAdapter, ChannelRef, MessageRef, SenderContext};
-use crate::bot_turns::{BotTurnTracker, TurnResult, HARD_BOT_TURN_LIMIT};
+use crate::bot_turns::{BotTurnTracker, TurnAction, TurnSeverity};
 use crate::config::{AllowBots, AllowUsers, SttConfig};
 use crate::format;
 use crate::media;
@@ -10,7 +10,7 @@ use std::sync::LazyLock;
 use serenity::builder::{CreateActionRow, CreateCommand, CreateInteractionResponse, CreateInteractionResponseMessage, CreateSelectMenu, CreateSelectMenuKind, CreateSelectMenuOption, CreateThread, EditMessage};
 use serenity::http::Http;
 use serenity::model::application::{ComponentInteractionDataKind, Interaction};
-use serenity::model::channel::{AutoArchiveDuration, Message, MessageType, ReactionType};
+use serenity::model::channel::{AutoArchiveDuration, ChannelType, Message, MessageType, ReactionType};
 use serenity::model::gateway::Ready;
 use serenity::model::id::{ChannelId, MessageId, UserId};
 use serenity::prelude::*;
@@ -259,30 +259,26 @@ impl EventHandler for Handler {
             let thread_key = msg.channel_id.to_string();
             let mut tracker = self.bot_turns.lock().await;
             if msg.author.bot {
-                match tracker.on_bot_message(&thread_key) {
-                    TurnResult::HardLimit => {
-                        tracing::warn!(channel_id = %msg.channel_id, "hard bot turn limit reached");
-                        if msg.author.id != bot_id {
-                            let _ = msg.channel_id.say(
-                                &ctx.http,
-                                format!("🛑 Hard bot turn limit reached ({HARD_BOT_TURN_LIMIT}). A human must reply to continue."),
-                            ).await;
+                match tracker.classify_bot_message(&thread_key) {
+                    TurnAction::Continue => {}
+                    TurnAction::SilentStop => return,
+                    TurnAction::WarnAndStop { severity, user_message } => {
+                        match severity {
+                            TurnSeverity::Hard => tracing::warn!(
+                                channel_id = %msg.channel_id,
+                                "hard bot turn limit reached",
+                            ),
+                            TurnSeverity::Soft => tracing::info!(
+                                channel_id = %msg.channel_id,
+                                max = self.max_bot_turns,
+                                "soft bot turn limit reached",
+                            ),
                         }
-                        return;
-                    }
-                    TurnResult::Stopped => return,
-                    TurnResult::SoftLimit(n) => {
-                        tracing::info!(channel_id = %msg.channel_id, turns = n, max = self.max_bot_turns, "soft bot turn limit reached");
                         if msg.author.id != bot_id {
-                            let _ = msg.channel_id.say(
-                                &ctx.http,
-                                format!("⚠️ Bot turn limit reached ({n}/{}). A human must reply in this thread to continue bot-to-bot conversation.", self.max_bot_turns),
-                            ).await;
+                            let _ = msg.channel_id.say(&ctx.http, &user_message).await;
                         }
                         return;
                     }
-                    TurnResult::Throttled => return,
-                    TurnResult::Ok => {}
                 }
             } else if matches!(msg.kind, MessageType::Regular | MessageType::InlineReply)
                 && !msg.content.is_empty()
@@ -359,9 +355,12 @@ impl EventHandler for Handler {
 
         // Thread detection: single to_channel() call for both allowed and
         // non-allowed channels. A message is "in a thread" when the channel
-        // has a parent_id AND the parent is in the allowlist (or allow_all).
+        // type is a thread variant AND the parent is in the allowlist (or allow_all).
         let (in_thread, bot_owns_thread) = match msg.channel_id.to_channel(&ctx.http).await {
-            Ok(serenity::model::channel::Channel::Guild(gc)) if gc.parent_id.is_some() => {
+            Ok(serenity::model::channel::Channel::Guild(gc))
+                if is_thread_channel(gc.kind) =>
+            {
+                // parent_id here points from thread → parent channel (not channel → category)
                 let parent_allowed = in_allowed_channel
                     || self.allow_all_channels
                     || gc.parent_id.is_some_and(|pid| self.allowed_channels.contains(&pid.get()));
@@ -864,6 +863,12 @@ fn resolve_mentions(content: &str, bot_id: UserId) -> String {
     out.trim().to_string()
 }
 
+/// Returns `true` if the given `ChannelType` is a Discord thread.
+/// Extracted for testability and to centralise thread detection logic.
+fn is_thread_channel(kind: ChannelType) -> bool {
+    matches!(kind, ChannelType::PublicThread | ChannelType::PrivateThread | ChannelType::NewsThread)
+}
+
 /// Pure decision function: should this message be processed or ignored?
 /// Returns `true` if the message should be processed (bot responds).
 /// Extracted from the EventHandler::message gating logic for testability.
@@ -1069,4 +1074,46 @@ mod tests {
             false,          // other_bot_present
         ));
     }
+
+    // --- is_thread_channel tests (regression for #518) ---
+    // PR #506 used parent_id.is_some() to detect threads, but category text
+    // channels also have parent_id (pointing to the category). This caused
+    // the bot to skip thread creation for normal channels inside categories.
+
+    /// Regression test for #518: a text channel inside a category has parent_id
+    /// set but is NOT a thread — is_thread_channel must return false.
+    #[test]
+    fn category_text_channel_is_not_thread() {
+        assert!(!is_thread_channel(ChannelType::Text));
+    }
+
+    /// Category channel itself is not a thread.
+    #[test]
+    fn category_channel_is_not_thread() {
+        assert!(!is_thread_channel(ChannelType::Category));
+    }
+
+    /// Voice channel is not a thread.
+    #[test]
+    fn voice_channel_is_not_thread() {
+        assert!(!is_thread_channel(ChannelType::Voice));
+    }
+
+    /// PublicThread is correctly detected as a thread.
+    #[test]
+    fn public_thread_is_thread() {
+        assert!(is_thread_channel(ChannelType::PublicThread));
+    }
+
+    /// PrivateThread is correctly detected as a thread.
+    #[test]
+    fn private_thread_is_thread() {
+        assert!(is_thread_channel(ChannelType::PrivateThread));
+    }
+
+    /// NewsThread is correctly detected as a thread.
+    #[test]
+    fn news_thread_is_thread() {
+        assert!(is_thread_channel(ChannelType::NewsThread));
+    }
 }

src/slack.rs

@@ -1,6 +1,6 @@
 use crate::acp::ContentBlock;
 use crate::adapter::{AdapterRouter, ChatAdapter, ChannelRef, MessageRef, SenderContext};
-use crate::bot_turns::{BotTurnTracker, TurnResult, HARD_BOT_TURN_LIMIT};
+use crate::bot_turns::{BotTurnTracker, TurnAction, TurnSeverity};
 use crate::config::{AllowBots, AllowUsers, SttConfig};
 use crate::media;
 use anyhow::{anyhow, Result};
@@ -672,42 +672,25 @@ pub async fn run_slack_adapter(
                                                 {
                                                     let mut tracker = bot_turns.lock().await;
                                                     if is_bot {
-                                                        match tracker.on_bot_message(&turn_key) {
-                                                            TurnResult::HardLimit => {
-                                                                warn!(channel_id, "hard bot turn limit reached");
-                                                                if !is_own_bot_msg {
-                                                                    let warn_channel = ChannelRef {
-                                                                        platform: "slack".into(),
-                                                                        channel_id: channel_id.to_string(),
-                                                                        thread_id: event["thread_ts"].as_str().map(|s| s.to_string()),
-                                                                        parent_id: None,
-                                                                    };
-                                                                    let _ = adapter.send_message(
-                                                                        &warn_channel,
-                                                                        &format!("🛑 Hard bot turn limit reached ({HARD_BOT_TURN_LIMIT}). A human must reply to continue."),
-                                                                    ).await;
+                                                        match tracker.classify_bot_message(&turn_key) {
+                                                            TurnAction::Continue => {}
+                                                            TurnAction::SilentStop => continue,
+                                                            TurnAction::WarnAndStop { severity, user_message } => {
+                                                                match severity {
+                                                                    TurnSeverity::Hard => warn!(channel_id, "hard bot turn limit reached"),
+                                                                    TurnSeverity::Soft => info!(channel_id, max = max_bot_turns, "soft bot turn limit reached"),
                                                                 }
-                                                                continue;
-                                                            }
-                                                            TurnResult::Stopped => continue,
-                                                            TurnResult::SoftLimit(n) => {
-                                                                info!(channel_id, turns = n, max = max_bot_turns, "soft bot turn limit reached");
                                                                 if !is_own_bot_msg {
                                                                     let warn_channel = ChannelRef {
                                                                         platform: "slack".into(),
                                                                         channel_id: channel_id.to_string(),
                                                                         thread_id: event["thread_ts"].as_str().map(|s| s.to_string()),
                                                                         parent_id: None,
                                                                     };
-                                                                    let _ = adapter.send_message(
-                                                                        &warn_channel,
-                                                                        &format!("⚠️ Bot turn limit reached ({n}/{max_bot_turns}). A human must reply in this thread to continue bot-to-bot conversation."),
-                                                                    ).await;
+                                                                    let _ = adapter.send_message(&warn_channel, &user_message).await;
                                                                 }
                                                                 continue;
                                                             }
-                                                            TurnResult::Throttled => continue,
-                                                            TurnResult::Ok => {}
                                                         }
                                                     } else {
                                                         tracker.on_human_message(&turn_key);
@@ -813,8 +796,12 @@ pub async fn run_slack_adapter(
                                                                     debug!(channel_id, thread_ts, "bot not involved in thread, ignoring");
                                                                     continue;
                                                                 }
-                                                                if other_bot {
-                                                                    debug!(channel_id, thread_ts, "multi-bot thread, requiring @mention");
+                                                                // In multi-bot threads, require @mention. The Slack
+                                                                // `app_mention` event usually handles the @-path on a
+                                                                // separate code path, but gate here too for Discord
+                                                                // parity and robustness if `app_mention` is missed.
+                                                                if other_bot && !mentions_bot {
+                                                                    debug!(channel_id, thread_ts, "multi-bot thread without @mention, ignoring");
                                                                     continue;
                                                                 }
                                                             }