Slim down verbose logging for cleaner default output

- Change default log level from DEBUG to INFO for void_bot logger
- Remove redundant startup messages and tool listings
- Reduce main loop cycle noise (only show stats when messages processed)
- Remove excessive notification processing status messages
- Move session-related logs to DEBUG level in bsky_utils.py
- Clean up user block attachment/detachment logs in tools/blocks.py

Keeps queue processing logs and important status messages while
eliminating noise from normal operation.

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

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

bsky.py

···
 
 # Configure logging
 logging.basicConfig(
-    level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger("void_bot")
-logger.setLevel(logging.DEBUG)
+logger.setLevel(logging.INFO)
 
 # Create a separate logger for prompts (set to WARNING to hide by default)
 prompt_logger = logging.getLogger("void_bot.prompts")
···
 
 def load_and_process_queued_notifications(void_agent, atproto_client):
     """Load and process all notifications from the queue in priority order."""
-    logger.info("Loading queued notifications from disk...")
     try:
         # Get all JSON files in queue directory (excluding processed_notifications.json)
         # Files are sorted by name, which puts priority files first (0_ prefix before 1_ prefix)
         queue_files = sorted([f for f in QUEUE_DIR.glob("*.json") if f.name != "processed_notifications.json"])
 
         if not queue_files:
-            logger.info("No queued notifications found")
             return
 
         logger.info(f"Processing {len(queue_files)} queued notifications")
···
                     notif_data = json.load(f)
 
                 # Process based on type using dict data directly
-                logger.info(f"Processing {notif_data['reason']} from @{notif_data['author']['handle']}")
                 success = False
                 if notif_data['reason'] == "mention":
                     success = process_mention(void_agent, atproto_client, notif_data)
···
                     if success:
                         message_counters['follows'] += 1
                 elif notif_data['reason'] == "repost":
-                    logger.info(f"Skipping repost notification from @{notif_data['author']['handle']}")
+                    # Skip reposts silently
                     success = True  # Skip reposts but mark as successful to remove from queue
                     if success:
                         message_counters['reposts_skipped'] += 1
···
 
 def process_notifications(void_agent, atproto_client):
     """Fetch new notifications, queue them, and process the queue."""
-    logger.info("Starting notification processing cycle...")
     try:
         # First, process any existing queued notifications
-        logger.info("Processing existing queued notifications...")
         load_and_process_queued_notifications(void_agent, atproto_client)
 
         # Get current time for marking notifications as seen
···
             logger.debug("No new notifications to queue")
 
         # Process the queue (including any newly added notifications)
-        logger.info("Processing notification queue after fetching...")
         load_and_process_queued_notifications(void_agent, atproto_client)
 
     except Exception as e:
···
     global start_time
     start_time = time.time()
     logger.info("=== STARTING VOID BOT ===")
-    logger.info("Initializing Void bot...")
-
-    # Initialize the Letta agent
-    logger.info("Calling initialize_void()...")
     void_agent = initialize_void()
     logger.info(f"Void agent initialized: {void_agent.id}")
     
     # Check if agent has required tools
     if hasattr(void_agent, 'tools') and void_agent.tools:
         tool_names = [tool.name for tool in void_agent.tools]
-        logger.info(f"Agent has tools: {tool_names}")
-        
         # Check for bluesky-related tools
         bluesky_tools = [name for name in tool_names if 'bluesky' in name.lower() or 'reply' in name.lower()]
-        if bluesky_tools:
-            logger.info(f"Found Bluesky-related tools: {bluesky_tools}")
-        else:
+        if not bluesky_tools:
             logger.warning("No Bluesky-related tools found! Agent may not be able to reply.")
     else:
         logger.warning("Agent has no tools registered!")
 
     # Initialize Bluesky client
-    logger.info("Connecting to Bluesky...")
     atproto_client = bsky_utils.default_login()
     logger.info("Connected to Bluesky")
 
     # Main loop
-    logger.info(f"=== ENTERING MAIN LOOP ===")
     logger.info(f"Starting notification monitoring, checking every {FETCH_NOTIFICATIONS_DELAY_SEC} seconds")
 
     cycle_count = 0
     while True:
         try:
             cycle_count += 1
-            logger.info(f"=== MAIN LOOP CYCLE {cycle_count} ===")
             process_notifications(void_agent, atproto_client)
             # Log cycle completion with stats
             elapsed_time = time.time() - start_time
             total_messages = sum(message_counters.values())
             messages_per_minute = (total_messages / elapsed_time * 60) if elapsed_time > 0 else 0
             
-            logger.info(f"Cycle {cycle_count} complete. Session totals: {total_messages} messages ({message_counters['mentions']} mentions, {message_counters['replies']} replies) | {messages_per_minute:.1f} msg/min")
-            logger.info(f"Sleeping for {FETCH_NOTIFICATIONS_DELAY_SEC} seconds...")
+            if total_messages > 0:
+                logger.info(f"Cycle {cycle_count} complete. Session totals: {total_messages} messages ({message_counters['mentions']} mentions, {message_counters['replies']} replies) | {messages_per_minute:.1f} msg/min")
             sleep(FETCH_NOTIFICATIONS_DELAY_SEC)
 
         except KeyboardInterrupt:

bsky_utils.py

···
     logger.debug(f"Session saved for {username}")
 
 def on_session_change(username: str, event: SessionEvent, session: Session) -> None:
-    logger.info(f"Session changed: {event} {repr(session)}")
+    logger.debug(f"Session changed: {event} {repr(session)}")
     if event in (SessionEvent.CREATE, SessionEvent.REFRESH):
-        logger.info(f"Saving changed session for {username}")
+        logger.debug(f"Saving changed session for {username}")
         save_session(username, session.export())
 
 def init_client(username: str, password: str) -> Client:
···
         pds_uri = "https://bsky.social"
 
     # Print the PDS URI
-    logger.info(f"Using PDS URI: {pds_uri}")
+    logger.debug(f"Using PDS URI: {pds_uri}")
 
     client = Client(pds_uri)
     client.on_session_change(
···
 
     session_string = get_session(username)
     if session_string:
-        logger.info(f"Reusing existing session for {username}")
+        logger.debug(f"Reusing existing session for {username}")
         client.login(session_string=session_string)
     else:
-        logger.info(f"Creating new session for {username}")
+        logger.debug(f"Creating new session for {username}")
         client.login(username, password)
 
     return client

tools/blocks.py

···
                 blocks = client.blocks.list(label=block_label)
                 if blocks and len(blocks) > 0:
                     block = blocks[0]
-                    logger.info(f"Found existing block: {block_label}")
+                    logger.debug(f"Found existing block: {block_label}")
                 else:
                     block = client.blocks.create(
                         label=block_label,
···
                 )
                               
                 results.append(f"✓ {handle}: Block attached")
-                logger.info(f"Successfully attached block {block_label} to agent")
+                logger.debug(f"Successfully attached block {block_label} to agent")
 
             except Exception as e:
                 results.append(f"✗ {handle}: Error - {str(e)}")
···
                         block_id=block_label_to_id[block_label]
                     )
                     results.append(f"✓ {handle}: Detached")
-                    logger.info(f"Successfully detached block {block_label} from agent")
+                    logger.debug(f"Successfully detached block {block_label} from agent")
                 except Exception as e:
                     results.append(f"✗ {handle}: Error during detachment - {str(e)}")
                     logger.error(f"Error detaching block {block_label}: {e}")