fix：进一步模块化，修复观察错位问题

src/common/logger.py

@@ -163,13 +163,13 @@ MOOD_STYLE_CONFIG = {
         "console_format": (
             "<white>{time:YYYY-MM-DD HH:mm:ss}</white> | "
             "<level>{level: <8}</level> | "
-            "<light-green>心情</light-green> | "
+            "</magenta>心情</magenta> | "
             "<level>{message}</level>"
         ),
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 心情 | {message}",
     },
     "simple": {
-        "console_format": "<level>{time:MM-DD HH:mm}</level> | <magenta>心情</magenta> | {message}",
+        "console_format": "<level>{time:MM-DD HH:mm}</level> | <magenta>心情 | {message} </magenta>",
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 心情 | {message}",
     },
 }
@@ -315,14 +315,14 @@ CHAT_STYLE_CONFIG = {
         "console_format": (
             "<white>{time:YYYY-MM-DD HH:mm:ss}</white> | "
             "<level>{level: <8}</level> | "
-            "<light-blue>见闻</light-blue> | "
+            "<green>见闻</green> | "
             "<level>{message}</level>"
         ),
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}",
     },
     "simple": {
         "console_format": (
-            "<level>{time:MM-DD HH:mm}</level> | <light-blue>见闻</light-blue> | <green>{message}</green>"
+            "<level>{time:MM-DD HH:mm}</level> | <green>见闻</green> | <green>{message}</green>"
         ),  # noqa: E501
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}",
     },
@@ -387,7 +387,7 @@ SUBHEARTFLOW_MANAGER_STYLE_CONFIG = {
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 麦麦水群[管理] | {message}",
     },
     "simple": {
-        "console_format": ("<level>{time:MM-DD HH:mm}</level> | <fg #3399FF>麦麦水群[管理] | {message}</fg #3399FF>"),  # noqa: E501
+        "console_format": ("<level>{time:MM-DD HH:mm}</level> | <fg #005BA2>麦麦水群[管理] | {message}</fg #005BA2>"),  # noqa: E501
         "file_format": "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 麦麦水群[管理] | {message}",
     },
 }

src/heart_flow/mai_state_manager.py

@@ -13,8 +13,8 @@ mai_state_config = LogConfig(
 logger = get_module_logger("mai_state_manager", config=mai_state_config)
 
 
-# enable_unlimited_hfc_chat = True
-enable_unlimited_hfc_chat = False
+enable_unlimited_hfc_chat = True
+# enable_unlimited_hfc_chat = False
 
 
 class MaiState(enum.Enum):
@@ -22,14 +22,14 @@ class MaiState(enum.Enum):
     聊天状态:
     OFFLINE: 不在线：回复概率极低，不会进行任何聊天
     PEEKING: 看一眼手机：回复概率较低，会进行一些普通聊天
-    NORMAL_CHAT: 正常聊天：回复概率较高，会进行一些普通聊天和少量的专注聊天
+    NORMAL_CHAT: 正常看手机：回复概率较高，会进行一些普通聊天和少量的专注聊天
     FOCUSED_CHAT: 专注聊天：回复概率极高，会进行专注聊天和少量的普通聊天
     """
 
     OFFLINE = "不在线"
-    PEEKING = "看一眼"
-    NORMAL_CHAT = "正常聊天"
-    FOCUSED_CHAT = "专心聊天"
+    PEEKING = "看一眼手机"
+    NORMAL_CHAT = "正常看手机"
+    FOCUSED_CHAT = "专心看手机"
 
     def get_normal_chat_max_num(self):
         # 调试用
@@ -137,11 +137,11 @@ class MaiStateManager:
         if current_status == MaiState.OFFLINE:
             logger.info("当前[离线]，没看手机，思考要不要上线看看......")
         elif current_status == MaiState.PEEKING:
-            logger.info("当前[看一眼]，思考要不要继续聊下去......")
+            logger.info("当前[看一眼手机]，思考要不要继续聊下去......")
         elif current_status == MaiState.NORMAL_CHAT:
-            logger.info("当前在[正常聊天]思考要不要继续聊下去......")
+            logger.info("当前在[正常看手机]思考要不要继续聊下去......")
         elif current_status == MaiState.FOCUSED_CHAT:
-            logger.info("当前在[专心聊天]思考要不要继续聊下去......")
+            logger.info("当前在[专心看手机]思考要不要继续聊下去......")
 
         # 1. 麦麦每分钟都有概率离线
         if time_since_last_min_check >= 60:

src/heart_flow/observation.py

@@ -22,6 +22,9 @@ class Observation:
         self.observe_type = observe_type
         self.observe_id = observe_id
         self.last_observe_time = datetime.now().timestamp()  # 初始化为当前时间
+    
+    async def observe(self):
+        pass
 
 
 # 聊天观察

src/heart_flow/sub_heartflow.py

@@ -43,6 +43,7 @@ class InterestChatting:
         max_probability=max_reply_probability,
         state_change_callback: Optional[Callable[[ChatState], None]] = None,
     ):
+        # 基础属性初始化
         self.interest_level: float = 0.0
         self.last_update_time: float = time.time()
         self.decay_rate_per_second: float = decay_rate
@@ -56,16 +57,26 @@ class InterestChatting:
         self.max_reply_probability: float = max_probability
         self.current_reply_probability: float = 0.0
         self.is_above_threshold: bool = False
+        
+        # 任务相关属性初始化
         self.update_task: Optional[asyncio.Task] = None
         self._stop_event = asyncio.Event()
+        self._task_lock = asyncio.Lock()
+        self._is_running = False
 
         self.interest_dict: Dict[str, tuple[MessageRecv, float, bool]] = {}
         self.update_interval = 1.0
-        self.start_updates(self.update_interval)  # 初始化时启动后台更新任务
 
         self.above_threshold = False
         self.start_hfc_probability = 0.0
 
+    @classmethod
+    async def create(cls, *args, **kwargs):
+        """异步工厂方法，用于创建并初始化 InterestChatting 实例"""
+        instance = cls(*args, **kwargs)
+        await instance.start_updates(instance.update_interval)
+        return instance
+
     def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool):
         self.interest_dict[message.message_info.message_id] = (message, interest_value, is_mentioned)
         self.last_interaction_time = time.time()
@@ -141,59 +152,74 @@ class InterestChatting:
     # --- 新增后台更新任务相关方法 ---
     async def _run_update_loop(self, update_interval: float = 1.0):
         """后台循环，定期更新兴趣和回复概率。"""
-        while not self._stop_event.is_set():
-            try:
-                if self.interest_level != 0:
-                    await self._calculate_decay()
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    if self.interest_level != 0:
+                        await self._calculate_decay()
 
-                await self._update_reply_probability()
+                    await self._update_reply_probability()
 
-                # 等待下一个周期或停止事件
-                await asyncio.wait_for(self._stop_event.wait(), timeout=update_interval)
-            except asyncio.TimeoutError:
-                # 正常超时，继续循环
-                continue
-            except asyncio.CancelledError:
-                logger.info("InterestChatting 更新循环被取消。")
-                break
-            except Exception as e:
-                logger.error(f"InterestChatting 更新循环出错: {e}")
-                logger.error(traceback.format_exc())
-                # 防止错误导致CPU飙升，稍作等待
-                await asyncio.sleep(5)
-        logger.info("InterestChatting 更新循环已停止。")
+                    # 等待下一个周期或停止事件
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=update_interval)
+                except asyncio.TimeoutError:
+                    # 正常超时，继续循环
+                    continue
+                except Exception as e:
+                    logger.error(f"InterestChatting 更新循环出错: {e}")
+                    logger.error(traceback.format_exc())
+                    # 防止错误导致CPU飙升，稍作等待
+                    await asyncio.sleep(5)
+        except asyncio.CancelledError:
+            logger.info("InterestChatting 更新循环被取消。")
+        finally:
+            self._is_running = False
+            logger.info("InterestChatting 更新循环已停止。")
 
-    def start_updates(self, update_interval: float = 1.0):
-        """启动后台更新任务"""
-        if self.update_task is None or self.update_task.done():
-            self._stop_event.clear()
-            self.update_task = asyncio.create_task(self._run_update_loop(update_interval))
-            logger.debug("后台兴趣更新任务已创建并启动。")
-        else:
-            logger.debug("后台兴趣更新任务已在运行中。")
+    async def start_updates(self, update_interval: float = 1.0):
+        """启动后台更新任务，使用锁确保并发安全"""
+        async with self._task_lock:
+            if self._is_running:
+                logger.debug("后台兴趣更新任务已在运行中。")
+                return
+
+            # 清理已完成或已取消的任务
+            if self.update_task and (self.update_task.done() or self.update_task.cancelled()):
+                self.update_task = None
+
+            if not self.update_task:
+                self._stop_event.clear()
+                self._is_running = True
+                self.update_task = asyncio.create_task(self._run_update_loop(update_interval))
+                logger.debug("后台兴趣更新任务已创建并启动。")
 
     async def stop_updates(self):
-        """停止后台更新任务"""
-        if self.update_task and not self.update_task.done():
+        """停止后台更新任务，使用锁确保并发安全"""
+        async with self._task_lock:
+            if not self._is_running:
+                logger.debug("后台兴趣更新任务未运行。")
+                return
+
             logger.info("正在停止 InterestChatting 后台更新任务...")
-            self._stop_event.set()  # 发送停止信号
-            try:
-                # 等待任务结束，设置超时
-                await asyncio.wait_for(self.update_task, timeout=5.0)
-                logger.info("InterestChatting 后台更新任务已成功停止。")
-            except asyncio.TimeoutError:
-                logger.warning("停止 InterestChatting 后台任务超时，尝试取消...")
-                self.update_task.cancel()
+            self._stop_event.set()
+
+            if self.update_task and not self.update_task.done():
                 try:
-                    await self.update_task  # 等待取消完成
-                except asyncio.CancelledError:
-                    logger.info("InterestChatting 后台更新任务已被取消。")
-            except Exception as e:
-                logger.error(f"停止 InterestChatting 后台任务时发生异常: {e}")
-            finally:
-                self.update_task = None
-        else:
-            logger.debug("InterestChatting 后台更新任务未运行或已完成。")
+                    # 等待任务结束，设置超时
+                    await asyncio.wait_for(self.update_task, timeout=5.0)
+                    logger.info("InterestChatting 后台更新任务已成功停止。")
+                except asyncio.TimeoutError:
+                    logger.warning("停止 InterestChatting 后台任务超时，尝试取消...")
+                    self.update_task.cancel()
+                    try:
+                        await self.update_task  # 等待取消完成
+                    except asyncio.CancelledError:
+                        logger.info("InterestChatting 后台更新任务已被取消。")
+                except Exception as e:
+                    logger.error(f"停止 InterestChatting 后台任务时发生异常: {e}")
+                finally:
+                    self.update_task = None
+                    self._is_running = False
 
     # --- 结束 新增方法 ---
 
@@ -214,7 +240,7 @@ class SubHeartflow:
 
         # 聊天状态管理
         self.chat_state: ChatStateInfo = ChatStateInfo()  # 该sub_heartflow的聊天状态信息
-        self.interest_chatting = InterestChatting(state_change_callback=self.set_chat_state)
+        self.interest_chatting = None  # 将在 initialize 中创建
 
         # 活动状态管理
         self.last_active_time = time.time()  # 最后活跃时间
@@ -234,6 +260,11 @@ class SubHeartflow:
 
         self.log_prefix = chat_manager.get_stream_name(self.subheartflow_id) or self.subheartflow_id
 
+    async def initialize(self):
+        """异步初始化方法"""
+        self.interest_chatting = await InterestChatting.create(state_change_callback=self.set_chat_state)
+        logger.debug(f"{self.log_prefix} InterestChatting 实例已创建并初始化。")
+
     async def add_time_current_state(self, add_time: float):
         self.current_state_time += add_time
 
@@ -412,7 +443,7 @@ class SubHeartflow:
         - 负责子心流的主要后台循环
         - 每30秒检查一次停止标志
         """
-        logger.info(f"{self.log_prefix} 子心流开始工作...")
+        logger.trace(f"{self.log_prefix} 子心流开始工作...")
 
         while not self.should_stop:
             await asyncio.sleep(30)  # 30秒检查一次停止标志

src/heart_flow/sub_mind.py

@@ -10,7 +10,7 @@ from ..plugins.utils.prompt_builder import Prompt, global_prompt_manager
 from src.do_tool.tool_use import ToolUser
 from src.plugins.utils.json_utils import safe_json_dumps, normalize_llm_response, process_llm_tool_calls
 from src.heart_flow.chat_state_info import ChatStateInfo
-
+from src.plugins.chat.chat_stream import chat_manager
 
 subheartflow_config = LogConfig(
     console_format=SUB_HEARTFLOW_STYLE_CONFIG["console_format"],
@@ -30,6 +30,8 @@ def init_prompt():
     prompt += "现在请你生成你的内心想法，要求思考群里正在进行的话题，之前大家聊过的话题，群里成员的关系。"
     prompt += "请你思考，要不要对群里的话题进行回复，以及如何对群聊内容进行回复\n"
     prompt += "回复的要求是：不要总是重复自己提到过的话题，如果你要回复，最好只回复一个人的一个话题\n"
+    prompt += "如果最后一条消息是你自己发的，观察到的内容只有你自己的发言，并且之后没有人回复你，不要回复。"
+    prompt += "如果聊天记录中最新的消息是你自己发送的，并且你还想继续回复，你应该紧紧衔接你发送的消息，进行话题的深入，补充，或追问等等。"
     prompt += "请注意不要输出多余内容(包括前后缀，冒号和引号，括号， 表情，等)，不要回复自己的发言\n"
     prompt += "现在请你先输出想法，{hf_do_next}，不要分点输出,文字不要浮夸"
     prompt += "在输出完想法后，请你思考应该使用什么工具。工具可以帮你取得一些你不知道的信息，或者进行一些操作。"
@@ -138,7 +140,7 @@ class SubMind:
             hf_do_next=hf_do_next,
         )
 
-        logger.debug(f"[{self.subheartflow_id}] 心流思考提示词构建完成")
+        # logger.debug(f"[{self.subheartflow_id}] 心流思考提示词构建完成")
 
         # ---------- 5. 执行LLM请求并处理响应 ----------
         content = ""  # 初始化内容变量
@@ -190,7 +192,8 @@ class SubMind:
             content = "思考过程中出现错误"
 
         # 记录最终思考结果
-        logger.debug(f"[{self.subheartflow_id}] 心流思考结果:\n{content}\n")
+        name = chat_manager.get_stream_name(self.subheartflow_id)
+        logger.debug(f"[{name}] \nPrompt:\n{prompt}\n\n心流思考结果:\n{content}\n")
 
         # 处理空响应情况
         if not content:

src/heart_flow/subheartflow_manager.py

@@ -75,18 +75,22 @@ class SubHeartflowManager:
                 return subflow
 
             # 创建新的子心流实例
-            logger.info(f"子心流 {subheartflow_id} 不存在，正在创建...")
+            # logger.info(f"子心流 {subheartflow_id} 不存在，正在创建...")
             try:
                 # 初始化子心流
                 new_subflow = SubHeartflow(subheartflow_id, mai_states)
 
+                # 异步初始化
+                await new_subflow.initialize()
+
                 # 添加聊天观察者
                 observation = ChattingObservation(chat_id=subheartflow_id)
                 new_subflow.add_observation(observation)
 
                 # 注册子心流
                 self.subheartflows[subheartflow_id] = new_subflow
-                logger.info(f"子心流 {subheartflow_id} 创建成功")
+                heartflow_name = chat_manager.get_stream_name(subheartflow_id) or subheartflow_id
+                logger.info(f"[{heartflow_name}] 开始看消息")
 
                 # 启动后台任务
                 asyncio.create_task(new_subflow.subheartflow_start_working())
@@ -264,104 +268,70 @@ class SubHeartflowManager:
 
     async def evaluate_interest_and_promote(self, current_mai_state: MaiStateInfo):
         """评估子心流兴趣度，满足条件且未达上限则提升到FOCUSED状态（基于start_hfc_probability）"""
-        log_prefix_manager = "[子心流管理器-兴趣评估]"
-        logger.debug(f"{log_prefix_manager} 开始周期... 当前状态: {current_mai_state.get_current_state().value}")
-
-        # 获取 FOCUSED 状态的数量上限
-        current_state_enum = current_mai_state.get_current_state()
-        focused_limit = current_state_enum.get_focused_chat_max_num()
+        log_prefix = "[兴趣评估]"
+        current_state = current_mai_state.get_current_state()
+        focused_limit = current_state.get_focused_chat_max_num()
+        
+        
+        if int(time.time()) % 20 == 0:  # 每20秒输出一次
+            logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 可以在{focused_limit}个群激情聊天")
+        
         if focused_limit <= 0:
-            logger.debug(
-                f"{log_prefix_manager} 当前状态 ({current_state_enum.value}) 不允许 FOCUSED 子心流, 跳过提升检查。"
-            )
+            # logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 不允许 FOCUSED 子心流")
             return
 
-        # 获取当前 FOCUSED 状态的数量 (初始值)
         current_focused_count = self.count_subflows_by_state(ChatState.FOCUSED)
-        logger.debug(f"{log_prefix_manager} 专注上限: {focused_limit}, 当前专注数: {current_focused_count}")
+        if current_focused_count >= focused_limit:
+            logger.debug(f"{log_prefix} 已达专注上限 ({current_focused_count}/{focused_limit})")
+            return
 
-        # 使用快照安全遍历
-        subflows_snapshot = list(self.subheartflows.values())
-        promoted_count = 0  # 记录本次提升的数量
-        try:
-            for sub_hf in subflows_snapshot:
-                flow_id = sub_hf.subheartflow_id
-                stream_name = chat_manager.get_stream_name(flow_id) or flow_id
-                log_prefix_flow = f"[{stream_name}]"
+        states_num = (
+            self.count_subflows_by_state(ChatState.ABSENT),
+            self.count_subflows_by_state(ChatState.CHAT),
+            current_focused_count
+        )
 
-                # 只处理 CHAT 状态的子心流
-                # The code snippet is checking if the `chat_status` attribute of `sub_hf.chat_state` is not equal to
-                # `ChatState.CHAT`. If the condition is met, the code will continue to the next iteration of the loop
-                # or block of code where this snippet is located.
-                # if sub_hf.chat_state.chat_status != ChatState.CHAT:
-                #     continue
-
-                # 检查是否满足提升概率
-                should_hfc = random.random() < sub_hf.interest_chatting.start_hfc_probability
-                if not should_hfc:
+        for sub_hf in list(self.subheartflows.values()):
+            flow_id = sub_hf.subheartflow_id
+            stream_name = chat_manager.get_stream_name(flow_id) or flow_id
+            
+            # 跳过非CHAT状态或已经是FOCUSED状态的子心流
+            if sub_hf.chat_state.chat_status == ChatState.FOCUSED:
+                continue
+            
+            from .mai_state_manager import enable_unlimited_hfc_chat
+            if not enable_unlimited_hfc_chat:
+                if sub_hf.chat_state.chat_status != ChatState.CHAT:
                     continue
+                
+            # 检查是否满足提升概率
+            if random.random() >= sub_hf.interest_chatting.start_hfc_probability:
+                continue
 
-                # --- 关键检查：检查 FOCUSED 数量是否已达上限 ---
-                # 注意：在循环内部再次获取当前数量，因为之前的提升可能已经改变了计数
-                # 使用已经记录并在循环中更新的 current_focused_count
-                if current_focused_count >= focused_limit:
-                    logger.debug(
-                        f"{log_prefix_manager} {log_prefix_flow} 达到专注上限 ({current_focused_count}/{focused_limit}), 无法提升。概率={sub_hf.interest_chatting.start_hfc_probability:.2f}"
-                    )
-                    continue  # 跳过这个子心流，继续检查下一个
+            # 再次检查是否达到上限
+            if current_focused_count >= focused_limit:
+                logger.debug(f"{log_prefix} [{stream_name}] 已达专注上限")
+                break
 
-                # --- 执行提升 ---
-                # 获取当前实例以检查最新状态 (防御性编程)
-                current_subflow = self.subheartflows.get(flow_id)
-                if not current_subflow:
-                    logger.warning(f"{log_prefix_manager} {log_prefix_flow} 尝试提升时状态已改变或实例消失，跳过。")
-                    continue
+            # 获取最新状态并执行提升
+            current_subflow = self.subheartflows.get(flow_id)
+            if not current_subflow:
+                continue
 
-                logger.info(
-                    f"{log_prefix_manager} {log_prefix_flow} 兴趣评估触发升级 (prob={sub_hf.interest_chatting.start_hfc_probability:.2f}, 上限:{focused_limit}, 当前:{current_focused_count}) -> FOCUSED"
-                )
+            logger.info(
+                f"{log_prefix} [{stream_name}] 触发 激情水群 (概率={current_subflow.interest_chatting.start_hfc_probability:.2f})"
+            )
 
-                states_num = (
-                    self.count_subflows_by_state(ChatState.ABSENT),
-                    self.count_subflows_by_state(ChatState.CHAT),  # 这个值在提升前计算
-                    current_focused_count,  # 这个值在提升前计算
-                )
+            # 执行状态提升
+            await current_subflow.set_chat_state(ChatState.FOCUSED, states_num)
+            
+            # 验证提升结果
+            if (final_subflow := self.subheartflows.get(flow_id)) and \
+                final_subflow.chat_state.chat_status == ChatState.FOCUSED:
+                current_focused_count += 1
 
-                # --- 状态设置 ---
-                original_state = current_subflow.chat_state.chat_status  # 记录原始状态
-                await current_subflow.set_chat_state(ChatState.FOCUSED, states_num)
 
-                # --- 状态验证 ---
-                final_subflow = self.subheartflows.get(flow_id)
-                if final_subflow:
-                    final_state = final_subflow.chat_state.chat_status
-                    if final_state == ChatState.FOCUSED:
-                        logger.debug(
-                            f"{log_prefix_manager} {log_prefix_flow} 成功从 {original_state.value} 升级到 FOCUSED 状态"
-                        )
-                        promoted_count += 1
-                        # 提升成功后，更新当前专注计数，以便后续检查能使用最新值
-                        current_focused_count += 1
-                    elif final_state == original_state:  # 状态未变
-                        logger.warning(
-                            f"{log_prefix_manager} {log_prefix_flow} 尝试从 {original_state.value} 升级 FOCUSED 失败，状态仍为: {final_state.value} (可能被内部逻辑阻止)"
-                        )
-                    else:  # 状态变成其他了?
-                        logger.warning(
-                            f"{log_prefix_manager} {log_prefix_flow} 尝试从 {original_state.value} 升级 FOCUSED 后状态变为 {final_state.value}"
-                        )
-                else:  # 子心流消失了?
-                    logger.warning(f"{log_prefix_manager} {log_prefix_flow} 升级后验证时子心流 {flow_id} 消失")
-
-        except Exception as e:
-            logger.error(f"{log_prefix_manager} 兴趣评估周期出错: {e}", exc_info=True)
-
-        if promoted_count > 0:
-            logger.info(f"{log_prefix_manager} 评估周期结束, 成功提升 {promoted_count} 个子心流到 FOCUSED。")
-        else:
-            logger.debug(f"{log_prefix_manager} 评估周期结束, 未提升任何子心流。")
-
-    async def randomly_deactivate_subflows(self, deactivation_probability: float = 0.3):
+    async def randomly_deactivate_subflows(self, deactivation_probability: float = 0.1):
         """以一定概率将 FOCUSED 或 CHAT 状态的子心流回退到 ABSENT 状态。"""
         log_prefix_manager = "[子心流管理器-随机停用]"
         logger.debug(f"{log_prefix_manager} 开始随机停用检查... (概率: {deactivation_probability:.0%})")

src/main.py

@@ -154,7 +154,7 @@ class MainSystem:
         """打印情绪状态"""
         while True:
             self.mood_manager.print_mood_status()
-            await asyncio.sleep(30)
+            await asyncio.sleep(60)
 
     @staticmethod
     async def remove_recalled_message_task():

src/plugins/chat/utils_image.py

@@ -152,7 +152,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/emoji_system/emoji_manager.py

@@ -28,6 +28,11 @@ EMOJI_DIR = os.path.join("data", "emoji")  # 表情包存储目录
 EMOJI_REGISTED_DIR = os.path.join("data", "emoji_registed")  # 已注册的表情包注册目录
 
 
+'''
+还没经过测试，有些地方数据库和内存数据同步可能不完全
+
+'''
+
 class MaiEmoji:
     """定义一个表情包"""
 
@@ -247,10 +252,12 @@ class EmojiManager:
     def record_usage(self, hash: str):
         """记录表情使用次数"""
         try:
+            db.emoji.update_one({"hash": hash}, {"$inc": {"usage_count": 1}})
             for emoji in self.emoji_objects:
                 if emoji.hash == hash:
                     emoji.usage_count += 1
                     break
+            
         except Exception as e:
             logger.error(f"记录表情使用失败: {str(e)}")
 
@@ -304,12 +311,11 @@ class EmojiManager:
             selected_emoji, similarity = random.choice(top_5_emojis)
 
             # 更新使用次数
-            db.emoji.update_one({"hash": selected_emoji.hash}, {"$inc": {"usage_count": 1}})
-
-            logger.info(f"[匹配] 找到表情包: {selected_emoji.description} (相似度: {similarity:.4f})")
+            self.record_usage(selected_emoji.hash)
 
             time_end = time.time()
-            logger.info(f"[匹配] 搜索表情包用时: {time_end - time_start:.2f} 秒")
+
+            logger.info(f"找到[{text_emotion}]表情包,用时:{time_end - time_start:.2f}秒: {selected_emoji.description}  (相似度: {similarity:.4f})")
             return selected_emoji.path, f"[ {selected_emoji.description} ]"
 
         except Exception as e:

src/plugins/heartFC_chat/heartFC_generator.py

@@ -57,9 +57,6 @@ class HeartFCGenerator:
             )
 
         if model_response:
-            logger.info(
-                f"{global_config.BOT_NICKNAME}的回复是：{model_response},生成回复时间: {t_generate_response.human_readable}"
-            )
             model_processed_response = await self._process_response(model_response)
 
             return model_processed_response

src/plugins/heartFC_chat/heartFC_readme.md

@@ -0,0 +1,159 @@
+# HeartFC_chat 工作原理文档
+
+HeartFC_chat 是一个基于心流理论的聊天系统，通过模拟人类的思维过程和情感变化来实现自然的对话交互。系统采用Plan-Replier-Sender循环机制，实现了智能化的对话决策和生成。
+
+## 核心工作流程
+
+### 1. 消息处理与存储 (HeartFCProcessor)
+[代码位置: src/plugins/heartFC_chat/heartflow_processor.py]
+
+消息处理器负责接收和预处理消息，主要完成以下工作：
+```mermaid
+graph TD
+    A[接收原始消息] --> B[解析为MessageRecv对象]
+    B --> C[消息缓冲处理]
+    C --> D[过滤检查]
+    D --> E[存储到数据库]
+```
+
+核心实现：
+- 消息处理入口：`process_message()` [行号: 38-215]
+  - 消息解析和缓冲：`message_buffer.start_caching_messages()` [行号: 63]
+  - 过滤检查：`_check_ban_words()`, `_check_ban_regex()` [行号: 196-215]
+  - 消息存储：`storage.store_message()` [行号: 108]
+
+### 2. 对话管理循环 (HeartFChatting)
+[代码位置: src/plugins/heartFC_chat/heartFC_chat.py]
+
+HeartFChatting是系统的核心组件，实现了完整的对话管理循环：
+
+```mermaid
+graph TD
+    A[Plan阶段] -->|决策是否回复| B[Replier阶段]
+    B -->|生成回复内容| C[Sender阶段]
+    C -->|发送消息| D[等待新消息]
+    D --> A
+```
+
+#### Plan阶段 [行号: 282-386]
+- 主要函数：`_planner()`
+- 功能实现：
+  * 获取观察信息：`observation.observe()` [行号: 297]
+  * 思维处理：`sub_mind.do_thinking_before_reply()` [行号: 301]
+  * LLM决策：使用`PLANNER_TOOL_DEFINITION`进行动作规划 [行号: 13-42]
+
+#### Replier阶段 [行号: 388-416]
+- 主要函数：`_replier_work()`
+- 调用生成器：`gpt_instance.generate_response()` [行号: 394]
+- 处理生成结果和错误情况
+
+#### Sender阶段 [行号: 418-450]
+- 主要函数：`_sender()`
+- 发送实现：
+  * 创建消息：`_create_thinking_message()` [行号: 452-477]
+  * 发送回复：`_send_response_messages()` [行号: 479-525]
+  * 处理表情：`_handle_emoji()` [行号: 527-567]
+
+### 3. 回复生成机制 (HeartFCGenerator)
+[代码位置: src/plugins/heartFC_chat/heartFC_generator.py]
+
+回复生成器负责产生高质量的回复内容：
+
+```mermaid
+graph TD
+    A[获取上下文信息] --> B[构建提示词]
+    B --> C[调用LLM生成]
+    C --> D[后处理优化]
+    D --> E[返回回复集]
+```
+
+核心实现：
+- 生成入口：`generate_response()` [行号: 39-67]
+  * 情感调节：`arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()` [行号: 47]
+  * 模型生成：`_generate_response_with_model()` [行号: 69-95]
+  * 响应处理：`_process_response()` [行号: 97-106]
+
+### 4. 提示词构建系统 (HeartFlowPromptBuilder)
+[代码位置: src/plugins/heartFC_chat/heartflow_prompt_builder.py]
+
+提示词构建器支持两种工作模式，HeartFC_chat专门使用Focus模式，而Normal模式是为normal_chat设计的：
+
+#### 专注模式 (Focus Mode) - HeartFC_chat专用
+- 实现函数：`_build_prompt_focus()` [行号: 116-141]
+- 特点：
+  * 专注于当前对话状态和思维
+  * 更强的目标导向性
+  * 用于HeartFC_chat的Plan-Replier-Sender循环
+  * 简化的上下文处理，专注于决策
+
+#### 普通模式 (Normal Mode) - Normal_chat专用
+- 实现函数：`_build_prompt_normal()` [行号: 143-215]
+- 特点：
+  * 用于normal_chat的常规对话
+  * 完整的个性化处理
+  * 关系系统集成
+  * 知识库检索：`get_prompt_info()` [行号: 217-591]
+
+HeartFC_chat的Focus模式工作流程：
+```mermaid
+graph TD
+    A[获取结构化信息] --> B[获取当前思维状态]
+    B --> C[构建专注模式提示词]
+    C --> D[用于Plan阶段决策]
+    D --> E[用于Replier阶段生成]
+```
+
+## 智能特性
+
+### 1. 对话决策机制
+- LLM决策工具定义：`PLANNER_TOOL_DEFINITION` [heartFC_chat.py 行号: 13-42]
+- 决策执行：`_planner()` [heartFC_chat.py 行号: 282-386]
+- 考虑因素：
+  * 上下文相关性
+  * 情感状态
+  * 兴趣程度
+  * 对话时机
+
+### 2. 状态管理
+[代码位置: src/plugins/heartFC_chat/heartFC_chat.py]
+- 状态机实现：`HeartFChatting`类 [行号: 44-567]
+- 核心功能：
+  * 初始化：`_initialize()` [行号: 89-112]
+  * 循环控制：`_run_pf_loop()` [行号: 192-281]
+  * 状态转换：`_handle_loop_completion()` [行号: 166-190]
+
+### 3. 回复生成策略
+[代码位置: src/plugins/heartFC_chat/heartFC_generator.py]
+- 温度调节：`current_model.temperature = global_config.llm_normal["temp"] * arousal_multiplier` [行号: 48]
+- 生成控制：`_generate_response_with_model()` [行号: 69-95]
+- 响应处理：`_process_response()` [行号: 97-106]
+
+## 系统配置
+
+### 关键参数
+- LLM配置：`model_normal` [heartFC_generator.py 行号: 32-37]
+- 过滤规则：`_check_ban_words()`, `_check_ban_regex()` [heartflow_processor.py 行号: 196-215]
+- 状态控制：`INITIAL_DURATION = 60.0` [heartFC_chat.py 行号: 11]
+
+### 优化建议
+1. 调整LLM参数：`temperature`和`max_tokens`
+2. 优化提示词模板：`init_prompt()` [heartflow_prompt_builder.py 行号: 8-115]
+3. 配置状态转换条件
+4. 维护过滤规则
+
+## 注意事项
+
+1. 系统稳定性
+- 异常处理：各主要函数都包含try-except块
+- 状态检查：`_processing_lock`确保并发安全
+- 循环控制：`_loop_active`和`_loop_task`管理
+
+2. 性能优化
+- 缓存使用：`message_buffer`系统
+- LLM调用优化：批量处理和复用
+- 异步处理：使用`asyncio`
+
+3. 质量控制
+- 日志记录：使用`get_module_logger()`
+- 错误追踪：详细的异常记录
+- 响应监控：完整的状态跟踪

src/plugins/heartFC_chat/heartflow_processor.py

@@ -12,6 +12,7 @@ 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 typing import Optional, Tuple
 
 # 定义日志配置
 processor_config = LogConfig(
@@ -22,193 +23,204 @@ logger = get_module_logger("heartflow_processor", config=processor_config)
 
 
 class HeartFCProcessor:
+    """心流处理器，负责处理接收到的消息并计算兴趣度"""
+    
     def __init__(self):
+        """初始化心流处理器，创建消息存储实例"""
         self.storage = MessageStorage()
 
-    async def process_message(self, message_data: str) -> None:
-        """处理接收到的原始消息数据，完成消息解析、缓冲、过滤、存储、兴趣度计算与更新等核心流程。
-
-        此函数是消息处理的核心入口，负责接收原始字符串格式的消息数据，并将其转化为结构化的 `MessageRecv` 对象。
-        主要执行步骤包括：
-        1. 解析 `message_data` 为 `MessageRecv` 对象，提取用户信息、群组信息等。
-        2. 将消息加入 `message_buffer` 进行缓冲处理，以应对消息轰炸或者某些人一条消息分几次发等情况。
-        3. 获取或创建对应的 `chat_stream` 和 `subheartflow` 实例，用于管理会话状态和心流。
-        4. 对消息内容进行初步处理（如提取纯文本）。
-        5. 应用全局配置中的过滤词和正则表达式，过滤不符合规则的消息。
-        6. 查询消息缓冲结果，如果消息被缓冲器拦截（例如，判断为消息轰炸的一部分），则中止后续处理。
-        7. 对于通过缓冲的消息，将其存储到 `MessageStorage` 中。
-
-        8. 调用海马体（`HippocampusManager`）计算消息内容的记忆激活率。（这部分算法后续会进行优化）
-        9. 根据是否被提及（@）和记忆激活率，计算最终的兴趣度增量。(提及的额外兴趣增幅)
-        10. 使用计算出的增量更新 `InterestManager` 中对应会话的兴趣度。
-        11. 记录处理后的消息信息及当前的兴趣度到日志。
-
-        注意：此函数本身不负责生成和发送回复。回复的决策和生成逻辑被移至 `HeartFC_Chat` 类中的监控任务，
-        该任务会根据 `InterestManager` 中的兴趣度变化来决定何时触发回复。
-
+    async def _handle_error(self, error: Exception, context: str, message: Optional[MessageRecv] = None) -> None:
+        """统一的错误处理函数
+        
         Args:
-            message_data: str: 从消息源接收到的原始消息字符串。
+            error: 捕获到的异常
+            context: 错误发生的上下文描述
+            message: 可选的消息对象，用于记录相关消息内容
+        """
+        logger.error(f"{context}: {error}")
+        logger.error(traceback.format_exc())
+        if message and hasattr(message, 'raw_message'):
+            logger.error(f"相关消息原始内容: {message.raw_message}")
+
+    async def _process_relationship(self, message: MessageRecv) -> None:
+        """处理用户关系逻辑
+        
+        Args:
+            message: 消息对象，包含用户信息
+        """
+        platform = message.message_info.platform
+        user_id = message.message_info.user_info.user_id
+        nickname = message.message_info.user_info.user_nickname
+        cardname = message.message_info.user_info.user_cardname or nickname
+
+        is_known = await relationship_manager.is_known_some_one(platform, user_id)
+        
+        if not is_known:
+            logger.info(f"首次认识用户: {nickname}")
+            await relationship_manager.first_knowing_some_one(
+                platform, user_id, nickname, cardname, ""
+            )
+        elif not await relationship_manager.is_qved_name(platform, user_id):
+            logger.info(f"给用户({nickname},{cardname})取名: {nickname}")
+            await relationship_manager.first_knowing_some_one(
+                platform, user_id, nickname, cardname, ""
+            )
+
+    async def _calculate_interest(self, message: MessageRecv) -> Tuple[float, bool]:
+        """计算消息的兴趣度
+        
+        Args:
+            message: 待处理的消息对象
+            
+        Returns:
+            Tuple[float, bool]: (兴趣度, 是否被提及)
+        """
+        is_mentioned, _ = is_mentioned_bot_in_message(message)
+        interested_rate = 0.0
+
+        with Timer("记忆激活"):
+            interested_rate = await HippocampusManager.get_instance().get_activate_from_text(
+                message.processed_plain_text,
+                fast_retrieval=True,
+            )
+            logger.trace(f"记忆激活率: {interested_rate:.2f}")
+
+        if is_mentioned:
+            interest_increase_on_mention = 1
+            interested_rate += interest_increase_on_mention
+
+        return interested_rate, is_mentioned
+
+    def _get_message_type(self, message: MessageRecv) -> str:
+        """获取消息类型
+        
+        Args:
+            message: 消息对象
+            
+        Returns:
+            str: 消息类型
+        """
+        if message.message_segment.type != "seglist":
+            return message.message_segment.type
+            
+        if (isinstance(message.message_segment.data, list) 
+            and all(isinstance(x, Seg) for x in message.message_segment.data)
+            and len(message.message_segment.data) == 1):
+            return message.message_segment.data[0].type
+            
+        return "seglist"
+
+    async def process_message(self, message_data: str) -> None:
+        """处理接收到的原始消息数据
+        
+        主要流程:
+        1. 消息解析与初始化
+        2. 消息缓冲处理
+        3. 过滤检查
+        4. 兴趣度计算
+        5. 关系处理
+        
+        Args:
+            message_data: 原始消息字符串
         """
-        timing_results = {}  # 初始化 timing_results
         message = None
         try:
+            # 1. 消息解析与初始化
             message = MessageRecv(message_data)
             groupinfo = message.message_info.group_info
             userinfo = message.message_info.user_info
             messageinfo = message.message_info
 
-            # 消息加入缓冲池
+            # 2. 消息缓冲与流程序化
             await message_buffer.start_caching_messages(message)
-
-            # 创建聊天流
+            
             chat = await chat_manager.get_or_create_stream(
                 platform=messageinfo.platform,
                 user_info=userinfo,
                 group_info=groupinfo,
             )
-
+            
             subheartflow = await heartflow.create_subheartflow(chat.stream_id)
-
             message.update_chat_stream(chat)
-
-            await heartflow.create_subheartflow(chat.stream_id)
-
             await message.process()
-            logger.trace(f"消息处理成功: {message.processed_plain_text}")
-
-            # 过滤词/正则表达式过滤
-            if self._check_ban_words(message.processed_plain_text, chat, userinfo) or self._check_ban_regex(
-                message.raw_message, chat, userinfo
-            ):
+            
+            # 3. 过滤检查
+            if self._check_ban_words(message.processed_plain_text, chat, userinfo) or \
+                self._check_ban_regex(message.raw_message, chat, userinfo):
                 return
 
-            # 查询缓冲器结果
+            # 4. 缓冲检查
             buffer_result = await message_buffer.query_buffer_result(message)
-
-            # 处理缓冲器结果 (Bombing logic)
             if not buffer_result:
-                f_type = "seglist"
-                if message.message_segment.type != "seglist":
-                    f_type = message.message_segment.type
-                else:
-                    if (
-                        isinstance(message.message_segment.data, list)
-                        and all(isinstance(x, Seg) for x in message.message_segment.data)
-                        and len(message.message_segment.data) == 1
-                    ):
-                        f_type = message.message_segment.data[0].type
-                if f_type == "text":
-                    logger.debug(f"触发缓冲，消息：{message.processed_plain_text}")
-                elif f_type == "image":
-                    logger.debug("触发缓冲，表情包/图片等待中")
-                elif f_type == "seglist":
-                    logger.debug("触发缓冲，消息列表等待中")
-                return  # 被缓冲器拦截，不生成回复
-
-            # ---- 只有通过缓冲的消息才进行存储和后续处理 ----
-
-            # 存储消息 (使用可能被缓冲器更新过的 message)
-            try:
-                await self.storage.store_message(message, chat)
-                logger.trace(f"存储成功 (通过缓冲后): {message.processed_plain_text}")
-            except Exception as e:
-                logger.error(f"存储消息失败: {e}")
-                logger.error(traceback.format_exc())
-                # 存储失败可能仍需考虑是否继续，暂时返回
+                msg_type = self._get_message_type(message)
+                type_messages = {
+                    "text": f"触发缓冲，消息：{message.processed_plain_text}",
+                    "image": "触发缓冲，表情包/图片等待中",
+                    "seglist": "触发缓冲，消息列表等待中"
+                }
+                logger.debug(type_messages.get(msg_type, "触发未知类型缓冲"))
                 return
 
-            # 激活度计算 (使用可能被缓冲器更新过的 message.processed_plain_text)
-            is_mentioned, _ = is_mentioned_bot_in_message(message)
-            interested_rate = 0.0  # 默认值
-            try:
-                with Timer("记忆激活", timing_results):
-                    interested_rate = await HippocampusManager.get_instance().get_activate_from_text(
-                        message.processed_plain_text,
-                        fast_retrieval=True,  # 使用更新后的文本
-                    )
-                logger.trace(f"记忆激活率 (通过缓冲后): {interested_rate:.2f}")
-            except Exception as e:
-                logger.error(f"计算记忆激活率失败: {e}")
-                logger.error(traceback.format_exc())
+            # 5. 消息存储
+            await self.storage.store_message(message, chat)
+            logger.trace(f"存储成功: {message.processed_plain_text}")
 
-            # --- 修改：兴趣度更新逻辑 --- #
-            if is_mentioned:
-                interest_increase_on_mention = 1
-                mentioned_boost = interest_increase_on_mention  # 从配置获取提及增加值
-                interested_rate += mentioned_boost
-
-            # 更新兴趣度 (调用 SubHeartflow 的方法)
+            # 6. 兴趣度计算与更新
+            interested_rate, is_mentioned = await self._calculate_interest(message)
             current_time = time.time()
             await subheartflow.interest_chatting.increase_interest(current_time, value=interested_rate)
-
-            # 添加到 SubHeartflow 的 interest_dict，给normal_chat处理
             await subheartflow.add_interest_dict_entry(message, interested_rate, is_mentioned)
 
-            # 打印消息接收和处理信息
+            # 7. 日志记录
             mes_name = chat.group_info.group_name if chat.group_info else "私聊"
-            current_time = time.strftime("%H:%M:%S", time.localtime(message.message_info.time))
+            current_time = time.strftime("%H点%M分%S秒", time.localtime(message.message_info.time))
             logger.info(
                 f"[{current_time}][{mes_name}]"
-                f"{message.message_info.user_info.user_nickname}:"
+                f"{userinfo.user_nickname}:"
                 f"{message.processed_plain_text}"
                 f"[兴趣度: {interested_rate:.2f}]"
             )
 
-            try:
-                is_known = await relationship_manager.is_known_some_one(
-                    message.message_info.platform, message.message_info.user_info.user_id
-                )
-                if not is_known:
-                    logger.info(f"首次认识用户: {message.message_info.user_info.user_nickname}")
-                    await relationship_manager.first_knowing_some_one(
-                        message.message_info.platform,
-                        message.message_info.user_info.user_id,
-                        message.message_info.user_info.user_nickname,
-                        message.message_info.user_info.user_cardname or message.message_info.user_info.user_nickname,
-                        "",
-                    )
-                else:
-                    # 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
-                    ):
-                        logger.info(f"更新已认识但未取名的用户: {message.message_info.user_info.user_nickname}")
-                        await relationship_manager.first_knowing_some_one(
-                            message.message_info.platform,
-                            message.message_info.user_info.user_id,
-                            message.message_info.user_info.user_nickname,
-                            message.message_info.user_info.user_cardname
-                            or message.message_info.user_info.user_nickname,
-                            "",
-                        )
-            except Exception as e:
-                logger.error(f"处理认识关系失败: {e}")
-                logger.error(traceback.format_exc())
+            # 8. 关系处理
+            await self._process_relationship(message)
 
         except Exception as e:
-            logger.error(f"消息处理失败 (process_message V3): {e}")
-            logger.error(traceback.format_exc())
-            if message:  # 记录失败的消息内容
-                logger.error(f"失败消息原始内容: {message.raw_message}")
+            await self._handle_error(e, "消息处理失败", message)
 
     def _check_ban_words(self, text: str, chat, userinfo) -> bool:
-        """检查消息中是否包含过滤词"""
+        """检查消息是否包含过滤词
+        
+        Args:
+            text: 待检查的文本
+            chat: 聊天对象
+            userinfo: 用户信息
+            
+        Returns:
+            bool: 是否包含过滤词
+        """
         for word in global_config.ban_words:
             if word in text:
-                logger.info(
-                    f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}"
-                )
+                chat_name = chat.group_info.group_name if chat.group_info else "私聊"
+                logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}")
                 logger.info(f"[过滤词识别]消息中含有{word}，filtered")
                 return True
         return False
 
     def _check_ban_regex(self, text: str, chat, userinfo) -> bool:
-        """检查消息是否匹配过滤正则表达式"""
+        """检查消息是否匹配过滤正则表达式
+        
+        Args:
+            text: 待检查的文本
+            chat: 聊天对象
+            userinfo: 用户信息
+            
+        Returns:
+            bool: 是否匹配过滤正则
+        """
         for pattern in global_config.ban_msgs_regex:
             if pattern.search(text):
-                logger.info(
-                    f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}"
-                )
+                chat_name = chat.group_info.group_name if chat.group_info else "私聊"
+                logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}")
                 logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered")
                 return True
         return False

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -21,8 +21,7 @@ logger = get_module_logger("prompt")
 def init_prompt():
     Prompt(
         """
-你有以下信息可供参考：
-{structured_info}
+{info_from_tools}
 {chat_target}
 {chat_talking_prompt}
 现在你想要在群里发言或者回复。\n
@@ -38,6 +37,12 @@ def init_prompt():
 {moderation_prompt}。注意：回复不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""",
         "heart_flow_prompt",
     )
+    
+    Prompt("""
+你有以下信息可供参考：
+{structured_info}
+以上的消息是你获取到的消息，或许可以帮助你更好地回复。
+""", "info_from_tools")
 
     # Planner提示词
     Prompt(
@@ -47,13 +52,9 @@ def init_prompt():
 看了以上内容，你产生的内心想法是：
 {current_mind_block}
 请结合你的内心想法和观察到的聊天内容，分析情况并使用 'decide_reply_action' 工具来决定你的最终行动。
-决策依据：
+注意你必须参考以下决策依据来选择工具：
 1. 如果聊天内容无聊、与你无关、或者你的内心想法认为不适合回复（例如在讨论你不懂或不感兴趣的话题），选择 'no_reply'。
-2. 如果聊天内容值得回应，且适合用文字表达（参考你的内心想法），选择 'text_reply'。如果你有情绪想表达，想在文字后追加一个表达情绪的表情，请同时提供 'emoji_query' (每个标签用一个词组表示，格式如下：
-            幽默的讽刺
-            悲伤的无奈
-            愤怒的抗议
-            愤怒的讽刺)。
+2. 如果聊天内容值得回应，且适合用文字表达（参考你的内心想法），选择 'text_reply'。如果你有情绪想表达，想在文字后追加一个表达情绪的表情，请同时提供 'emoji_query' (每个标签用一个词组表示，格式例如：幽默的讽刺,单纯的开心,愤怒的抗议)。
 3. 如果聊天内容或你的内心想法适合用一个表情来回应，选择 'emoji_reply' 并提供表情主题 'emoji_query'。
 4. 如果最后一条消息是你自己发的，观察到的内容只有你自己的发言，并且之后没有人回复你，通常选择 'no_reply'，除非有特殊原因需要追问。
 5. 如果聊天记录中最新的消息是你自己发送的，并且你还想继续回复，你应该紧紧衔接你发送的消息，进行话题的深入，补充，或追问等等；。
@@ -152,7 +153,7 @@ class PromptBuilder:
             message_list_before_now,
             replace_bot_name=True,
             merge_messages=False,
-            timestamp_mode="relative",
+            timestamp_mode="normal",
             read_mark=0.0,
         )
 
@@ -162,12 +163,19 @@ class PromptBuilder:
             prompt_ger += "你喜欢用倒装句"
         if random.random() < 0.02:
             prompt_ger += "你喜欢用反问句"
+            
+        if structured_info:
+            structured_info_prompt = await global_prompt_manager.format_prompt(
+                "info_from_tools",
+                structured_info = structured_info)
+        else:
+            structured_info_prompt = ""
 
         logger.debug("开始构建prompt")
 
         prompt = await global_prompt_manager.format_prompt(
             "heart_flow_prompt",
-            structured_info=structured_info,
+            info_from_tools=structured_info_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/moods/moods.py

@@ -256,7 +256,7 @@ class MoodManager:
     def print_mood_status(self) -> None:
         """打印当前情绪状态"""
         logger.info(
-            f"[情绪状态]愉悦度: {self.current_mood.valence:.2f}, "
+            f"愉悦度: {self.current_mood.valence:.2f}, "
             f"唤醒度: {self.current_mood.arousal:.2f}, "
             f"心情: {self.current_mood.text}"
         )

src/plugins/utils/chat_message_builder.py

@@ -304,7 +304,7 @@ async def build_readable_messages(
 
         readable_read_mark = translate_timestamp_to_human_readable(read_mark, mode=timestamp_mode)
         read_mark_line = (
-            f"\n\n--- 以上消息已读 (标记时间: {readable_read_mark}) ---\n--- 请关注你上次思考之后以下的新消息---\n"
+            f"\n\n--- 以上消息已读 (标记时间: {readable_read_mark}) ---\n--- 以下新消息未读---\n"
         )
 
         # 组合结果，确保空部分不引入多余的标记或换行