feat: upgrade memory flush system

- Use LLM to summarize discarded context into concise daily memory entries
- Batch trim to half when exceeding max_turns/max_tokens, reducing flush frequency
- Run summarization asynchronously in background thread, no blocking on replies
- Add daily scheduled flush (23:55) as fallback for low-activity days
- Sync trimmed messages back to agent to keep context state consistent

bridge/agent_bridge.py

@@ -375,10 +375,6 @@ class AgentBridge:
             # Store session_id on agent so executor can clear DB on fatal errors
             agent._current_session_id = session_id
 
-            # Record message count before execution so we can diff new messages
-            with agent.messages_lock:
-                pre_run_len = len(agent.messages)
-
             try:
                 # Use agent's run_stream method with event handler
                 response = agent.run_stream(
@@ -397,19 +393,19 @@ class AgentBridge:
             # Persist new messages generated during this run
             if session_id:
                 channel_type = (context.get("channel_type") or "") if context else ""
-                with agent.messages_lock:
-                    new_messages = agent.messages[pre_run_len:]
+                new_messages = getattr(agent, '_last_run_new_messages', [])
                 if new_messages:
                     self._persist_messages(session_id, list(new_messages), channel_type)
-                elif pre_run_len > 0 and len(agent.messages) == 0:
-                    # Agent cleared its messages (recovery from format error / overflow)
-                    # Also clear the DB to prevent reloading dirty data
-                    try:
-                        from agent.memory import get_conversation_store
-                        get_conversation_store().clear_session(session_id)
-                        logger.info(f"[AgentBridge] Cleared DB for recovered session: {session_id}")
-                    except Exception as e:
-                        logger.warning(f"[AgentBridge] Failed to clear DB after recovery: {e}")
+                else:
+                    with agent.messages_lock:
+                        msg_count = len(agent.messages)
+                    if msg_count == 0:
+                        try:
+                            from agent.memory import get_conversation_store
+                            get_conversation_store().clear_session(session_id)
+                            logger.info(f"[AgentBridge] Cleared DB for recovered session: {session_id}")
+                        except Exception as e:
+                            logger.warning(f"[AgentBridge] Failed to clear DB after recovery: {e}")
             
             # Check if there are files to send (from read tool)
             if hasattr(agent, 'stream_executor') and hasattr(agent.stream_executor, 'files_to_send'):

bridge/agent_initializer.py

@@ -115,14 +115,19 @@ class AgentInitializer:
             runtime_info=runtime_info  # Pass runtime_info for dynamic time updates
         )
         
-        # Attach memory manager
+        # Attach memory manager and share LLM model for summarization
         if memory_manager:
             agent.memory_manager = memory_manager
+            if hasattr(agent, 'model') and agent.model:
+                memory_manager.flush_manager.llm_model = agent.model
 
         # Restore persisted conversation history for this session
         if session_id:
             self._restore_conversation_history(agent, session_id)
 
+        # Start daily memory flush timer (once, on first agent init regardless of session)
+        self._start_daily_flush_timer()
+
         return agent
 
     def _restore_conversation_history(self, agent, session_id: str) -> None:
@@ -514,3 +519,59 @@ class AgentInitializer:
                 logger.info(f"[AgentInitializer] Migrated {len(keys_to_migrate)} API keys to .env: {list(keys_to_migrate.keys())}")
             except Exception as e:
                 logger.warning(f"[AgentInitializer] Failed to migrate API keys: {e}")
+
+    def _start_daily_flush_timer(self):
+        """Start a background thread that flushes all agents' memory daily at 23:55."""
+        if getattr(self.agent_bridge, '_daily_flush_started', False):
+            return
+        self.agent_bridge._daily_flush_started = True
+
+        import threading
+
+        def _daily_flush_loop():
+            while True:
+                try:
+                    now = datetime.datetime.now()
+                    target = now.replace(hour=23, minute=55, second=0, microsecond=0)
+                    if target <= now:
+                        target += datetime.timedelta(days=1)
+                    wait_seconds = (target - now).total_seconds()
+                    logger.info(f"[DailyFlush] Next flush at {target.strftime('%Y-%m-%d %H:%M')} (in {wait_seconds/3600:.1f}h)")
+                    time.sleep(wait_seconds)
+
+                    self._flush_all_agents()
+                except Exception as e:
+                    logger.warning(f"[DailyFlush] Error in daily flush loop: {e}")
+                    time.sleep(3600)
+
+        t = threading.Thread(target=_daily_flush_loop, daemon=True)
+        t.start()
+
+    def _flush_all_agents(self):
+        """Flush memory for all active agent sessions."""
+        agents = []
+        if self.agent_bridge.default_agent:
+            agents.append(("default", self.agent_bridge.default_agent))
+        for sid, agent in self.agent_bridge.agents.items():
+            agents.append((sid, agent))
+
+        if not agents:
+            return
+
+        flushed = 0
+        for label, agent in agents:
+            try:
+                if not agent.memory_manager:
+                    continue
+                with agent.messages_lock:
+                    messages = list(agent.messages)
+                if not messages:
+                    continue
+                result = agent.memory_manager.flush_manager.create_daily_summary(messages)
+                if result:
+                    flushed += 1
+            except Exception as e:
+                logger.warning(f"[DailyFlush] Failed for session {label}: {e}")
+
+        if flushed:
+            logger.info(f"[DailyFlush] Flushed {flushed}/{len(agents)} agent session(s)")