refactor(core): 移除睡眠系统

由于睡眠系统存在设计缺陷、实现复杂且维护成本高，并且实际使用效果不佳，常常导致非预期的行为（如错过重要消息或在不应睡眠时睡眠），现决定将其从核心代码中完全移除。

移除内容包括：
- 删除了整个 `sleep_system` 模块及其所有相关逻辑、状态管理和定时任务。
- 清理了配置文件 `config.py` 和 `official_configs.py` 中的 `SleepSystemConfig`。
- 移除了 `main.py` 中关于睡眠系统的初始化调用。
- 清理了 `message_manager` 和 `proactive_thinker` 中对睡眠状态的检查。
- 更新了 `bot_config_template.toml` 模板文件，移除了所有睡眠系统相关的配置项。

此举旨在简化项目架构，提高系统的稳定性和可预测性。未来的相关功能可能会以更健壮、更模块化的插件形式重新实现。

src/chat/message_manager/message_manager.py

@@ -20,7 +20,6 @@ from src.plugin_system.apis.chat_api import get_chat_manager
 
 from .distribution_manager import stream_loop_manager
 from .global_notice_manager import NoticeScope, global_notice_manager
-from .sleep_system.state_manager import SleepState, get_sleep_state_manager
 
 if TYPE_CHECKING:
     pass
@@ -148,14 +147,6 @@ class MessageManager:
 
     async def add_message(self, stream_id: str, message: DatabaseMessages):
         """添加消息到指定聊天流"""
-        # 在消息处理的最前端检查睡眠状态
-        if global_config.sleep_system.enable:
-            current_sleep_state = get_sleep_state_manager().get_current_state()
-            if current_sleep_state == SleepState.SLEEPING:
-                logger.info(f"处于 {current_sleep_state.name} 状态，消息被拦截。")
-                return  # 直接返回，不处理消息
-
-        # TODO: 在这里为 WOKEN_UP_ANGRY 等未来状态添加特殊处理逻辑
 
         try:
             # 检查是否为notice消息

src/chat/message_manager/sleep_system/sleep_logic.py

@@ -1,112 +0,0 @@
-import random
-from datetime import datetime, timedelta
-
-from src.common.logger import get_logger
-from src.config.config import global_config
-from src.schedule.schedule_manager import schedule_manager
-from . import utils
-from .state_manager import SleepState,get_sleep_state_manager
-
-
-
-logger = get_logger("sleep_logic")
-
-
-class SleepLogic:
-    """
-    核心睡眠逻辑，睡眠系统的“大脑”
-
-    负责根据当前的配置、时间、日程表以及状态，判断是否需要切换睡眠状态。
-    它本身是无状态的，所有的状态都读取和写入 SleepStateManager。
-    """
-
-    def check_and_update_sleep_state(self):
-        """
-        检查并更新当前的睡眠状态，这是整个逻辑的入口。
-        由定时任务周期性调用。
-        """
-        current_state = get_sleep_state_manager().get_current_state()
-        now = datetime.now()
-
-        if current_state == SleepState.AWAKE:
-            self._check_should_fall_asleep(now)
-        elif current_state == SleepState.SLEEPING:
-            self._check_should_wake_up(now)
-        elif current_state == SleepState.INSOMNIA:
-            # TODO: 实现失眠逻辑
-            # 例如：检查失眠状态是否结束，如果结束则转换回 SLEEPING
-            pass
-        elif current_state == SleepState.WOKEN_UP_ANGRY:
-            # TODO: 实现起床气逻辑
-            # 例如：检查生气状态是否结束，如果结束则转换回 SLEEPING 或 AWAKE
-            pass
-
-    def _check_should_fall_asleep(self, now: datetime):
-        """
-        当状态为 AWAKE 时，检查是否应该进入睡眠。
-        """
-        from .state_manager import SleepState
-        should_sleep, wake_up_time = utils.should_be_sleeping(now)
-        if should_sleep:
-            logger.info("判断结果：应进入睡眠状态。")
-            get_sleep_state_manager().set_state(SleepState.SLEEPING, wake_up=wake_up_time)
-
-    def _check_should_wake_up(self, now: datetime):
-        """
-        当状态为 SLEEPING 时，检查是否应该醒来。
-        这里包含了处理跨天获取日程的核心逻辑。
-        """
-        from .state_manager import SleepState
-        wake_up_time = get_sleep_state_manager().get_wake_up_time()
-
-        # 核心逻辑：两段式检测
-        # 如果 state_manager 中还没有起床时间，说明是昨晚入睡，需要等待今天凌晨的新日程。
-        sleep_start_time = get_sleep_state_manager().get_sleep_start_time()
-        if not wake_up_time:
-            if sleep_start_time and now.date() > sleep_start_time.date():
-                logger.debug("当前为睡眠状态但无起床时间，尝试从新日程中解析...")
-                _, new_wake_up_time = self._get_wakeup_times_from_schedule(now)
-
-                if new_wake_up_time:
-                    logger.info(f"成功从新日程获取到起床时间: {new_wake_up_time.strftime('%H:%M')}")
-                    get_sleep_state_manager().set_wake_up_time(new_wake_up_time)
-                    wake_up_time = new_wake_up_time
-                else:
-                    logger.debug("未能获取到新的起床时间，继续睡眠。")
-                    return
-            else:
-                logger.info("还没有到达第二天,继续睡眠。")
-        if wake_up_time:
-            logger.info(f"尚未到苏醒时间,苏醒时间在{wake_up_time}")
-        if wake_up_time and now >= wake_up_time:
-            logger.info(f"当前时间 {now.strftime('%H:%M')} 已到达或超过预定起床时间 {wake_up_time.strftime('%H:%M')}。")
-            get_sleep_state_manager().set_state(SleepState.AWAKE)
-
-    def _get_wakeup_times_from_schedule(self, now: datetime) -> tuple[datetime | None, datetime | None]:
-            """
-            当使用“日程表”模式时，从此方法获取wakeup时间。
-            实现了核心逻辑：
-            - 解析“今天”日程中的wakeup时间。
-            """
-            # 阶段一：获取当天的睡觉时间
-            today_schedule = schedule_manager.today_schedule
-            wake_up_time = None
-            if today_schedule:
-                for event in today_schedule:
-                    activity = event.get("activity", "").lower()
-                    if "wake_up" in activity or "醒来" in activity or "起床" in activity:
-                        try:
-                            time_range = event.get("time_range", "")
-                            start_str, _ = time_range.split("-")
-                            sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time()
-                            wake_up_time = datetime.combine(now.date(), sleep_t)
-                            break
-                        except (ValueError, AttributeError):
-                            logger.warning(f"解析日程中的睡眠时间失败: {event}")
-                            continue
-
-            return None, wake_up_time
-
-
-# 全局单例
-sleep_logic = SleepLogic()

src/chat/message_manager/sleep_system/state_manager.py

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

src/chat/message_manager/sleep_system/tasks.py

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

src/chat/message_manager/sleep_system/utils.py

@@ -1,105 +0,0 @@
-"""
-睡眠系统的工具函数模块
-
-此模块包含了被 state_manager 和 sleep_logic 共享的、无状态的逻辑函数，
-目的是为了解决循环引用的问题。
-"""
-import random
-from datetime import datetime, timedelta
-
-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("sleep_utils")
-
-
-def _get_fixed_sleep_times(now: datetime) -> tuple[datetime | None, datetime | None]:
-    """
-    当使用“固定时间”模式时，从此方法计算睡眠和起床时间。
-    会加入配置中的随机偏移量，让作息更自然。
-    """
-    sleep_config = global_config.sleep_system
-    try:
-        sleep_offset = random.randint(
-            -sleep_config.sleep_time_offset_minutes, sleep_config.sleep_time_offset_minutes
-        )
-        wake_up_offset = random.randint(
-            -sleep_config.wake_up_time_offset_minutes, sleep_config.wake_up_time_offset_minutes
-        )
-
-        sleep_t = datetime.strptime(sleep_config.fixed_sleep_time, "%H:%M").time()
-        wake_up_t = datetime.strptime(sleep_config.fixed_wake_up_time, "%H:%M").time()
-
-        sleep_time = datetime.combine(now.date(), sleep_t) + timedelta(minutes=sleep_offset)
-
-        # 如果起床时间比睡觉时间早，说明是第二天
-        wake_up_day = now.date() + timedelta(days=1) if wake_up_t < sleep_t else now.date()
-        wake_up_time = datetime.combine(wake_up_day, wake_up_t) + timedelta(minutes=wake_up_offset)
-
-        return sleep_time, wake_up_time
-    except (ValueError, TypeError) as e:
-        logger.error(f"解析固定睡眠时间失败: {e}")
-        return None, None
-
-
-def _get_sleep_times_from_schedule(now: datetime) -> tuple[datetime | None, datetime | None]:
-    """
-    当使用“日程表”模式时，从此方法获取睡眠时间。
-    实现了核心逻辑：
-    - 解析“今天”日程中的睡觉时间。
-    """
-    # 阶段一：获取当天的睡觉时间
-    today_schedule = schedule_manager.today_schedule
-    sleep_time = None
-    if today_schedule:
-        for event in today_schedule:
-            activity = event.get("activity", "").lower()
-            if "sleep" in activity or "睡觉" in activity  or "入睡" in activity or "进入梦乡" in activity:
-                try:
-                    time_range = event.get("time_range", "")
-                    start_str, _ = time_range.split("-")
-                    sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time()
-                    sleep_time = datetime.combine(now.date(), sleep_t)
-                    break
-                except (ValueError, AttributeError):
-                    logger.warning(f"解析日程中的睡眠时间失败: {event}")
-                    continue
-    wake_up_time = None
-
-    return sleep_time, wake_up_time
-
-
-def should_be_sleeping(now: datetime) -> tuple[bool, datetime | None]:
-    """
-    判断在当前时刻，是否应该处于睡眠时间。
-
-    Returns:
-        元组 (是否应该睡眠, 预期的起床时间或None)
-    """
-    sleep_config = global_config.sleep_system
-    if not sleep_config.enable:
-        return False, None
-
-    sleep_time, wake_up_time = None, None
-
-    if sleep_config.sleep_by_schedule:
-        sleep_time, _ = _get_sleep_times_from_schedule(now)
-        if not sleep_time:
-            logger.debug("日程表模式开启，但未找到睡眠时间，使用固定时间作为备用。")
-            sleep_time, wake_up_time = _get_fixed_sleep_times(now)
-    else:
-        sleep_time, wake_up_time = _get_fixed_sleep_times(now)
-
-    if not sleep_time:
-        return False, None
-
-    # 检查当前时间是否在睡眠时间范围内
-    if now >= sleep_time:
-        # 如果起床时间是第二天（通常情况），且当前时间小于起床时间，则在睡眠范围内
-        if wake_up_time and wake_up_time > sleep_time and now < wake_up_time:
-             return True, wake_up_time
-        # 如果当前时间大于入睡时间，说明已经进入睡眠窗口
-        return True, wake_up_time
-
-    return False, None

src/config/config.py

@@ -40,7 +40,6 @@ from src.config.official_configs import (
     ProactiveThinkingConfig,
     ResponsePostProcessConfig,
     ResponseSplitterConfig,
-    SleepSystemConfig,
     ToolConfig,
     VideoAnalysisConfig,
     VoiceConfig,
@@ -410,7 +409,6 @@ class Config(ValidatedConfigBase):
         default_factory=lambda: DependencyManagementConfig(), description="依赖管理配置"
     )
     web_search: WebSearchConfig = Field(default_factory=lambda: WebSearchConfig(), description="网络搜索配置")
-    sleep_system: SleepSystemConfig = Field(default_factory=lambda: SleepSystemConfig(), description="睡眠系统配置")
     planning_system: PlanningSystemConfig = Field(
         default_factory=lambda: PlanningSystemConfig(), description="规划系统配置"
     )

src/config/official_configs.py

@@ -593,52 +593,6 @@ class AntiPromptInjectionConfig(ValidatedConfigBase):
     shield_suffix: str = Field(default=" 🛡️", description="保护后缀")
 
 
-class SleepSystemConfig(ValidatedConfigBase):
-    """睡眠系统配置类"""
-
-    enable: bool = Field(default=True, description="是否启用睡眠系统")
-    sleep_by_schedule: bool = Field(default=True, description="是否根据日程表进行睡觉")
-    fixed_sleep_time: str = Field(default="23:00", description="固定的睡觉时间")
-    fixed_wake_up_time: str = Field(default="07:00", description="固定的起床时间")
-    sleep_time_offset_minutes: int = Field(
-        default=15, ge=0, le=60, description="睡觉时间随机偏移量范围（分钟），实际睡觉时间会在±该值范围内随机"
-    )
-    wake_up_time_offset_minutes: int = Field(
-        default=15, ge=0, le=60, description="起床时间随机偏移量范围（分钟），实际起床时间会在±该值范围内随机"
-    )
-    wakeup_threshold: float = Field(default=15.0, ge=1.0, description="唤醒阈值，达到此值时会被唤醒")
-    private_message_increment: float = Field(default=3.0, ge=0.1, description="私聊消息增加的唤醒度")
-    group_mention_increment: float = Field(default=2.0, ge=0.1, description="群聊艾特增加的唤醒度")
-    decay_rate: float = Field(default=0.2, ge=0.0, description="每次衰减的唤醒度数值")
-    decay_interval: float = Field(default=30.0, ge=1.0, description="唤醒度衰减间隔(秒)")
-    angry_duration: float = Field(default=300.0, ge=10.0, description="愤怒状态持续时间(秒)")
-    angry_prompt: str = Field(default="你被人吵醒了非常生气，说话带着怒气", description="被吵醒后的愤怒提示词")
-    re_sleep_delay_minutes: int = Field(
-        default=5, ge=1, description="被唤醒后，如果多久没有新消息则尝试重新入睡（分钟）"
-    )
-
-    # --- 失眠机制相关参数 ---
-    enable_insomnia_system: bool = Field(default=True, description="是否启用失眠系统")
-    insomnia_trigger_delay_minutes: list[int] = Field(
-        default_factory=lambda: [30, 60], description="入睡后触发失眠判定的延迟时间范围（分钟）"
-    )
-    insomnia_duration_minutes: list[int] = Field(
-        default_factory=lambda: [15, 45], description="单次失眠状态的持续时间范围（分钟）"
-    )
-    insomnia_chance_pressure: float = Field(default=0.1, ge=0.0, le=1.0, description="失眠基础概率")
-
-    # --- 弹性睡眠与睡前消息 ---
-    enable_flexible_sleep: bool = Field(default=True, description="是否启用弹性睡眠")
-    flexible_sleep_pressure_threshold: float = Field(
-        default=40.0, description="触发弹性睡眠的睡眠压力阈值，低于该值可能延迟入睡"
-    )
-    max_sleep_delay_minutes: int = Field(default=60, description="单日最大延迟入睡分钟数")
-    enable_pre_sleep_notification: bool = Field(default=True, description="是否启用睡前消息")
-    pre_sleep_prompt: str = Field(
-        default="我准备睡觉了，请生成一句简短自然的晚安问候。", description="用于生成睡前消息的提示"
-    )
-
-
 class ContextGroup(ValidatedConfigBase):
     """
     上下文共享组配置

src/main.py

@@ -13,7 +13,6 @@ from rich.traceback import install
 
 from src.chat.emoji_system.emoji_manager import get_emoji_manager
 from src.chat.memory_system.memory_manager import memory_manager
-from src.chat.message_manager.sleep_system.tasks import start_sleep_system_tasks
 from src.chat.message_receive.bot import chat_bot
 from src.chat.message_receive.chat_stream import get_chat_manager
 from src.chat.utils.statistic import OnlineTimeRecordTask, StatisticOutputTask
@@ -518,14 +517,6 @@ MoFox_Bot(第三方修改版)
             except Exception as e:
                 logger.error(f"日程表管理器初始化失败: {e}")
 
-        # 初始化睡眠系统
-        if global_config.sleep_system.enable:
-            try:
-                await start_sleep_system_tasks()
-                logger.info("睡眠系统初始化成功")
-            except Exception as e:
-                logger.error(f"睡眠系统初始化失败: {e}")
-
     def _safe_init(self, component_name: str, init_func) -> callable:
         """安全初始化组件，捕获异常"""
 

src/plugins/built_in/proactive_thinker/proacive_thinker_event.py

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

template/bot_config_template.toml

@@ -1,5 +1,5 @@
 [inner]
-version = "7.3.5"
+version = "7.4.5"
 
 #----以下是给开发人员阅读的，如果你只是部署了MoFox-Bot，不需要阅读----
 #如果你想要修改配置文件，请递增version的值
@@ -485,44 +485,6 @@ searxng_api_keys = []# SearXNG 实例 API 密钥列表
 enabled_engines = ["ddg"] # 启用的搜索引擎列表，可选: "exa", "tavily", "ddg","bing", "metaso"
 search_strategy = "single" # 搜索策略: "single"(使用第一个可用引擎), "parallel"(并行使用所有启用的引擎), "fallback"(按顺序尝试，失败则尝试下一个)
 
-[sleep_system]
-enable = false #"是否启用睡眠系统"
-sleep_by_schedule = true #"是否根据日程表进行睡觉"
-fixed_sleep_time = "23:00" #"固定的睡觉时间"
-fixed_wake_up_time = "07:00" #"固定的起床时间"
-sleep_time_offset_minutes = 15 #"睡觉时间随机偏移量范围（分钟），实际睡觉时间会在±该值范围内随机"
-wake_up_time_offset_minutes = 15 #"起床时间随机偏移量范围（分钟），实际起床时间会在±该值范围内随机"
-wakeup_threshold = 15.0 #唤醒阈值，达到此值时会被唤醒"
-private_message_increment = 3.0 #"私聊消息增加的唤醒度"
-group_mention_increment = 2.0 #"群聊艾特增加的唤醒度"
-decay_rate = 0.2 #"每次衰减的唤醒度数值"
-decay_interval = 30.0 #"唤醒度衰减间隔(秒)"
-angry_duration = 300.0 #"愤怒状态持续时间(秒)"
-angry_prompt = "你被人吵醒了非常生气，说话带着怒气" # "被吵醒后的愤怒提示词"
-re_sleep_delay_minutes = 5 # "被唤醒后，如果多久没有新消息则尝试重新入睡（分钟）"
-
-# --- 失眠机制相关参数 ---
-enable_insomnia_system = false # 是否启用失眠系统
-# 失眠概率 (0.0 to 1.0)
-insomnia_chance_pressure = 0.1
-
-# --- 弹性睡眠与睡前消息 ---
-# 是否启用弹性睡眠。启用后，AI不会到点立刻入睡，而是会根据睡眠压力增加5-10分钟的缓冲，并可能因为压力不足而推迟睡眠。
-enable_flexible_sleep = false
-# 触发弹性睡眠的睡眠压力阈值。当AI的睡眠压力低于此值时，可能会推迟入睡。
-flexible_sleep_pressure_threshold = 40.0
-# 每日最大可推迟入睡的总分钟数。
-max_sleep_delay_minutes = 60
-
-# 是否在进入“准备入睡”状态时发送一条消息通知。
-enable_pre_sleep_notification = false
-# 用于生成睡前消息的提示。AI会根据这个提示生成一句晚安问候。
-pre_sleep_prompt = "我准备睡觉了，请生成一句简短自然的晚安问候。"
-insomnia_duration_minutes = [30, 60] # 单次失眠状态的持续时间范围（分钟）
-# --- 睡后失眠 ---
-# 入睡后，经过一段延迟后触发失眠判定的延迟时间（分钟），设置为范围以增加随机性
-insomnia_trigger_delay_minutes = [15, 45]
-
 [cross_context] # 跨群聊/私聊上下文共享配置
 # 这是总开关，用于一键启用或禁用此功能
 enable = true