feat(chat): 为消息管理器添加睡眠与唤醒机制

将 `SleepManager` 和 `WakeUpManager` 集成到 `MessageManager` 中，以实现机器人的睡眠和唤醒功能。

在睡眠状态下，机器人将忽略常规消息，不进行处理。只有当接收到特定唤醒触发器（如私聊消息或在群聊中被@）时，机器人才能被唤醒并恢复正常的消息处理流程。

此机制旨在模拟更自然的用户行为，并在机器人非活跃时段减少不必要的打扰。

src/chat/message_manager/message_manager.py

@@ -13,7 +13,8 @@ from src.common.data_models.database_data_model import DatabaseMessages
 from src.common.data_models.message_manager_data_model import StreamContext, MessageManagerStats, StreamStats
 from src.chat.chatter_manager import ChatterManager
 from src.chat.planner_actions.action_manager import ChatterActionManager
-from src.plugin_system.base.component_types import ChatMode
+from .sleep_manager.sleep_manager import SleepManager
+from .sleep_manager.wakeup_manager import WakeUpManager
 
 if TYPE_CHECKING:
     from src.common.data_models.message_manager_data_model import StreamContext
@@ -37,6 +38,10 @@ class MessageManager:
         self.action_manager = ChatterActionManager()
         self.chatter_manager = ChatterManager(self.action_manager)
 
+        # 初始化睡眠和唤醒管理器
+        self.sleep_manager = SleepManager()
+        self.wakeup_manager = WakeUpManager(self.sleep_manager)
+
     async def start(self):
         """启动消息管理器"""
         if self.is_running:
@@ -45,6 +50,7 @@ class MessageManager:
 
         self.is_running = True
         self.manager_task = asyncio.create_task(self._manager_loop())
+        await self.wakeup_manager.start()
         logger.info("消息管理器已启动")
 
     async def stop(self):
@@ -63,6 +69,8 @@ class MessageManager:
         if self.manager_task and not self.manager_task.done():
             self.manager_task.cancel()
         
+        await self.wakeup_manager.stop()
+
         logger.info("消息管理器已停止")
 
     def add_message(self, stream_id: str, message: DatabaseMessages):
@@ -82,6 +90,9 @@ class MessageManager:
         """管理器主循环"""
         while self.is_running:
             try:
+                # 更新睡眠状态
+                await self.sleep_manager.update_sleep_state(self.wakeup_manager)
+                
                 await self._check_all_streams()
                 await asyncio.sleep(self.check_interval)
             except asyncio.CancelledError:
@@ -127,6 +138,28 @@ class MessageManager:
             if not unread_messages:
                 return
             
+            # --- 睡眠状态检查 ---
+            from .sleep_manager.sleep_state import SleepState
+            if self.sleep_manager.is_sleeping():
+                logger.info(f"Bot正在睡觉，检查聊天流 {stream_id} 是否有唤醒触发器。")
+                
+                was_woken_up = False
+                is_private = context.is_private_chat()
+
+                for message in unread_messages:
+                    is_mentioned = message.is_mentioned or False
+                    if is_private or is_mentioned:
+                        if self.wakeup_manager.add_wakeup_value(is_private, is_mentioned):
+                            was_woken_up = True
+                            break # 一旦被吵醒，就跳出循环并处理消息
+                
+                if not was_woken_up:
+                    logger.debug(f"聊天流 {stream_id} 中没有唤醒触发器，保持消息未读状态。")
+                    return # 退出，不处理消息
+                
+                logger.info(f"Bot被聊天流 {stream_id} 中的消息吵醒，继续处理。")
+            # --- 睡眠状态检查结束 ---
+
             logger.debug(f"开始处理聊天流 {stream_id} 的 {len(unread_messages)} 条未读消息")
 
             # 直接使用StreamContext对象进行处理
@@ -189,7 +222,7 @@ class MessageManager:
             unread_count=len(context.get_unread_messages()),
             history_count=len(context.history_messages),
             last_check_time=context.last_check_time,
-            has_active_task=context.processing_task and not context.processing_task.done(),
+            has_active_task=bool(context.processing_task and not context.processing_task.done()),
         )
 
     def get_manager_stats(self) -> Dict[str, Any]:

src/chat/message_manager/sleep_manager/notification_sender.py

@@ -0,0 +1,32 @@
+from src.common.logger import get_logger
+from ..hfc_context import HfcContext
+
+logger = get_logger("notification_sender")
+
+
+class NotificationSender:
+    @staticmethod
+    async def send_goodnight_notification(context: HfcContext):
+        """发送晚安通知"""
+        #try:
+            #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}")
+
+    @staticmethod
+    async def send_insomnia_notification(context: HfcContext, reason: str):
+        """发送失眠通知"""
+        #try:
+            #from ..proactive.events import ProactiveTriggerEvent
+            #from ..proactive.proactive_thinker import ProactiveThinker
+
+            #event = ProactiveTriggerEvent(source="sleep_manager", reason=reason)
+            #proactive_thinker = ProactiveThinker(context, context.chat_instance.cycle_processor)
+            #await proactive_thinker.think(event)
+        #except Exception as e:
+            #logger.error(f"发送失眠通知失败: {e}")

src/chat/message_manager/sleep_manager/sleep_manager.py

@@ -0,0 +1,304 @@
+import asyncio
+import random
+from datetime import datetime, timedelta, date
+from typing import Optional, TYPE_CHECKING
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+from .notification_sender import NotificationSender
+from .sleep_state import SleepState, SleepStateSerializer
+from .time_checker import TimeChecker
+
+if TYPE_CHECKING:
+    pass
+
+logger = get_logger("sleep_manager")
+
+
+class SleepManager:
+    """
+    睡眠管理器，核心组件之一，负责管理角色的睡眠周期和状态转换。
+    它实现了一个状态机，根据预设的时间表、睡眠压力和随机因素，
+    在不同的睡眠状态（如清醒、准备入睡、睡眠、失眠）之间进行切换。
+    """
+    def __init__(self):
+        """
+        初始化睡眠管理器。
+        """
+        self.time_checker = TimeChecker()  # 时间检查器，用于判断当前是否处于理论睡眠时间
+        self.last_sleep_log_time = 0  # 上次记录睡眠日志的时间戳
+        self.sleep_log_interval = 35  # 睡眠日志记录间隔（秒）
+
+        # --- 统一睡眠状态管理 ---
+        self._current_state: SleepState = SleepState.AWAKE  # 当前睡眠状态
+        self._sleep_buffer_end_time: Optional[datetime] = None  # 睡眠缓冲结束时间，用于状态转换
+        self._total_delayed_minutes_today: float = 0.0  # 今天总共延迟入睡的分钟数
+        self._last_sleep_check_date: Optional[date] = None  # 上次检查睡眠状态的日期
+        self._last_fully_slept_log_time: float = 0  # 上次完全进入睡眠状态的时间戳
+        self._re_sleep_attempt_time: Optional[datetime] = None  # 被吵醒后，尝试重新入睡的时间点
+
+        # 从本地存储加载上一次的睡眠状态
+        self._load_sleep_state()
+
+    def get_current_sleep_state(self) -> SleepState:
+        """获取当前的睡眠状态。"""
+        return self._current_state
+
+    def is_sleeping(self) -> bool:
+        """判断当前是否处于正在睡觉的状态。"""
+        return self._current_state == SleepState.SLEEPING
+
+    async def update_sleep_state(self, wakeup_manager: Optional["WakeUpManager"] = None):
+        """
+        更新睡眠状态的核心方法，实现状态机的主要逻辑。
+        该方法会被周期性调用，以检查并更新当前的睡眠状态。
+
+        Args:
+            wakeup_manager (Optional["WakeUpManager"]): 唤醒管理器，用于获取睡眠压力等上下文信息。
+        """
+        # 如果全局禁用了睡眠系统，则强制设置为清醒状态并返回
+        if not global_config.sleep_system.enable:
+            if self._current_state != SleepState.AWAKE:
+                logger.debug("睡眠系统禁用，强制设为 AWAKE")
+                self._current_state = SleepState.AWAKE
+            return
+
+        now = datetime.now()
+        today = now.date()
+
+        # 跨天处理：如果日期变化，重置每日相关的睡眠状态
+        if self._last_sleep_check_date != today:
+            logger.info(f"新的一天 ({today})，重置睡眠状态。")
+            self._total_delayed_minutes_today = 0
+            self._current_state = SleepState.AWAKE
+            self._sleep_buffer_end_time = None
+            self._last_sleep_check_date = today
+            self._save_sleep_state()
+
+        # 检查当前是否处于理论上的睡眠时间段
+        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:
+                self._handle_awake_to_sleep(now, activity, wakeup_manager)
+
+        elif self._current_state == SleepState.PREPARING_SLEEP:
+            self._handle_preparing_sleep(now, is_in_theoretical_sleep, wakeup_manager)
+
+        elif self._current_state == SleepState.SLEEPING:
+            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:
+            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 global_config.sleep_system.enable_flexible_sleep:
+            # --- 新的弹性睡眠逻辑 ---
+            if wakeup_manager:
+                sleep_pressure = wakeup_manager.context.sleep_pressure
+                pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold
+                max_delay_minutes = global_config.sleep_system.max_sleep_delay_minutes
+
+                buffer_seconds = 0
+                # 如果睡眠压力低于阈值，则计算延迟时间
+                if sleep_pressure <= pressure_threshold:
+                    # 压力差，归一化到 (0, 1]
+                    pressure_diff = (pressure_threshold - sleep_pressure) / pressure_threshold
+                    # 延迟分钟数，压力越低，延迟越长
+                    delay_minutes = int(pressure_diff * max_delay_minutes)
+                    
+                    # 确保总延迟不超过当日最大值
+                    remaining_delay = max_delay_minutes - self._total_delayed_minutes_today
+                    delay_minutes = min(delay_minutes, remaining_delay)
+
+                    if delay_minutes > 0:
+                        # 增加一些随机性
+                        buffer_seconds = random.randint(int(delay_minutes * 0.8 * 60), int(delay_minutes * 1.2 * 60))
+                        self._total_delayed_minutes_today += buffer_seconds / 60.0
+                        logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 较低，延迟 {buffer_seconds / 60:.1f} 分钟入睡。")
+                    else:
+                        # 延迟额度已用完，设置一个较短的准备时间
+                        buffer_seconds = random.randint(1 * 60, 2 * 60)
+                        logger.info("今日延迟入睡额度已用完，进入短暂准备后入睡。")
+                else:
+                    # 睡眠压力较高，设置一个较短的准备时间
+                    buffer_seconds = random.randint(1 * 60, 2 * 60)
+                    logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 较高，将在短暂准备后入睡。")
+
+                # 发送睡前通知
+                if global_config.sleep_system.enable_pre_sleep_notification:
+                    asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context))
+
+                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()
+            else:
+                # 无法获取 wakeup_manager，退回旧逻辑
+                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.warning("无法获取 WakeUpManager，弹性睡眠采用默认1-3分钟延迟。")
+                self._save_sleep_state()
+        else:
+            # 非弹性睡眠模式
+            if wakeup_manager and global_config.sleep_system.enable_pre_sleep_notification:
+                asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context))
+            self._current_state = SleepState.SLEEPING
+       
+
+    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
+                # 检查是否触发失眠
+                insomnia_reason = None
+                if sleep_pressure < pressure_threshold:
+                    insomnia_reason = "low_pressure"
+                    logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 低于阈值 ({pressure_threshold})，触发睡后失眠。")
+                elif random.random() < getattr(global_config.sleep_system, "random_insomnia_chance", 0.1):
+                    insomnia_reason = "random"
+                    logger.info("随机触发失眠。")
+
+                if insomnia_reason:
+                    self._current_state = SleepState.INSOMNIA
+                    
+                    # 设置失眠的持续时间
+                    duration_minutes_range = global_config.sleep_system.insomnia_duration_minutes
+                    duration_minutes = random.randint(*duration_minutes_range)
+                    self._sleep_buffer_end_time = now + timedelta(minutes=duration_minutes)
+                    
+                    # 发送失眠通知
+                    asyncio.create_task(NotificationSender.send_insomnia_notification(wakeup_manager.context, insomnia_reason))
+                    logger.info(f"进入失眠状态 (原因: {insomnia_reason})，将持续 {duration_minutes} 分钟。")
+                else:
+                    # 睡眠压力正常，不触发失眠，清除检查时间点
+                    logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 正常，未触发睡后失眠。")
+                    self._sleep_buffer_end_time = None
+                self._save_sleep_state()
+        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:
+                    logger.info("睡眠压力足够，从被吵醒状态转换到准备入睡。")
+                    buffer_seconds = random.randint(3 * 60, 8 * 60)
+                    self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
+                    self._current_state = SleepState.PREPARING_SLEEP
+                    self._re_sleep_attempt_time = None
+                else:
+                    # 睡眠压力不足，延迟一段时间后再次尝试
+                    delay_minutes = 15
+                    self._re_sleep_attempt_time = now + timedelta(minutes=delay_minutes)
+                    logger.info(
+                        f"睡眠压力({sleep_pressure:.1f})仍然较低，暂时保持清醒，在 {delay_minutes} 分钟后再次尝试。"
+                    )
+                self._save_sleep_state()
+
+    def reset_sleep_state_after_wakeup(self):
+        """
+        当角色被用户消息等外部因素唤醒时调用此方法。
+        将状态强制转换为 WOKEN_UP，并设置一个延迟，之后会尝试重新入睡。
+        """
+        if self._current_state in [SleepState.PREPARING_SLEEP, SleepState.SLEEPING, SleepState.INSOMNIA]:
+            logger.info("被唤醒，进入 WOKEN_UP 状态！")
+            self._current_state = SleepState.WOKEN_UP
+            self._sleep_buffer_end_time = None
+            re_sleep_delay_minutes = getattr(global_config.sleep_system, "re_sleep_delay_minutes", 10)
+            self._re_sleep_attempt_time = datetime.now() + timedelta(minutes=re_sleep_delay_minutes)
+            logger.info(f"将在 {re_sleep_delay_minutes} 分钟后尝试重新入睡。")
+            self._save_sleep_state()
+
+    def _save_sleep_state(self):
+        """将当前所有睡眠相关的状态打包并保存到本地存储。"""
+        state_data = {
+            "_current_state": self._current_state,
+            "_sleep_buffer_end_time": self._sleep_buffer_end_time,
+            "_total_delayed_minutes_today": self._total_delayed_minutes_today,
+            "_last_sleep_check_date": self._last_sleep_check_date,
+            "_re_sleep_attempt_time": self._re_sleep_attempt_time,
+        }
+        SleepStateSerializer.save(state_data)
+
+    def _load_sleep_state(self):
+        """从本地存储加载并恢复所有睡眠相关的状态。"""
+        state_data = SleepStateSerializer.load()
+        self._current_state = state_data["_current_state"]
+        self._sleep_buffer_end_time = state_data["_sleep_buffer_end_time"]
+        self._total_delayed_minutes_today = state_data["_total_delayed_minutes_today"]
+        self._last_sleep_check_date = state_data["_last_sleep_check_date"]
+        self._re_sleep_attempt_time = state_data["_re_sleep_attempt_time"]

src/chat/message_manager/sleep_manager/sleep_state.py

@@ -0,0 +1,110 @@
+from enum import Enum, auto
+from datetime import datetime
+from src.common.logger import get_logger
+from src.manager.local_store_manager import local_storage
+
+logger = get_logger("sleep_state")
+
+
+class SleepState(Enum):
+    """
+    定义了角色可能处于的几种睡眠状态。
+    这是一个状态机，用于管理角色的睡眠周期。
+    """
+
+    AWAKE = auto()  # 清醒状态
+    INSOMNIA = auto()  # 失眠状态
+    PREPARING_SLEEP = auto()  # 准备入睡状态，一个短暂的过渡期
+    SLEEPING = auto()  # 正在睡觉状态
+    WOKEN_UP = auto()  # 被吵醒状态
+
+
+class SleepStateSerializer:
+    """
+    睡眠状态序列化器。
+    负责将内存中的睡眠状态对象持久化到本地存储（如JSON文件），
+    以及在程序启动时从本地存储中恢复状态。
+    这样可以确保即使程序重启，角色的睡眠状态也能得以保留。
+    """
+    @staticmethod
+    def save(state_data: dict):
+        """
+        将当前的睡眠状态数据保存到本地存储。
+
+        Args:
+            state_data (dict): 包含睡眠状态信息的字典。
+                               datetime对象会被转换为时间戳，Enum成员会被转换为其名称字符串。
+        """
+        try:
+            # 准备要序列化的数据字典
+            state = {
+                # 保存当前状态的枚举名称
+                "current_state": state_data["_current_state"].name,
+                # 将datetime对象转换为Unix时间戳以便序列化
+                "sleep_buffer_end_time_ts": state_data["_sleep_buffer_end_time"].timestamp()
+                if state_data["_sleep_buffer_end_time"]
+                else None,
+                "total_delayed_minutes_today": state_data["_total_delayed_minutes_today"],
+                # 将date对象转换为ISO格式的字符串
+                "last_sleep_check_date_str": state_data["_last_sleep_check_date"].isoformat()
+                if state_data["_last_sleep_check_date"]
+                else None,
+                "re_sleep_attempt_time_ts": state_data["_re_sleep_attempt_time"].timestamp()
+                if state_data["_re_sleep_attempt_time"]
+                else None,
+            }
+            # 写入本地存储
+            local_storage["schedule_sleep_state"] = state
+            logger.debug(f"已保存睡眠状态: {state}")
+        except Exception as e:
+            logger.error(f"保存睡眠状态失败: {e}")
+
+    @staticmethod
+    def load() -> dict:
+        """
+        从本地存储加载并解析睡眠状态。
+
+        Returns:
+            dict: 包含恢复后睡眠状态信息的字典。
+                  如果加载失败或没有找到数据，则返回一个默认的清醒状态。
+        """
+        # 定义一个默认的状态，以防加载失败
+        state_data = {
+            "_current_state": SleepState.AWAKE,
+            "_sleep_buffer_end_time": None,
+            "_total_delayed_minutes_today": 0,
+            "_last_sleep_check_date": None,
+            "_re_sleep_attempt_time": None,
+        }
+        try:
+            # 从本地存储读取数据
+            state = local_storage["schedule_sleep_state"]
+            if state and isinstance(state, dict):
+                # 恢复当前状态枚举
+                state_name = state.get("current_state")
+                if state_name and hasattr(SleepState, state_name):
+                    state_data["_current_state"] = SleepState[state_name]
+
+                # 从时间戳恢复datetime对象
+                end_time_ts = state.get("sleep_buffer_end_time_ts")
+                if end_time_ts:
+                    state_data["_sleep_buffer_end_time"] = datetime.fromtimestamp(end_time_ts)
+
+                # 恢复重新入睡尝试时间
+                re_sleep_ts = state.get("re_sleep_attempt_time_ts")
+                if re_sleep_ts:
+                    state_data["_re_sleep_attempt_time"] = datetime.fromtimestamp(re_sleep_ts)
+
+                # 恢复今日延迟睡眠总分钟数
+                state_data["_total_delayed_minutes_today"] = state.get("total_delayed_minutes_today", 0)
+
+                # 从ISO格式字符串恢复date对象
+                date_str = state.get("last_sleep_check_date_str")
+                if date_str:
+                    state_data["_last_sleep_check_date"] = datetime.fromisoformat(date_str).date()
+
+                logger.info(f"成功从本地存储加载睡眠状态: {state}")
+        except Exception as e:
+            # 如果加载过程中出现任何问题，记录警告并返回默认状态
+            logger.warning(f"加载睡眠状态失败，将使用默认值: {e}")
+        return state_data

src/chat/message_manager/sleep_manager/time_checker.py

@@ -0,0 +1,109 @@
+from datetime import datetime, time, timedelta
+from typing import Optional, List, Dict, Any
+import random
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+from src.schedule.schedule_manager import schedule_manager
+
+logger = get_logger("time_checker")
+
+
+class TimeChecker:
+    def __init__(self):
+        # 缓存当天的偏移量，确保一天内使用相同的偏移量
+        self._daily_sleep_offset: int = 0
+        self._daily_wake_offset: int = 0
+        self._offset_date = None
+    
+    def _get_daily_offsets(self):
+        """获取当天的睡眠和起床时间偏移量，每天生成一次"""
+        today = datetime.now().date()
+        
+        # 如果是新的一天，重新生成偏移量
+        if self._offset_date != today:
+            sleep_offset_range = global_config.sleep_system.sleep_time_offset_minutes
+            wake_offset_range = global_config.sleep_system.wake_up_time_offset_minutes
+            
+            # 生成 ±offset_range 范围内的随机偏移量
+            self._daily_sleep_offset = random.randint(-sleep_offset_range, sleep_offset_range)
+            self._daily_wake_offset = random.randint(-wake_offset_range, wake_offset_range)
+            self._offset_date = today
+            
+            logger.debug(f"生成新的每日偏移量 - 睡觉时间偏移: {self._daily_sleep_offset}分钟, 起床时间偏移: {self._daily_wake_offset}分钟")
+        
+        return self._daily_sleep_offset, self._daily_wake_offset
+
+    @staticmethod
+    def get_today_schedule() -> Optional[List[Dict[str, Any]]]:
+        """从全局 ScheduleManager 获取今天的日程安排。"""
+        return schedule_manager.today_schedule
+
+    def is_in_theoretical_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]:
+        if global_config.sleep_system.sleep_by_schedule:
+            if self.get_today_schedule():
+                return self._is_in_schedule_sleep_time(now_time)
+            else:
+                return self._is_in_sleep_time(now_time)
+        else:
+            return self._is_in_sleep_time(now_time)
+
+    def _is_in_schedule_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]:
+        """检查当前时间是否落在日程表的任何一个睡眠活动中"""
+        sleep_keywords = ["休眠", "睡觉", "梦乡"]
+        today_schedule = self.get_today_schedule()
+        if today_schedule:
+            for event in today_schedule:
+                try:
+                    activity = event.get("activity", "").strip()
+                    time_range = event.get("time_range")
+
+                    if not activity or not time_range:
+                        continue
+
+                    if any(keyword in activity for keyword in sleep_keywords):
+                        start_str, end_str = time_range.split("-")
+                        start_time = datetime.strptime(start_str.strip(), "%H:%M").time()
+                        end_time = datetime.strptime(end_str.strip(), "%H:%M").time()
+
+                        if start_time <= end_time:  # 同一天
+                            if start_time <= now_time < end_time:
+                                return True, activity
+                        else:  # 跨天
+                            if now_time >= start_time or now_time < end_time:
+                                return True, activity
+                except (ValueError, KeyError, AttributeError) as e:
+                    logger.warning(f"解析日程事件时出错: {event}, 错误: {e}")
+                    continue
+        return False, None
+
+    def _is_in_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]:
+        """检查当前时间是否在固定的睡眠时间内（应用偏移量）"""
+        try:
+            start_time_str = global_config.sleep_system.fixed_sleep_time
+            end_time_str = global_config.sleep_system.fixed_wake_up_time
+            
+            # 获取当天的偏移量
+            sleep_offset, wake_offset = self._get_daily_offsets()
+            
+            # 解析基础时间
+            base_start_time = datetime.strptime(start_time_str, "%H:%M")
+            base_end_time = datetime.strptime(end_time_str, "%H:%M")
+            
+            # 应用偏移量
+            actual_start_time = (base_start_time + timedelta(minutes=sleep_offset)).time()
+            actual_end_time = (base_end_time + timedelta(minutes=wake_offset)).time()
+            
+            logger.debug(f"固定睡眠时间检查 - 基础时间: {start_time_str}-{end_time_str}, "
+                        f"偏移后时间: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')}, "
+                        f"当前时间: {now_time.strftime('%H:%M')}")
+
+            if actual_start_time <= actual_end_time:
+                if actual_start_time <= now_time < actual_end_time:
+                    return True, f"固定睡眠时间(偏移后: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')})"
+            else:
+                if now_time >= actual_start_time or now_time < actual_end_time:
+                    return True, f"固定睡眠时间(偏移后: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')})"
+        except ValueError as e:
+            logger.error(f"固定的睡眠时间格式不正确，请使用 HH:MM 格式: {e}")
+        return False, None

src/chat/message_manager/sleep_manager/wakeup_manager.py

@@ -0,0 +1,230 @@
+import asyncio
+import time
+from typing import Optional, TYPE_CHECKING
+from src.common.logger import get_logger
+from src.config.config import global_config
+from src.manager.local_store_manager import local_storage
+
+if TYPE_CHECKING:
+    from .sleep_manager import SleepManager
+
+
+logger = get_logger("wakeup")
+
+
+class WakeUpManager:
+    def __init__(self, sleep_manager: "SleepManager"):
+        """
+        初始化唤醒度管理器
+
+        Args:
+            sleep_manager: 睡眠管理器实例
+
+        功能说明:
+        - 管理休眠状态下的唤醒度累积
+        - 处理唤醒度的自然衰减
+        - 控制愤怒状态的持续时间
+        """
+        self.sleep_manager = sleep_manager
+        self.wakeup_value = 0.0  # 当前唤醒度
+        self.is_angry = False  # 是否处于愤怒状态
+        self.angry_start_time = 0.0  # 愤怒状态开始时间
+        self.last_decay_time = time.time()  # 上次衰减时间
+        self._decay_task: Optional[asyncio.Task] = None
+        self.is_running = False
+        self.last_log_time = 0
+        self.log_interval = 30
+
+        # 从配置文件获取参数
+        sleep_config = global_config.sleep_system
+        self.wakeup_threshold = sleep_config.wakeup_threshold
+        self.private_message_increment = sleep_config.private_message_increment
+        self.group_mention_increment = sleep_config.group_mention_increment
+        self.decay_rate = sleep_config.decay_rate
+        self.decay_interval = sleep_config.decay_interval
+        self.angry_duration = sleep_config.angry_duration
+        self.enabled = sleep_config.enable
+        self.angry_prompt = sleep_config.angry_prompt
+
+        self._load_wakeup_state()
+
+    def _get_storage_key(self) -> str:
+        """获取本地存储键"""
+        return "global_wakeup_manager_state"
+
+    def _load_wakeup_state(self):
+        """从本地存储加载状态"""
+        state = local_storage[self._get_storage_key()]
+        if state and isinstance(state, dict):
+            self.wakeup_value = state.get("wakeup_value", 0.0)
+            self.is_angry = state.get("is_angry", False)
+            self.angry_start_time = state.get("angry_start_time", 0.0)
+            logger.info(f"成功从本地存储加载唤醒状态: {state}")
+        else:
+            logger.info("未找到本地唤醒状态，将使用默认值初始化。")
+
+    def _save_wakeup_state(self):
+        """将当前状态保存到本地存储"""
+        state = {
+            "wakeup_value": self.wakeup_value,
+            "is_angry": self.is_angry,
+            "angry_start_time": self.angry_start_time,
+        }
+        local_storage[self._get_storage_key()] = state
+        logger.debug(f"已将唤醒状态保存到本地存储: {state}")
+
+    async def start(self):
+        """启动唤醒度管理器"""
+        if not self.enabled:
+            logger.info("唤醒度系统已禁用，跳过启动")
+            return
+        
+        self.is_running = True
+        if not self._decay_task or self._decay_task.done():
+            self._decay_task = asyncio.create_task(self._decay_loop())
+            self._decay_task.add_done_callback(self._handle_decay_completion)
+            logger.info("唤醒度管理器已启动")
+
+    async def stop(self):
+        """停止唤醒度管理器"""
+        self.is_running = False
+        if self._decay_task and not self._decay_task.done():
+            self._decay_task.cancel()
+            await asyncio.sleep(0)
+            logger.info("唤醒度管理器已停止")
+
+    def _handle_decay_completion(self, task: asyncio.Task):
+        """处理衰减任务完成"""
+        try:
+            if exception := task.exception():
+                logger.error(f"唤醒度衰减任务异常: {exception}")
+            else:
+                logger.info("唤醒度衰减任务正常结束")
+        except asyncio.CancelledError:
+            logger.info("唤醒度衰减任务被取消")
+
+    async def _decay_loop(self):
+        """唤醒度衰减循环"""
+        while self.is_running:
+            await asyncio.sleep(self.decay_interval)
+
+            current_time = time.time()
+
+            # 检查愤怒状态是否过期
+            if self.is_angry and current_time - self.angry_start_time >= self.angry_duration:
+                self.is_angry = False
+                # 通知情绪管理系统清除愤怒状态
+                from src.mood.mood_manager import mood_manager
+                mood_manager.clear_angry_from_wakeup("global_mood")
+                logger.info("愤怒状态结束，恢复正常")
+                self._save_wakeup_state()
+
+            # 唤醒度自然衰减
+            if self.wakeup_value > 0:
+                old_value = self.wakeup_value
+                self.wakeup_value = max(0, self.wakeup_value - self.decay_rate)
+                if old_value != self.wakeup_value:
+                    logger.debug(f"唤醒度衰减: {old_value:.1f} -> {self.wakeup_value:.1f}")
+                    self._save_wakeup_state()
+
+    def add_wakeup_value(self, is_private_chat: bool, is_mentioned: bool = False) -> bool:
+        """
+        增加唤醒度值
+
+        Args:
+            is_private_chat: 是否为私聊
+            is_mentioned: 是否被艾特(仅群聊有效)
+
+        Returns:
+            bool: 是否达到唤醒阈值
+        """
+        # 如果系统未启用，直接返回
+        if not self.enabled:
+            return False
+
+        # 只有在休眠且非失眠状态下才累积唤醒度
+        from .sleep_state import SleepState
+
+        current_sleep_state = self.sleep_manager.get_current_sleep_state()
+        if current_sleep_state != SleepState.SLEEPING:
+            return False
+
+        old_value = self.wakeup_value
+
+        if is_private_chat:
+            # 私聊每条消息都增加唤醒度
+            self.wakeup_value += self.private_message_increment
+            logger.debug(f"私聊消息增加唤醒度: +{self.private_message_increment}")
+        elif is_mentioned:
+            # 群聊只有被艾特才增加唤醒度
+            self.wakeup_value += self.group_mention_increment
+            logger.debug(f"群聊艾特增加唤醒度: +{self.group_mention_increment}")
+        else:
+            # 群聊未被艾特，不增加唤醒度
+            return False
+
+        current_time = time.time()
+        if current_time - self.last_log_time > self.log_interval:
+            logger.info(
+                f"唤醒度变化: {old_value:.1f} -> {self.wakeup_value:.1f} (阈值: {self.wakeup_threshold})"
+            )
+            self.last_log_time = current_time
+        else:
+            logger.debug(
+                f"唤醒度变化: {old_value:.1f} -> {self.wakeup_value:.1f} (阈值: {self.wakeup_threshold})"
+            )
+
+        # 检查是否达到唤醒阈值
+        if self.wakeup_value >= self.wakeup_threshold:
+            self._trigger_wakeup()
+            return True
+
+        self._save_wakeup_state()
+        return False
+
+    def _trigger_wakeup(self):
+        """触发唤醒，进入愤怒状态"""
+        self.is_angry = True
+        self.angry_start_time = time.time()
+        self.wakeup_value = 0.0  # 重置唤醒度
+
+        self._save_wakeup_state()
+
+        # 通知情绪管理系统进入愤怒状态
+        from src.mood.mood_manager import mood_manager
+        mood_manager.set_angry_from_wakeup("global_mood")
+
+        # 通知SleepManager重置睡眠状态
+        self.sleep_manager.reset_sleep_state_after_wakeup()
+
+        logger.info(f"唤醒度达到阈值({self.wakeup_threshold})，被吵醒进入愤怒状态！")
+
+    def get_angry_prompt_addition(self) -> str:
+        """获取愤怒状态下的提示词补充"""
+        if self.is_angry:
+            return self.angry_prompt
+        return ""
+
+    def is_in_angry_state(self) -> bool:
+        """检查是否处于愤怒状态"""
+        if self.is_angry:
+            current_time = time.time()
+            if current_time - self.angry_start_time >= self.angry_duration:
+                self.is_angry = False
+                # 通知情绪管理系统清除愤怒状态
+                from src.mood.mood_manager import mood_manager
+                mood_manager.clear_angry_from_wakeup("global_mood")
+                logger.info("愤怒状态自动过期")
+                return False
+        return self.is_angry
+
+    def get_status_info(self) -> dict:
+        """获取当前状态信息"""
+        return {
+            "wakeup_value": self.wakeup_value,
+            "wakeup_threshold": self.wakeup_threshold,
+            "is_angry": self.is_angry,
+            "angry_remaining_time": max(0, self.angry_duration - (time.time() - self.angry_start_time))
+            if self.is_angry
+            else 0,
+        }