Add synthesis timing functionality to X bot

- Add --synthesis-interval and --synthesis-only command line arguments
- Import send_synthesis_message from bsky.py
- Add synthesis timing logic to x_main_loop similar to bsky.py
- Support synthesis-only mode for periodic reflection without notification processing
- Add synthesis interval checking with time-based triggers

The X bot now has the same synthesis capabilities as the Bluesky bot.

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

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

x.py

···
     return yaml.dump(simplified_thread, default_flow_style=False, sort_keys=False)
 
 
-def ensure_x_user_blocks_attached(thread_data: Dict, agent_id: Optional[str] = None) -> None:
-    """
-    Ensure all users in the thread have their X user blocks attached.
-    Creates blocks with initial content including their handle if they don't exist.
-    
-    Args:
-        thread_data: Dict with 'tweets' and 'users' keys from get_thread_context()
-        agent_id: The Letta agent ID to attach blocks to (defaults to config agent_id)
-    """
-    if not thread_data or "users" not in thread_data:
-        return
-    
-    try:
-        from tools.blocks import attach_x_user_blocks, x_user_note_set
-        from config_loader import get_letta_config
-        from letta_client import Letta
-        
-        # Get Letta client and agent_id from config
-        config = get_letta_config()
-        client = Letta(token=config['api_key'], timeout=config['timeout'])
-        
-        # Use provided agent_id or get from config
-        if agent_id is None:
-            agent_id = config['agent_id']
-        
-        # Get agent info to create a mock agent_state for the functions
-        class MockAgentState:
-            def __init__(self, agent_id):
-                self.id = agent_id
-        
-        agent_state = MockAgentState(agent_id)
-        
-        users_data = thread_data["users"]
-        user_ids = list(users_data.keys())
-        
-        if not user_ids:
-            return
-        
-        logger.info(f"Ensuring X user blocks for {len(user_ids)} users: {user_ids}")
-        
-        # Get current blocks to check which users already have blocks with content
-        current_blocks = client.agents.blocks.list(agent_id=agent_id)
-        existing_user_blocks = {}
-        
-        for block in current_blocks:
-            if block.label.startswith("x_user_"):
-                user_id = block.label.replace("x_user_", "")
-                existing_user_blocks[user_id] = block
-        
-        # Attach all user blocks (this will create missing ones with basic content)
-        attach_result = attach_x_user_blocks(user_ids, agent_state)
-        logger.info(f"X user block attachment result: {attach_result}")
-        
-        # For newly created blocks, update with user handle information
-        for user_id in user_ids:
-            if user_id not in existing_user_blocks:
-                user_info = users_data[user_id]
-                username = user_info.get('username', 'unknown')
-                name = user_info.get('name', 'Unknown')
-                
-                # Set initial content with handle information
-                initial_content = f"# X User: {user_id}\n\n**Handle:** @{username}\n**Name:** {name}\n\nNo additional information about this user yet."
-                
-                try:
-                    x_user_note_set(user_id, initial_content, agent_state)
-                    logger.info(f"Set initial content for X user {user_id} (@{username})")
-                except Exception as e:
-                    logger.error(f"Failed to set initial content for X user {user_id}: {e}")
-        
-    except Exception as e:
-        logger.error(f"Error ensuring X user blocks: {e}")
-
 
 # X Caching and Queue System Functions
 
···
             logger.info("Found #voidstop, skipping this mention")
             return True
         
-        # Ensure X user blocks are attached
-        try:
-            ensure_x_user_blocks_attached(thread_data, void_agent.id)
-        except Exception as e:
-            logger.warning(f"Failed to ensure X user blocks: {e}")
-            # Continue without user blocks rather than failing completely
+        # Note: X user block attachment removed - no longer using user-specific memory blocks
         
         # Create prompt for Letta agent
         # First try to use cached author info from queued mention
···
     
     return void_agent
 
-def x_main_loop(testing_mode=False, cleanup_interval=10):
+def x_main_loop(testing_mode=False, cleanup_interval=10, synthesis_interval=600, synthesis_only=False):
     """
     Main X bot loop that continuously monitors for mentions and processes them.
     Similar to bsky.py main() but for X/Twitter.
···
     Args:
         testing_mode: If True, don't actually post to X
         cleanup_interval: Run user block cleanup every N cycles (0 to disable)
+        synthesis_interval: Send synthesis message every N seconds (0 to disable)
+        synthesis_only: If True, only send synthesis messages (no notification processing)
     """
     import time
     from time import sleep
     from config_loader import get_letta_config
     from letta_client import Letta
+    from bsky import send_synthesis_message
     
     logger.info("=== STARTING X VOID BOT ===")
     
···
     else:
         logger.info("User block cleanup disabled")
     
+    if synthesis_interval > 0:
+        logger.info(f"Synthesis messages enabled every {synthesis_interval} seconds ({synthesis_interval/60:.1f} minutes)")
+    else:
+        logger.info("Synthesis messages disabled")
+    
+    # Synthesis-only mode
+    if synthesis_only:
+        if synthesis_interval <= 0:
+            logger.error("Synthesis-only mode requires --synthesis-interval > 0")
+            return
+            
+        logger.info(f"Starting X synthesis-only mode, interval: {synthesis_interval} seconds ({synthesis_interval/60:.1f} minutes)")
+        
+        while True:
+            try:
+                # Send synthesis message immediately on first run
+                logger.info("🧠 Sending X synthesis message")
+                # No atproto_client for X bot, just pass None
+                send_synthesis_message(letta_client, void_agent.id, atproto_client=None)
+                
+                # Wait for next interval
+                logger.info(f"Waiting {synthesis_interval} seconds until next synthesis...")
+                sleep(synthesis_interval)
+                
+            except KeyboardInterrupt:
+                logger.info("=== X SYNTHESIS MODE STOPPED BY USER ===")
+                break
+            except Exception as e:
+                logger.error(f"Error in X synthesis loop: {e}")
+                logger.info(f"Sleeping for {synthesis_interval} seconds due to error...")
+                sleep(synthesis_interval)
+    
     cycle_count = 0
     start_time = time.time()
+    last_synthesis_time = time.time()
     
     while True:
         try:
···
             if cleanup_interval > 0 and cycle_count % cleanup_interval == 0:
                 logger.debug(f"Running periodic user block cleanup (cycle {cycle_count})")
                 periodic_user_block_cleanup(letta_client, void_agent.id)
+            
+            # Check if synthesis interval has passed
+            if synthesis_interval > 0:
+                current_time = time.time()
+                if current_time - last_synthesis_time >= synthesis_interval:
+                    logger.info(f"⏰ {synthesis_interval/60:.1f} minutes have passed, triggering X synthesis")
+                    send_synthesis_message(letta_client, void_agent.id, atproto_client=None)
+                    last_synthesis_time = current_time
             
             # Log cycle completion
             elapsed_time = time.time() - start_time
···
             parser.add_argument('--test', action='store_true', help='Run in testing mode (no actual posts)')
             parser.add_argument('--cleanup-interval', type=int, default=10, 
                               help='Run user block cleanup every N cycles (default: 10, 0 to disable)')
+            parser.add_argument('--synthesis-interval', type=int, default=600, 
+                              help='Send synthesis message every N seconds (default: 600 = 10 minutes, 0 to disable)')
+            parser.add_argument('--synthesis-only', action='store_true', 
+                              help='Run in synthesis-only mode (only send synthesis messages, no notification processing)')
             args = parser.parse_args()
-            x_main_loop(testing_mode=args.test, cleanup_interval=args.cleanup_interval)
+            x_main_loop(testing_mode=args.test, cleanup_interval=args.cleanup_interval, 
+                       synthesis_interval=args.synthesis_interval, synthesis_only=args.synthesis_only)
         elif sys.argv[1] == "loop":
             x_notification_loop()
         elif sys.argv[1] == "reply":