Revert "实现了新的睡眠系统喵~",我看了不如我回去自己写一个()

This reverts commit e1dde64fc6.

src/chat/message_manager/message_manager.py

@@ -17,11 +17,10 @@ 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.sleep_manager import SleepManager
-# from .sleep_manager.wakeup_manager import WakeUpManager
+from .sleep_manager.wakeup_manager import WakeUpManager
 
 if TYPE_CHECKING:
     pass
@@ -44,9 +43,9 @@ class MessageManager:
         self.action_manager = ChatterActionManager()
         self.chatter_manager = ChatterManager(self.action_manager)
 
-        # 初始化睡眠和唤醒管理器 (已被新插件取代)
+        # 初始化睡眠和唤醒管理器
-        # self.sleep_manager = SleepManager()
+        self.sleep_manager = SleepManager()
-        # self.wakeup_manager = WakeUpManager(self.sleep_manager)
+        self.wakeup_manager = WakeUpManager(self.sleep_manager)
 
         # 消息缓存系统 - 直接集成到消息管理器
         self.message_caches: Dict[str, deque] = defaultdict(deque)  # 每个流的消息缓存
@@ -94,8 +93,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()
@@ -142,8 +141,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()
@@ -153,9 +152,6 @@ 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:
@@ -339,14 +335,9 @@ class MessageManager:
                     inactive_streams.append(stream_id)
             for stream_id in inactive_streams:
                 try:
-                    # 修复: 直接通过 stream_id 获取 chat_stream，避免潜在的未绑定问题
+                    await chat_stream.context_manager.clear_context()
-                    inactive_stream = chat_manager.streams.get(stream_id)
+                    del chat_manager.streams[stream_id]
-                    if inactive_stream:
+                    logger.info(f"清理不活跃聊天流: {stream_id}")
-                        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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,291 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,218 @@
+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

@@ -1,49 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Optional
-
-from src.plugin_system import BasePlugin, register_plugin
-
-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
-
-@register_plugin
-class SleepSystemPlugin(BasePlugin):
-    plugin_name: str = "sleep_system"
-    
-    def on_load(self) -> None:
-        global sleep_task, sleep_logic_instance
-        logger.info("睡眠系统插件正在加载...")
-        
-        # 1. 加载配置
-        config = self.get_config(self.plugin_name, SleepSystemConfig)
-        
-        # 2. 初始化状态管理器
-        state_file = Path(f"data/{self.plugin_name}_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("睡眠系统插件已卸载，定时任务已停止。")

src/plugins/built_in/sleep_system/api.py

@@ -1,9 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,2 +0,0 @@
-# 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

@@ -1,134 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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("尝试停止一个尚未启动的睡眠系统任务。")