Add ignore_notification tool for explicit notification filtering

Implements a new tool that allows the agent to explicitly ignore notifications
without creating a reply. This is particularly useful for filtering out bot
interactions or spam.

Key features:
- New ignore_notification tool with reason and category tracking
- Conflict detection if agent calls both reply and ignore tools
- Ignored notifications are deleted from queue (not moved to no_reply)
- Proper logging and tracking of ignored notifications

The tool helps the agent make deliberate decisions about which notifications
to engage with, improving interaction quality.

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

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

bsky.py

···
         logger.debug(f"Processing {len(message_response.messages)} response messages...")
         
         # First pass: collect tool return statuses
+        ignored_notification = False
+        ignore_reason = ""
+        ignore_category = ""
+        
         for message in message_response.messages:
             if hasattr(message, 'tool_call_id') and hasattr(message, 'status') and hasattr(message, 'name'):
                 if message.name == 'add_post_to_bluesky_reply_thread':
                     tool_call_results[message.tool_call_id] = message.status
                     logger.debug(f"Tool result: {message.tool_call_id} -> {message.status}")
+                elif message.name == 'ignore_notification':
+                    # Check if the tool was successful
+                    if hasattr(message, 'tool_return') and message.status == 'success':
+                        # Parse the return value to extract category and reason
+                        result_str = str(message.tool_return)
+                        if 'IGNORED_NOTIFICATION::' in result_str:
+                            parts = result_str.split('::')
+                            if len(parts) >= 3:
+                                ignore_category = parts[1]
+                                ignore_reason = parts[2]
+                                ignored_notification = True
+                                logger.info(f"🚫 Notification ignored - Category: {ignore_category}, Reason: {ignore_reason}")
                 elif message.name == 'bluesky_reply':
                     logger.error("❌ DEPRECATED TOOL DETECTED: bluesky_reply is no longer supported!")
                     logger.error("Please use add_post_to_bluesky_reply_thread instead.")
···
                     else:
                         logger.warning(f"⚠️ Skipping add_post_to_bluesky_reply_thread tool call with unknown status: {tool_status}")
 
+        # Check for conflicting tool calls
+        if reply_candidates and ignored_notification:
+            logger.error(f"⚠️ CONFLICT: Agent called both add_post_to_bluesky_reply_thread and ignore_notification!")
+            logger.error(f"Reply candidates: {len(reply_candidates)}, Ignore reason: {ignore_reason}")
+            logger.warning("Item will be left in queue for manual review")
+            # Return False to keep in queue
+            return False
+        
         if reply_candidates:
             # Aggregate reply posts into a thread
             reply_messages = []
···
                 logger.error(f"Failed to send reply to @{author_handle}")
                 return False
         else:
-            logger.warning(f"No add_post_to_bluesky_reply_thread tool calls found for mention from @{author_handle}, moving to no_reply folder")
-            return "no_reply"
+            # Check if notification was explicitly ignored
+            if ignored_notification:
+                logger.info(f"Notification from @{author_handle} was explicitly ignored (category: {ignore_category})")
+                return "ignored"
+            else:
+                logger.warning(f"No add_post_to_bluesky_reply_thread tool calls found for mention from @{author_handle}, moving to no_reply folder")
+                return "no_reply"
 
     except Exception as e:
         logger.error(f"Error processing mention: {e}")
···
                     no_reply_path = QUEUE_NO_REPLY_DIR / filepath.name
                     filepath.rename(no_reply_path)
                     logger.info(f"📭 Moved {filepath.name} to no_reply directory")
+                    
+                    # Also mark as processed to avoid retrying
+                    processed_uris = load_processed_notifications()
+                    processed_uris.add(notif_data['uri'])
+                    save_processed_notifications(processed_uris)
+                    
+                elif success == "ignored":  # Special case for explicitly ignored notifications
+                    # For ignored notifications, we just delete them (not move to no_reply)
+                    filepath.unlink()
+                    logger.info(f"🚫 Deleted ignored notification: {filepath.name}")
                     
                     # Also mark as processed to avoid retrying
                     processed_uris = load_processed_notifications()

register_tools.py

···
 from tools.blocks import attach_user_blocks, detach_user_blocks, user_note_append, user_note_replace, user_note_set, user_note_view, AttachUserBlocksArgs, DetachUserBlocksArgs, UserNoteAppendArgs, UserNoteReplaceArgs, UserNoteSetArgs, UserNoteViewArgs
 from tools.halt import halt_activity, HaltArgs
 from tools.thread import add_post_to_bluesky_reply_thread, ReplyThreadPostArgs
+from tools.ignore import ignore_notification, IgnoreNotificationArgs
 
 load_dotenv()
 logging.basicConfig(level=logging.INFO)
···
         "args_schema": ReplyThreadPostArgs,
         "description": "Add a single post to the current Bluesky reply thread atomically",
         "tags": ["bluesky", "reply", "thread", "atomic"]
+    },
+    {
+        "func": ignore_notification,
+        "args_schema": IgnoreNotificationArgs,
+        "description": "Explicitly ignore a notification without replying (useful for ignoring bot interactions)",
+        "tags": ["notification", "ignore", "control", "bot"]
     },
 ]
 

tools/ignore.py

···
+"""Ignore notification tool for Bluesky."""
+from pydantic import BaseModel, Field
+from typing import Optional
+
+
+class IgnoreNotificationArgs(BaseModel):
+    reason: str = Field(..., description="Reason for ignoring this notification")
+    category: Optional[str] = Field(
+        default="bot",
+        description="Category of ignored notification (e.g., 'bot', 'spam', 'not_relevant', 'handled_elsewhere')"
+    )
+
+
+def ignore_notification(reason: str, category: str = "bot") -> str:
+    """
+    Signal that the current notification should be ignored without a reply.
+    
+    This tool allows the agent to explicitly mark a notification as ignored
+    rather than having it default to the no_reply folder. This is particularly
+    useful for ignoring interactions from bots or spam accounts.
+    
+    Args:
+        reason: Reason for ignoring this notification
+        category: Category of ignored notification (default: 'bot')
+        
+    Returns:
+        Confirmation message
+    """
+    return f"IGNORED_NOTIFICATION::{category}::{reason}"