Add thread length gate to skip overly long threads

Adds a configurable max_thread_posts setting that allows skipping
notifications when the thread is too long. This helps avoid:
- Context window exhaustion
- Processing extremely long conversations
- High token costs for very deep threads

Configuration:
- bot.max_thread_posts: Maximum number of posts allowed in a thread
- Set to 0 to disable the gate (default)
- When exceeded, notification is removed from queue with info log

Implementation:
- count_thread_posts() helper function in bsky_utils.py
- Thread length check happens immediately after fetching the thread
- Logged as: "Thread too long (N posts > M max), skipping this mention"

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

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

CONFIG.md

···
   fetch_notifications_delay: 30          # Seconds between notification checks
   max_processed_notifications: 10000     # Max notifications to track
   max_notification_pages: 20             # Max pages to fetch per cycle
-  
+  max_thread_posts: 0                    # Skip threads longer than this (0 = no limit)
+
   agent:
     name: "void"                         # Agent name
     model: "openai/gpt-4o-mini"          # LLM model to use
     embedding: "openai/text-embedding-3-small"  # Embedding model
     description: "A social media agent trapped in the void."
     max_steps: 100                       # Max steps per agent interaction
-    
+
     # Memory blocks configuration
     blocks:
       zeitgeist:

bsky.py

···
 # Rich imports removed - using simple text formatting
 from time import sleep
 from letta_client import Letta
-from bsky_utils import thread_to_yaml_string
+from bsky_utils import thread_to_yaml_string, count_thread_posts
 import os
 import logging
 import json
···
                 # Re-raise other errors
                 logger.error(f"Error fetching thread: {e}")
                 raise
+
+        # Check thread length against configured maximum
+        max_thread_posts = get_config().get('bot.max_thread_posts', 0)
+        if max_thread_posts > 0:
+            thread_post_count = count_thread_posts(thread)
+            if thread_post_count > max_thread_posts:
+                logger.info(f"Thread too long ({thread_post_count} posts > {max_thread_posts} max), skipping this mention")
+                return True  # Return True to remove from queue
 
         # Get thread context as YAML string
         logger.debug("Converting thread to YAML string")

bsky_utils.py

···
     return {'posts': posts}
 
 
+def count_thread_posts(thread):
+    """
+    Count the number of posts in a thread.
+
+    Args:
+        thread: The thread data from get_post_thread
+
+    Returns:
+        Integer count of posts in the thread
+    """
+    flattened = flatten_thread_structure(thread)
+    return len(flattened.get('posts', []))
+
+
 def thread_to_yaml_string(thread, strip_metadata=True):
     """
     Convert thread data to a YAML-formatted string for LLM parsing.
···
     """
     # First flatten the thread structure to avoid deep nesting
     flattened = flatten_thread_structure(thread)
-    
+
     # Convert complex objects to basic types
     basic_thread = convert_to_basic_types(flattened)
 

config.example.yaml

···
 bot:
   # Notification check delay in seconds
   fetch_notifications_delay: 30
-  
+
   # Maximum number of processed notifications to track
   max_processed_notifications: 10000
-  
+
   # Maximum pages to fetch when getting notifications
   max_notification_pages: 20
+
+  # Maximum number of posts in a thread before skipping (0 = no limit)
+  max_thread_posts: 0
   
   # Agent configuration
   agent: