refactor: require @mention for every thread turn

Drop the active_threads thread-owner mechanism. Previously the first user
to @mention the bot in a thread became its "owner" and could send plain
follow-ups, while every other participant had to @mention every turn —
an asymmetry that made multi-user threads awkward.

Now channel and thread messages are only handled via the app_mention
event, regardless of who started the thread. handle_message only handles
DMs. This makes participation rules uniform: anyone joining a thread plays
by the same gating as the original poster (@mention every turn). Memory
remains keyed by thread_ts, so once a participant @mentions, they share
the full thread history with everyone else in it.

- Remove self.active_threads dict and the seeding in handle_mention
- Simplify handle_message to only respond to channel_type == "im"
- Remove unused _is_bot_mentioned helper
- Tests: assert thread plain follow-ups are ignored even from the original
  mentioner; assert two users @mentioning the same thread share history

Author: John-Lin

bot/slack.py

@@ -34,10 +34,6 @@ def __init__(
         self.agent = openai_agent
         self._user_name_cache: dict[str, str] = {}
 
-        # Maps thread_ts to the user_id who first @mentioned the bot, so only
-        # that user's follow-up messages in the thread are handled without a mention.
-        self.active_threads: dict[str, str] = {}
-
         # Set up event handlers
         self.app.event("app_mention")(self.handle_mention)
         self.app.event("message")(self.handle_message)
@@ -58,33 +54,21 @@ async def initialize_bot_info(self) -> None:
             self.bot_id = None
 
     async def handle_mention(self, event, say, ack):
-        """Handle mentions of the bot in channels."""
+        """Handle mentions of the bot in channels and threads."""
         await ack()
-        thread_ts = event.get("thread_ts", event.get("ts"))
-        user_id = event.get("user")
-        if thread_ts not in self.active_threads and user_id:
-            self.active_threads[thread_ts] = user_id
         await self._process_message(event, say)
 
     async def handle_message(self, message, say, ack):
-        """Handle direct messages and follow-up messages in active threads."""
+        """Handle direct messages. Channel and thread messages must @mention
+        the bot and are handled by ``handle_mention`` via the ``app_mention``
+        event — every turn in a thread requires an explicit mention, regardless
+        of who started the thread.
+        """
         await ack()
         if message.get("subtype"):
             return
 
-        channel_type = message.get("channel_type")
-        thread_ts = message.get("thread_ts")
-
-        is_dm = channel_type == "im"
-        # Respond only to the user who first @mentioned the bot in this thread,
-        # and skip messages that @mention the bot (handle_mention handles those).
-        is_active_thread_followup = (
-            thread_ts is not None
-            and self.active_threads.get(thread_ts) == message.get("user")
-            and not self._is_bot_mentioned(message)
-        )
-
-        if is_dm or is_active_thread_followup:
+        if message.get("channel_type") == "im":
             await self._process_message(message, say)
 
     async def _get_display_name(self, user_id: str) -> str:
@@ -99,11 +83,6 @@ async def _get_display_name(self, user_id: str) -> str:
         self._user_name_cache[user_id] = name
         return name
 
-    def _is_bot_mentioned(self, message) -> bool:
-        if not getattr(self, "bot_id", None):
-            return False
-        return f"<@{self.bot_id}>" in message.get("text", "")
-
     async def _process_message(self, event, say):
         """Process incoming messages and generate responses."""
         channel = event["channel"]

tests/test_slack.py

@@ -174,6 +174,101 @@ async def test_bot_own_messages_are_ignored(self, bot):
 
         bot.agent.run.assert_not_called()
 
+    @pytest.mark.anyio
+    async def test_thread_followup_without_mention_is_ignored(self, bot):
+        """A plain (non-@mention) message in a thread is ignored, even if the
+        same user previously @mentioned the bot in that thread. Every turn
+        requires an explicit mention.
+        """
+        # First turn: user @mentions in thread.
+        mention_event = {
+            "channel": "C001",
+            "user": "U123",
+            "text": "<@U_BOT> first question",
+            "thread_ts": "1111111111.111111",
+            "ts": "1111111111.111111",
+        }
+        await bot.handle_mention(mention_event, AsyncMock(), AsyncMock())
+        assert bot.agent.run.call_count == 1
+
+        # Second turn: same user, same thread, no @mention — should be ignored.
+        followup = {
+            "channel": "C001",
+            "channel_type": "channel",
+            "user": "U123",
+            "text": "follow up without mention",
+            "thread_ts": "1111111111.111111",
+            "ts": "2222222222.222222",
+        }
+        await bot.handle_message(followup, AsyncMock(), AsyncMock())
+
+        # Still only the original mention call.
+        assert bot.agent.run.call_count == 1
+
+
+class TestMultiUserThread:
+    @pytest.mark.anyio
+    async def test_second_user_mention_in_same_thread_shares_history(self, bot):
+        """When a second user joins a thread by @mentioning the bot, they engage
+        the same conversation key (thread_ts) so the bot has shared history.
+        """
+        thread_ts = "1111111111.111111"
+
+        alice_mention = {
+            "channel": "C001",
+            "user": "U_ALICE",
+            "text": "<@U_BOT> what is the capital of France?",
+            "thread_ts": thread_ts,
+            "ts": thread_ts,
+        }
+        bob_mention = {
+            "channel": "C001",
+            "user": "U_BOB",
+            "text": "<@U_BOT> and Germany?",
+            "thread_ts": thread_ts,
+            "ts": "2222222222.222222",
+        }
+
+        await bot.handle_mention(alice_mention, AsyncMock(), AsyncMock())
+        await bot.handle_mention(bob_mention, AsyncMock(), AsyncMock())
+
+        # Both calls used the same thread_ts as the conversation key.
+        assert bot.agent.run.call_count == 2
+        assert bot.agent.run.call_args_list[0].args[0] == thread_ts
+        assert bot.agent.run.call_args_list[1].args[0] == thread_ts
+
+    @pytest.mark.anyio
+    async def test_second_user_plain_message_in_thread_is_ignored(self, bot):
+        """A second user typing a plain (non-@mention) message in an active
+        thread is ignored — they must @mention to participate.
+        """
+        thread_ts = "1111111111.111111"
+
+        # Alice opens the thread with a mention.
+        alice_mention = {
+            "channel": "C001",
+            "user": "U_ALICE",
+            "text": "<@U_BOT> hi",
+            "thread_ts": thread_ts,
+            "ts": thread_ts,
+        }
+        await bot.handle_mention(alice_mention, AsyncMock(), AsyncMock())
+        assert bot.agent.run.call_count == 1
+
+        # Bob types in the thread without mentioning the bot.
+        bob_plain = {
+            "channel": "C001",
+            "channel_type": "channel",
+            "user": "U_BOB",
+            "text": "hey what's going on",
+            "thread_ts": thread_ts,
+            "ts": "2222222222.222222",
+        }
+        await bot.handle_message(bob_plain, AsyncMock(), AsyncMock())
+
+        # Bob's plain message did not trigger the bot.
+        assert bot.agent.run.call_count == 1
+
 
 class TestErrorHandling:
     @pytest.mark.anyio