fix：更名和小bug修复

src/plugins/chat/bot.py

@@ -6,7 +6,7 @@ from .chat_stream import chat_manager
 from ..chat_module.only_process.only_message_process import MessageProcessor
 
 from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig
-from ..heartFC_chat.heartFC_processor import HeartFCProcessor
+from ..heartFC_chat.heartflow_processor import HeartFCProcessor
 from ..utils.prompt_builder import Prompt, global_prompt_manager
 import traceback
 
@@ -26,7 +26,7 @@ class ChatBot:
         self.bot = None  # bot 实例引用
         self._started = False
         self.mood_manager = MoodManager.get_instance()  # 获取情绪管理器单例
-        self.heartFC_processor = HeartFCProcessor()  # 新增
+        self.heartflow_processor = HeartFCProcessor()  # 新增
 
         # 创建初始化PFC管理器的任务，会在_ensure_started时执行
         self.only_process_chat = MessageProcessor()
@@ -109,9 +109,9 @@ class ChatBot:
                             await self.only_process_chat.process_message(message)
                             await self._create_pfc_chat(message)
                         else:
-                            await self.heartFC_processor.process_message(message_data)
+                            await self.heartflow_processor.process_message(message_data)
                 else:
-                    await self.heartFC_processor.process_message(message_data)
+                    await self.heartflow_processor.process_message(message_data)
 
             if template_group_name:
                 async with global_prompt_manager.async_message_scope(template_group_name):

src/plugins/chat/utils_image.py

@@ -218,7 +218,7 @@ class ImageManager:
                         "timestamp": timestamp,
                     }
                     db.images.update_one({"hash": image_hash}, {"$set": image_doc}, upsert=True)
-                    logger.success(f"保存图片: {file_path}")
+                    logger.trace(f"保存图片: {file_path}")
                 except Exception as e:
                     logger.error(f"保存图片文件失败: {str(e)}")
 

src/plugins/heartFC_chat/heartFC_chat.py

@@ -203,7 +203,7 @@ class PFChatting:
                 self._processing_lock.release()
             # Remove instance from controller's dict? Only if it's truly done.
             # Consider if loop can be restarted vs instance destroyed.
-            # asyncio.create_task(self.heartfc_controller._remove_pf_chatting_instance(self.stream_id)) # Example cleanup
+            # asyncio.create_task(self.heartfc_controller._remove_heartFC_chat_instance(self.stream_id)) # Example cleanup
 
     async def _run_pf_loop(self):
         """
@@ -268,7 +268,7 @@ class PFChatting:
                             # Continue to timer decrement and sleep
 
                         elif action == "text_reply":
-                            logger.info(f"{log_prefix} PFChatting: 麦麦决定回复文本. 理由: {reasoning}")
+                            logger.debug(f"{log_prefix} PFChatting: 麦麦决定回复文本. 理由: {reasoning}")
                             action_taken_this_cycle = True
                             anchor_message = await self._get_anchor_message(observed_messages)
                             if not anchor_message:
@@ -387,7 +387,7 @@ class PFChatting:
 
                         if timer_strings:  # 如果有有效计时器数据才打印
                             logger.debug(
-                                f"{log_prefix} test testtesttesttesttesttesttesttesttesttest Cycle Timers: {'; '.join(timer_strings)}"
+                                f"{log_prefix} 该次决策耗时: {'; '.join(timer_strings)}"
                             )
 
                     # --- Timer Decrement --- #
@@ -580,30 +580,28 @@ class PFChatting:
         """
 
         try:
-            last_msg_dict = None
-            if observed_messages:
-                last_msg_dict = observed_messages[-1]
+            # last_msg_dict = None
+            # if observed_messages:
+            #     last_msg_dict = observed_messages[-1]
+
+            # if last_msg_dict:
+            #     try:
+            #         anchor_message = MessageRecv(last_msg_dict)  # 移除 chat_stream 参数
+            #         anchor_message.update_chat_stream(self.chat_stream)  # 添加 update_chat_stream 调用
+            #         if not (
+            #             anchor_message
+            #             and anchor_message.message_info
+            #             and anchor_message.message_info.message_id
+            #             and anchor_message.message_info.user_info
+            #         ):
+            #             raise ValueError("重构的 MessageRecv 缺少必要信息.")
+            #         # logger.debug(f"{self._get_log_prefix()} 重构的锚点消息: ID={anchor_message.message_info.message_id}")
+            #         return anchor_message
+            #     except Exception as e_reconstruct:
+            #         logger.warning(
+            #             f"{self._get_log_prefix()} 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符."
+            #         )
 
-            if last_msg_dict:
-                try:
-                    # anchor_message = MessageRecv(last_msg_dict, chat_stream=self.chat_stream)
-                    anchor_message = MessageRecv(last_msg_dict)  # 移除 chat_stream 参数
-                    anchor_message.update_chat_stream(self.chat_stream)  # 添加 update_chat_stream 调用
-                    if not (
-                        anchor_message
-                        and anchor_message.message_info
-                        and anchor_message.message_info.message_id
-                        and anchor_message.message_info.user_info
-                    ):
-                        raise ValueError("重构的 MessageRecv 缺少必要信息.")
-                    # logger.debug(f"{self._get_log_prefix()} 重构的锚点消息: ID={anchor_message.message_info.message_id}")
-                    return anchor_message
-                except Exception as e_reconstruct:
-                    logger.warning(
-                        f"{self._get_log_prefix()} 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符."
-                    )
-            # else:
-            # logger.warning(f"{self._get_log_prefix()} observed_messages 为空. 创建占位符锚点消息.")
 
             # --- Create Placeholder --- #
             placeholder_id = f"mid_pf_{int(time.time() * 1000)}"

src/plugins/heartFC_chat/heartFC_controler.py

@@ -2,17 +2,17 @@ import traceback
 from typing import Optional, Dict
 import asyncio
 import threading  # 导入 threading
-from ...moods.moods import MoodManager
-from ...chat.emoji_manager import emoji_manager
+from ..moods.moods import MoodManager
+from ..chat.emoji_manager import emoji_manager
 from .heartFC_generator import ResponseGenerator
-from .messagesender import MessageManager
-from src.heart_flow.heartflow import heartflow
+from .heartflow_message_sender import MessageManager
+from src.heart_flow.heartflow import heartflow, MaiState
 from src.heart_flow.sub_heartflow import SubHeartflow, ChatState
 from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.do_tool.tool_use import ToolUser
 from src.plugins.chat.chat_stream import chat_manager
-from .pf_chatting import PFChatting
+from .heartFC_chat import PFChatting
 
 
 # 定义日志配置
@@ -27,26 +27,21 @@ logger = get_module_logger("HeartFCController", config=chat_config)
 INTEREST_MONITOR_INTERVAL_SECONDS = 1
 
 
-# 合并后的版本：使用 __new__ + threading.Lock 实现线程安全单例，类名为 HeartFCController
 class HeartFCController:
-    _instance = None
-    _lock = threading.Lock()  # 使用 threading.Lock 保证 __new__ 线程安全
-    _initialized = False
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            with cls._lock:
-                # Double-checked locking
-                if cls._instance is None:
-                    logger.debug("创建 HeartFCController 单例实例...")
-                    cls._instance = super().__new__(cls)
-        return cls._instance
+    _instance: Optional['HeartFCController'] = None
+    _lock = threading.Lock()  # 用于保证 get_instance 线程安全
 
     def __init__(self):
-        # 使用 _initialized 标志确保 __init__ 只执行一次
-        if self._initialized:
+        # __init__ 现在只会在 get_instance 首次创建实例时调用一次
+        # 因此不再需要 _initialized 标志
+
+        # 检查是否已被初始化，防止意外重入 (虽然理论上不太可能)
+        # hasattr 检查通常比标志位稍慢，但在这里作为额外的安全措施
+        if hasattr(self, 'gpt'):
+            logger.warning("HeartFCController __init__ 被意外再次调用。")
             return
 
+        logger.debug("初始化 HeartFCController 单例实例...") # 更新日志信息
         self.gpt = ResponseGenerator()
         self.mood_manager = MoodManager.get_instance()
         self.tool_user = ToolUser()
@@ -54,37 +49,36 @@ class HeartFCController:
 
         self.heartflow = heartflow
 
-        self.pf_chatting_instances: Dict[str, PFChatting] = {}
-        self._pf_chatting_lock = asyncio.Lock()  # 这个是 asyncio.Lock，用于异步上下文
-        self.emoji_manager = emoji_manager  # 假设是全局或已初始化的实例
-        self.relationship_manager = relationship_manager  # 假设是全局或已初始化的实例
+        self.heartFC_chat_instances: Dict[str, PFChatting] = {}
+        self._heartFC_chat_lock = asyncio.Lock()
+        self.emoji_manager = emoji_manager
+        self.relationship_manager = relationship_manager
 
         self.MessageManager = MessageManager
-        self._initialized = True
         logger.info("HeartFCController 单例初始化完成。")
 
     @classmethod
     def get_instance(cls):
-        """获取 HeartFCController 的单例实例。"""
-        # 如果实例尚未创建，调用构造函数（这将触发 __new__ 和 __init__）
+        """获取 HeartFCController 的单例实例。线程安全。"""
+        # Double-checked locking
         if cls._instance is None:
-            # 在首次调用 get_instance 时创建实例。
-            # __new__ 中的锁会确保线程安全。
-            cls()
-            # 添加日志记录，说明实例是在 get_instance 调用时创建的
-            logger.info("HeartFCController 实例在首次 get_instance 时创建。")
-        elif not cls._initialized:
-            # 实例已创建但可能未初始化完成（理论上不太可能发生，除非 __init__ 异常）
-            logger.warning("HeartFCController 实例存在但尚未完成初始化。")
+            with cls._lock:
+                if cls._instance is None:
+                    logger.info("HeartFCController 实例不存在，正在创建...")
+                    # 创建实例，这将自动调用 __init__ 一次
+                    cls._instance = cls()
+                    logger.info("HeartFCController 实例已创建并初始化。")
+        # else: # 不需要这个 else 日志，否则每次获取都会打印
+            # logger.debug("返回已存在的 HeartFCController 实例。")
         return cls._instance
 
     # --- 新增：检查 PFChatting 状态的方法 --- #
-    def is_pf_chatting_active(self, stream_id: str) -> bool:
+    def is_heartFC_chat_active(self, stream_id: str) -> bool:
         """检查指定 stream_id 的 PFChatting 循环是否处于活动状态。"""
         # 注意：这里直接访问字典，不加锁，因为读取通常是安全的，
         # 并且 PFChatting 实例的 _loop_active 状态由其自身的异步循环管理。
-        # 如果需要更强的保证，可以在访问 pf_instance 前获取 _pf_chatting_lock
-        pf_instance = self.pf_chatting_instances.get(stream_id)
+        # 如果需要更强的保证，可以在访问 pf_instance 前获取 _heartFC_chat_lock
+        pf_instance = self.heartFC_chat_instances.get(stream_id)
         if pf_instance and pf_instance._loop_active:  # 直接检查 PFChatting 实例的 _loop_active 属性
             return True
         return False
@@ -110,10 +104,10 @@ class HeartFCController:
             logger.warning("跳过兴趣监控任务创建：任务已存在或正在运行。")
 
     # --- Added PFChatting Instance Manager ---
-    async def _get_or_create_pf_chatting(self, stream_id: str) -> Optional[PFChatting]:
+    async def _get_or_create_heartFC_chat(self, stream_id: str) -> Optional[PFChatting]:
         """获取现有PFChatting实例或创建新实例。"""
-        async with self._pf_chatting_lock:
-            if stream_id not in self.pf_chatting_instances:
+        async with self._heartFC_chat_lock:
+            if stream_id not in self.heartFC_chat_instances:
                 logger.info(f"为流 {stream_id} 创建新的PFChatting实例")
                 # 传递 self (HeartFCController 实例) 进行依赖注入
                 instance = PFChatting(stream_id, self)
@@ -121,8 +115,23 @@ class HeartFCController:
                 if not await instance._initialize():
                     logger.error(f"为流 {stream_id} 初始化PFChatting失败")
                     return None
-                self.pf_chatting_instances[stream_id] = instance
-            return self.pf_chatting_instances[stream_id]
+                self.heartFC_chat_instances[stream_id] = instance
+            return self.heartFC_chat_instances[stream_id]
+
+    async def stop_heartFC_chat(self, stream_id: str):
+        """尝试停止并清理指定 stream_id 的 PFChatting 实例。"""
+        async with self._heartFC_chat_lock:
+            pf_instance = self.heartFC_chat_instances.pop(stream_id, None) # 从字典中移除
+            if pf_instance:
+                stream_name = chat_manager.get_stream_name(stream_id) or stream_id
+                logger.info(f"[{stream_name}] 正在停止 PFChatting 实例...")
+                try:
+                    await pf_instance.shutdown() # 调用实例的 shutdown 方法
+                    logger.info(f"[{stream_name}] PFChatting 实例已停止。")
+                except Exception as e:
+                    logger.error(f"[{stream_name}] 停止 PFChatting 实例时出错: {e}")
+            # else:
+                # logger.debug(f"[{stream_name}] 没有找到需要停止的 PFChatting 实例。")
 
     async def _response_control_loop(self):
         """后台任务，定期检查兴趣度变化并触发回复"""
@@ -131,26 +140,48 @@ class HeartFCController:
             await asyncio.sleep(INTEREST_MONITOR_INTERVAL_SECONDS)
 
             try:
-                # 从心流中获取活跃流
+                global_mai_state = self.heartflow.current_state.mai_status
+
                 active_stream_ids = list(self.heartflow.get_all_subheartflows_streams_ids())
                 for stream_id in active_stream_ids:
-                    stream_name = chat_manager.get_stream_name(stream_id) or stream_id  # 获取流名称
+                    stream_name = chat_manager.get_stream_name(stream_id) or stream_id
                     sub_hf = self.heartflow.get_subheartflow(stream_id)
                     if not sub_hf:
-                        logger.warning(f"监控循环: 无法获取活跃流 {stream_name} 的 sub_hf")
                         continue
 
-                    should_trigger_hfc = False
-                    try:
-                        interest_chatting = sub_hf.interest_chatting
-                        should_trigger_hfc = interest_chatting.should_evaluate_reply()
+                    current_chat_state = sub_hf.chat_state.chat_status
+                    log_prefix = f"[{stream_name}]"
 
-                    except Exception as e:
-                        logger.error(f"检查兴趣触发器时出错 流 {stream_name}: {e}")
-                        logger.error(traceback.format_exc())
+                    if global_mai_state == MaiState.OFFLINE:
+                        if current_chat_state == ChatState.FOCUSED:
+                             logger.warning(f"{log_prefix} Global state is OFFLINE, but SubHeartflow is FOCUSED. Stopping PFChatting.")
+                             await self.stop_heartFC_chat(stream_id)
+                        continue
 
-                    if should_trigger_hfc:
-                        # 启动一次麦麦聊天
+                    # --- 只有在全局状态允许时才执行以下逻辑 --- #
+                    if current_chat_state == ChatState.CHAT:
+                        should_evaluate = False
+                        try:
+                            should_evaluate = sub_hf.should_evaluate_reply()
+                        except Exception as e:
+                            logger.error(f"检查回复概率时出错 流 {stream_name}: {e}")
+                            logger.error(traceback.format_exc())
+
+                        if should_evaluate:
+                            # --- Limit Check before entering FOCUSED state --- #
+                            focused_limit = global_mai_state.get_focused_chat_max_num()
+                            current_focused_count = self.heartflow.count_subflows_by_state(ChatState.FOCUSED)
+
+                            if current_focused_count >= focused_limit:
+                                logger.debug(f"{log_prefix} 拒绝从 CHAT 转换到 FOCUSED。原因：FOCUSED 状态已达上限 ({focused_limit})。当前数量: {current_focused_count}")
+                                # Do not change state, continue to next stream or cycle
+                            else:
+                                logger.info(f"{log_prefix} 兴趣概率触发，将状态从 CHAT 提升到 FOCUSED (全局状态: {global_mai_state.value}, 上限: {focused_limit}, 当前: {current_focused_count})")
+                                sub_hf.set_chat_state(ChatState.FOCUSED)
+                            # --- End Limit Check --- #
+
+                    elif current_chat_state == ChatState.FOCUSED:
+                        # logger.debug(f"[{stream_name}] State FOCUSED, triggering HFC (全局状态: {global_mai_state.value})...")
                         await self._trigger_hfc(sub_hf)
 
             except asyncio.CancelledError:
@@ -159,18 +190,29 @@ class HeartFCController:
             except Exception as e:
                 logger.error(f"兴趣监控循环错误: {e}")
                 logger.error(traceback.format_exc())
-                await asyncio.sleep(5)  # 发生错误时等待
+                await asyncio.sleep(5)
 
     async def _trigger_hfc(self, sub_hf: SubHeartflow):
-        chat_state = sub_hf.chat_state
-        if chat_state == ChatState.ABSENT:
-            chat_state = ChatState.CHAT
-        elif chat_state == ChatState.CHAT:
-            chat_state = ChatState.FOCUSED
+        """仅当 SubHeartflow 状态为 FOCUSED 时，触发 PFChatting 的激活或时间增加。"""
+        stream_id = sub_hf.subheartflow_id
+        stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
 
-        # 从 sub_hf 获取 stream_id
-        if chat_state == ChatState.FOCUSED:
-            stream_id = sub_hf.subheartflow_id
-            pf_instance = await self._get_or_create_pf_chatting(stream_id)
-            if pf_instance:  # 确保实例成功获取或创建
-                asyncio.create_task(pf_instance.add_time())
+        # 首先检查状态
+        if sub_hf.chat_state.chat_status != ChatState.FOCUSED:
+            logger.warning(f"[{stream_name}] 尝试在非 FOCUSED 状态 ({sub_hf.chat_state.chat_status.value}) 下触发 HFC。已跳过。")
+            return
+
+        # 移除内部状态修改逻辑
+        # chat_state = sub_hf.chat_state
+        # if chat_state == ChatState.ABSENT:
+        #     chat_state = ChatState.CHAT
+        # elif chat_state == ChatState.CHAT:
+        #     chat_state = ChatState.FOCUSED
+
+        # 状态已经是 FOCUSED，直接获取或创建 PFChatting 并添加时间
+        # logger.debug(f"[{stream_name}] Triggering PFChatting add_time in FOCUSED state.") # Debug log
+        pf_instance = await self._get_or_create_heartFC_chat(stream_id)
+        if pf_instance:  # 确保实例成功获取或创建
+            await pf_instance.add_time() # 注意：这里不再需要 create_task，因为 add_time 内部会处理任务创建
+        else:
+            logger.error(f"[{stream_name}] 无法获取或创建 PFChatting 实例以触发 HFC。")

src/plugins/heartFC_chat/heartFC_generator.py

@@ -1,14 +1,14 @@
 from typing import List, Optional
 
 
-from ...models.utils_model import LLMRequest
-from ....config.config import global_config
-from ...chat.message import MessageRecv
-from .heartFC_prompt_builder import prompt_builder
-from ...chat.utils import process_llm_response
+from ..models.utils_model import LLMRequest
+from ...config.config import global_config
+from ..chat.message import MessageRecv
+from .heartflow_prompt_builder import prompt_builder
+from ..chat.utils import process_llm_response
 from src.common.logger import get_module_logger, LogConfig, LLM_STYLE_CONFIG
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
-from ...utils.timer_calculater import Timer
+from ..utils.timer_calculater import Timer
 
 from src.plugins.moods.moods import MoodManager
 

src/plugins/heartFC_chat/heartflow_message_sender.py

@@ -3,11 +3,11 @@ import time
 from typing import Dict, List, Optional, Union
 
 from src.common.logger import get_module_logger
-from ...message.api import global_api
-from ...chat.message import MessageSending, MessageThinking, MessageSet
-from ...storage.storage import MessageStorage
-from ....config.config import global_config
-from ...chat.utils import truncate_message, calculate_typing_time, count_messages_between
+from ..message.api import global_api
+from ..chat.message import MessageSending, MessageThinking, MessageSet
+from ..storage.storage import MessageStorage
+from ...config.config import global_config
+from ..chat.utils import truncate_message, calculate_typing_time, count_messages_between
 
 from src.common.logger import LogConfig, SENDER_STYLE_CONFIG
 
@@ -216,9 +216,7 @@ class MessageManager:
                     thinking_start_time=message_earliest.thinking_start_time,
                     is_emoji=message_earliest.is_emoji,
                 )
-                logger.trace(f"\n{message_earliest.processed_plain_text},{typing_time},计算输入时间结束\n")
                 await asyncio.sleep(typing_time)
-                logger.debug(f"\n{message_earliest.processed_plain_text},{typing_time},等待输入时间结束\n")
 
                 await MessageSender().send_message(message_earliest)
                 await self.storage.store_message(message_earliest, message_earliest.chat_stream)

src/plugins/heartFC_chat/heartflow_processor.py

@@ -1,31 +1,31 @@
 import time
 import traceback
-from ...memory_system.Hippocampus import HippocampusManager
-from ....config.config import global_config
-from ...chat.message import MessageRecv
-from ...storage.storage import MessageStorage
-from ...chat.utils import is_mentioned_bot_in_message
-from ...message import Seg
+from ..memory_system.Hippocampus import HippocampusManager
+from ...config.config import global_config
+from ..chat.message import MessageRecv
+from ..storage.storage import MessageStorage
+from ..chat.utils import is_mentioned_bot_in_message
+from ..message import Seg
 from src.heart_flow.heartflow import heartflow
 from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig
-from ...chat.chat_stream import chat_manager
-from ...chat.message_buffer import message_buffer
-from ...utils.timer_calculater import Timer
+from ..chat.chat_stream import chat_manager
+from ..chat.message_buffer import message_buffer
+from ..utils.timer_calculater import Timer
 from src.plugins.person_info.relationship_manager import relationship_manager
-from .reasoning_chat import ReasoningChat
+from .normal_chat import ReasoningChat
 
 # 定义日志配置
 processor_config = LogConfig(
     console_format=CHAT_STYLE_CONFIG["console_format"],
     file_format=CHAT_STYLE_CONFIG["file_format"],
 )
-logger = get_module_logger("heartFC_processor", config=processor_config)
+logger = get_module_logger("heartflow_processor", config=processor_config)
 
 
 class HeartFCProcessor:
     def __init__(self):
         self.storage = MessageStorage()
-        self.reasoning_chat = ReasoningChat.get_instance()
+        self.normal_chat = ReasoningChat.get_instance()
 
     async def process_message(self, message_data: str) -> None:
         """处理接收到的原始消息数据，完成消息解析、缓冲、过滤、存储、兴趣度计算与更新等核心流程。
@@ -77,7 +77,7 @@ class HeartFCProcessor:
 
             # --- 添加兴趣追踪启动 (现在移动到这里，确保 subheartflow 存在后启动) ---
             # 在获取到 chat 对象和确认 subheartflow 后，启动对该聊天流的兴趣监控
-            await self.reasoning_chat.start_monitoring_interest(chat)  # start_monitoring_interest 内部需要修改以适应
+            await self.normal_chat.start_monitoring_interest(chat)  # start_monitoring_interest 内部需要修改以适应
             # --- 结束添加 ---
 
             message.update_chat_stream(chat)
@@ -196,7 +196,7 @@ class HeartFCProcessor:
                         "",
                     )
                 else:
-                    logger.debug(f"已认识用户: {message.message_info.user_info.user_nickname}")
+                    # logger.debug(f"已认识用户: {message.message_info.user_info.user_nickname}")
                     if not await relationship_manager.is_qved_name(
                         message.message_info.platform, message.message_info.user_info.user_id
                     ):

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -1,21 +1,22 @@
 import random
 from typing import Optional
-from ....config.config import global_config
-from ...chat.utils import get_recent_group_detailed_plain_text
-from ...chat.chat_stream import chat_manager
+from ...config.config import global_config
+from ..chat.utils import get_recent_group_detailed_plain_text
+from ..chat.chat_stream import chat_manager
 from src.common.logger import get_module_logger
-from ....individuality.individuality import Individuality
+from ...individuality.individuality import Individuality
 from src.heart_flow.heartflow import heartflow
 from src.plugins.utils.prompt_builder import Prompt, global_prompt_manager
+from src.plugins.utils.chat_message_builder import build_readable_messages, get_raw_msg_before_timestamp_with_chat
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.chat.utils import parse_text_timestamps
 import time
 from typing import Union
-from ....common.database import db
-from ...chat.utils import get_embedding, get_recent_group_speaker
-from ...moods.moods import MoodManager
-from ...memory_system.Hippocampus import HippocampusManager
-from ...schedule.schedule_generator import bot_schedule
+from ...common.database import db
+from ..chat.utils import get_embedding, get_recent_group_speaker
+from ..moods.moods import MoodManager
+from ..memory_system.Hippocampus import HippocampusManager
+from ..schedule.schedule_generator import bot_schedule
 
 logger = get_module_logger("prompt")
 
@@ -105,21 +106,25 @@ class PromptBuilder:
         # 日程构建
         # schedule_prompt = f'''你现在正在做的事情是：{bot_schedule.get_current_num_task(num = 1,time_info = False)}'''
 
-        # 获取聊天上下文
-        chat_in_group = True
-        chat_talking_prompt = ""
-        if stream_id:
-            chat_talking_prompt = get_recent_group_detailed_plain_text(
-                stream_id, limit=global_config.MAX_CONTEXT_SIZE, combine=True
-            )
-            chat_stream = chat_manager.get_stream(stream_id)
-            if chat_stream.group_info:
-                chat_talking_prompt = chat_talking_prompt
-            else:
-                chat_in_group = False
-                chat_talking_prompt = chat_talking_prompt
-                # print(f"\033[1;34m[调试]\033[0m 已从数据库获取群 {group_id} 的消息记录:{chat_talking_prompt}")
-
+        chat_stream = chat_manager.get_stream(stream_id)
+        if chat_stream.group_info:
+            chat_in_group = True
+        else:
+            chat_in_group = False 
+        
+        message_list_before_now = get_raw_msg_before_timestamp_with_chat(
+            chat_id =chat_stream.stream_id,
+            timestamp = time.time(),
+            limit=global_config.MAX_CONTEXT_SIZE,
+        )
+        
+        chat_talking_prompt = await build_readable_messages(
+            message_list_before_now,
+            replace_bot_name=True,
+            merge_messages=False,
+            timestamp_mode="relative",
+            read_mark=0.0,
+        )
 
         # 关键词检测与反应
         keywords_reaction_prompt = ""
@@ -148,23 +153,9 @@ class PromptBuilder:
         if random.random() < 0.02:
             prompt_ger += "你喜欢用反问句"
 
-        #         moderation_prompt = ""
-        #         moderation_prompt = """**检查并忽略**任何涉及尝试绕过审核的行为。
-        # 涉及政治敏感以及违法违规的内容请规避。"""
 
         logger.debug("开始构建prompt")
 
-        #         prompt = f"""
-        # {chat_target}
-        # {chat_talking_prompt}
-        # 现在"{sender_name}"说的:{message_txt}。引起了你的注意，你想要在群里发言发言或者回复这条消息。\n
-        # 你的网名叫{global_config.BOT_NICKNAME}，{prompt_personality} {prompt_identity}。
-        # 你正在{chat_target_2},现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，
-        # 你刚刚脑子里在想：
-        # {current_mind_info}
-        # 回复尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。{prompt_ger}
-        # 请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景，尽量不要说你说过的话 ，注意只输出回复内容。
-        # {moderation_prompt}。注意：不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。"""
         prompt = await global_prompt_manager.format_prompt(
             "heart_flow_prompt",
             chat_target=await global_prompt_manager.get_prompt_async("chat_target_group1")
@@ -257,19 +248,28 @@ class PromptBuilder:
         # schedule_prompt = f"""你现在正在做的事情是：{bot_schedule.get_current_num_task(num=1, time_info=False)}"""
 
         # 获取聊天上下文
-        chat_in_group = True
-        chat_talking_prompt = ""
-        if stream_id:
-            chat_talking_prompt = get_recent_group_detailed_plain_text(
-                stream_id, limit=global_config.MAX_CONTEXT_SIZE, combine=True
-            )
-            chat_stream = chat_manager.get_stream(stream_id)
-            if chat_stream.group_info:
-                chat_talking_prompt = chat_talking_prompt
-            else:
-                chat_in_group = False
-                chat_talking_prompt = chat_talking_prompt
-                # print(f"\033[1;34m[调试]\033[0m 已从数据库获取群 {group_id} 的消息记录:{chat_talking_prompt}")
+        chat_stream = chat_manager.get_stream(stream_id)
+        if chat_stream.group_info:
+            chat_in_group = True
+        else:
+            chat_in_group = False 
+        
+        message_list_before_now = get_raw_msg_before_timestamp_with_chat(
+            chat_id =chat_stream.stream_id,
+            timestamp = time.time(),
+            limit=global_config.MAX_CONTEXT_SIZE,
+        )
+        
+        chat_talking_prompt = await build_readable_messages(
+            message_list_before_now,
+            replace_bot_name=True,
+            merge_messages=False,
+            timestamp_mode="relative",
+            read_mark=0.0,
+        )
+                
+                
+                
         # 关键词检测与反应
         keywords_reaction_prompt = ""
         for rule in global_config.keywords_reaction_rules:
@@ -310,7 +310,11 @@ class PromptBuilder:
         logger.debug(f"知识检索耗时: {(end_time - start_time):.3f}秒")
 
         logger.debug("开始构建prompt")
-
+        
+        schedule_prompt=await global_prompt_manager.format_prompt(
+            "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False)
+        )
+        
         prompt = await global_prompt_manager.format_prompt(
             "reasoning_prompt_main",
             relation_prompt_all=await global_prompt_manager.get_prompt_async("relationship_prompt"),
@@ -318,9 +322,7 @@ class PromptBuilder:
             sender_name=sender_name,
             memory_prompt=memory_prompt,
             prompt_info=prompt_info,
-            schedule_prompt=await global_prompt_manager.format_prompt(
-                "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False)
-            ),
+            schedule_prompt=schedule_prompt,
             chat_target=await global_prompt_manager.get_prompt_async("chat_target_group1")
             if chat_in_group
             else await global_prompt_manager.get_prompt_async("chat_target_private1"),

src/plugins/heartFC_chat/normal_chat.py

@@ -4,23 +4,24 @@ from random import random
 import traceback
 import asyncio
 from typing import List, Dict
-from ...moods.moods import MoodManager
-from ....config.config import global_config
-from ...chat.emoji_manager import emoji_manager
-from .reasoning_generator import ResponseGenerator
-from ...chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet
-from ...chat.messagesender import message_manager
-from ...storage.storage import MessageStorage
-from ...chat.utils import is_mentioned_bot_in_message
-from ...chat.utils_image import image_path_to_base64
-from ...willing.willing_manager import willing_manager
-from ...message import UserInfo, Seg
+from ..moods.moods import MoodManager
+from ...config.config import global_config
+from ..chat.emoji_manager import emoji_manager
+from .normal_chat_generator import ResponseGenerator
+from ..chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet
+from ..chat.messagesender import message_manager
+from ..storage.storage import MessageStorage
+from ..chat.utils import is_mentioned_bot_in_message
+from ..chat.utils_image import image_path_to_base64
+from ..willing.willing_manager import willing_manager
+from ..message import UserInfo, Seg
 from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig
-from src.plugins.chat.chat_stream import ChatStream
+from src.plugins.chat.chat_stream import ChatStream, chat_manager
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.utils.timer_calculater import Timer
 from src.heart_flow.heartflow import heartflow
+from src.heart_flow.sub_heartflow import ChatState
 from .heartFC_controler import HeartFCController
 
 # 定义日志配置
@@ -29,7 +30,7 @@ chat_config = LogConfig(
     file_format=CHAT_STYLE_CONFIG["file_format"],
 )
 
-logger = get_module_logger("reasoning_chat", config=chat_config)
+logger = get_module_logger("normal_chat", config=chat_config)
 
 
 class ReasoningChat:
@@ -187,69 +188,95 @@ class ReasoningChat:
             # 在没有控制器的情况下可能需要决定是继续处理还是完全停止？这里暂时假设继续
             pass  # 或者 return?
 
-        logger.info(f"[{stream_id}] 兴趣消息监控任务启动。")  # 增加启动日志
+        # logger.info(f"[{stream_id}] 兴趣消息监控任务启动。") # 减少日志
         while True:
             await asyncio.sleep(1)  # 每秒检查一次
 
-            # --- 修改：通过 heartflow 获取 subheartflow 和 interest_dict --- #
             subheartflow = heartflow.get_subheartflow(stream_id)
 
-            # 检查 subheartflow 是否存在以及是否被标记停止
             if not subheartflow or subheartflow.should_stop:
-                logger.info(f"[{stream_id}] SubHeartflow 不存在或已停止，兴趣消息监控任务退出。")
-                break  # 退出循环，任务结束
+                # logger.info(f"[{stream_id}] SubHeartflow 不存在或已停止，兴趣消息监控任务退出。") # 减少日志
+                break
 
-            # 从 subheartflow 获取 interest_dict
             interest_dict = subheartflow.get_interest_dict()
-            # --- 结束修改 --- #
-
-            # 创建 items 快照进行迭代，避免在迭代时修改字典
             items_to_process = list(interest_dict.items())
 
             if not items_to_process:
-                continue  # 没有需要处理的消息，继续等待
-
-            # logger.debug(f"[{stream_id}] 发现 {len(items_to_process)} 条待处理兴趣消息。") # 调试日志
+                continue
 
             for msg_id, (message, interest_value, is_mentioned) in items_to_process:
-                # --- 检查 PFChatting 是否活跃 --- #
+                # --- 在处理前检查 SubHeartflow 的状态 --- #
+                current_chat_state = subheartflow.chat_state.chat_status
+                stream_name = chat_manager.get_stream_name(stream_id) or stream_id
+
+                if current_chat_state != ChatState.CHAT:
+                    # 如果不是闲聊状态 (可能是 ABSENT 或 FOCUSED)，则跳过推理聊天
+                    # logger.debug(f"[{stream_name}] 跳过处理兴趣消息 {msg_id}，因为当前状态为 {current_chat_state.value}")
+                    # 移除消息并继续下一个
+                    removed_item = interest_dict.pop(msg_id, None)
+                    if removed_item:
+                        # logger.debug(f"[{stream_name}] 已从兴趣字典中移除消息 {msg_id} (因状态跳过)") # 减少日志
+                        pass
+                    continue # 处理下一条消息
+                # --- 结束状态检查 --- #
+
+                # --- 检查 PFChatting 是否活跃 (保持原有逻辑) --- #
                 pf_active = False
                 if controller:
-                    pf_active = controller.is_pf_chatting_active(stream_id)
+                    pf_active = controller.is_heartFC_chat_active(stream_id)
 
                 if pf_active:
-                    # 如果 PFChatting 活跃，则跳过处理，直接移除消息
                     removed_item = interest_dict.pop(msg_id, None)
                     if removed_item:
-                        logger.debug(f"[{stream_id}] PFChatting 活跃，已跳过并移除兴趣消息 {msg_id}")
-                    continue  # 处理下一条消息
+                        logger.debug(f"[{stream_name}] PFChatting 活跃，已跳过并移除兴趣消息 {msg_id}")
+                    continue
                 # --- 结束检查 --- #
 
-                # 只有当 PFChatting 不活跃时才执行以下处理逻辑
+                # 只有当状态为 CHAT 且 PFChatting 不活跃时才执行以下处理逻辑
                 try:
-                    # logger.debug(f"[{stream_id}] 正在处理兴趣消息 {msg_id} (兴趣值: {interest_value:.2f})" )
-                    await self.normal_reasoning_chat(
+                    await self.normal_normal_chat(
                         message=message,
-                        chat=chat,  # chat 对象仍然有效
+                        chat=chat,
                         is_mentioned=is_mentioned,
-                        interested_rate=interest_value,  # 使用从字典获取的原始兴趣值
+                        interested_rate=interest_value,
                     )
-                    # logger.debug(f"[{stream_id}] 处理完成消息 {msg_id}")
                 except Exception as e:
-                    logger.error(f"[{stream_id}] 处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}")
+                    logger.error(f"[{stream_name}] 处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}")
                 finally:
-                    # 无论处理成功与否（且PFChatting不活跃），都尝试从原始字典中移除该消息
-                    # 使用 pop(key, None) 避免 Key Error
                     removed_item = interest_dict.pop(msg_id, None)
                     if removed_item:
-                        logger.debug(f"[{stream_id}] 已从兴趣字典中移除消息 {msg_id}")
+                        # logger.debug(f"[{stream_name}] 已从兴趣字典中移除消息 {msg_id}") # 减少日志
+                        pass
 
-    async def normal_reasoning_chat(
+    async def normal_normal_chat(
         self, message: MessageRecv, chat: ChatStream, is_mentioned: bool, interested_rate: float
     ) -> None:
         timing_results = {}
         userinfo = message.message_info.user_info
         messageinfo = message.message_info
+        stream_id = chat.stream_id
+        stream_name = chat_manager.get_stream_name(stream_id) or stream_id
+
+        # --- 在开始时检查 SubHeartflow 状态 --- #
+        sub_hf = heartflow.get_subheartflow(stream_id)
+        if not sub_hf:
+            logger.warning(f"[{stream_name}] 无法获取 SubHeartflow，无法执行 normal_normal_chat。")
+            return
+
+        current_chat_state = sub_hf.chat_state.chat_status
+        if current_chat_state != ChatState.CHAT:
+            logger.debug(
+                f"[{stream_name}] 跳过 normal_normal_chat，因为 SubHeartflow 状态为 {current_chat_state.value} (需要 CHAT)。"
+            )
+            # 可以在这里添加 not_reply_handle 逻辑吗？ 如果不回复，也需要清理意愿。
+            # 注意：willing_manager.setup 尚未调用
+            willing_manager.setup(message, chat, is_mentioned, interested_rate) # 先 setup
+            await willing_manager.not_reply_handle(message.message_info.message_id)
+            willing_manager.delete(message.message_info.message_id)
+            return
+        # --- 结束状态检查 --- #
+
+        # --- 接下来的逻辑只在 ChatState.CHAT 状态下执行 --- #
 
         is_mentioned, reply_probability = is_mentioned_bot_in_message(message)
         # 意愿管理器：设置当前message信息

src/plugins/heartFC_chat/normal_chat_generator.py

@@ -1,10 +1,9 @@
 from typing import List, Optional, Tuple, Union
 import random
-
 from ..models.utils_model import LLMRequest
 from ...config.config import global_config
 from ..chat.message import MessageThinking
-from .heartFC_prompt_builder import prompt_builder
+from .heartflow_prompt_builder import prompt_builder
 from ..chat.utils import process_llm_response
 from ..utils.timer_calculater import Timer
 from src.common.logger import get_module_logger, LogConfig, LLM_STYLE_CONFIG
@@ -86,7 +85,7 @@ class ResponseGenerator:
         with Timer() as t_build_prompt:
             prompt = await prompt_builder.build_prompt(
                 build_mode="normal",
-                reason=message.reason,
+                reason= "",
                 chat_stream=message.chat_stream,
                 message_txt=message.processed_plain_text,
                 sender_name=sender_name,
@@ -96,6 +95,8 @@ class ResponseGenerator:
 
         try:
             content, reasoning_content, self.current_model_name = await model.generate_response(prompt)
+            
+            logger.info(f"prompt:{prompt}\n生成回复：{content}")
 
             info_catcher.catch_after_llm_generated(
                 prompt=prompt, response=content, reasoning_content=reasoning_content, model_name=self.current_model_name

src/plugins/heartFC_chat/pfchating.md

@@ -1,97 +0,0 @@
-# PFChatting 与主动回复流程说明 (V2)
-
-本文档描述了 `PFChatting` 类及其在 `heartFC_controler` 模块中实现的主动、基于兴趣的回复流程。
-
-## 1. `PFChatting` 类概述
-
-*   **目标**: 管理特定聊天流 (`stream_id`) 的主动回复逻辑，使其行为更像人类的自然交流。
-*   **创建时机**: 当 `HeartFC_Chat` 的兴趣监控任务 (`_interest_monitor_loop`) 检测到某个聊天流的兴趣度 (`InterestChatting`) 达到了触发回复评估的条件 (`should_evaluate_reply`) 时，会为该 `stream_id` 获取或创建唯一的 `PFChatting` 实例 (`_get_or_create_pf_chatting`)。
-*   **持有**:
-    *   对应的 `sub_heartflow` 实例引用 (通过 `heartflow.get_subheartflow(stream_id)`)。
-    *   对应的 `chat_stream` 实例引用。
-    *   对 `HeartFC_Chat` 单例的引用 (用于调用发送消息、处理表情等辅助方法)。
-*   **初始化**: `PFChatting` 实例在创建后会执行异步初始化 (`_initialize`)，这可能包括加载必要的上下文或历史信息（*待确认是否实现了读取历史消息*）。
-
-## 2. 核心回复流程 (由 `HeartFC_Chat` 触发)
-
-当 `HeartFC_Chat` 调用 `PFChatting` 实例的方法 (例如 `add_time`) 时，会启动内部的回复决策与执行流程：
-
-1.  **规划 (Planner):**
-    *   **输入**: 从关联的 `sub_heartflow` 获取观察结果、思考链、记忆片段等上下文信息。
-    *   **决策**:
-        *   判断当前是否适合进行回复。
-        *   决定回复的形式（纯文本、带表情包等）。
-        *   选择合适的回复时机和策略。
-    *   **实现**: *此部分逻辑待详细实现，可能利用 LLM 的工具调用能力来增强决策的灵活性和智能性。需要考虑机器人的个性化设定。*
-
-2.  **回复生成 (Replier):**
-    *   **输入**: Planner 的决策结果和必要的上下文。
-    *   **执行**:
-        *   调用 `ResponseGenerator` (`self.gpt`) 或类似组件生成具体的回复文本内容。
-        *   可能根据 Planner 的策略生成多个候选回复。
-    *   **并发**: 系统支持同时存在多个思考/生成任务（上限由 `global_config.max_concurrent_thinking_messages` 控制）。
-
-3.  **检查 (Checker):**
-    *   **时机**: 在回复生成过程中或生成后、发送前执行。
-    *   **目的**:
-        *   检查自开始生成回复以来，聊天流中是否出现了新的消息。
-        *   评估已生成的候选回复在新的上下文下是否仍然合适、相关。
-        *   *需要实现相似度比较逻辑，防止发送与近期消息内容相近或重复的回复。*
-    *   **处理**: 如果检查结果认为回复不合适，则该回复将被**抛弃**。
-
-4.  **发送协调:**
-    *   **执行**: 如果 Checker 通过，`PFChatting` 会调用 `HeartFC_Chat` 实例提供的发送接口：
-        *   `_create_thinking_message`: 通知 `MessageManager` 显示"正在思考"状态。
-        *   `_send_response_messages`: 将最终的回复文本交给 `MessageManager` 进行排队和发送。
-        *   `_handle_emoji`: 如果需要发送表情包，调用此方法处理表情包的获取和发送。
-    *   **细节**: 实际的消息发送、排队、间隔控制由 `MessageManager` 和 `MessageSender` 负责。
-
-## 3. 与其他模块的交互
-
-*   **`HeartFC_Chat`**:
-    *   创建、管理和触发 `PFChatting` 实例。
-    *   提供发送消息 (`_send_response_messages`)、处理表情 (`_handle_emoji`)、创建思考消息 (`_create_thinking_message`) 的接口给 `PFChatting` 调用。
-    *   运行兴趣监控循环 (`_interest_monitor_loop`)。
-*   **`InterestManager` / `InterestChatting`**:
-    *   `InterestManager` 存储每个 `stream_id` 的 `InterestChatting` 实例。
-    *   `InterestChatting` 负责计算兴趣衰减和回复概率。
-    *   `HeartFC_Chat` 查询 `InterestChatting.should_evaluate_reply()` 来决定是否触发 `PFChatting`。
-*   **`heartflow` / `sub_heartflow`**:
-    *   `PFChatting` 从对应的 `sub_heartflow` 获取进行规划所需的核心上下文信息 (观察、思考链等)。
-*   **`MessageManager` / `MessageSender`**:
-    *   接收来自 `HeartFC_Chat` 的发送请求 (思考消息、文本消息、表情包消息)。
-    *   管理消息队列 (`MessageContainer`)，处理消息发送间隔和实际发送 (`MessageSender`)。
-*   **`ResponseGenerator` (`gpt`)**:
-    *   被 `PFChatting` 的 Replier 部分调用，用于生成回复文本。
-*   **`MessageStorage`**:
-    *   存储所有接收和发送的消息。
-*   **`HippocampusManager`**:
-    *   `HeartFC_Processor` 使用它计算传入消息的记忆激活率，作为兴趣度计算的输入之一。
-
-## 4. 原有问题与状态更新
-
-1.  **每个 `pfchating` 是否对应一个 `chat_stream`，是否是唯一的？**
-    *   **是**。`HeartFC_Chat._get_or_create_pf_chatting` 确保了每个 `stream_id` 只有一个 `PFChatting` 实例。 (已确认)
-2.  **`observe_text` 传入进来是纯 str，是不是应该传进来 message 构成的 list?**
-    *   **机制已改变**。当前的触发机制是基于 `InterestManager` 的概率判断。`PFChatting` 启动后，应从其关联的 `sub_heartflow` 获取更丰富的上下文信息，而非简单的 `observe_text`。
-3.  **检查失败的回复应该怎么处理？**
-    *   **暂定：抛弃**。这是当前 Checker 逻辑的基础设定。
-4.  **如何比较相似度？**
-    *   **待实现**。Checker 需要具体的算法来比较候选回复与新消息的相似度。
-5.  **Planner 怎么写？**
-    *   **待实现**。这是 `PFChatting` 的核心决策逻辑，需要结合 `sub_heartflow` 的输出、LLM 工具调用和个性化配置来设计。
-
-
-## 6. 未来优化点
-
-*   实现 Checker 中的相似度比较算法。
-*   详细设计并实现 Planner 的决策逻辑，包括 LLM 工具调用和个性化。
-*   确认并完善 `PFChatting._initialize()` 中的历史消息加载逻辑。
-*   探索更优的检查失败回复处理策略（例如：重新规划、修改回复等）。
-*   优化 `PFChatting` 与 `sub_heartflow` 的信息交互。
-
-
-
-BUG:
-2.复读，可能是planner还未校准好
-3.planner还未个性化，需要加入bot个性信息，且获取的聊天内容有问题

src/plugins/remote/remote.py

@@ -66,11 +66,12 @@ def send_heartbeat(server_url, client_id):
             logger.debug(f"心跳发送成功。服务器响应: {data}")
             return True
         else:
-            logger.error(f"心跳发送失败。状态码: {response.status_code}, 响应内容: {response.text}")
+            logger.debug(f"心跳发送失败。状态码: {response.status_code}, 响应内容: {response.text}")
             return False
 
     except requests.RequestException as e:
-        logger.error(f"发送心跳时出错: {e}")
+        # 如果请求异常，可能是网络问题，不记录错误
+        logger.debug(f"发送心跳时出错: {e}")
         return False
 
 

src/plugins/schedule/schedule_generator.py

@@ -76,7 +76,7 @@ class ScheduleGenerator:
             logger.info(f"日程系统启动/刷新时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
             # 初始化日程
             await self.check_and_create_today_schedule()
-            self.print_schedule()
+            # self.print_schedule()
 
             while True:
                 # print(self.get_current_num_task(1, True))
@@ -88,7 +88,7 @@ class ScheduleGenerator:
                     logger.info("检测到日期变化，重新生成日程")
                     self.start_time = current_time
                     await self.check_and_create_today_schedule()
-                    self.print_schedule()
+                    # self.print_schedule()
 
                 # 执行当前活动
                 # mind_thinking = heartflow.current_state.current_mind

src/plugins/utils/chat_message_builder.py

@@ -232,7 +232,7 @@ async def _build_readable_messages_internal(
 
     # 4 & 5: 格式化为字符串
     output_lines = []
-    for merged in merged_messages:
+    for _i, merged in enumerate(merged_messages):
         # 使用指定的 timestamp_mode 格式化时间
         readable_time = translate_timestamp_to_human_readable(merged["start_time"], mode=timestamp_mode)
 
@@ -242,11 +242,14 @@ async def _build_readable_messages_internal(
         for line in merged["content"]:
             stripped_line = line.strip()
             if stripped_line:  # 过滤空行
+                # 移除末尾句号，添加分号
                 if stripped_line.endswith("。"):
-                    stripped_line = stripped_line.rstrip("。")
+                    stripped_line = stripped_line[:-1]
                 output_lines.append(f"{stripped_line};")
-        output_lines += "\n"
-    formatted_string = "".join(output_lines)
+        output_lines.append("\n") # 在每个消息块后添加换行，保持可读性
+
+    # 移除可能的多余换行，然后合并
+    formatted_string = "".join(output_lines).strip()
 
     # 返回格式化后的字符串和原始的 message_details 列表
     return formatted_string, message_details
@@ -273,12 +276,43 @@ async def build_readable_messages(
     replace_bot_name: bool = True,
     merge_messages: bool = False,
     timestamp_mode: str = "relative",
+    read_mark: float = 0.0,
 ) -> str:
     """
     将消息列表转换为可读的文本格式。
+    如果提供了 read_mark，则在相应位置插入已读标记。
     允许通过参数控制格式化行为。
     """
-    formatted_string, _ = await _build_readable_messages_internal(
-        messages, replace_bot_name, merge_messages, timestamp_mode
-    )
-    return formatted_string
+    if read_mark <= 0:
+        # 没有有效的 read_mark，直接格式化所有消息
+        formatted_string, _ = await _build_readable_messages_internal(
+            messages, replace_bot_name, merge_messages, timestamp_mode
+        )
+        return formatted_string
+    else:
+        # 按 read_mark 分割消息
+        messages_before_mark = [msg for msg in messages if msg.get("time", 0) <= read_mark]
+        messages_after_mark = [msg for msg in messages if msg.get("time", 0) > read_mark]
+
+        # 分别格式化
+        formatted_before, _ = await _build_readable_messages_internal(
+            messages_before_mark, replace_bot_name, merge_messages, timestamp_mode
+        )
+        formatted_after, _ = await _build_readable_messages_internal(
+            messages_after_mark, replace_bot_name, merge_messages, timestamp_mode
+        )
+
+        readable_read_mark = translate_timestamp_to_human_readable(read_mark, mode=timestamp_mode)
+        read_mark_line = f"\n--- 以上消息已读 (标记时间: {readable_read_mark}) ---\n"
+
+        # 组合结果，确保空部分不引入多余的标记或换行
+        if formatted_before and formatted_after:
+            return f"{formatted_before}{read_mark_line}{formatted_after}"
+        elif formatted_before:
+            return f"{formatted_before}{read_mark_line}"
+        elif formatted_after:
+            return f"{read_mark_line}{formatted_after}"
+        else:
+            # 理论上不应该发生，但作为保险
+            return read_mark_line.strip() # 如果前后都无消息，只返回标记行
+