feat(chat): 引入睡眠系统，在睡眠状态下拦截消息

在消息处理的最前端 (`MessageManager`) 增加了对睡眠状态的检查。当系统处于 `SLEEPING` 状态时，将直接拦截所有新消息，不再进行后续处理。

同时，为了配合睡眠系统的正常运作：
- 将睡眠系统的定时任务初始化移至 `main.py`，确保其在应用启动时正确加载。
- 在主动思维插件 (`proactive_thinker`) 的定时任务（冷启动和日常唤醒）中增加了睡眠状态检查，避免在睡眠期间触发主动行为。

src/chat/message_manager/message_manager.py

@@ -19,6 +19,8 @@ from src.config.config import global_config
 from src.plugin_system.apis.chat_api import get_chat_manager
 
 from .distribution_manager import stream_loop_manager
+from .sleep_system.state_manager import SleepState, sleep_state_manager
+
 
 if TYPE_CHECKING:
     pass
@@ -88,6 +90,7 @@ class MessageManager:
             logger.error(f"启动自适应流管理器失败: {e}")
 
         # 启动睡眠和唤醒管理器
+        # 睡眠系统的定时任务启动移至 main.py
 
         # 启动流循环管理器并设置chatter_manager
         await stream_loop_manager.start()
@@ -142,6 +145,14 @@ class MessageManager:
 
     async def add_message(self, stream_id: str, message: DatabaseMessages):
         """添加消息到指定聊天流"""
+        # 在消息处理的最前端检查睡眠状态
+        current_sleep_state = sleep_state_manager.get_current_state()
+        if current_sleep_state == SleepState.SLEEPING:
+            logger.info(f"处于 {current_sleep_state.name} 状态，消息被拦截。")
+            return  # 直接返回，不处理消息
+
+        # TODO: 在这里为 WOKEN_UP_ANGRY 等未来状态添加特殊处理逻辑
+
         try:
             chat_manager = get_chat_manager()
             chat_stream = await chat_manager.get_stream(stream_id)

src/chat/message_manager/sleep_system/sleep_logic.py

@@ -0,0 +1,194 @@
+from datetime import datetime, time, timedelta
+import random
+from typing import Optional, Tuple
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+from src.schedule.schedule_manager import schedule_manager
+from .state_manager import SleepState, sleep_state_manager
+
+logger = get_logger("sleep_logic")
+
+
+class SleepLogic:
+    """
+    核心睡眠逻辑，睡眠系统的“大脑”
+
+    负责根据当前的配置、时间、日程表以及状态，判断是否需要切换睡眠状态。
+    它本身是无状态的，所有的状态都读取和写入 SleepStateManager。
+    """
+
+    def check_and_update_sleep_state(self):
+        """
+        检查并更新当前的睡眠状态，这是整个逻辑的入口。
+        由定时任务周期性调用。
+        """
+        current_state = sleep_state_manager.get_current_state()
+        now = datetime.now()
+
+        if current_state == SleepState.AWAKE:
+            self._check_should_fall_asleep(now)
+        elif current_state == SleepState.SLEEPING:
+            self._check_should_wake_up(now)
+        elif current_state == SleepState.INSOMNIA:
+            # TODO: 实现失眠逻辑
+            # 例如：检查失眠状态是否结束，如果结束则转换回 SLEEPING
+            pass
+        elif current_state == SleepState.WOKEN_UP_ANGRY:
+            # TODO: 实现起床气逻辑
+            # 例如：检查生气状态是否结束，如果结束则转换回 SLEEPING 或 AWAKE
+            pass
+
+    def _check_should_fall_asleep(self, now: datetime):
+        """
+        当状态为 AWAKE 时，检查是否应该进入睡眠。
+        """
+        should_sleep, wake_up_time = self._should_be_sleeping(now)
+        if should_sleep:
+            logger.info("判断结果：应进入睡眠状态。")
+            sleep_state_manager.set_state(SleepState.SLEEPING, wake_up=wake_up_time)
+
+    def _check_should_wake_up(self, now: datetime):
+        """
+        当状态为 SLEEPING 时，检查是否应该醒来。
+        这里包含了处理跨天获取日程的核心逻辑。
+        """
+        wake_up_time = sleep_state_manager.get_wake_up_time()
+
+        # 核心逻辑：两段式检测
+        # 如果 state_manager 中还没有起床时间，说明是昨晚入睡，需要等待今天凌晨的新日程。
+        sleep_start_time = sleep_state_manager.get_sleep_start_time()
+        if not wake_up_time and sleep_start_time and now.date() > sleep_start_time.date():
+            logger.debug("当前为睡眠状态但无起床时间，尝试从新日程中解析...")
+            _, new_wake_up_time = self._get_wakeup_times_from_schedule(now)
+
+            if new_wake_up_time:
+                logger.info(f"成功从新日程获取到起床时间: {new_wake_up_time.strftime('%H:%M')}")
+                sleep_state_manager.set_wake_up_time(new_wake_up_time)
+                wake_up_time = new_wake_up_time
+            else:
+                logger.debug("未能获取到新的起床时间，继续睡眠。")
+                return
+        else:
+            logger.info("还没有到达第二天,继续睡眠。")
+
+        if wake_up_time and now >= wake_up_time:
+            logger.info(f"当前时间 {now.strftime('%H:%M')} 已到达或超过预定起床时间 {wake_up_time.strftime('%H:%M')}。")
+            sleep_state_manager.set_state(SleepState.AWAKE)
+
+    def _should_be_sleeping(self, now: datetime) -> Tuple[bool, Optional[datetime]]:
+        """
+        判断在当前时刻，是否应该处于睡眠时间。
+
+        Returns:
+            元组 (是否应该睡眠, 预期的起床时间或None)
+        """
+        sleep_config = global_config.sleep_system
+        if not sleep_config.enable:
+            return False, None
+
+        sleep_time, wake_up_time = None, None
+
+        if sleep_config.sleep_by_schedule:
+            sleep_time, _ = self._get_sleep_times_from_schedule(now)
+            if not sleep_time:
+                logger.debug("日程表模式开启，但未找到睡眠时间，使用固定时间作为备用。")
+                sleep_time, wake_up_time = self._get_fixed_sleep_times(now)
+        else:
+            sleep_time, wake_up_time = self._get_fixed_sleep_times(now)
+
+        if not sleep_time:
+            return False, None
+
+        # 检查当前时间是否在睡眠时间范围内
+        if now >= sleep_time:
+            # 如果起床时间是第二天（通常情况），且当前时间小于起床时间，则在睡眠范围内
+            if wake_up_time and wake_up_time > sleep_time and now < wake_up_time:
+                 return True, wake_up_time
+            # 如果当前时间大于入睡时间，说明已经进入睡眠窗口
+            return True, wake_up_time
+            
+        return False, None
+
+    def _get_fixed_sleep_times(self, now: datetime) -> Tuple[Optional[datetime], Optional[datetime]]:
+        """
+        当使用“固定时间”模式时，从此方法计算睡眠和起床时间。
+        会加入配置中的随机偏移量，让作息更自然。
+        """
+        sleep_config = global_config.sleep_system
+        try:
+            sleep_offset = random.randint(
+                -sleep_config.sleep_time_offset_minutes, sleep_config.sleep_time_offset_minutes
+            )
+            wake_up_offset = random.randint(
+                -sleep_config.wake_up_time_offset_minutes, sleep_config.wake_up_time_offset_minutes
+            )
+
+            sleep_t = datetime.strptime(sleep_config.fixed_sleep_time, "%H:%M").time()
+            wake_up_t = datetime.strptime(sleep_config.fixed_wake_up_time, "%H:%M").time()
+
+            sleep_time = datetime.combine(now.date(), sleep_t) + timedelta(minutes=sleep_offset)
+            
+            # 如果起床时间比睡觉时间早，说明是第二天
+            wake_up_day = now.date() + timedelta(days=1) if wake_up_t < sleep_t else now.date()
+            wake_up_time = datetime.combine(wake_up_day, wake_up_t) + timedelta(minutes=wake_up_offset)
+
+            return sleep_time, wake_up_time
+        except (ValueError, TypeError) as e:
+            logger.error(f"解析固定睡眠时间失败: {e}")
+            return None, None
+
+    def _get_sleep_times_from_schedule(self, now: datetime) -> Tuple[Optional[datetime], Optional[datetime]]:
+        """
+        当使用“日程表”模式时，从此方法获取睡眠时间。
+        实现了核心逻辑：
+        - 解析“今天”日程中的睡觉时间。
+        """
+        # 阶段一：获取当天的睡觉时间
+        today_schedule = schedule_manager.today_schedule
+        sleep_time = None
+        if today_schedule:
+            for event in today_schedule:
+                activity = event.get("activity", "").lower()
+                if "sleep" in activity or "睡觉" in activity or "休息" in activity:
+                    try:
+                        time_range = event.get("time_range", "")
+                        start_str, _ = time_range.split("-")
+                        sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time()
+                        sleep_time = datetime.combine(now.date(), sleep_t)
+                        break
+                    except (ValueError, AttributeError):
+                        logger.warning(f"解析日程中的睡眠时间失败: {event}")
+                        continue
+        wake_up_time = None
+
+        return sleep_time, wake_up_time
+    
+    def _get_wakeup_times_from_schedule(self, now: datetime) -> Tuple[Optional[datetime], Optional[datetime]]:
+            """
+            当使用“日程表”模式时，从此方法获取睡眠时间。
+            实现了核心逻辑：
+            - 解析“今天”日程中的睡觉时间。
+            """
+            # 阶段一：获取当天的睡觉时间
+            today_schedule = schedule_manager.today_schedule
+            wake_up_time = None
+            if today_schedule:
+                for event in today_schedule:
+                    activity = event.get("activity", "").lower()
+                    if "wake_up" in activity or "醒来" in activity or "起床" in activity:
+                        try:
+                            time_range = event.get("time_range", "")
+                            start_str, _ = time_range.split("-")
+                            sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time()
+                            wake_up_time = datetime.combine(now.date(), sleep_t)
+                            break
+                        except (ValueError, AttributeError):
+                            logger.warning(f"解析日程中的睡眠时间失败: {event}")
+                            continue
+
+            return None, wake_up_time
+
+
+# 全局单例
+sleep_logic = SleepLogic()

src/chat/message_manager/sleep_system/state_manager.py

@@ -0,0 +1,190 @@
+import enum
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+
+from src.common.logger import get_logger
+from src.manager.local_store_manager import local_storage
+
+logger = get_logger("sleep_state_manager")
+
+
+class SleepState(enum.Enum):
+    """
+    定义了所有可能的睡眠状态。
+    使用枚举可以使状态管理更加清晰和安全。
+    """
+
+    AWAKE = "awake"  # 清醒状态，正常活动
+    SLEEPING = "sleeping"  # 沉睡状态，此时应拦截消息
+    INSOMNIA = "insomnia"  # 失眠状态（为未来功能预留）
+    WOKEN_UP_ANGRY = "woken_up_angry"  # 被吵醒后的生气状态（为未来功能预留）
+
+
+class SleepStateManager:
+    """
+    睡眠状态管理器 (单例模式)
+
+    这是整个睡眠系统的数据核心，负责：
+    1. 管理当前的睡眠状态（如：是否在睡觉、唤醒度等）。
+    2. 将状态持久化到本地JSON文件(`local_store.json`)，实现重启后状态不丢失。
+    3. 提供统一的接口供其他模块查询和修改睡眠状态。
+    """
+
+    _instance = None
+    _STATE_KEY = "sleep_system_state"  # 在 local_store.json 中存储的键名
+
+    def __new__(cls, *args, **kwargs):
+        # 实现单例模式，确保全局只有一个状态管理器实例
+        if not cls._instance:
+            cls._instance = super(SleepStateManager, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        """
+        初始化状态管理器，定义状态数据结构并从本地加载历史状态。
+        """
+        self.state: Dict[str, Any] = {}
+        self._default_state()
+        self.load_state()
+
+    def _default_state(self):
+        """
+        定义并重置为默认的“清醒”状态。
+        当机器人启动或从睡眠中醒来时调用。
+        """
+        self.state = {
+            "state": SleepState.AWAKE.value,
+            "state_until": None,  # 特殊状态（如生气）的自动结束时间
+            "sleep_start_time": None,  # 本次睡眠的开始时间
+            "wake_up_time": None,  # 预定的起床时间
+            "wakefulness": 0.0,  # 唤醒度/清醒值，用于判断是否被吵醒
+            "last_checked": None,  # 定时任务最后检查的时间
+        }
+
+    def load_state(self):
+        """
+        程序启动时，从 local_storage 加载上一次的状态。
+        如果找不到历史状态，则初始化为默认状态。
+        """
+        stored_state = local_storage[self._STATE_KEY]
+        if isinstance(stored_state, dict):
+            # 合并加载的状态，以防新增字段
+            self.state.update(stored_state)
+            # 确保 state 字段是枚举成员
+            if "state" in self.state and not isinstance(self.state["state"], SleepState):
+                try:
+                    self.state["state"] = SleepState(self.state["state"])
+                except ValueError:
+                    logger.warning(f"加载了无效的睡眠状态 '{self.state['state']}'，重置为 AWAKE。")
+                    self.state["state"] = SleepState.AWAKE
+            else:
+                 self.state["state"] = SleepState.AWAKE # 兼容旧数据
+
+            logger.info(f"成功加载睡眠状态: {self.get_current_state().name}")
+        else:
+            logger.info("未找到已存储的睡眠状态，将使用默认值。")
+            self.save_state()
+
+    def save_state(self):
+        """
+        将当前内存中的状态保存到 local_storage。
+        在保存前，会将枚举类型的 state 转换为字符串，以便JSON序列化。
+        """
+        data_to_save = self.state.copy()
+        # 将 state 枚举成员转换为它的值（字符串）
+        data_to_save["state"] = self.state["state"]
+        local_storage[self._STATE_KEY] = data_to_save
+        logger.debug(f"睡眠状态已保存: {data_to_save}")
+
+    def get_current_state(self) -> SleepState:
+        """
+        获取当前的睡眠状态。
+        在返回状态前，会先检查特殊状态（如生气）是否已过期。
+        """
+        # 检查特殊状态是否已过期
+        state_until_str = self.state.get("state_until")
+        if state_until_str:
+            state_until = datetime.fromisoformat(state_until_str)
+            if datetime.now() > state_until:
+                logger.info(f"特殊状态 {self.state['state'].name} 已结束，自动恢复为 SLEEPING。")
+                # 假设特殊状态（如生气）结束后，是恢复到普通睡眠状态
+                self.set_state(SleepState.SLEEPING)
+
+        return self.state["state"]
+
+    def set_state(
+        self,
+        new_state: SleepState,
+        duration_seconds: Optional[float] = None,
+        sleep_start: Optional[datetime] = None,
+        wake_up: Optional[datetime] = None,
+    ):
+        """
+        核心函数：切换到新的睡眠状态，并更新相关的状态数据。
+        """
+        current_state = self.get_current_state()
+        if current_state == new_state:
+            return  # 状态未改变
+
+        logger.info(f"睡眠状态变更: {current_state.name} -> {new_state.name}")
+        self.state["state"] = new_state
+
+        if new_state == SleepState.AWAKE:
+            self._default_state() # 醒来时重置所有状态
+            self.state["state"] = SleepState.AWAKE # 确保状态正确
+        
+        elif new_state == SleepState.SLEEPING:
+            self.state["sleep_start_time"] = (sleep_start or datetime.now()).isoformat()
+            self.state["wake_up_time"] = wake_up.isoformat() if wake_up else None
+            self.state["state_until"] = None # 清除特殊状态持续时间
+            self.state["wakefulness"] = 0.0 # 进入睡眠时清零唤醒度
+
+        elif new_state in [SleepState.WOKEN_UP_ANGRY, SleepState.INSOMNIA]:
+            if duration_seconds:
+                self.state["state_until"] = (datetime.now() + timedelta(seconds=duration_seconds)).isoformat()
+            else:
+                self.state["state_until"] = None
+
+
+        self.save_state()
+
+    def update_last_checked(self):
+        """更新最后检查时间"""
+        self.state["last_checked"] = datetime.now().isoformat()
+        self.save_state()
+
+    def get_wake_up_time(self) -> Optional[datetime]:
+        """获取预定的起床时间，如果已设置的话。"""
+        wake_up_str = self.state.get("wake_up_time")
+        if wake_up_str:
+            try:
+                return datetime.fromisoformat(wake_up_str)
+            except (ValueError, TypeError):
+                return None
+        return None
+
+    def get_sleep_start_time(self) -> Optional[datetime]:
+        """获取本次睡眠的开始时间，如果已设置的话。"""
+        sleep_start_str = self.state.get("sleep_start_time")
+        if sleep_start_str:
+            try:
+                return datetime.fromisoformat(sleep_start_str)
+            except (ValueError, TypeError):
+                return None
+        return None
+
+    def set_wake_up_time(self, wake_up: datetime):
+        """
+        更新起床时间。
+        主要用于“日程表”模式下，当第二天凌晨拿到新日程时，更新之前未知的起床时间。
+        """
+        if self.get_current_state() == SleepState.AWAKE:
+            logger.warning("尝试为清醒状态设置起床时间，操作被忽略。")
+            return
+        self.state["wake_up_time"] = wake_up.isoformat()
+        logger.info(f"更新预定起床时间为: {self.state['wake_up_time']}")
+        self.save_state()
+
+
+# 全局单例
+sleep_state_manager = SleepStateManager()

src/chat/message_manager/sleep_system/tasks.py

@@ -0,0 +1,43 @@
+from src.common.logger import get_logger
+from src.manager.async_task_manager import AsyncTask, async_task_manager
+from .sleep_logic import sleep_logic
+
+logger = get_logger("sleep_tasks")
+
+
+class SleepSystemCheckTask(AsyncTask):
+    """
+    睡眠系统周期性检查任务。
+    继承自 AsyncTask，由 async_task_manager 统一管理。
+    """
+
+    def __init__(self, run_interval: int = 60):
+        """
+        初始化任务。
+        Args:
+            run_interval (int): 任务运行的时间间隔（秒）。默认为60秒检查一次。
+        """
+        super().__init__(task_name="SleepSystemCheckTask", run_interval=run_interval)
+
+    async def run(self):
+        """
+        任务的核心执行过程。
+        每次运行时，调用 sleep_logic 的主函数来检查和更新状态。
+        """
+        logger.debug("睡眠系统定时任务触发，开始检查状态...")
+        try:
+            # 调用“大脑”进行一次思考和判断
+            sleep_logic.check_and_update_sleep_state()
+        except Exception as e:
+            logger.error(f"周期性检查睡眠状态时发生未知错误: {e}", exc_info=True)
+
+
+async def start_sleep_system_tasks():
+    """
+    启动睡眠系统的后台定时检查任务。
+    这个函数应该在程序启动时（例如 main.py）被调用。
+    """
+    logger.info("正在启动睡眠系统后台任务...")
+    check_task = SleepSystemCheckTask()
+    await async_task_manager.add_task(check_task)
+    logger.info("睡眠系统后台任务已成功启动。")

src/main.py

@@ -29,6 +29,7 @@ from src.plugin_system.core.event_manager import event_manager
 from src.plugin_system.core.plugin_manager import plugin_manager
 from src.schedule.monthly_plan_manager import monthly_plan_manager
 from src.schedule.schedule_manager import schedule_manager
+from src.chat.message_manager.sleep_system.tasks import start_sleep_system_tasks
 
 # 插件系统现在使用统一的插件加载器
 install(extra_lines=3)
@@ -519,6 +520,14 @@ MoFox_Bot(第三方修改版)
             except Exception as e:
                 logger.error(f"日程表管理器初始化失败: {e}")
 
+        # 初始化睡眠系统
+        if global_config.sleep_system.enable:
+            try:
+                await start_sleep_system_tasks()
+                logger.info("睡眠系统初始化成功")
+            except Exception as e:
+                logger.error(f"睡眠系统初始化失败: {e}")
+
     def _safe_init(self, component_name: str, init_func) -> callable:
         """安全初始化组件，捕获异常"""
 

src/plugins/built_in/proactive_thinker/proacive_thinker_event.py

@@ -13,6 +13,7 @@ from src.manager.async_task_manager import AsyncTask, async_task_manager
 from src.plugin_system import BaseEventHandler, EventType
 from src.plugin_system.apis import chat_api, message_api, person_api
 from src.plugin_system.base.base_event import HandlerResult
+from src.chat.message_manager.sleep_system.state_manager import SleepState, sleep_state_manager
 
 from .proactive_thinker_executor import ProactiveThinkerExecutor
 
@@ -38,6 +39,10 @@ class ColdStartTask(AsyncTask):
         await asyncio.sleep(30)  # 延迟以确保所有服务和聊天流已从数据库加载完毕
 
         try:
+            current_state = sleep_state_manager.get_current_state()
+            if current_state  == SleepState.SLEEPING:
+                logger.info("bot正在睡觉,跳过本次任务")
+                return
             logger.info("【冷启动】开始扫描白名单，唤醒沉睡的聊天流...")
 
             # 【修复】增加对私聊总开关的判断
@@ -147,6 +152,10 @@ class ProactiveThinkingTask(AsyncTask):
             # 计算下一次检查前的休眠时间
             next_interval = self._get_next_interval()
             try:
+                current_state = sleep_state_manager.get_current_state()
+                if current_state  == SleepState.SLEEPING:
+                    logger.info("bot正在睡觉,跳过本次任务")
+                    return
                 logger.debug(f"【日常唤醒】下一次检查将在 {next_interval:.2f} 秒后进行。")
                 await asyncio.sleep(next_interval)