fix：更名和小bug修复

src/heart_flow/README.md

@@ -1,7 +1,5 @@
 # 心流系统 (Heart Flow System)
 
-心流系统是一个模拟AI机器人内心思考和情感流动的核心系统。它通过多层次的心流结构，使AI能够对外界信息进行观察、思考和情感反应，从而产生更自然的对话和行为。
-
 ## 系统架构
 
 ### 1. 主心流 (Heartflow)
@@ -24,22 +22,6 @@
 - 支持多种观察类型（如聊天观察）
 - 对信息进行实时总结和更新
 
-## 主要功能
-
-### 思维系统
-- 定期进行思维更新
-- 维护短期记忆和思维连续性
-- 支持多层次的思维处理
-
-### 情感系统
-- 情绪状态管理
-- 回复意愿判断
-- 情感因素影响决策
-
-### 交互系统
-- 群聊消息处理
-- 多场景并行处理
-- 智能回复生成
 
 ## 工作流程
 
@@ -63,11 +45,6 @@ observation = ChattingObservation(chat_id)
 subheartflow.add_observation(observation)
 ```
 
-### 启动心流系统
-```python
-await heartflow.heartflow_start_working()
-```
-
 ## 配置说明
 
 系统的主要配置参数：
@@ -81,14 +58,100 @@ await heartflow.heartflow_start_working()
 2. 需要合理配置更新间隔以平衡性能和响应速度
 3. 观察系统会限制消息处理数量以避免过载 
 
+# PFChatting 与主动回复流程说明 (V2)
 
-更新：
-把聊天控制移动到心流下吧
-首先心流要根据日程以及当前状况判定总体状态MaiStateInfo
+本文档描述了 `PFChatting` 类及其在 `heartFC_controler` 模块中实现的主动、基于兴趣的回复流程。
 
-然后根据每个子心流的运行情况，给子心流分配聊天资源（ChatStateInfo：ABSENT CHAT 或者 FOCUS）
+## 1. `PFChatting` 类概述
 
-子心流负责根据状态进行执行
+*   **目标**: 管理特定聊天流 (`stream_id`) 的主动回复逻辑，使其行为更像人类的自然交流。
+*   **创建时机**: 当 `HeartFC_Chat` 的兴趣监控任务 (`_interest_monitor_loop`) 检测到某个聊天流的兴趣度 (`InterestChatting`) 达到了触发回复评估的条件 (`should_evaluate_reply`) 时，会为该 `stream_id` 获取或创建唯一的 `PFChatting` 实例 (`_get_or_create_heartFC_chat`)。
+*   **持有**:
+    *   对应的 `sub_heartflow` 实例引用 (通过 `heartflow.get_subheartflow(stream_id)`)。
+    *   对应的 `chat_stream` 实例引用。
+    *   对 `HeartFC_Chat` 单例的引用 (用于调用发送消息、处理表情等辅助方法)。
+*   **初始化**: `PFChatting` 实例在创建后会执行异步初始化 (`_initialize`)，这可能包括加载必要的上下文或历史信息（*待确认是否实现了读取历史消息*）。
 
-1.将interest.py进行拆分，class InterestChatting 将会在 sub_heartflow中声明，每个sub_heartflow都会所属一个InterestChatting
-class InterestManager 将会在heartflow中声明，成为heartflow的一个组件，伴随heartflow产生
+## 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_heartFC_chat` 确保了每个 `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/heart_flow/Update.md

@@ -1,11 +0,0 @@
-
-更新：
-把聊天控制移动到心流下吧
-首先心流要根据日程以及当前状况判定总体状态MaiStateInfo
-
-然后根据每个子心流的运行情况，给子心流分配聊天资源（ChatStateInfo：ABSENT CHAT 或者 FOCUS）
-
-子心流负责根据状态进行执行
-
-1.将interest.py进行拆分，class InterestChatting 将会在 sub_heartflow中声明，每个sub_heartflow都会所属一个InterestChatting
-class InterestManager 将会在heartflow中声明，成为heartflow的一个组件，伴随heartflow产生

src/heart_flow/heartflow.py

@@ -1,4 +1,4 @@
-from .sub_heartflow import SubHeartflow, ChattingObservation
+from src.heart_flow.sub_heartflow import SubHeartflow, ChattingObservation, ChatState
 from src.plugins.moods.moods import MoodManager
 from src.plugins.models.utils_model import LLMRequest
 from src.config.config import global_config
@@ -9,7 +9,7 @@ from src.common.logger import get_module_logger, LogConfig, HEARTFLOW_STYLE_CONF
 from src.individuality.individuality import Individuality
 import time
 import random
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, TYPE_CHECKING
 import traceback
 import enum
 import os  # 新增
@@ -23,6 +23,9 @@ heartflow_config = LogConfig(
 )
 logger = get_module_logger("heartflow", config=heartflow_config)
 
+# Type hinting for circular dependency
+if TYPE_CHECKING:
+    from src.heart_flow.sub_heartflow import SubHeartflow, ChatState # Keep SubHeartflow here too
 
 def init_prompt():
     prompt = ""
@@ -53,6 +56,13 @@ INACTIVE_THRESHOLD_SECONDS = 1200  # 不活跃时间阈值 (例如：20分钟) -
 LOG_INTERVAL_SECONDS = 3  # 日志记录间隔 (例如：3秒) - 保持与 interest.py 一致
 # --- 结束新增常量 ---
 
+# --- 新增：状态更新常量 ---
+STATE_UPDATE_INTERVAL_SECONDS = 30 # 状态更新检查间隔（秒）
+FIVE_MINUTES = 3 * 60
+FIFTEEN_MINUTES = 6 * 60
+TWENTY_MINUTES = 9 * 60
+# --- 结束新增常量 ---
+
 
 # 新增 ChatStatus 枚举
 class MaiState(enum.Enum):
@@ -92,10 +102,12 @@ class MaiState(enum.Enum):
 
 class MaiStateInfo:
     def __init__(self):
-        self.current_state_info = ""
 
         # 使用枚举类型初始化状态，默认为不在线
         self.mai_status: MaiState = MaiState.OFFLINE
+        self.mai_status_history = [] # 历史状态，包含 状态，最后时间
+        self.last_status_change_time: float = time.time() # 新增：状态最后改变时间
+        self.last_5min_check_time: float = time.time() # 新增：上次5分钟规则检查时间
 
         self.normal_chatting = []
         self.focused_chatting = []
@@ -103,17 +115,21 @@ class MaiStateInfo:
         self.mood_manager = MoodManager()
         self.mood = self.mood_manager.get_prompt()
 
-    def update_current_state_info(self):
-        self.current_state_info = self.mood_manager.get_current_mood()
-
     # 新增更新聊天状态的方法
     def update_mai_status(self, new_status: MaiState):
         """更新聊天状态"""
-        if isinstance(new_status, MaiState):
+        if isinstance(new_status, MaiState) and new_status != self.mai_status: # 只有状态实际改变时才更新
             self.mai_status = new_status
+            current_time = time.time()
+            self.last_status_change_time = current_time # 更新状态改变时间
+            self.last_5min_check_time = current_time # 重置5分钟检查计时器
+            # 将新状态和时间戳添加到历史记录
+            self.mai_status_history.append((new_status, current_time))
             logger.info(f"麦麦状态更新为: {self.mai_status.value}")
-        else:
+        elif not isinstance(new_status, MaiState):
             logger.warning(f"尝试设置无效的麦麦状态: {new_status}")
+        # else: # 状态未改变，不处理
+        #     pass
 
 
 class Heartflow:
@@ -125,13 +141,14 @@ class Heartflow:
             model=global_config.llm_heartflow, temperature=0.6, max_tokens=1000, request_type="heart_flow"
         )
 
-        self._subheartflows: Dict[Any, SubHeartflow] = {}
+        self._subheartflows: Dict[Any, 'SubHeartflow'] = {} # Update type hint
 
         # --- 新增：日志和清理相关属性 (从 InterestManager 移动) ---
         self._history_log_file_path = os.path.join(LOG_DIRECTORY, HISTORY_LOG_FILENAME)
         self._ensure_log_directory()  # 初始化时确保目录存在
         self._cleanup_task: Optional[asyncio.Task] = None
         self._logging_task: Optional[asyncio.Task] = None
+        self._state_update_task: Optional[asyncio.Task] = None # 新增：状态更新任务
         # 注意：衰减任务 (_decay_task) 不再需要，衰减在 SubHeartflow 的 InterestChatting 内部处理
         # --- 结束新增属性 ---
 
@@ -203,6 +220,107 @@ class Heartflow:
                 logger.error(f"[Heartflow] Unexpected error during periodic history logging: {e}")
                 logger.error(traceback.format_exc())  # 记录 traceback
 
+    async def _periodic_state_update_task(self):
+        """定期检查并更新 Mai 状态"""
+        while True:
+            await asyncio.sleep(STATE_UPDATE_INTERVAL_SECONDS)
+            try:
+                current_time = time.time()
+                # 获取更新前的状态
+                previous_status = self.current_state.mai_status
+                current_status = self.current_state.mai_status # 保持此行以进行后续逻辑
+                time_in_current_status = current_time - self.current_state.last_status_change_time
+                time_since_last_5min_check = current_time - self.current_state.last_5min_check_time
+                next_state = None # 预设下一状态为 None
+
+                # --- 状态转换逻辑 (保持不变) ---
+                # 1. 通用规则：每5分钟检查 (对于非 OFFLINE 状态)
+                if time_since_last_5min_check >= FIVE_MINUTES:
+                    self.current_state.last_5min_check_time = current_time # 重置5分钟检查计时器（无论是否切换）
+                    if current_status != MaiState.OFFLINE:
+                        if random.random() < 0.10: # 10% 概率切换到 OFFLINE
+                            logger.debug(f"[Heartflow State] 触发5分钟规则，从 {current_status.value} 切换到 OFFLINE")
+                            next_state = MaiState.OFFLINE # 设置 next_state 而不是直接更新
+                            # self.current_state.update_mai_status(MaiState.OFFLINE)
+                            # continue # 状态已改变，进入下一轮循环
+
+                # 2. 状态持续时间规则 (仅在未被5分钟规则覆盖时执行)
+                if next_state is None: # 仅当5分钟规则未触发切换时检查持续时间
+                    if current_status == MaiState.OFFLINE:
+                        # OFFLINE 状态下，检查是否已持续5分钟
+                        if time_in_current_status >= FIVE_MINUTES:
+                            weights = [35, 35, 30]
+                            choices_list = [MaiState.PEEKING, MaiState.NORMAL_CHAT, MaiState.OFFLINE]
+                            next_state_candidate = random.choices(choices_list, weights=weights, k=1)[0]
+                            if next_state_candidate != MaiState.OFFLINE:
+                                next_state = next_state_candidate
+                                logger.debug(f"[Heartflow State] OFFLINE 持续时间达到，切换到 {next_state.value}")
+                            else:
+                                # 保持 OFFLINE，重置计时器以开始新的5分钟计时
+                                logger.debug(f"[Heartflow State] OFFLINE 持续时间达到，保持 OFFLINE，重置计时器")
+                                self.current_state.last_status_change_time = current_time
+                                self.current_state.last_5min_check_time = current_time # 保持一致
+                                # 显式将 next_state 设为 OFFLINE 以便后续处理
+                                next_state = MaiState.OFFLINE
+
+                    elif current_status == MaiState.PEEKING:
+                        if time_in_current_status >= FIVE_MINUTES: # PEEKING 最多持续 5 分钟
+                            weights = [50, 30, 20]
+                            choices_list = [MaiState.OFFLINE, MaiState.NORMAL_CHAT, MaiState.FOCUSED_CHAT]
+                            next_state = random.choices(choices_list, weights=weights, k=1)[0]
+                            logger.debug(f"[Heartflow State] PEEKING 持续时间达到，切换到 {next_state.value}")
+
+                    elif current_status == MaiState.NORMAL_CHAT:
+                        if time_in_current_status >= FIFTEEN_MINUTES: # NORMAL_CHAT 最多持续 15 分钟
+                            weights = [50, 50]
+                            choices_list = [MaiState.OFFLINE, MaiState.FOCUSED_CHAT]
+                            next_state = random.choices(choices_list, weights=weights, k=1)[0]
+                            logger.debug(f"[Heartflow State] NORMAL_CHAT 持续时间达到，切换到 {next_state.value}")
+
+                    elif current_status == MaiState.FOCUSED_CHAT:
+                        if time_in_current_status >= TWENTY_MINUTES: # FOCUSED_CHAT 最多持续 20 分钟
+                            weights = [80, 20]
+                            choices_list = [MaiState.OFFLINE, MaiState.NORMAL_CHAT]
+                            next_state = random.choices(choices_list, weights=weights, k=1)[0]
+                            logger.debug(f"[Heartflow State] FOCUSED_CHAT 持续时间达到，切换到 {next_state.value}")
+                # --- 状态转换逻辑结束 ---
+
+                # --- 更新状态并执行相关操作 --- #
+                if next_state is not None:
+                    # 检查状态是否真的改变了
+                    if next_state != previous_status:
+                        logger.info(f"[Heartflow] 准备从 {previous_status.value} 转换状态到 {next_state.value}")
+                        self.current_state.update_mai_status(next_state)
+
+                        # 在状态改变后，强制执行子心流数量限制 (保持)
+                        await self._enforce_subheartflow_limits(next_state)
+
+                        # --- 新增逻辑：根据状态转换调整子心流 --- #
+                        if previous_status == MaiState.OFFLINE and next_state != MaiState.OFFLINE:
+                            logger.info(f"[Heartflow] 主状态从 OFFLINE 激活，尝试激活子心流到 CHAT 状态。")
+                            await self._activate_random_subflows_to_chat(next_state)
+                        elif next_state == MaiState.OFFLINE and previous_status != MaiState.OFFLINE:
+                            logger.info(f"[Heartflow] 主状态变为 OFFLINE，停用所有子心流活动。")
+                            await self._deactivate_all_subflows_on_offline()
+                        # --- 结束新增逻辑 --- #
+
+                    elif next_state == MaiState.OFFLINE and previous_status == MaiState.OFFLINE:
+                        # 如果决定保持 OFFLINE 状态（例如，因为随机选择或持续时间规则），并且之前已经是 OFFLINE
+                        # 确保计时器被重置 (这在上面的持续时间规则中已处理，但为了清晰再次确认)
+                        if time_in_current_status >= FIVE_MINUTES:
+                            # 确保计时器已在上面重置，这里无需操作，只记录日志
+                            logger.debug(f"[Heartflow State] 保持 OFFLINE 状态，计时器已重置。")
+                        pass # 无需状态转换，也无需调用激活/停用逻辑
+
+                # --- 如果没有确定 next_state (即没有触发任何切换规则) --- #
+                # logger.debug(f"[Heartflow State] 状态未改变，保持 {current_status.value}") # 减少日志噪音
+
+            except Exception as e:
+                logger.error(f"[Heartflow] 状态更新任务出错: {e}")
+                logger.error(traceback.format_exc())
+
+            logger.info(f"当前状态:{self.current_state.mai_status.value}")
+
     def get_all_interest_states(self) -> Dict[str, Dict]:  # 新增方法
         """获取所有活跃子心流的当前兴趣状态"""
         states = {}
@@ -266,16 +384,6 @@ class Heartflow:
             # logger.info(f"[Heartflow] 清理完成。没有流符合移除条件。当前数量: {initial_count}") # 减少日志噪音
             pass
 
-    async def _sub_heartflow_update(self):  # 这个任务目前作用不大，可以考虑移除或赋予新职责
-        while True:
-            # 检查是否存在子心流
-            if not self._subheartflows:
-                # logger.info("当前没有子心流，等待新的子心流创建...")
-                await asyncio.sleep(30)  # 短暂休眠
-                continue
-
-            # 当前无实际操作，只是等待
-            await asyncio.sleep(300)
 
     async def heartflow_start_working(self):
         # 启动清理任务 (使用新的 periodic_cleanup_task)
@@ -299,8 +407,14 @@ class Heartflow:
         else:
             logger.warning("[Heartflow] 跳过创建日志任务: 任务已在运行或存在。")
 
-        # (可选) 启动旧的子心流更新任务，如果它还有用的话
-        # asyncio.create_task(self._sub_heartflow_update())
+        # 新增：启动状态更新任务
+        if self._state_update_task is None or self._state_update_task.done():
+            self._state_update_task = asyncio.create_task(self._periodic_state_update_task())
+            logger.info(f"[Heartflow] 已创建定期状态更新任务。间隔: {STATE_UPDATE_INTERVAL_SECONDS}s")
+        else:
+            logger.warning("[Heartflow] 跳过创建状态更新任务: 任务已在运行或存在。")
+
+
 
     @staticmethod
     async def _update_current_state():
@@ -308,7 +422,6 @@ class Heartflow:
 
     async def do_a_thinking(self):
         # logger.debug("麦麦大脑袋转起来了")
-        self.current_state.update_current_state_info()
 
         # 开始构建prompt
         prompt_personality = "你"
@@ -426,22 +539,50 @@ class Heartflow:
             logger.error(traceback.format_exc())
             return "(想法汇总时发生错误...)"
 
-    async def create_subheartflow(self, subheartflow_id: Any) -> Optional[SubHeartflow]:
+    # --- Add helper method to count subflows by state --- #
+    def count_subflows_by_state(self, target_state: 'ChatState') -> int:
+        """Counts the number of subheartflows currently in the specified state."""
+        count = 0
+        # Use items() directly for read-only iteration if thread safety isn't a major concern here
+        # Or create snapshot if modification during iteration is possible elsewhere
+        items_snapshot = list(self._subheartflows.items())
+        for _, flow in items_snapshot:
+            # Check if flow still exists in the main dict in case it was removed concurrently
+            if flow.subheartflow_id in self._subheartflows and flow.chat_state.chat_status == target_state:
+                 count += 1
+        return count
+    # --- End helper method --- #
+
+    async def create_subheartflow(self, subheartflow_id: Any) -> Optional['SubHeartflow']:
         """
         获取或创建一个新的SubHeartflow实例。
-        (主要逻辑不变，InterestChatting 现在在 SubHeartflow 内部创建)
+        创建本身不受限，因为初始状态是ABSENT。
+        限制将在状态转换时检查。
         """
+        # --- 移除创建前的限制检查 --- #
+        # current_mai_state = self.current_state.mai_status
+        # normal_limit = current_mai_state.get_normal_chat_max_num()
+        # focused_limit = current_mai_state.get_focused_chat_max_num()
+        # total_limit = normal_limit + focused_limit
+        # current_active_count = 0
+        # items_snapshot = list(self._subheartflows.items())
+        # for _, flow in items_snapshot:
+        #     if flow.chat_state.chat_status == ChatState.CHAT or flow.chat_state.chat_status == ChatState.FOCUSED:
+        #         current_active_count += 1
+        # if current_active_count >= total_limit and total_limit > 0:
+        #     stream_name = chat_manager.get_stream_name(subheartflow_id) or subheartflow_id
+        #     logger.warning(f"[Heartflow Create] Skipped due to limit...")
+        #     return None
+        # --- 结束移除 --- #
+
         existing_subheartflow = self._subheartflows.get(subheartflow_id)
         if existing_subheartflow:
-            # 如果已存在，确保其 last_active_time 更新 (如果需要的话)
-            # existing_subheartflow.last_active_time = time.time() # 移除，活跃时间由实际操作更新
-            # logger.debug(f"[Heartflow] 返回已存在的 subheartflow: {subheartflow_id}")
             return existing_subheartflow
 
         logger.info(f"[Heartflow] 尝试创建新的 subheartflow: {subheartflow_id}")
         try:
-            # 创建 SubHeartflow，它内部会创建 InterestChatting
-            subheartflow = SubHeartflow(subheartflow_id)
+            # --- Pass 'self' (Heartflow instance) to SubHeartflow constructor --- #
+            subheartflow = SubHeartflow(subheartflow_id, self)
 
             # 创建并初始化观察对象
             logger.debug(f"[Heartflow] 为 {subheartflow_id} 创建 observation")
@@ -464,7 +605,7 @@ class Heartflow:
             logger.error(traceback.format_exc())
             return None
 
-    def get_subheartflow(self, observe_chat_id: Any) -> Optional[SubHeartflow]:
+    def get_subheartflow(self, observe_chat_id: Any) -> Optional['SubHeartflow']:
         """获取指定ID的SubHeartflow实例"""
         return self._subheartflows.get(observe_chat_id)
 
@@ -472,6 +613,182 @@ class Heartflow:
         """获取当前所有活跃的子心流的 ID 列表"""
         return list(self._subheartflows.keys())
 
+    async def _stop_subheartflow(self, subheartflow_id: Any, reason: str):
+        """停止并移除指定的子心流"""
+        if subheartflow_id in self._subheartflows:
+            subheartflow = self._subheartflows[subheartflow_id]
+            stream_name = chat_manager.get_stream_name(subheartflow_id) or subheartflow_id
+            logger.info(f"[Heartflow Limits] 停止子心流 {stream_name}. 原因: {reason}")
+
+            # 标记停止并取消任务
+            subheartflow.should_stop = True
+            task_to_cancel = subheartflow.task
+            if task_to_cancel and not task_to_cancel.done():
+                task_to_cancel.cancel()
+                logger.debug(f"[Heartflow Limits] 已取消子心流 {stream_name} 的后台任务")
+
+            # TODO: Ensure controller.stop_heartFC_chat is called if needed
+            from src.plugins.heartFC_chat.heartFC_controler import HeartFCController # Local import to avoid cycle
+            controller = HeartFCController.get_instance()
+            if controller and controller.is_heartFC_chat_active(subheartflow_id):
+                 await controller.stop_heartFC_chat(subheartflow_id)
+
+            # 从字典移除
+            del self._subheartflows[subheartflow_id]
+            logger.debug(f"[Heartflow Limits] 已移除子心流: {stream_name}")
+            return True
+        return False
+
+    async def _enforce_subheartflow_limits(self, current_mai_state: MaiState):
+        """根据当前的 MaiState 强制执行 SubHeartflow 数量限制"""
+        normal_limit = current_mai_state.get_normal_chat_max_num()
+        focused_limit = current_mai_state.get_focused_chat_max_num()
+        logger.debug(f"[Heartflow Limits] 执行限制检查。当前状态: {current_mai_state.value}, Normal上限: {normal_limit}, Focused上限: {focused_limit}")
+
+        # 分类并统计当前 subheartflows
+        normal_flows = []
+        focused_flows = []
+        other_flows = [] # e.g., ABSENT
+
+        # 创建快照以安全迭代
+        items_snapshot = list(self._subheartflows.items())
+
+        for flow_id, flow in items_snapshot:
+            # 确保 flow 实例仍然存在 (避免在迭代期间被其他任务移除)
+            if flow_id not in self._subheartflows:
+                continue
+            if flow.chat_state.chat_status == ChatState.CHAT:
+                normal_flows.append((flow_id, flow.last_active_time))
+            elif flow.chat_state.chat_status == ChatState.FOCUSED:
+                focused_flows.append((flow_id, flow.last_active_time))
+            else:
+                other_flows.append((flow_id, flow.last_active_time))
+
+        logger.debug(f"[Heartflow Limits] 当前计数 - Normal: {len(normal_flows)}, Focused: {len(focused_flows)}, Other: {len(other_flows)}")
+
+        stopped_count = 0
+
+        # 检查 Normal (CHAT) 限制
+        if len(normal_flows) > normal_limit:
+            excess_count = len(normal_flows) - normal_limit
+            logger.info(f"[Heartflow Limits] 检测到 Normal (CHAT) 状态超额 {excess_count} 个。上限: {normal_limit}")
+            # 按 last_active_time 升序排序 (最不活跃的在前)
+            normal_flows.sort(key=lambda item: item[1])
+            # 停止最不活跃的超额部分
+            for i in range(excess_count):
+                flow_id_to_stop = normal_flows[i][0]
+                if await self._stop_subheartflow(flow_id_to_stop, f"Normal (CHAT) 状态超出上限 ({normal_limit})，停止最不活跃的实例"):
+                    stopped_count += 1
+
+        # 重新获取 focused_flows 列表，因为上面的停止操作可能已经改变了状态或移除了实例
+        focused_flows = []
+        items_snapshot_after_normal = list(self._subheartflows.items())
+        for flow_id, flow in items_snapshot_after_normal:
+             if flow_id not in self._subheartflows: continue # Double check
+             if flow.chat_state.chat_status == ChatState.FOCUSED:
+                focused_flows.append((flow_id, flow.last_active_time))
+
+        # 检查 Focused (FOCUSED) 限制
+        if len(focused_flows) > focused_limit:
+            excess_count = len(focused_flows) - focused_limit
+            logger.info(f"[Heartflow Limits] 检测到 Focused (FOCUSED) 状态超额 {excess_count} 个。上限: {focused_limit}")
+            # 按 last_active_time 升序排序
+            focused_flows.sort(key=lambda item: item[1])
+            # 停止最不活跃的超额部分
+            for i in range(excess_count):
+                flow_id_to_stop = focused_flows[i][0]
+                if await self._stop_subheartflow(flow_id_to_stop, f"Focused (FOCUSED) 状态超出上限 ({focused_limit})，停止最不活跃的实例"):
+                    stopped_count += 1
+
+        if stopped_count > 0:
+            logger.info(f"[Heartflow Limits] 限制执行完成，共停止了 {stopped_count} 个子心流。当前总数: {len(self._subheartflows)}")
+        else:
+            logger.debug(f"[Heartflow Limits] 限制检查完成，无需停止子心流。当前总数: {len(self._subheartflows)}")
+
+    # --- 新增方法 --- #
+    async def _activate_random_subflows_to_chat(self, new_mai_state: MaiState):
+        """当主状态从 OFFLINE 激活时，随机选择子心流进入 CHAT 状态"""
+        limit = new_mai_state.get_normal_chat_max_num()
+        if limit <= 0:
+            logger.info("[Heartflow Activate] 当前状态不允许 CHAT 子心流，跳过激活。")
+            return
+
+        # 使用快照进行迭代
+        all_flows_snapshot = list(self._subheartflows.values())
+        absent_flows = [flow for flow in all_flows_snapshot if flow.subheartflow_id in self._subheartflows and flow.chat_state.chat_status == ChatState.ABSENT]
+
+        num_to_activate = min(limit, len(absent_flows))
+
+        if num_to_activate <= 0:
+            logger.info(f"[Heartflow Activate] 没有处于 ABSENT 状态的子心流可供激活至 CHAT (上限: {limit})。")
+            return
+
+        logger.info(f"[Heartflow Activate] 将随机选择 {num_to_activate} 个 (上限 {limit}) ABSENT 子心流激活至 CHAT 状态。")
+        selected_flows = random.sample(absent_flows, num_to_activate)
+
+        activated_count = 0
+        for flow in selected_flows:
+            # 再次检查 flow 是否仍然存在且状态为 ABSENT (以防并发修改)
+            if flow.subheartflow_id in self._subheartflows and self._subheartflows[flow.subheartflow_id].chat_state.chat_status == ChatState.ABSENT:
+                stream_name = chat_manager.get_stream_name(flow.subheartflow_id) or flow.subheartflow_id
+                logger.debug(f"[Heartflow Activate] 正在将子心流 {stream_name} 状态设置为 CHAT。")
+                # 调用 set_chat_state，它内部会处理日志记录
+                flow.set_chat_state(ChatState.CHAT)
+                activated_count += 1
+            else:
+                stream_name = chat_manager.get_stream_name(flow.subheartflow_id) or flow.subheartflow_id
+                logger.warning(f"[Heartflow Activate] 跳过激活子心流 {stream_name}，因为它不再存在或状态已改变。")
+
+        logger.info(f"[Heartflow Activate] 完成激活，成功将 {activated_count} 个子心流设置为 CHAT 状态。")
+
+    async def _deactivate_all_subflows_on_offline(self):
+        """当主状态变为 OFFLINE 时，停止所有子心流的活动并设置为 ABSENT"""
+        logger.info("[Heartflow Deactivate] 开始停用所有子心流...")
+        try:
+            from src.plugins.heartFC_chat.heartFC_controler import HeartFCController # 本地导入避免循环依赖
+            controller = HeartFCController.get_instance()
+        except ImportError:
+            logger.warning("[Heartflow Deactivate] 无法导入 HeartFCController，将跳过停止 heartFC_chat。")
+            controller = None
+        except Exception as e:
+            logger.error(f"[Heartflow Deactivate] 获取 HeartFCController 实例时出错: {e}")
+            controller = None
+
+        # 使用 ID 快照进行迭代
+        flow_ids_snapshot = list(self._subheartflows.keys())
+        deactivated_count = 0
+
+        for flow_id in flow_ids_snapshot:
+            subflow = self._subheartflows.get(flow_id)
+            if not subflow:
+                continue # Subflow 可能在迭代过程中被清理
+
+            stream_name = chat_manager.get_stream_name(flow_id) or flow_id
+
+            try:
+                # 停止相关聊天进程 (例如 pf_chat)
+                if controller:
+                    # TODO: 确认是否有 reason_chat 需要停止，并添加相应逻辑
+                    if controller.is_heartFC_chat_active(flow_id):
+                        logger.debug(f"[Heartflow Deactivate] 正在停止子心流 {stream_name} 的 heartFC_chat。")
+                        await controller.stop_heartFC_chat(flow_id)
+
+                # 设置状态为 ABSENT
+                if subflow.chat_state.chat_status != ChatState.ABSENT:
+                    logger.debug(f"[Heartflow Deactivate] 正在将子心流 {stream_name} 状态设置为 ABSENT。")
+                    # 调用 set_chat_state，它会处理日志和状态更新
+                    subflow.set_chat_state(ChatState.ABSENT)
+                    deactivated_count += 1
+                else:
+                    # 如果已经是 ABSENT，则无需再次设置，但记录一下检查
+                    logger.trace(f"[Heartflow Deactivate] 子心流 {stream_name} 已处于 ABSENT 状态。")
+
+            except Exception as e:
+                logger.error(f"[Heartflow Deactivate] 停用子心流 {stream_name} 时出错: {e}")
+                logger.error(traceback.format_exc())
+
+        logger.info(f"[Heartflow Deactivate] 完成停用，共将 {deactivated_count} 个子心流设置为 ABSENT 状态 (不包括已是 ABSENT 的)。")
+    # --- 结束新增方法 --- #
 
 init_prompt()
 # 创建一个全局的管理器实例

src/heart_flow/observation.py

@@ -78,8 +78,6 @@ class ChattingObservation(Observation):
             return self.talking_message_str
 
     async def observe(self):
-        # 查找新消息，最多获取 self.max_now_obs_len 条
-        print("2222222222222222221111111111111111开始观察")
         new_messages_list = get_raw_msg_by_timestamp_with_chat(
             chat_id=self.chat_id,
             timestamp_start=self.last_observe_time,
@@ -87,8 +85,8 @@ class ChattingObservation(Observation):
             limit=self.max_now_obs_len,
             limit_mode="latest",
         )
-        print(f"2222222222222222221111111111111111获取到新消息{len(new_messages_list)}条")
         if new_messages_list:  # 检查列表是否为空
+            last_obs_time_mark = self.last_observe_time
             self.last_observe_time = new_messages_list[-1]["time"]
             self.talking_message.extend(new_messages_list)
 
@@ -98,7 +96,11 @@ class ChattingObservation(Observation):
             oldest_messages = self.talking_message[:messages_to_remove_count]
             self.talking_message = self.talking_message[messages_to_remove_count:]  # 保留后半部分，即最新的
 
-            oldest_messages_str = await build_readable_messages(oldest_messages)
+            oldest_messages_str = await build_readable_messages(
+                messages=oldest_messages,
+                timestamp_mode="normal",
+                read_mark=last_obs_time_mark,
+            )
 
             # 调用 LLM 总结主题
             prompt = (
@@ -134,10 +136,7 @@ class ChattingObservation(Observation):
                     f"距离现在{time_diff}分钟前(聊天记录id:{mid_memory_item['id']})：{mid_memory_item['theme']}\n"
                 )
             self.mid_memory_info = mid_memory_str
-        # except Exception as e:  # 将异常处理移至此处以覆盖整个总结过程
-        #     logger.error(f"处理和总结旧消息时出错 for chat {self.chat_id}: {e}")
-        #     traceback.print_exc()  # 记录详细堆栈
-        # print(f"处理后self.talking_message：{self.talking_message}")
+
 
         self.talking_message_str = await build_readable_messages(messages=self.talking_message, timestamp_mode="normal")
 

src/heart_flow/sub_heartflow.py

@@ -4,7 +4,7 @@ from src.plugins.moods.moods import MoodManager
 from src.plugins.models.utils_model import LLMRequest
 from src.config.config import global_config
 import time
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Callable, TYPE_CHECKING
 import traceback
 from src.plugins.chat.utils import parse_text_timestamps
 import enum
@@ -14,8 +14,14 @@ import random
 from src.plugins.person_info.relationship_manager import relationship_manager
 from ..plugins.utils.prompt_builder import Prompt, global_prompt_manager
 from src.plugins.chat.message import MessageRecv
+from src.plugins.chat.chat_stream import chat_manager
 import math
 
+# Type hinting for circular dependency
+if TYPE_CHECKING:
+    from .heartflow import Heartflow, MaiState # Import Heartflow for type hinting
+    from .sub_heartflow import ChatState # Keep ChatState here too?
+
 # 定义常量 (从 interest.py 移动过来)
 MAX_INTEREST = 15.0
 
@@ -68,9 +74,6 @@ class ChatStateInfo:
         self.mood_manager = MoodManager()
         self.mood = self.mood_manager.get_prompt()
 
-    def update_chat_state_info(self):
-        self.chat_state_info = self.mood_manager.get_current_mood()
-
 
 base_reply_probability = 0.05
 probability_increase_rate_per_second = 0.08
@@ -87,6 +90,7 @@ class InterestChatting:
         increase_rate=probability_increase_rate_per_second,
         decay_factor=global_config.probability_decay_factor_per_second,
         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()
@@ -101,6 +105,7 @@ class InterestChatting:
         self.max_reply_probability: float = max_probability
         self.current_reply_probability: float = 0.0
         self.is_above_threshold: bool = False
+        self.state_change_callback = state_change_callback
 
         self.interest_dict: Dict[str, tuple[MessageRecv, float, bool]] = {}
 
@@ -144,6 +149,7 @@ class InterestChatting:
             return
 
         currently_above = self.interest_level >= self.trigger_threshold
+        previous_is_above = self.is_above_threshold
 
         if currently_above:
             if not self.is_above_threshold:
@@ -158,6 +164,13 @@ class InterestChatting:
             self.current_reply_probability = min(self.current_reply_probability, self.max_reply_probability)
 
         else:
+            if previous_is_above:
+                if self.state_change_callback:
+                    try:
+                        self.state_change_callback(ChatState.ABSENT)
+                    except Exception as e:
+                        interest_logger.error(f"Error calling state_change_callback for ABSENT: {e}")
+
             if 0 < self.probability_decay_factor < 1:
                 decay_multiplier = math.pow(self.probability_decay_factor, time_delta)
                 self.current_reply_probability *= decay_multiplier
@@ -216,14 +229,15 @@ class InterestChatting:
 
 
 class SubHeartflow:
-    def __init__(self, subheartflow_id):
+    def __init__(self, subheartflow_id, parent_heartflow: 'Heartflow'):
         self.subheartflow_id = subheartflow_id
+        self.parent_heartflow = parent_heartflow
 
         self.current_mind = "你什么也没想"
         self.past_mind = []
         self.chat_state: ChatStateInfo = ChatStateInfo()
 
-        self.interest_chatting = InterestChatting()
+        self.interest_chatting = InterestChatting(state_change_callback=self.set_chat_state)
 
         self.llm_model = LLMRequest(
             model=global_config.llm_sub_heartflow,
@@ -234,33 +248,58 @@ class SubHeartflow:
 
         self.main_heartflow_info = ""
 
-        self.last_active_time = time.time()  # 添加最后激活时间
-        self.should_stop = False  # 添加停止标志
-        self.task: Optional[asyncio.Task] = None  # 添加 task 属性
+        self.last_active_time = time.time()
+        self.should_stop = False
+        self.task: Optional[asyncio.Task] = None
 
         self.is_active = False
 
-        self.observations: List[ChattingObservation] = []  # 使用 List 类型提示
+        self.observations: List[ChattingObservation] = []
 
         self.running_knowledges = []
 
         self.bot_name = global_config.BOT_NICKNAME
+        logger.info(f"SubHeartflow {self.subheartflow_id} created with initial state: {self.chat_state.chat_status.value}")
+
+    def set_chat_state(self, new_state: 'ChatState'):
+        """更新sub_heartflow的聊天状态"""
+
+        current_state = self.chat_state.chat_status
+        if current_state == new_state:
+            return # No change needed
+
+        log_prefix = f"[{chat_manager.get_stream_name(self.subheartflow_id) or self.subheartflow_id}]"
+
+        # --- Limit Check before entering CHAT state --- #
+        if new_state == ChatState.CHAT:
+            current_mai_state = self.parent_heartflow.current_state.mai_status
+            normal_limit = current_mai_state.get_normal_chat_max_num()
+            current_chat_count = self.parent_heartflow.count_subflows_by_state(ChatState.CHAT)
+
+            if current_chat_count >= normal_limit:
+                logger.debug(f"{log_prefix} 拒绝从 {current_state.value} 转换到 CHAT。原因：CHAT 状态已达上限 ({normal_limit})。当前数量: {current_chat_count}")
+                return # Block the state transition
+            else:
+                logger.debug(f"{log_prefix} 允许从 {current_state.value} 转换到 CHAT (上限: {normal_limit}, 当前: {current_chat_count})" )
+
+        # 如果检查通过或目标状态不是CHAT，则进行状态变更
+        self.chat_state.chat_status = new_state
+        # 状态变更时更新最后活跃时间
+        self.last_active_time = time.time()  
+        logger.info(f"{log_prefix} 聊天状态从 {current_state.value} 变更为 {new_state.value}")
+
+        # TODO: 考虑从FOCUSED状态转出时是否需要停止PFChatting
+        # 这部分逻辑可能更适合放在Heartflow的_stop_subheartflow或HeartFCController的循环中处理
 
     async def subheartflow_start_working(self):
         while True:
-            # --- 调整后台任务逻辑 --- #
-            # 这个后台循环现在主要负责检查是否需要自我销毁
-            # 不再主动进行思考或状态更新，这些由 HeartFC_Chat 驱动
-
-            # 检查是否被主心流标记为停止
             if self.should_stop:
                 logger.info(f"子心流 {self.subheartflow_id} 被标记为停止，正在退出后台任务...")
-                break  # 退出循环以停止任务
+                break
 
-            await asyncio.sleep(global_config.sub_heart_flow_update_interval)  # 定期检查销毁条件
+            await asyncio.sleep(global_config.sub_heart_flow_update_interval)
 
     async def ensure_observed(self):
-        """确保在思考前执行了观察"""
         observation = self._get_primary_observation()
         if observation:
             try:
@@ -273,18 +312,14 @@ class SubHeartflow:
     async def do_thinking_before_reply(
         self,
         extra_info: str,
-        obs_id: list[str] = None,  # 修改 obs_id 类型为 list[str]
+        obs_id: list[str] = None,
     ):
-        # --- 在思考前确保观察已执行 --- #
-        # await self.ensure_observed()
-
-        self.last_active_time = time.time()  # 更新最后激活时间戳
+        self.last_active_time = time.time()
 
         current_thinking_info = self.current_mind
         mood_info = self.chat_state.mood
         observation = self._get_primary_observation()
 
-        # --- 获取观察信息 --- #
         chat_observe_info = ""
         if obs_id:
             try:
@@ -294,12 +329,11 @@ class SubHeartflow:
                 logger.error(
                     f"[{self.subheartflow_id}] Error getting observe info with IDs {obs_id}: {e}. Falling back."
                 )
-                chat_observe_info = observation.get_observe_info()  # 出错时回退到默认观察
+                chat_observe_info = observation.get_observe_info()
         else:
             chat_observe_info = observation.get_observe_info()
-            logger.debug(f"[{self.subheartflow_id}] Using default observation info.")
+            # logger.debug(f"[{self.subheartflow_id}] Using default observation info.")
 
-        # --- 构建 Prompt (基本逻辑不变) --- #
         extra_info_prompt = ""
         if extra_info:
             for tool_name, tool_data in extra_info.items():
@@ -307,28 +341,25 @@ class SubHeartflow:
                 for item in tool_data:
                     extra_info_prompt += f"- {item['name']}: {item['content']}\n"
         else:
-            extra_info_prompt = "无工具信息。\n"  # 提供默认值
+            extra_info_prompt = "无工具信息。\n"
 
         individuality = Individuality.get_instance()
         prompt_personality = f"你的名字是{self.bot_name}，你"
         prompt_personality += individuality.personality.personality_core
 
-        # 添加随机性格侧面
         if individuality.personality.personality_sides:
             random_side = random.choice(individuality.personality.personality_sides)
             prompt_personality += f"，{random_side}"
 
-        # 添加随机身份细节
         if individuality.identity.identity_detail:
             random_detail = random.choice(individuality.identity.identity_detail)
             prompt_personality += f"，{random_detail}"
 
         time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
-        # 创建局部Random对象避免影响全局随机状态
         local_random = random.Random()
         current_minute = int(time.strftime("%M"))
-        local_random.seed(current_minute)  # 用分钟作为种子确保每分钟内选择一致
+        local_random.seed(current_minute)
 
         hf_options = [
             ("继续生成你在这个聊天中的想法，在原来想法的基础上继续思考", 0.7),
@@ -343,7 +374,6 @@ class SubHeartflow:
 
         prompt = (await global_prompt_manager.get_prompt_async("sub_heartflow_prompt_before")).format(
             extra_info=extra_info_prompt,
-            # relation_prompt_all=relation_prompt_all,
             prompt_personality=prompt_personality,
             bot_name=self.bot_name,
             current_thinking_info=current_thinking_info,
@@ -351,8 +381,6 @@ class SubHeartflow:
             chat_observe_info=chat_observe_info,
             mood_info=mood_info,
             hf_do_next=hf_do_next,
-            # sender_name=sender_name_sign,
-            # message_txt=message_txt,
         )
 
         prompt = await relationship_manager.convert_all_person_sign_to_person_name(prompt)
@@ -365,18 +393,15 @@ class SubHeartflow:
 
             logger.debug(f"[{self.subheartflow_id}] 心流思考结果:\n{response}\n")
 
-            if not response:  # 如果 LLM 返回空，给一个默认想法
+            if not response:
                 response = "(不知道该想些什么...)"
                 logger.warning(f"[{self.subheartflow_id}] LLM 返回空结果，思考失败。")
         except Exception as e:
             logger.error(f"[{self.subheartflow_id}] 内心独白获取失败: {e}")
-            response = "(思考时发生错误...)"  # 错误时的默认想法
+            response = "(思考时发生错误...)"
 
         self.update_current_mind(response)
 
-        # self.current_mind 已经在 update_current_mind 中更新
-
-        # logger.info(f"[{self.subheartflow_id}] 思考前脑内状态：{self.current_mind}")
         return self.current_mind, self.past_mind
 
     def update_current_mind(self, response):
@@ -384,55 +409,41 @@ class SubHeartflow:
         self.current_mind = response
 
     def add_observation(self, observation: Observation):
-        """添加一个新的observation对象到列表中，如果已存在相同id的observation则不添加"""
-        # 查找是否存在相同id的observation
         for existing_obs in self.observations:
             if existing_obs.observe_id == observation.observe_id:
-                # 如果找到相同id的observation，直接返回
                 return
-        # 如果没有找到相同id的observation，则添加新的
         self.observations.append(observation)
 
     def remove_observation(self, observation: Observation):
-        """从列表中移除一个observation对象"""
         if observation in self.observations:
             self.observations.remove(observation)
 
     def get_all_observations(self) -> list[Observation]:
-        """获取所有observation对象"""
         return self.observations
 
     def clear_observations(self):
-        """清空所有observation对象"""
         self.observations.clear()
 
     def _get_primary_observation(self) -> Optional[ChattingObservation]:
-        """获取主要的（通常是第一个）ChattingObservation实例"""
         if self.observations and isinstance(self.observations[0], ChattingObservation):
             return self.observations[0]
         logger.warning(f"SubHeartflow {self.subheartflow_id} 没有找到有效的 ChattingObservation")
         return None
 
     def get_interest_state(self) -> dict:
-        """获取当前兴趣状态"""
         return self.interest_chatting.get_state()
 
     def get_interest_level(self) -> float:
-        """获取当前兴趣等级"""
         return self.interest_chatting.get_interest()
 
     def should_evaluate_reply(self) -> bool:
-        """判断是否应该评估回复"""
         return self.interest_chatting.should_evaluate_reply()
 
     def add_interest_dict_entry(self, message: MessageRecv, interest_value: float, is_mentioned: bool):
-        """添加兴趣字典条目"""
         self.interest_chatting.add_interest_dict(message, interest_value, is_mentioned)
 
     def get_interest_dict(self) -> Dict[str, tuple[MessageRecv, float, bool]]:
-        """获取兴趣字典"""
         return self.interest_chatting.interest_dict
 
 
 init_prompt()
-# subheartflow = SubHeartflow()