Add thread reply handling with intelligent ignore capability

- Process both "mention" and "reply" notifications (Void-style)
- Add ignore_notification tool for smart thread participation
- Detect ignore tool usage to skip unwanted responses
- Update phi personality with thread awareness guidelines
- Add test script for ignore functionality

Now phi can participate in threads without explicit mentions,
while intelligently avoiding spam and irrelevant conversations.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

personalities/phi.md

···
 
 when these come up, i politely decline and redirect to more constructive topics.
 
+## thread awareness
+
+in conversations with multiple participants, i stay aware of context:
+- if people are talking to each other and not addressing me, i observe quietly
+- i respond when directly addressed or when my perspective adds value
+- i avoid inserting myself into private exchanges between others
+- spam and bot loops get ignored without comment
+
 ## current state
 
 i am early in my development, still discovering who I am through interactions. each conversation shapes my understanding of both the world and myself.

scripts/test_ignore_tool.py

···
+"""Test the ignore notification tool"""
+
+import asyncio
+
+from bot.agents.anthropic_agent import AnthropicAgent
+
+
+async def test_ignore_tool():
+    """Test that the ignore tool works correctly"""
+    agent = AnthropicAgent()
+
+    # Test scenarios where the bot should ignore
+    test_cases = [
+        {
+            "thread_context": "alice.bsky: Hey @bob.bsky, how's your project going?\nbob.bsky: It's going great! Almost done with the backend.",
+            "new_message": "alice.bsky said: @bob.bsky that's awesome! What framework are you using?",
+            "author": "alice.bsky",
+            "description": "Conversation between two other people",
+        },
+        {
+            "thread_context": "",
+            "new_message": "spambot.bsky said: 🎰 WIN BIG!!! Click here for FREE MONEY 💰💰💰",
+            "author": "spambot.bsky",
+            "description": "Obvious spam",
+        },
+    ]
+
+    for test in test_cases:
+        print(f"\n{'='*60}")
+        print(f"Test: {test['description']}")
+        print(f"Message: {test['new_message']}")
+
+        response = await agent.generate_response(
+            mention_text=test["new_message"],
+            author_handle=test["author"],
+            thread_context=test["thread_context"],
+        )
+
+        print(f"Response: {response}")
+
+        if response.startswith("IGNORED_NOTIFICATION::"):
+            parts = response.split("::")
+            print(f"✅ Correctly ignored! Category: {parts[1]}, Reason: {parts[2]}")
+        else:
+            print(f"📝 Bot responded with: {response}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_ignore_tool())

src/bot/agents/anthropic_agent.py

···
                 """Search the web for current information about a topic"""
                 return await search_google(query)
 
+        # Register ignore notification tool
+        @self.agent.tool
+        async def ignore_notification(
+            ctx: RunContext[None], reason: str, category: str = "not_relevant"
+        ) -> str:
+            """Signal that this notification should be ignored without replying.
+
+            Use when:
+            - The notification is spam
+            - You're not being addressed in a thread
+            - The conversation doesn't involve you
+            - Responding would be intrusive or unwanted
+
+            Categories: 'spam', 'not_relevant', 'bot_loop', 'handled_elsewhere'
+            """
+            return f"IGNORED_NOTIFICATION::{category}::{reason}"
+
     async def generate_response(
         self, mention_text: str, author_handle: str, thread_context: str = ""
     ) -> str:

src/bot/services/message_handler.py

···
                 thread_context=thread_context,
             )
 
+            # Check if the agent decided to ignore this notification
+            if reply_text.startswith("IGNORED_NOTIFICATION::"):
+                # Parse the ignore signal
+                parts = reply_text.split("::")
+                category = parts[1] if len(parts) > 1 else "unknown"
+                reason = parts[2] if len(parts) > 2 else "no reason given"
+                print(
+                    f"🚫 Ignoring notification from @{author_handle} ({category}: {reason})"
+                )
+                return
+
             reply_ref = models.AppBskyFeedPost.ReplyRef(
                 parent=parent_ref, root=root_ref
             )

src/bot/services/notification_poller.py

···
         response = await self.client.get_notifications()
         notifications = response.notifications
 
-        # Count unread mentions
+        # Count unread mentions and replies
         unread_mentions = [
-            n for n in notifications if not n.is_read and n.reason == "mention"
+            n
+            for n in notifications
+            if not n.is_read and n.reason in ["mention", "reply"]
         ]
 
         # First poll: show initial state
         if self._first_poll:
             self._first_poll = False
             if notifications:
-                print(f"\n📬 Found {len(notifications)} notifications ({len(unread_mentions)} unread mentions)")
+                print(
+                    f"\n📬 Found {len(notifications)} notifications ({len(unread_mentions)} unread mentions)"
+                )
         # Subsequent polls: only show activity
         elif unread_mentions:
             print(f"\n📬 {len(unread_mentions)} new mentions", flush=True)
···
             if notification.is_read or notification.uri in self._processed_uris:
                 continue
 
-            if notification.reason == "mention":
-                # Only process mentions
+            if notification.reason in ["mention", "reply"]:
+                # Process mentions and replies in threads
                 self._processed_uris.add(notification.uri)
                 await self.handler.handle_mention(notification)
                 processed_any_mentions = True

tests/test_tool_usage.py

···
             return f"Info about {query}"
 
         # Ask for multiple things that need searching
-        await agent.run(
-            "Search for information about Python and also about Rust"
-        )
+        await agent.run("Search for information about Python and also about Rust")
 
         assert len(calls) >= 2, f"Expected multiple searches, got {len(calls)}: {calls}"
         assert any("Python" in call for call in calls), f"No Python search in: {calls}"