Merge branch 'dev' of https://github.com/MoFox-Studio/MoFox_Bot into dev

src/chat/message_manager/message_manager.py

@@ -17,10 +17,11 @@ from src.common.data_models.message_manager_data_model import MessageManagerStat
 from src.common.logger import get_logger
 from src.config.config import global_config
 from src.plugin_system.apis.chat_api import get_chat_manager
+from src.plugins.built_in.sleep_system.api import on_message_received
 
 from .distribution_manager import stream_loop_manager
-from .sleep_manager.sleep_manager import SleepManager
-from .sleep_manager.wakeup_manager import WakeUpManager
+# from .sleep_manager.sleep_manager import SleepManager
+# from .sleep_manager.wakeup_manager import WakeUpManager
 
 if TYPE_CHECKING:
     pass
@@ -43,9 +44,9 @@ class MessageManager:
         self.action_manager = ChatterActionManager()
         self.chatter_manager = ChatterManager(self.action_manager)
 
-        # 初始化睡眠和唤醒管理器
-        self.sleep_manager = SleepManager()
-        self.wakeup_manager = WakeUpManager(self.sleep_manager)
+        # 初始化睡眠和唤醒管理器 (已被新插件取代)
+        # self.sleep_manager = SleepManager()
+        # self.wakeup_manager = WakeUpManager(self.sleep_manager)
 
         # 消息缓存系统 - 直接集成到消息管理器
         self.message_caches: Dict[str, deque] = defaultdict(deque)  # 每个流的消息缓存
@@ -93,8 +94,8 @@ class MessageManager:
         except Exception as e:
             logger.error(f"启动自适应流管理器失败: {e}")
 
-        # 启动睡眠和唤醒管理器
-        await self.wakeup_manager.start()
+        # 启动睡眠和唤醒管理器 (已被新插件取代)
+        # await self.wakeup_manager.start()
 
         # 启动流循环管理器并设置chatter_manager
         await stream_loop_manager.start()
@@ -141,8 +142,8 @@ class MessageManager:
         except Exception as e:
             logger.error(f"停止自适应流管理器失败: {e}")
 
-        # 停止睡眠和唤醒管理器
-        await self.wakeup_manager.stop()
+        # 停止睡眠和唤醒管理器 (已被新插件取代)
+        # await self.wakeup_manager.stop()
 
         # 停止流循环管理器
         await stream_loop_manager.stop()
@@ -152,6 +153,9 @@ class MessageManager:
     async def add_message(self, stream_id: str, message: DatabaseMessages):
         """添加消息到指定聊天流"""
         try:
+            # 触发睡眠系统外部事件
+            on_message_received()
+
             chat_manager = get_chat_manager()
             chat_stream = await chat_manager.get_stream(stream_id)
             if not chat_stream:
@@ -335,9 +339,14 @@ class MessageManager:
                     inactive_streams.append(stream_id)
             for stream_id in inactive_streams:
                 try:
-                    await chat_stream.context_manager.clear_context()
+                    # 修复: 直接通过 stream_id 获取 chat_stream，避免潜在的未绑定问题
+                    inactive_stream = chat_manager.streams.get(stream_id)
+                    if inactive_stream:
+                        await inactive_stream.context_manager.clear_context()
                         del chat_manager.streams[stream_id]
                         logger.info(f"清理不活跃聊天流: {stream_id}")
+                    else:
+                        logger.warning(f"尝试清理一个不存在的流: {stream_id}")
                 except Exception as e:
                     logger.error(f"清理聊天流 {stream_id} 失败: {e}")
             if inactive_streams:

src/chat/message_manager/sleep_manager/notification_sender.py

@@ -1,33 +0,0 @@
-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):  # type: ignore
-        """发送晚安通知"""
-        # 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, reason: str):  # type: ignore
-        """发送失眠通知"""
-        # 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

@@ -1,291 +0,0 @@
-import asyncio
-import random
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Optional
-
-from src.common.logger import get_logger
-from src.config.config import global_config
-
-from .notification_sender import NotificationSender
-from .sleep_state import SleepContext, SleepState
-from .time_checker import TimeChecker
-
-if TYPE_CHECKING:
-    from .wakeup_manager import WakeUpManager
-
-logger = get_logger("sleep_manager")
-
-
-class SleepManager:
-    """
-    睡眠管理器，核心组件之一，负责管理角色的睡眠周期和状态转换。
-    它实现了一个状态机，根据预设的时间表、睡眠压力和随机因素，
-    在不同的睡眠状态（如清醒、准备入睡、睡眠、失眠）之间进行切换。
-    """
-
-    def __init__(self):
-        """
-        初始化睡眠管理器。
-        """
-        self.context = SleepContext()  # 睡眠上下文，管理所有状态
-        self.time_checker = TimeChecker()  # 时间检查器
-        self.last_sleep_log_time = 0  # 上次记录睡眠日志的时间戳
-        self.sleep_log_interval = 35  # 睡眠日志记录间隔（秒）
-        self._last_fully_slept_log_time: float = 0  # 上次完全进入睡眠状态的时间戳
-
-    def get_current_sleep_state(self) -> SleepState:
-        """获取当前的睡眠状态。"""
-        return self.context.current_state
-
-    def is_sleeping(self) -> bool:
-        """判断当前是否处于正在睡觉的状态。"""
-        return self.context.current_state == SleepState.SLEEPING
-
-    def is_woken_up(self) -> bool:
-        """判断当前是否处于被吵醒的状态。"""
-        return self.context.current_state == SleepState.WOKEN_UP
-
-    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.context.current_state != SleepState.AWAKE:
-                logger.debug("睡眠系统禁用，强制设为 AWAKE")
-                self.context.current_state = SleepState.AWAKE
-            return
-
-        now = datetime.now()
-        today = now.date()
-
-        # 跨天处理：如果日期变化，重置每日相关的睡眠状态
-        if self.context.last_sleep_check_date != today:
-            logger.info(f"新的一天 ({today})，重置睡眠状态。")
-            self.context.total_delayed_minutes_today = 0
-            self.context.current_state = SleepState.AWAKE
-            self.context.sleep_buffer_end_time = None
-            self.context.last_sleep_check_date = today
-            self.context.save()
-
-        # 检查当前是否处于理论上的睡眠时间段
-        is_in_theoretical_sleep, activity = self.time_checker.is_in_theoretical_sleep_time(now.time())
-
-        # --- 状态机核心处理逻辑 ---
-        current_state = self.context.current_state
-        if current_state == SleepState.AWAKE:
-            if is_in_theoretical_sleep:
-                self._handle_awake_to_sleep(now, activity, wakeup_manager)
-
-        elif current_state == SleepState.PREPARING_SLEEP:
-            self._handle_preparing_sleep(now, is_in_theoretical_sleep, wakeup_manager)
-
-        elif current_state == SleepState.SLEEPING:
-            self._handle_sleeping(now, is_in_theoretical_sleep, activity, wakeup_manager)
-
-        elif current_state == SleepState.INSOMNIA:
-            self._handle_insomnia(now, is_in_theoretical_sleep)
-
-        elif 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: str | None, 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.context.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.context.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.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
-                self.context.current_state = SleepState.PREPARING_SLEEP
-                logger.info(f"进入准备入睡状态，将在 {buffer_seconds / 60:.1f} 分钟内入睡。")
-                self.context.save()
-            else:
-                # 无法获取 wakeup_manager，退回旧逻辑
-                buffer_seconds = random.randint(1 * 60, 3 * 60)
-                self.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
-                self.context.current_state = SleepState.PREPARING_SLEEP
-                logger.warning("无法获取 WakeUpManager，弹性睡眠采用默认1-3分钟延迟。")
-                self.context.save()
-        else:
-            # 非弹性睡眠模式
-            if wakeup_manager and global_config.sleep_system.enable_pre_sleep_notification:
-                asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context))
-            self.context.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.context.current_state = SleepState.AWAKE
-            self.context.sleep_buffer_end_time = None
-            self.context.save()
-        # 如果缓冲时间结束，则正式进入睡眠状态
-        elif self.context.sleep_buffer_end_time and now >= self.context.sleep_buffer_end_time:
-            logger.info("睡眠缓冲期结束，正式进入休眠状态。")
-            self.context.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.context.sleep_buffer_end_time = now + timedelta(minutes=delay_minutes)
-            logger.info(f"已设置睡后失眠检查，将在 {delay_minutes} 分钟后触发。")
-
-            self.context.save()
-
-    def _handle_sleeping(
-        self,
-        now: datetime,
-        is_in_theoretical_sleep: bool,
-        activity: str | None,
-        wakeup_manager: Optional["WakeUpManager"],
-    ):
-        """处理“正在睡觉”状态下的逻辑。"""
-        # 如果理论睡眠时间结束，则自然醒来
-        if not is_in_theoretical_sleep:
-            logger.info("理论休眠时间结束，自然醒来。")
-            self.context.current_state = SleepState.AWAKE
-            self.context.save()
-        # 检查是否到了触发“睡后失眠”的时间点
-        elif self.context.sleep_buffer_end_time and now >= self.context.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.context.current_state = SleepState.INSOMNIA
-
-                    # 设置失眠的持续时间
-                    duration_minutes_range = global_config.sleep_system.insomnia_duration_minutes
-                    duration_minutes = random.randint(*duration_minutes_range)
-                    self.context.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.context.sleep_buffer_end_time = None
-                self.context.save()
-        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.context.current_state = SleepState.AWAKE
-            self.context.sleep_buffer_end_time = None
-            self.context.save()
-        # 如果失眠持续时间已过，则恢复睡眠
-        elif self.context.sleep_buffer_end_time and now >= self.context.sleep_buffer_end_time:
-            logger.info("失眠状态持续时间已过，恢复睡眠。")
-            self.context.current_state = SleepState.SLEEPING
-            self.context.sleep_buffer_end_time = None
-            self.context.save()
-
-    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.context.current_state = SleepState.AWAKE
-            self.context.re_sleep_attempt_time = None
-            self.context.save()
-        # 到了尝试重新入睡的时间点
-        elif self.context.re_sleep_attempt_time and now >= self.context.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.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds)
-                    self.context.current_state = SleepState.PREPARING_SLEEP
-                    self.context.re_sleep_attempt_time = None
-                else:
-                    # 睡眠压力不足，延迟一段时间后再次尝试
-                    delay_minutes = 15
-                    self.context.re_sleep_attempt_time = now + timedelta(minutes=delay_minutes)
-                    logger.info(
-                        f"睡眠压力({sleep_pressure:.1f})仍然较低，暂时保持清醒，在 {delay_minutes} 分钟后再次尝试。"
-                    )
-                self.context.save()
-
-    def reset_sleep_state_after_wakeup(self):
-        """
-        当角色被用户消息等外部因素唤醒时调用此方法。
-        将状态强制转换为 WOKEN_UP，并设置一个延迟，之后会尝试重新入睡。
-        """
-        if self.context.current_state in [SleepState.PREPARING_SLEEP, SleepState.SLEEPING, SleepState.INSOMNIA]:
-            logger.info("被唤醒，进入 WOKEN_UP 状态！")
-            self.context.current_state = SleepState.WOKEN_UP
-            self.context.sleep_buffer_end_time = None
-            re_sleep_delay_minutes = getattr(global_config.sleep_system, "re_sleep_delay_minutes", 10)
-            self.context.re_sleep_attempt_time = datetime.now() + timedelta(minutes=re_sleep_delay_minutes)
-            logger.info(f"将在 {re_sleep_delay_minutes} 分钟后尝试重新入睡。")
-            self.context.save()

src/chat/message_manager/sleep_manager/sleep_state.py

@@ -1,86 +0,0 @@
-from datetime import date, datetime
-from enum import Enum, auto
-
-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 SleepContext:
-    """
-    睡眠上下文，负责封装和管理所有与睡眠相关的状态，并处理其持久化。
-    """
-
-    def __init__(self):
-        """初始化睡眠上下文，并从本地存储加载初始状态。"""
-        self.current_state: SleepState = SleepState.AWAKE
-        self.sleep_buffer_end_time: datetime | None = None
-        self.total_delayed_minutes_today: float = 0.0
-        self.last_sleep_check_date: date | None = None
-        self.re_sleep_attempt_time: datetime | None = None
-        self.load()
-
-    def save(self):
-        """将当前的睡眠状态数据保存到本地存储。"""
-        try:
-            state = {
-                "current_state": self.current_state.name,
-                "sleep_buffer_end_time_ts": self.sleep_buffer_end_time.timestamp()
-                if self.sleep_buffer_end_time
-                else None,
-                "total_delayed_minutes_today": self.total_delayed_minutes_today,
-                "last_sleep_check_date_str": self.last_sleep_check_date.isoformat()
-                if self.last_sleep_check_date
-                else None,
-                "re_sleep_attempt_time_ts": self.re_sleep_attempt_time.timestamp()
-                if self.re_sleep_attempt_time
-                else None,
-            }
-            local_storage["schedule_sleep_state"] = state
-            logger.debug(f"已保存睡眠上下文: {state}")
-        except Exception as e:
-            logger.error(f"保存睡眠上下文失败: {e}")
-
-    def load(self):
-        """从本地存储加载并解析睡眠状态。"""
-        try:
-            state = local_storage["schedule_sleep_state"]
-            if not (state and isinstance(state, dict)):
-                logger.info("未找到本地睡眠上下文，使用默认值。")
-                return
-
-            state_name = state.get("current_state")
-            if state_name and hasattr(SleepState, state_name):
-                self.current_state = SleepState[state_name]
-
-            end_time_ts = state.get("sleep_buffer_end_time_ts")
-            if end_time_ts:
-                self.sleep_buffer_end_time = datetime.fromtimestamp(end_time_ts)
-
-            re_sleep_ts = state.get("re_sleep_attempt_time_ts")
-            if re_sleep_ts:
-                self.re_sleep_attempt_time = datetime.fromtimestamp(re_sleep_ts)
-
-            self.total_delayed_minutes_today = state.get("total_delayed_minutes_today", 0.0)
-
-            date_str = state.get("last_sleep_check_date_str")
-            if date_str:
-                self.last_sleep_check_date = datetime.fromisoformat(date_str).date()
-
-            logger.info(f"成功从本地存储加载睡眠上下文: {state}")
-        except Exception as e:
-            logger.warning(f"加载睡眠上下文失败，将使用默认值: {e}")

src/chat/message_manager/sleep_manager/time_checker.py

@@ -1,119 +0,0 @@
-import random
-from datetime import datetime, time, timedelta
-from typing import Any
-
-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() -> list[dict[str, Any]] | None:
-        """从全局 ScheduleManager 获取今天的日程安排。"""
-        return schedule_manager.today_schedule
-
-    def is_in_theoretical_sleep_time(self, now_time: time) -> tuple[bool, str | None]:
-        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, str | None]:
-        """检查当前时间是否落在日程表的任何一个睡眠活动中"""
-        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, str | None]:
-        """检查当前时间是否在固定的睡眠时间内（应用偏移量）"""
-        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_context.py

@@ -1,45 +0,0 @@
-from src.common.logger import get_logger
-from src.manager.local_store_manager import local_storage
-
-logger = get_logger("wakeup_context")
-
-
-class WakeUpContext:
-    """
-    唤醒上下文，负责封装和管理所有与唤醒相关的状态，并处理其持久化。
-    """
-
-    def __init__(self):
-        """初始化唤醒上下文，并从本地存储加载初始状态。"""
-        self.wakeup_value: float = 0.0
-        self.is_angry: bool = False
-        self.angry_start_time: float = 0.0
-        self.sleep_pressure: float = 100.0  # 新增：睡眠压力
-        self.load()
-
-    def _get_storage_key(self) -> str:
-        """获取本地存储键"""
-        return "global_wakeup_manager_state"
-
-    def load(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)
-            self.sleep_pressure = state.get("sleep_pressure", 100.0)
-            logger.info(f"成功从本地存储加载唤醒上下文: {state}")
-        else:
-            logger.info("未找到本地唤醒上下文，将使用默认值初始化。")
-
-    def save(self):
-        """将当前状态保存到本地存储"""
-        state = {
-            "wakeup_value": self.wakeup_value,
-            "is_angry": self.is_angry,
-            "angry_start_time": self.angry_start_time,
-            "sleep_pressure": self.sleep_pressure,
-        }
-        local_storage[self._get_storage_key()] = state
-        logger.debug(f"已将唤醒上下文保存到本地存储: {state}")

src/chat/message_manager/sleep_manager/wakeup_manager.py

@@ -1,218 +0,0 @@
-import asyncio
-import time
-from typing import TYPE_CHECKING
-
-from src.chat.message_manager.sleep_manager.wakeup_context import WakeUpContext
-from src.common.logger import get_logger
-from src.config.config import global_config
-
-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.context = WakeUpContext()  # 使用新的上下文管理器
-        self.angry_chat_id: str | None = None
-        self.last_decay_time = time.time()
-        self._decay_task: asyncio.Task | None = 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
-
-    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.context.is_angry and current_time - self.context.angry_start_time >= self.angry_duration:
-                self.context.is_angry = False
-                # 通知情绪管理系统清除愤怒状态
-                from src.mood.mood_manager import mood_manager
-
-                if self.angry_chat_id:
-                    mood_manager.clear_angry_from_wakeup(self.angry_chat_id)
-                    self.angry_chat_id = None
-                else:
-                    logger.warning("Angry state ended but no angry_chat_id was set.")
-                logger.info("愤怒状态结束，恢复正常")
-                self.context.save()
-
-            # 唤醒度自然衰减
-            if self.context.wakeup_value > 0:
-                old_value = self.context.wakeup_value
-                self.context.wakeup_value = max(0, self.context.wakeup_value - self.decay_rate)
-                if old_value != self.context.wakeup_value:
-                    logger.debug(f"唤醒度衰减: {old_value:.1f} -> {self.context.wakeup_value:.1f}")
-                    self.context.save()
-
-    def add_wakeup_value(self, is_private_chat: bool, is_mentioned: bool = False, chat_id: str | None = None) -> 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.context.wakeup_value
-
-        if is_private_chat:
-            # 私聊每条消息都增加唤醒度
-            self.context.wakeup_value += self.private_message_increment
-            logger.debug(f"私聊消息增加唤醒度: +{self.private_message_increment}")
-        elif is_mentioned:
-            # 群聊只有被艾特才增加唤醒度
-            self.context.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.context.wakeup_value:.1f} (阈值: {self.wakeup_threshold})"
-            )
-            self.last_log_time = current_time
-        else:
-            logger.debug(
-                f"唤醒度变化: {old_value:.1f} -> {self.context.wakeup_value:.1f} (阈值: {self.wakeup_threshold})"
-            )
-
-        # 检查是否达到唤醒阈值
-        if self.context.wakeup_value >= self.wakeup_threshold:
-            if not chat_id:
-                logger.error("Wakeup threshold reached, but no chat_id was provided. Cannot trigger wakeup.")
-                return False
-            self._trigger_wakeup(chat_id)
-            return True
-
-        self.context.save()
-        return False
-
-    def _trigger_wakeup(self, chat_id: str):
-        """触发唤醒，进入愤怒状态"""
-        self.context.is_angry = True
-        self.context.angry_start_time = time.time()
-        self.context.wakeup_value = 0.0  # 重置唤醒度
-        self.angry_chat_id = chat_id
-
-        self.context.save()
-
-        # 通知情绪管理系统进入愤怒状态
-        from src.mood.mood_manager import mood_manager
-
-        mood_manager.set_angry_from_wakeup(chat_id)
-
-        # 通知SleepManager重置睡眠状态
-        self.sleep_manager.reset_sleep_state_after_wakeup()
-
-        logger.info(f"唤醒度达到阈值({self.wakeup_threshold})，被吵醒进入愤怒状态！")
-
-    def get_angry_prompt_addition(self) -> str:
-        """获取愤怒状态下的提示词补充"""
-        if self.context.is_angry:
-            return self.angry_prompt
-        return ""
-
-    def is_in_angry_state(self) -> bool:
-        """检查是否处于愤怒状态"""
-        if self.context.is_angry:
-            current_time = time.time()
-            if current_time - self.context.angry_start_time >= self.angry_duration:
-                self.context.is_angry = False
-                # 通知情绪管理系统清除愤怒状态
-                from src.mood.mood_manager import mood_manager
-
-                if self.angry_chat_id:
-                    mood_manager.clear_angry_from_wakeup(self.angry_chat_id)
-                    self.angry_chat_id = None
-                else:
-                    logger.warning("Angry state expired in check, but no angry_chat_id was set.")
-                logger.info("愤怒状态自动过期")
-                return False
-        return self.context.is_angry
-
-    def get_status_info(self) -> dict:
-        """获取当前状态信息"""
-        return {
-            "wakeup_value": self.context.wakeup_value,
-            "wakeup_threshold": self.wakeup_threshold,
-            "is_angry": self.context.is_angry,
-            "angry_remaining_time": max(0, self.angry_duration - (time.time() - self.context.angry_start_time))
-            if self.context.is_angry
-            else 0,
-        }

src/plugins/built_in/sleep_system/__init__.py

@@ -0,0 +1,56 @@
+import logging
+from pathlib import Path
+from typing import Optional
+from bot.plugin import Plugin
+from bot.plugin.meta import Meta
+from bot.plugin.plugin_config import PluginConfig
+
+from .config import SleepSystemConfig
+from .state_manager import StateManager
+from .sleep_logic import SleepLogic
+from .tasks import SleepCycleTask
+
+# 日志配置
+logger = logging.getLogger(__name__)
+
+# 全局任务变量
+sleep_task: Optional[SleepCycleTask] = None
+sleep_logic_instance: Optional[SleepLogic] = None
+
+class SleepSystemPlugin(Plugin):
+    
+    def on_load(self) -> None:
+        global sleep_task, sleep_logic_instance
+        logger.info("睡眠系统插件正在加载...")
+        
+        # 1. 加载配置
+        config = self.get_config(SleepSystemConfig)
+        
+        # 2. 初始化状态管理器
+        state_file = Path("data/sleep_system_state.json")
+        state_manager = StateManager(state_file_path=state_file)
+        
+        # 3. 初始化核心逻辑
+        sleep_logic_instance = SleepLogic(config=config, state_manager=state_manager)
+        
+        # 4. 初始化并启动定时任务
+        sleep_task = SleepCycleTask(sleep_logic=sleep_logic_instance, interval_seconds=30)
+        sleep_task.start()
+        
+        logger.info("睡眠系统插件加载完成，定时任务已启动。")
+
+    def on_unload(self) -> None:
+        global sleep_task, sleep_logic_instance
+        logger.info("睡眠系统插件正在卸载...")
+        if sleep_task:
+            sleep_task.stop()
+        sleep_logic_instance = None
+        logger.info("睡眠系统插件已卸载，定时任务已停止。")
+
+    def get_meta(self) -> Meta:
+        return Meta(
+            name="睡眠系统",
+            description="一个基于状态机的、行为可预测的睡眠系统。",
+            author="Kilo Code",
+            version="1.0.0",
+        )

src/plugins/built_in/sleep_system/api.py

@@ -0,0 +1,9 @@
+import asyncio
+from . import sleep_logic_instance
+
+def on_message_received():
+    """
+    当接收到用户消息时调用此函数，用于处理睡眠中断。
+    """
+    if sleep_logic_instance:
+        asyncio.create_task(sleep_logic_instance.handle_external_event())

src/plugins/built_in/sleep_system/config.py

@@ -0,0 +1,18 @@
+from typing import Tuple
+from pydantic import BaseModel, Field
+
+
+class SleepSystemConfig(BaseModel):
+    # 睡眠时间段，格式为 (时, 分)
+    sleep_time: Tuple[int, int] = Field(default=(23, 0), description="每日固定的入睡时间点")
+    wake_up_time: Tuple[int, int] = Field(default=(7, 0), description="每日固定的唤醒时间点")
+
+    # 睡前准备时间（分钟）
+    prepare_sleep_duration: int = Field(default=15, ge=5, le=30, description="进入睡眠状态前的准备时间（分钟）")
+
+    # 失眠设置
+    insomnia_probability: float = Field(default=0.1, ge=0, le=1, description="在睡眠状态下触发失眠的概率")
+    insomnia_duration_minutes: Tuple[int, int] = Field(default=(10, 30), description="失眠状态的持续时间范围（分钟）")
+
+    # 被吵醒设置
+    woken_up_cooldown_minutes: int = Field(default=10, description="被吵醒后尝试重新入睡的冷却时间（分钟）")

src/plugins/built_in/sleep_system/py.typed

@@ -0,0 +1,2 @@
+# This file is intentionally left empty.
+# It is a marker file that tells MyPy to perform type checking on this package.

src/plugins/built_in/sleep_system/sleep_logic.py

@@ -0,0 +1,134 @@
+import logging
+import random
+import time
+from datetime import datetime, time as dt_time, timedelta
+from .config import SleepSystemConfig
+from .state_manager import StateManager, SleepState
+
+logger = logging.getLogger(__name__)
+
+class SleepLogic:
+    """
+    实现睡眠系统的核心状态机逻辑。
+    """
+    def __init__(self, config: SleepSystemConfig, state_manager: StateManager):
+        self.config = config
+        self.state_manager = state_manager
+
+    async def update_state(self) -> None:
+        """
+        核心更新函数，由定时任务调用。
+        根据当前时间和状态，决定是否进行状态转换。
+        """
+        current_state = await self.state_manager.get_state()
+        now = datetime.now()
+        
+        handler = getattr(self, f"_handle_{current_state.current_state.lower()}", self._handle_unknown)
+        await handler(current_state, now)
+
+    def _is_in_sleep_time_range(self, now: datetime) -> bool:
+        """检查当前时间是否在理论睡眠时间范围内"""
+        wake_up_time = dt_time(self.config.wake_up_time[0], self.config.wake_up_time[1])
+        sleep_time = dt_time(self.config.sleep_time[0], self.config.sleep_time[1])
+        now_time = now.time()
+
+        if sleep_time > wake_up_time:  # 跨天睡眠
+            return now_time >= sleep_time or now_time < wake_up_time
+        else:  # 当天睡眠
+            return sleep_time <= now_time < wake_up_time
+
+    async def _handle_awake(self, state: SleepState, now: datetime):
+        """处理 AWAKE 状态的逻辑"""
+        # 检查是否到了准备睡觉的时间
+        sleep_datetime = datetime.combine(now.date(), dt_time(self.config.sleep_time[0], self.config.sleep_time[1]))
+        prepare_start_time = sleep_datetime - timedelta(minutes=self.config.prepare_sleep_duration)
+
+        if prepare_start_time <= now < sleep_datetime:
+            await self._transition_to(state, "PREPARING_SLEEP", duration_minutes=self.config.prepare_sleep_duration)
+            logger.info("时间已到，进入睡前准备状态。")
+            # 在这里可以触发“准备睡觉”的情绪或回复
+
+    async def _handle_preparing_sleep(self, state: SleepState, now: datetime):
+        """处理 PREPARING_SLEEP 状态的逻辑"""
+        if state.state_end_time and now.timestamp() >= state.state_end_time:
+            # 准备时间结束，进入睡眠
+            if self._is_in_sleep_time_range(now):
+                await self._transition_to(state, "SLEEPING")
+                logger.info("准备时间结束，已进入睡眠状态。")
+            else:
+                await self._transition_to(state, "AWAKE")
+                logger.info("准备期间离开了理论睡眠时间，返回 AWAKE 状态。")
+
+    async def _handle_sleeping(self, state: SleepState, now: datetime):
+        """处理 SLEEPING 状态的逻辑"""
+        # 检查是否到了起床时间
+        if not self._is_in_sleep_time_range(now):
+            await self._transition_to(state, "AWAKE")
+            logger.info("理论睡眠时间结束，已切换到 AWAKE 状态。")
+            # 在这里可以触发“睡醒”的情绪
+            return
+
+        # 根据概率随机触发失眠
+        if random.random() < self.config.insomnia_probability:
+            duration = random.randint(self.config.insomnia_duration_minutes[0], self.config.insomnia_duration_minutes[1])
+            await self._transition_to(state, "INSOMNIA", duration_minutes=duration)
+            logger.info(f"随机触发失眠，持续 {duration} 分钟。")
+            # 在这里可以触发“烦躁”的情绪
+
+    async def _handle_insomnia(self, state: SleepState, now: datetime):
+        """处理 INSOMNIA 状态的逻辑"""
+        # 检查失眠时间是否结束
+        if state.state_end_time and now.timestamp() >= state.state_end_time:
+            await self._transition_to(state, "SLEEPING")
+            logger.info("失眠时间结束，返回睡眠状态。")
+        # 如果在失眠期间就到了起床时间，直接唤醒
+        elif not self._is_in_sleep_time_range(now):
+            await self._transition_to(state, "AWAKE")
+            logger.info("在失眠期间到达起床时间，已唤醒。")
+
+    async def _handle_woken_up(self, state: SleepState, now: datetime):
+        """处理 WOKEN_UP 状态的逻辑"""
+        # 检查冷却时间是否结束
+        if state.state_end_time and now.timestamp() >= state.state_end_time:
+            if self._is_in_sleep_time_range(now):
+                await self._transition_to(state, "PREPARING_SLEEP", duration_minutes=self.config.prepare_sleep_duration)
+                logger.info("被吵醒冷却时间结束，尝试重新入睡。")
+            else:
+                await self._transition_to(state, "AWAKE")
+                logger.info("被吵醒后到达起床时间，已唤醒。")
+
+    async def _handle_unknown(self, state: SleepState, now: datetime):
+        """处理未知状态"""
+        logger.warning(f"检测到未知的睡眠状态: {state.current_state}。将重置为 AWAKE。")
+        await self._transition_to(state, "AWAKE")
+
+    async def handle_external_event(self):
+        """处理外部事件，例如收到用户消息"""
+        current_state = await self.state_manager.get_state()
+        if current_state.current_state in ["SLEEPING", "INSOMNIA"]:
+            await self._transition_to(current_state, "WOKEN_UP", duration_minutes=self.config.woken_up_cooldown_minutes)
+            logger.info("在睡眠中被外部事件打断，进入 WOKEN_UP 状态。")
+            # 在这里可以触发“起床气”情绪
+
+    async def _transition_to(self, old_state: SleepState, new_state_name: str, duration_minutes: int = 0):
+        """
+        状态转换的统一处理函数。
+        
+        Args:
+            old_state: 转换前的状态对象。
+            new_state_name: 新状态的名称。
+            duration_minutes: 新状态的持续时间（分钟），如果为0则不设结束时间。
+        """
+        current_timestamp = time.time()
+        new_end_time = None
+        if duration_minutes > 0:
+            new_end_time = current_timestamp + duration_minutes * 60
+
+        new_state = SleepState(
+            current_state=new_state_name,
+            state_end_time=new_end_time,
+            last_updated=current_timestamp,
+            metadata=old_state.metadata  # 继承 metadata
+        )
+        await self.state_manager.save_state(new_state)
+        logger.info(f"睡眠状态已从 {old_state.current_state} 转换为 {new_state_name}。")

src/plugins/built_in/sleep_system/state_manager.py

@@ -0,0 +1,83 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+import asyncio
+
+# 设置日志记录
+logger = logging.getLogger(__name__)
+
+class SleepState(BaseModel):
+    """定义睡眠状态的数据模型"""
+    current_state: str = Field(default="AWAKE", description="当前的睡眠状态")
+    state_end_time: Optional[float] = Field(default=None, description="当前状态的预计结束时间戳")
+    last_updated: float = Field(description="状态最后更新的时间戳")
+    metadata: Dict[str, Any] = Field(default={}, description="用于存储额外状态信息的字典")
+
+class StateManager:
+    """
+    负责睡眠状态的持久化管理。
+    将状态以 JSON 格式读/写到本地文件，以降低耦合。
+    """
+    def __init__(self, state_file_path: Path):
+        self.state_file_path = state_file_path
+        self._state: Optional[SleepState] = None
+        self._lock = asyncio.Lock()
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """从文件加载状态，如果文件不存在或为空，则创建默认状态"""
+        try:
+            if self.state_file_path.exists() and self.state_file_path.stat().st_size > 0:
+                with open(self.state_file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self._state = SleepState(**data)
+                    logger.info(f"睡眠状态已从 {self.state_file_path} 加载。")
+            else:
+                self._create_default_state()
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.warning(f"无法解析状态文件 {self.state_file_path}: {e}。将创建新的默认状态。")
+            self._create_default_state()
+        except Exception as e:
+            logger.error(f"加载睡眠状态时发生未知错误: {e}")
+            self._create_default_state()
+
+    def _create_default_state(self) -> None:
+        """创建一个默认的清醒状态"""
+        import time
+        self._state = SleepState(last_updated=time.time())
+        logger.info("未找到现有状态文件，已创建默认的睡眠状态 (AWAKE)。")
+        # 立即保存一次，以确保文件被创建
+        asyncio.create_task(self.save_state())
+
+    async def get_state(self) -> SleepState:
+        """异步获取当前的状态"""
+        async with self._lock:
+            if self._state is None:
+                self._load_state()
+            # 此时 _state 必然已被 _load_state 或 _create_default_state 初始化
+            assert self._state is not None, "State should be initialized here"
+            return self._state.copy(deep=True)
+
+    async def save_state(self, new_state: Optional[SleepState] = None) -> None:
+        """
+        异步保存当前状态到文件。
+        如果提供了 new_state，则先更新内部状态。
+        """
+        async with self._lock:
+            if new_state:
+                self._state = new_state
+
+            if self._state is None:
+                logger.warning("尝试保存一个空的状态，操作已跳过。")
+                return
+
+            try:
+                # 确保目录存在
+                self.state_file_path.parent.mkdir(parents=True, exist_ok=True)
+                with open(self.state_file_path, 'w', encoding='utf-8') as f:
+                    json.dump(self._state.dict(), f, indent=4, ensure_ascii=False)
+                logger.debug(f"睡眠状态已成功保存到 {self.state_file_path}。")
+            except Exception as e:
+                logger.error(f"保存睡眠状态到 {self.state_file_path} 时失败: {e}")

src/plugins/built_in/sleep_system/tasks.py

@@ -0,0 +1,48 @@
+import asyncio
+import logging
+from typing import Optional
+from .sleep_logic import SleepLogic
+
+logger = logging.getLogger(__name__)
+
+class SleepCycleTask:
+    """
+    负责周期性地更新睡眠状态的后台任务。
+    """
+    def __init__(self, sleep_logic: SleepLogic, interval_seconds: int = 30):
+        self.sleep_logic = sleep_logic
+        self.interval_seconds = interval_seconds
+        self._task: Optional[asyncio.Task] = None
+        self._is_running = False
+
+    async def _run(self):
+        """任务的内部循环"""
+        logger.info("睡眠系统周期性更新任务已启动。")
+        while self._is_running:
+            try:
+                await self.sleep_logic.update_state()
+                await asyncio.sleep(self.interval_seconds)
+            except asyncio.CancelledError:
+                logger.info("睡眠系统任务被取消。")
+                break
+            except Exception as e:
+                logger.error(f"睡眠系统任务在执行期间发生错误: {e}", exc_info=True)
+                # 发生错误后，等待一段时间再继续，避免快速失败循环
+                await asyncio.sleep(self.interval_seconds * 2)
+
+    def start(self):
+        """启动后台任务"""
+        if not self._is_running:
+            self._is_running = True
+            self._task = asyncio.create_task(self._run())
+        else:
+            logger.warning("尝试启动一个已经在运行的睡眠系统任务。")
+
+    def stop(self):
+        """停止后台任务"""
+        if self._is_running and self._task:
+            self._is_running = False
+            self._task.cancel()
+            logger.info("睡眠系统周期性更新任务已请求停止。")
+        else:
+            logger.warning("尝试停止一个尚未启动的睡眠系统任务。")