feat: persistent storage of conversation history

bridge/agent_bridge.py

@@ -325,6 +325,10 @@ class AgentBridge:
                                 logger.warning(f"[AgentBridge] Failed to attach context to scheduler: {e}")
                             break
             
+            # 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(
@@ -336,9 +340,16 @@ class AgentBridge:
                 # Restore original tools
                 if context and context.get("is_scheduled_task"):
                     agent.tools = original_tools
-                
+
                 # Log execution summary
                 event_handler.log_summary()
+
+            # 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:]
+                self._persist_messages(session_id, list(new_messages), channel_type)
             
             # Check if there are files to send (from read tool)
             if hasattr(agent, 'stream_executor') and hasattr(agent.stream_executor, 'files_to_send'):
@@ -475,6 +486,32 @@ class AgentBridge:
             except Exception as e:
                 logger.warning(f"[AgentBridge] Failed to migrate API keys: {e}")
     
+    def _persist_messages(
+        self, session_id: str, new_messages: list, channel_type: str = ""
+    ) -> None:
+        """
+        Persist new messages to the conversation store after each agent run.
+
+        Failures are logged but never propagate — they must not interrupt replies.
+        """
+        if not new_messages:
+            return
+        try:
+            from config import conf
+            if not conf().get("conversation_persistence", True):
+                return
+        except Exception:
+            pass
+        try:
+            from agent.memory import get_conversation_store
+            get_conversation_store().append_messages(
+                session_id, new_messages, channel_type=channel_type
+            )
+        except Exception as e:
+            logger.warning(
+                f"[AgentBridge] Failed to persist messages for session={session_id}: {e}"
+            )
+
     def clear_session(self, session_id: str):
         """
         Clear a specific session's agent and conversation history

bridge/agent_initializer.py

@@ -118,8 +118,41 @@ class AgentInitializer:
         # Attach memory manager
         if memory_manager:
             agent.memory_manager = memory_manager
-        
+
+        # Restore persisted conversation history for this session
+        if session_id:
+            self._restore_conversation_history(agent, session_id)
+
         return agent
+
+    def _restore_conversation_history(self, agent, session_id: str) -> None:
+        """
+        Load persisted conversation messages from SQLite and inject them
+        into the agent's in-memory message list.
+
+        Only runs when conversation persistence is enabled (default: True).
+        Respects agent_max_context_turns to limit how many turns are loaded.
+        """
+        from config import conf
+        if not conf().get("conversation_persistence", True):
+            return
+
+        try:
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            max_turns = conf().get("agent_max_context_turns", 30)
+            saved = store.load_messages(session_id, max_turns=max_turns)
+            if saved:
+                with agent.messages_lock:
+                    agent.messages = saved
+                logger.info(
+                    f"[AgentInitializer] Restored {len(saved)} messages for session={session_id}"
+                )
+        except Exception as e:
+            logger.warning(
+                f"[AgentInitializer] Failed to restore conversation history for "
+                f"session={session_id}: {e}"
+            )
     
     def _load_env_file(self):
         """Load environment variables from .env file"""