Fix race condition causing duplicate message processing

- Add processing_queue flag to prevent concurrent queue processing
- Check processing flag before attempting to process queue
- Cancel and clear flush task when processing begins
- Add proper cleanup in finally block to always reset flag
- Improve shutdown handling to cancel pending tasks
- Process remaining messages on shutdown before exit

Fixes issue where multiple timeout flushes would trigger simultaneously,
causing the same batch of messages to be sent to the agent multiple times.

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

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

src/jetstream_letta_bridge.py

···
         # Message processing
         self.message_queue: List[Dict[str, Any]] = []
         self.queue_lock = asyncio.Lock()
+        self.processing_queue = False  # Flag to prevent concurrent processing
         self.batch_size = config.get('agent', {}).get('batch_size', 1)
         self.queue_flush_timeout = config.get('agent', {}).get('queue_flush_timeout', 30)  # seconds
         self.queue_first_message_time: Optional[float] = None
···
         try:
             await asyncio.sleep(self.queue_flush_timeout)
 
-            # Check if we still have messages to process
+            # Check if we still have messages to process and not already processing
             async with self.queue_lock:
-                if self.message_queue:
+                if self.message_queue and not self.processing_queue:
                     console.print(f"[{self.agent_name}] ⏰ Timeout flush: {len(self.message_queue)} messages")
+                    # Process outside the lock
+                else:
+                    logger.debug(f"[{self.agent_name}] Flush skipped - queue empty or already processing")
+                    return
 
             await self.process_message_queue()
 
         except asyncio.CancelledError:
             # Task was cancelled, which is fine
+            logger.debug(f"[{self.agent_name}] Flush task cancelled")
             pass
 
     async def process_message_queue(self) -> None:
         """Process all queued messages by sending them to the agent."""
-        if not self.message_queue:
-            return
+        # Acquire lock and check if we should process
+        async with self.queue_lock:
+            # Check if already processing or queue is empty
+            if self.processing_queue:
+                logger.debug(f"[{self.agent_name}] Already processing queue, skipping")
+                return
 
-        # Get all queued items
-        async with self.queue_lock:
+            if not self.message_queue:
+                logger.debug(f"[{self.agent_name}] Queue is empty, nothing to process")
+                return
+
+            # Set processing flag and get items
+            self.processing_queue = True
             items_to_process = self.message_queue.copy()
             self.message_queue.clear()
             # Reset queue timing
             self.queue_first_message_time = None
+            # Cancel flush task since we're processing now
             if self.flush_task and not self.flush_task.done():
                 self.flush_task.cancel()
-
-        if not items_to_process:
-            return
+                self.flush_task = None
         
         # Create combined prompt for batch processing
         if len(items_to_process) == 1:
···
             console.print(f"[{self.agent_name}] ❌ {error_name}: {str(e)[:100]}")
             logger.error(f"[{self.agent_name}] Agent communication error: {e}")
             # Continue processing - don't let one error stop the bridge
+        finally:
+            # Always clear the processing flag when done
+            async with self.queue_lock:
+                self.processing_queue = False
+            logger.debug(f"[{self.agent_name}] Queue processing complete, flag cleared")
     
     def agent_stream_handler(self, chunk) -> None:
         """Handle streaming chunks from the agent."""
···
     
     async def stop(self) -> None:
         """Stop the bridge."""
+        logger.debug(f"[{self.agent_name}] Stopping bridge...")
         self.running = False
+
+        # Cancel any pending flush task
+        if self.flush_task and not self.flush_task.done():
+            logger.debug(f"[{self.agent_name}] Cancelling flush task")
+            self.flush_task.cancel()
+            try:
+                await self.flush_task
+            except asyncio.CancelledError:
+                pass
+
+        # Process any remaining messages in queue
+        if self.message_queue:
+            logger.debug(f"[{self.agent_name}] Processing {len(self.message_queue)} remaining messages")
+            await self.process_message_queue()
+
         await self.disconnect_jetstream()
         await self.did_cache.close()
-        
+
         # Final statistics
         elapsed = time.time() - self.start_time
-        console.print(f"\n📊 Final Stats:")
+        console.print(f"\n[{self.agent_name}] 📊 Final Stats:")
         console.print(f"   Received: {self.blips_received}")
         console.print(f"   Sent: {self.messages_sent_to_agent}")
         console.print(f"   Published: {self.blips_published}")
         console.print(f"   Runtime: {elapsed/60:.1f}m")
-        console.print(f"   Rate: {self.blips_received / (elapsed / 60):.1f}/min")
+        if elapsed > 0:
+            console.print(f"   Rate: {self.blips_received / (elapsed / 60):.1f}/min")
 
 
 def list_available_agents(directory: str) -> None: