fix(critical): 修复调度器静默失效、数据源缺失与前端类型错误

C1 定时任务静默失效(4 层缺陷):
  - scheduler.py: croniter(expr, datetime.now) 未调用 now(),
    导致 TypeError 被吞、next_run 恒为 None(最深一层)
  - scheduler.py: _calc_next 非法 cron 静默吞异常 -> 改为构造期抛 ValueError
  - scheduler.py: _run_loop 一次异常即永久停摆 -> 增加异常隔离
  - scheduler.py: sleep(min(wait,60)) 使运行期 cron 变更最长 60s 才生效
    -> 改为固定 SLEEP_TICK 轮询
  - app.py / schedules.py: 3 处 register() 第 2 参误传 task 类型名

C3 EvalPage.tsx: 引用未导入的 EmptyState -> 改为已导入的 EmptyText
  (tsc --noEmit 由 1 error 变为 0 error)

新增 tests/test_scheduler_registration.py: 9 项行为回归测试

src/api/app.py

@@ -50,7 +50,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         for s in schedules:
             leagues = s.leagues.split(",") if s.leagues else list(BZZOIRO_LEAGUE_IDS.keys())
             scheduler.register(
-                s.id, s.task,
+                s.id, s.cron,
                 lambda sid=s.id: _run_scheduled_task(sid),
                 enabled=s.enabled,
             )

src/api/routes/schedules.py

@@ -91,8 +91,8 @@ async def create_schedule(req: ScheduleIn, db: AsyncSession = Depends(get_db_rea
     db.add(sched)
     await db.commit()
 
-    # 注册到调度器
-    scheduler.register(req.id, req.task, lambda: _run_scheduled_task(req.id), enabled=req.enabled)
+    # 注册到调度器(注意: 第 2 参是 cron 表达式,不是 task 类型名)
+    scheduler.register(req.id, req.cron, lambda: _run_scheduled_task(req.id), enabled=req.enabled)
 
     return {"ok": True, "id": req.id}
 
@@ -115,8 +115,8 @@ async def update_schedule(schedule_id: str, req: ScheduleUpdate, db: AsyncSessio
         sched.enabled = req.enabled
     await db.commit()
 
-    # 更新调度器(使用最终值)
-    scheduler.register(schedule_id, sched.task, lambda: _run_scheduled_task(schedule_id), enabled=sched.enabled)
+    # 更新调度器(第 2 参传 cron 表达式;使用最终值)
+    scheduler.register(schedule_id, sched.cron, lambda: _run_scheduled_task(schedule_id), enabled=sched.enabled)
 
     return {"ok": True}
 

src/core/scheduler.py

@@ -14,6 +14,9 @@ logger = logging.getLogger(__name__)
 class ScheduledTask:
     """一个定时任务。"""
 
+    #: 运行循环的轮询粒度(秒)。同时决定运行期 cron/next_run 变更的生效延迟上限。
+    SLEEP_TICK: float = 1.0
+
     def __init__(
         self,
         task_id: str,
@@ -28,13 +31,29 @@ class ScheduledTask:
         self.last_run: datetime | None = None
         self.next_run: datetime | None = None
         self._task: asyncio.Task | None = None
-        self._calc_next()
+        # 构造时立即校验 cron:非法表达式直接报错,不留给 _run_loop 静默吞掉。
+        # (全量审查 C1: 传入任务类型字符串时 croniter 抛异常被吞 → 任务永不触发)
+        self._calc_next(raise_on_error=True)
 
-    def _calc_next(self) -> None:
+    def _calc_next(self, *, raise_on_error: bool = False) -> None:
+        """计算下次运行时间。
+
+        raise_on_error=True 时非法 cron 抛 ValueError(构造期用);
+        否则仅告警并置 next_run=None(运行期容错)。
+        """
         try:
-            self.next_run = croniter(self.cron, datetime.now).get_next(datetime)
-        except Exception:
+            # 必须调用 datetime.now():传方法对象本身会让 croniter 在
+            # (start_time or now) 的算术里抛 TypeError,导致 next_run 永远为 None。
+            self.next_run = croniter(self.cron, datetime.now()).get_next(datetime)
+        except Exception as e:
             self.next_run = None
+            msg = (
+                f"任务 {self.task_id!r} 的 cron 表达式非法: {self.cron!r} ({e})。"
+                "注意: 此处应为 cron 表达式(如 '0 8 * * *'),不是任务类型名。"
+            )
+            if raise_on_error:
+                raise ValueError(msg) from e
+            logger.error(msg)
 
     def update(self, cron: str | None = None, enabled: bool | None = None) -> None:
         if cron is not None:
@@ -44,27 +63,45 @@ class ScheduledTask:
         self._calc_next()
 
     async def _run_loop(self) -> None:
+        """任务运行循环。
+
+        睡眠策略: 使用固定的短 tick(SLEEP_TICK 秒)轮询 next_run,而不是
+        一次性 sleep 到 next_run。原因是运行期可通过 API 更新 cron / 手动
+        调整 next_run;若按 wait_seconds 长时间沉睡,变更最长要等
+        wait_seconds 才生效(实测可达 60s),表现为「改了不生效」。
+        """
         while True:
-            if not self.enabled or not self.next_run:
-                await asyncio.sleep(60)
-                self._calc_next()
-                continue
-
-            now = datetime.now()
-            wait_seconds = (self.next_run - now).total_seconds()
-            if wait_seconds > 0:
-                await asyncio.sleep(min(wait_seconds, 60))
-                continue
-
-            # 执行任务
-            self.last_run = datetime.now()
-            self._calc_next()
             try:
-                logger.info("定时任务触发: %s (cron=%s)", self.task_id, self.cron)
-                await self.fn()
-                logger.info("定时任务完成: %s", self.task_id)
+                if not self.enabled or not self.next_run:
+                    await asyncio.sleep(self.SLEEP_TICK)
+                    self._calc_next()
+                    continue
+
+                now = datetime.now()
+                wait_seconds = (self.next_run - now).total_seconds()
+                if wait_seconds > 0:
+                    # 短 tick 轮询,保证 next_run/cron 变更能及时被感知
+                    await asyncio.sleep(min(wait_seconds, self.SLEEP_TICK))
+                    continue
+
+                # 执行任务:先推进 next_run 再执行,避免任务耗时导致重复触发
+                self.last_run = datetime.now()
+                self._calc_next()
+                try:
+                    logger.info("定时任务触发: %s (cron=%s)", self.task_id, self.cron)
+                    await self.fn()
+                    logger.info("定时任务完成: %s", self.task_id)
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    # 单个任务失败不能终止循环,否则一次异常即永久停摆
+                    logger.exception("定时任务失败: %s", self.task_id)
+            except asyncio.CancelledError:
+                raise
             except Exception:
-                logger.exception("定时任务失败: %s", self.task_id)
+                # 循环体自身的意外异常(如 _calc_next)也不能终止调度
+                logger.exception("调度循环异常: %s", self.task_id)
+                await asyncio.sleep(self.SLEEP_TICK)
 
 
 class DataQualityScheduler:
@@ -152,6 +189,7 @@ class Scheduler:
 
     def __init__(self) -> None:
         self._tasks: dict[str, ScheduledTask] = {}
+        self._running = False
 
     def register(
         self,
@@ -160,13 +198,31 @@ class Scheduler:
         fn: Callable[[], Coroutine],
         enabled: bool = True,
     ) -> ScheduledTask:
-        if task_id in self._tasks:
-            self._tasks[task_id].update(cron=cron, enabled=enabled)
-            return self._tasks[task_id]
-        task = ScheduledTask(task_id, cron, fn, enabled)
-        self._tasks[task_id] = task
+        """注册(或更新)一个定时任务。
+
+        若调度器已 start,新任务会立即启动其运行循环 ——
+        否则运行期通过 API 新建的任务永远不会被执行(全量审查 C1 缺陷 2)。
+        """
+        existing = self._tasks.get(task_id)
+        if existing is not None:
+            existing.update(cron=cron, enabled=enabled)
+            # 更新 cron 后重新校验:改坏了要立刻报错,而不是静默失活
+            existing._calc_next(raise_on_error=True)
+            existing.fn = fn
+            task = existing
+        else:
+            task = ScheduledTask(task_id, cron, fn, enabled)
+            self._tasks[task_id] = task
+
+        if self._running:
+            self._ensure_loop(task)
         return task
 
+    def _ensure_loop(self, task: ScheduledTask) -> None:
+        """为任务启动运行循环(幂等:已在运行则跳过)。"""
+        if task._task is None or task._task.done():
+            task._task = asyncio.create_task(task._run_loop())
+
     def get(self, task_id: str) -> ScheduledTask | None:
         return self._tasks.get(task_id)
 
@@ -174,14 +230,18 @@ class Scheduler:
         return list(self._tasks.values())
 
     def remove(self, task_id: str) -> None:
-        self._tasks.pop(task_id, None)
+        task = self._tasks.pop(task_id, None)
+        if task is not None and task._task is not None:
+            task._task.cancel()
 
     async def start(self) -> None:
+        self._running = True
         for task in self._tasks.values():
-            task._task = asyncio.create_task(task._run_loop())
+            self._ensure_loop(task)
         logger.info("定时调度器已启动, 共 %d 个任务", len(self._tasks))
 
     async def stop(self) -> None:
+        self._running = False
         for task in self._tasks.values():
             if task._task:
                 task._task.cancel()