refactor(sleep): 重构睡眠系统以实现睡后失眠机制

重构了原有的睡眠管理状态机，将睡前失眠逻辑调整为更真实的“睡后失眠”模式。现在系统会在角色入睡一段时间后，根据当前的睡眠压力判断是否触发失眠状态。

主要变更：
- **状态机调整**: 移除了入睡前的失眠检查，改为在进入`SLEEPING`状态后，延迟一段时间再根据睡眠压力触发`INSOMNIA`状态。
- **通知系统重构**: `NotificationSender`被简化，现在通过触发主动思考事件 (`goodnight`, `post_sleep_insomnia`) 来发送通知，而不是直接调用生成器API。
- **配置更新**: 将固定的失眠持续时间改为一个随机范围，并增加了触发失眠判定的延迟时间配置。
- **代码解耦**: `EnergyManager`现在直接依赖新的`SleepManager`，不再通过旧的`schedule_manager`。

src/chat/chat_loop/energy_manager.py

@@ -4,8 +4,7 @@ from typing import Optional
 from src.common.logger import get_logger
 from src.config.config import global_config
 from .hfc_context import HfcContext
-from src.schedule.schedule_manager import schedule_manager
-
+from src.chat.chat_loop.sleep_manager import sleep_manager
 logger = get_logger("hfc")
 
 
@@ -74,7 +73,7 @@ class EnergyManager:
                 continue
 
             # 判断当前是否为睡眠时间
-            is_sleeping = schedule_manager.is_sleeping()
+            is_sleeping = sleep_manager.SleepManager().is_sleeping()
 
             if is_sleeping:
                 # 睡眠中：减少睡眠压力

src/chat/chat_loop/hfc_context.py

@@ -70,7 +70,7 @@ class HfcContext:
         # breaking形式下的累积兴趣值
         self.breaking_accumulated_interest = 0.0
         # 引用HeartFChatting实例，以便其他组件可以调用其方法
-        self.chat_instance: Optional["HeartFChatting"] = None
+        self.chat_instance: "HeartFChatting"
 
     def save_context_state(self):
         """将当前状态保存到聊天流"""

src/chat/chat_loop/proactive/proactive_thinker.py

@@ -76,6 +76,8 @@ class ProactiveThinker:
                 new_mood = "深夜emo，胡思乱想"
             elif trigger_event.reason == "goodnight":
                 new_mood = "有点困了，准备睡觉了"
+            elif trigger_event.reason == "post_sleep_insomnia":
+                new_mood = "可恶，刚刚好像睡着了又醒了，现在睡不着了"
 
             if new_mood:
                 mood_obj.mood_state = new_mood

src/chat/chat_loop/sleep_manager/notification_sender.py

@@ -1,68 +1,33 @@
 import asyncio
-import random
-import hashlib
 from src.common.logger import get_logger
-from src.config.config import global_config
-from src.plugin_system.apis import send_api, generator_api
+from ..hfc_context import HfcContext
 
 logger = get_logger("notification_sender")
 
 
 class NotificationSender:
     @staticmethod
-    async def send_pre_sleep_notification():
-        """异步生成并发送睡前通知"""
+    async def send_goodnight_notification(context: HfcContext):
+        """发送晚安通知"""
         try:
-            groups = global_config.sleep_system.pre_sleep_notification_groups
-            prompt = global_config.sleep_system.pre_sleep_prompt
-
-            if not groups:
-                logger.info("未配置睡前通知的群组，跳过发送。")
-                return
-
-            if not prompt:
-                logger.warning("睡前通知的prompt为空，跳过发送。")
-                return
-
-            # 为防止消息风暴，稍微延迟一下
-            await asyncio.sleep(random.uniform(5, 15))
-
-            for group_id_str in groups:
-                try:
-                    # 格式 "platform:group_id"
-                    parts = group_id_str.split(":")
-                    if len(parts) != 2:
-                        logger.warning(f"无效的群组ID格式: {group_id_str}")
-                        continue
-
-                    platform, group_id = parts
-
-                    # 使用与 ChatStream.get_stream_id 相同的逻辑生成 stream_id
-                    key = "_".join([platform, group_id])
-                    stream_id = hashlib.md5(key.encode()).hexdigest()
-
-                    logger.info(f"正在为群组 {group_id_str} (Stream ID: {stream_id}) 生成睡前消息...")
-
-                    # 调用 generator_api 生成回复
-                    success, reply_set, _ = await generator_api.generate_reply(
-                        chat_id=stream_id, extra_info=prompt, request_type="schedule.pre_sleep_notification"
-                    )
-
-                    if success and reply_set:
-                        # 提取文本内容并发送
-                        reply_text = "".join([content for msg_type, content in reply_set if msg_type == "text"])
-                        if reply_text:
-                            logger.info(f"向群组 {group_id_str} 发送睡前消息: {reply_text}")
-                            await send_api.text_to_stream(text=reply_text, stream_id=stream_id)
-                        else:
-                            logger.warning(f"为群组 {group_id_str} 生成的回复内容为空。")
-                    else:
-                        logger.error(f"为群组 {group_id_str} 生成睡前消息失败。")
-
-                    await asyncio.sleep(random.uniform(2, 5))  # 避免发送过快
-
-                except Exception as e:
-                    logger.error(f"向群组 {group_id_str} 发送睡前消息失败: {e}")
-
+            from ..proactive.events import ProactiveTriggerEvent
+            from ..proactive.proactive_thinker import ProactiveThinker
+            
+            event = ProactiveTriggerEvent(source="sleep_manager", reason="goodnight")
+            proactive_thinker = ProactiveThinker(context, context.chat_instance.cycle_processor)
+            await proactive_thinker.think(event)
         except Exception as e:
-            logger.error(f"发送睡前通知任务失败: {e}")
+            logger.error(f"发送晚安通知失败: {e}")
+
+    @staticmethod
+    async def send_insomnia_notification(context: HfcContext):
+        """发送失眠通知"""
+        try:
+            from ..proactive.events import ProactiveTriggerEvent
+            from ..proactive.proactive_thinker import ProactiveThinker
+
+            event = ProactiveTriggerEvent(source="sleep_manager", reason="post_sleep_insomnia")
+            proactive_thinker = ProactiveThinker(context, context.chat_instance.cycle_processor)
+            await proactive_thinker.think(event)
+        except Exception as e:
+            logger.error(f"发送失眠通知失败: {e}")

src/chat/chat_loop/sleep_manager/sleep_manager.py

@@ -49,7 +49,7 @@ class SleepManager:
         today = now.date()
 
         if self._last_sleep_check_date != today:
-            logger.info(f"新的一天 ({today})，重置睡眠状态为 AWAKE。")
+            logger.info(f"新的一天 ({today})，重置睡眠状态。")
             self._total_delayed_minutes_today = 0
             self._current_state = SleepState.AWAKE
             self._sleep_buffer_end_time = None
@@ -58,93 +58,107 @@ class SleepManager:
 
         is_in_theoretical_sleep, activity = self.time_checker.is_in_theoretical_sleep_time(now.time())
 
+        # 状态机处理
         if self._current_state == SleepState.AWAKE:
             if is_in_theoretical_sleep:
-                logger.info(f"进入理论休眠时间 '{activity}'，开始进行睡眠决策...")
-                sleep_pressure = wakeup_manager.context.sleep_pressure if wakeup_manager else 999
-                pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold
-
-                if (
-                    sleep_pressure < pressure_threshold
-                    and self._total_delayed_minutes_today < global_config.sleep_system.max_sleep_delay_minutes
-                ):
-                    delay_minutes = 15
-                    self._total_delayed_minutes_today += delay_minutes
-                    self._sleep_buffer_end_time = now + timedelta(minutes=delay_minutes)
-                    self._current_state = SleepState.INSOMNIA
-                    logger.info(
-                        f"睡眠压力 ({sleep_pressure:.1f}) 低于阈值 ({pressure_threshold})，进入失眠状态，延迟入睡 {delay_minutes} 分钟。"
-                    )
-                    if global_config.sleep_system.enable_pre_sleep_notification:
-                        asyncio.create_task(NotificationSender.send_pre_sleep_notification())
-                else:
-                    buffer_seconds = random.randint(5 * 60, 10 * 60)
-                    self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
-                    self._current_state = SleepState.PREPARING_SLEEP
-                    logger.info(
-                        f"睡眠压力正常或已达今日最大延迟，进入准备入睡状态，将在 {buffer_seconds / 60:.1f} 分钟内入睡。"
-                    )
-                    if global_config.sleep_system.enable_pre_sleep_notification:
-                        asyncio.create_task(NotificationSender.send_pre_sleep_notification())
-                self._save_sleep_state()
-
-        elif self._current_state == SleepState.INSOMNIA:
-            if not is_in_theoretical_sleep:
-                logger.info("已离开理论休眠时间，失眠结束，恢复清醒。")
-                self._current_state = SleepState.AWAKE
-                self._save_sleep_state()
-            elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time:
-                logger.info("失眠状态下的延迟时间已过，重新评估是否入睡...")
-                sleep_pressure = wakeup_manager.context.sleep_pressure if wakeup_manager else 999
-                pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold
-
-                if (
-                    sleep_pressure >= pressure_threshold
-                    or self._total_delayed_minutes_today >= global_config.sleep_system.max_sleep_delay_minutes
-                ):
-                    logger.info("睡眠压力足够或已达最大延迟，从失眠状态转换到准备入睡。")
-                    buffer_seconds = random.randint(5 * 60, 10 * 60)
-                    self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
-                    self._current_state = SleepState.PREPARING_SLEEP
-                else:
-                    logger.info(f"睡眠压力({sleep_pressure:.1f})仍然较低，再延迟15分钟。")
-                    delay_minutes = 15
-                    self._total_delayed_minutes_today += delay_minutes
-                    self._sleep_buffer_end_time = now + timedelta(minutes=delay_minutes)
-                self._save_sleep_state()
+                self._handle_awake_to_sleep(now, activity, wakeup_manager)
 
         elif self._current_state == SleepState.PREPARING_SLEEP:
-            if not is_in_theoretical_sleep:
-                logger.info("准备入睡期间离开理论休眠时间，取消入睡，恢复清醒。")
-                self._current_state = SleepState.AWAKE
-                self._sleep_buffer_end_time = None
-                self._save_sleep_state()
-            elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time:
-                logger.info("睡眠缓冲期结束，正式进入休眠状态。")
-                self._current_state = SleepState.SLEEPING
-                self._last_fully_slept_log_time = now.timestamp()
-                self._save_sleep_state()
+            self._handle_preparing_sleep(now, is_in_theoretical_sleep, wakeup_manager)
 
         elif self._current_state == SleepState.SLEEPING:
-            if not is_in_theoretical_sleep:
-                logger.info("理论休眠时间结束，自然醒来。")
-                self._current_state = SleepState.AWAKE
-                self._save_sleep_state()
-            else:
-                current_timestamp = now.timestamp()
-                if current_timestamp - self.last_sleep_log_time > self.sleep_log_interval:
-                    logger.info(f"当前处于休眠活动 '{activity}' 中。")
-                    self.last_sleep_log_time = current_timestamp
+            self._handle_sleeping(now, is_in_theoretical_sleep, activity, wakeup_manager)
+
+        elif self._current_state == SleepState.INSOMNIA:
+            self._handle_insomnia(now, is_in_theoretical_sleep)
 
         elif self._current_state == SleepState.WOKEN_UP:
-            if not is_in_theoretical_sleep:
-                logger.info("理论休眠时间结束，被吵醒的状态自动结束。")
-                self._current_state = SleepState.AWAKE
-                self._re_sleep_attempt_time = None
+            self._handle_woken_up(now, is_in_theoretical_sleep, wakeup_manager)
+
+    def _handle_awake_to_sleep(self, now: datetime, activity: Optional[str], wakeup_manager: Optional["WakeUpManager"]):
+        if activity:
+            logger.info(f"进入理论休眠时间 '{activity}'，开始进行睡眠决策...")
+        else:
+            logger.info("进入理论休眠时间，开始进行睡眠决策...")
+        
+        if wakeup_manager and global_config.sleep_system.enable_pre_sleep_notification:
+            asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context))
+
+        buffer_seconds = random.randint(1 * 60, 3 * 60)
+        self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
+        self._current_state = SleepState.PREPARING_SLEEP
+        logger.info(f"进入准备入睡状态，将在 {buffer_seconds / 60:.1f} 分钟内入睡。")
+        self._save_sleep_state()
+
+    def _handle_preparing_sleep(self, now: datetime, is_in_theoretical_sleep: bool, wakeup_manager: Optional["WakeUpManager"]):
+        if not is_in_theoretical_sleep:
+            logger.info("准备入睡期间离开理论休眠时间，取消入睡，恢复清醒。")
+            self._current_state = SleepState.AWAKE
+            self._sleep_buffer_end_time = None
+            self._save_sleep_state()
+        elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time:
+            logger.info("睡眠缓冲期结束，正式进入休眠状态。")
+            self._current_state = SleepState.SLEEPING
+            self._last_fully_slept_log_time = now.timestamp()
+            
+            delay_minutes_range = global_config.sleep_system.insomnia_trigger_delay_minutes
+            delay_minutes = random.randint(delay_minutes_range[0], delay_minutes_range[1])
+            self._sleep_buffer_end_time = now + timedelta(minutes=delay_minutes)
+            logger.info(f"已设置睡后失眠检查，将在 {delay_minutes} 分钟后触发。")
+            
+            self._save_sleep_state()
+
+    def _handle_sleeping(self, now: datetime, is_in_theoretical_sleep: bool, activity: Optional[str], wakeup_manager: Optional["WakeUpManager"]):
+        if not is_in_theoretical_sleep:
+            logger.info("理论休眠时间结束，自然醒来。")
+            self._current_state = SleepState.AWAKE
+            self._save_sleep_state()
+        elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time:
+            if wakeup_manager:
+                sleep_pressure = wakeup_manager.context.sleep_pressure
+                pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold
+                if sleep_pressure < pressure_threshold:
+                    logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 低于阈值 ({pressure_threshold})，触发睡后失眠。")
+                    self._current_state = SleepState.INSOMNIA
+                    
+                    duration_minutes_range = global_config.sleep_system.insomnia_duration_minutes
+                    duration_minutes = random.randint(duration_minutes_range[0], duration_minutes_range[1])
+                    self._sleep_buffer_end_time = now + timedelta(minutes=duration_minutes)
+                    
+                    asyncio.create_task(NotificationSender.send_insomnia_notification(wakeup_manager.context))
+                    logger.info(f"进入失眠状态，将持续 {duration_minutes} 分钟。")
+                else:
+                    logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 正常，未触发睡后失眠。")
+                    self._sleep_buffer_end_time = None
                 self._save_sleep_state()
-            elif self._re_sleep_attempt_time and now >= self._re_sleep_attempt_time:
-                logger.info("被吵醒后经过一段时间，尝试重新入睡...")
-                sleep_pressure = wakeup_manager.context.sleep_pressure if wakeup_manager else 999
+        else:
+            current_timestamp = now.timestamp()
+            if current_timestamp - self.last_sleep_log_time > self.sleep_log_interval and activity:
+                logger.info(f"当前处于休眠活动 '{activity}' 中。")
+                self.last_sleep_log_time = current_timestamp
+
+    def _handle_insomnia(self, now: datetime, is_in_theoretical_sleep: bool):
+        if not is_in_theoretical_sleep:
+            logger.info("已离开理论休眠时间，失眠结束，恢复清醒。")
+            self._current_state = SleepState.AWAKE
+            self._sleep_buffer_end_time = None
+            self._save_sleep_state()
+        elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time:
+            logger.info("失眠状态持续时间已过，恢复睡眠。")
+            self._current_state = SleepState.SLEEPING
+            self._sleep_buffer_end_time = None
+            self._save_sleep_state()
+
+    def _handle_woken_up(self, now: datetime, is_in_theoretical_sleep: bool, wakeup_manager: Optional["WakeUpManager"]):
+        if not is_in_theoretical_sleep:
+            logger.info("理论休眠时间结束，被吵醒的状态自动结束。")
+            self._current_state = SleepState.AWAKE
+            self._re_sleep_attempt_time = None
+            self._save_sleep_state()
+        elif self._re_sleep_attempt_time and now >= self._re_sleep_attempt_time:
+            logger.info("被吵醒后经过一段时间，尝试重新入睡...")
+            if wakeup_manager:
+                sleep_pressure = wakeup_manager.context.sleep_pressure
                 pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold
 
                 if sleep_pressure >= pressure_threshold:

src/config/official_configs.py

@@ -625,7 +625,12 @@ class SleepSystemConfig(ValidatedConfigBase):
 
     # --- 失眠机制相关参数 ---
     enable_insomnia_system: bool = Field(default=True, description="是否启用失眠系统")
-    insomnia_duration_minutes: int = Field(default=30, ge=1, description="单次失眠状态的持续时间（分钟）")
+    insomnia_trigger_delay_minutes: List[int] = Field(
+        default_factory=lambda:[30, 60], description="入睡后触发失眠判定的延迟时间范围（分钟）"
+    )
+    insomnia_duration_minutes: List[int] = Field(
+        default_factory=lambda:[15, 45], description="单次失眠状态的持续时间范围（分钟）"
+    )
     sleep_pressure_threshold: float = Field(default=30.0, description="触发“压力不足型失眠”的睡眠压力阈值")
     deep_sleep_threshold: float = Field(default=80.0, description="进入“深度睡眠”的睡眠压力阈值")
     insomnia_chance_low_pressure: float = Field(default=0.6, ge=0.0, le=1.0, description="压力不足时的失眠基础概率")