claude-nb 0.3.0 → 0.4.0

package/lib/board_tui.py

@@ -0,0 +1,112 @@
+"""board_tui — tmux-native team UI with mouse support.
+
+Opens a single terminal window with tmux. Each worker is a window (tab).
+Mouse click on the tab bar to switch. That's it.
+"""
+
+import os
+import subprocess
+import sys
+
+from lib.board_db import BoardDB
+
+UI_SESSION = "cnb-ui"
+
+
+def _tmux(*args: str) -> int:
+    return subprocess.run(["tmux", *args], capture_output=True, text=True, timeout=5).returncode
+
+
+def _tmux_out(*args: str) -> str:
+    r = subprocess.run(["tmux", *args], capture_output=True, text=True, timeout=5)
+    return r.stdout.strip() if r.returncode == 0 else ""
+
+
+def _session_exists(name: str) -> bool:
+    return _tmux("has-session", "-t", name) == 0
+
+
+def cmd_tui(db: BoardDB) -> None:
+    """Open team UI: one tmux window per worker, mouse-clickable tabs."""
+    if not db.env:
+        print("ERROR: 需要完整环境才能启动 TUI")
+        raise SystemExit(1)
+
+    prefix = db.env.prefix
+    workers = [r[0] for r in db.query("SELECT name FROM sessions WHERE name != 'all' ORDER BY name")]
+
+    if not workers:
+        print("ERROR: 没有注册的 session")
+        raise SystemExit(1)
+
+    online = [w for w in workers if _session_exists(f"{prefix}-{w}")]
+    if not online:
+        print("ERROR: 没有在线的 worker，先运行 cnb swarm start")
+        raise SystemExit(1)
+
+    # Kill old UI session if exists
+    if _session_exists(UI_SESSION):
+        _tmux("kill-session", "-t", UI_SESSION)
+
+    # Create session grouped with first worker
+    _tmux("new-session", "-d", "-s", UI_SESSION, "-t", f"{prefix}-{online[0]}")
+
+    # Link remaining workers as windows
+    for name in online[1:]:
+        _tmux("link-window", "-s", f"{prefix}-{name}", "-t", UI_SESSION, "-a")
+
+    # Rename windows
+    win_indices = _tmux_out("list-windows", "-t", UI_SESSION, "-F", "#{window_index}").split("\n")
+    for i, name in enumerate(online):
+        if i < len(win_indices):
+            _tmux("rename-window", "-t", f"{UI_SESSION}:{win_indices[i]}", name)
+
+    # Mouse + clean visual config
+    opts = {
+        "mouse": "on",
+        "status": "on",
+        "status-position": "top",
+        "status-style": "bg=default,fg=white",
+        "status-left": " cnb ",
+        "status-left-style": "bold",
+        "status-left-length": "6",
+        "status-right": f" {len(online)} online ",
+        "status-right-style": "dim",
+        "window-status-format": " #W ",
+        "window-status-current-format": " #W ",
+        "window-status-style": "dim",
+        "window-status-current-style": "bold,underscore",
+        "window-status-separator": "",
+    }
+    for k, v in opts.items():
+        _tmux("set-option", "-t", UI_SESSION, k, v)
+
+    # Open in new terminal window
+    _open_terminal()
+
+
+def _open_terminal() -> None:
+    """Open a new terminal window attached to cnb-ui."""
+    attach_cmd = f"tmux attach -t {UI_SESSION}"
+
+    if sys.platform == "darwin":
+        if os.path.isdir("/Applications/iTerm.app"):
+            script = (
+                'tell application "iTerm"\n'
+                "  activate\n"
+                f'  create window with default profile command "{attach_cmd}"\n'
+                "end tell"
+            )
+        else:
+            script = f'tell application "Terminal"\n  do script "{attach_cmd}"\n  activate\nend tell'
+        subprocess.run(["osascript", "-e", script], capture_output=True)
+        print("OK 已打开 — 点击顶部 tab 切换同学")
+    else:
+        import shutil
+
+        for term in ("gnome-terminal", "xterm", "konsole", "alacritty"):
+            if shutil.which(term):
+                subprocess.Popen([term, "--", "bash", "-c", attach_cmd])
+                print("OK 已打开 — 点击顶部 tab 切换同学")
+                return
+        print(f"运行: {attach_cmd}")

package/lib/board_view.py

@@ -15,6 +15,7 @@ def _git(project_root: Path, *args: str) -> str:
         ["git", "-C", str(project_root), *args],
         capture_output=True,
         text=True,
+        timeout=5,
     )
     return r.stdout
 
@@ -40,16 +41,6 @@ def _tmux_pane_command(name: str) -> str:
         return ""
 
 
-def _pgrep(pattern: str) -> str | None:
-    try:
-        r = subprocess.run(["pgrep", "-f", pattern], capture_output=True, text=True, timeout=3)
-        if r.returncode == 0:
-            return r.stdout.strip().split("\n")[0]
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        pass
-    return None
-
-
 def cmd_overview(db: BoardDB) -> None:
     """Default view when running cnb with no args."""
     prefix = db.env.prefix
@@ -80,10 +71,7 @@ def cmd_overview(db: BoardDB) -> None:
         print(line)
 
     # ── recent messages ──
-    rows = db.query(
-        "SELECT ts, sender, recipient, substr(body, 1, 80) "
-        "FROM messages ORDER BY id DESC LIMIT 5"
-    )
+    rows = db.query("SELECT ts, sender, recipient, substr(body, 1, 80) FROM messages ORDER BY id DESC LIMIT 5")
     if rows:
         print()
         print("Recent:")
@@ -91,20 +79,20 @@ def cmd_overview(db: BoardDB) -> None:
             print(f"  [{ts_val}] {sender} → {recipient}: {body}")
 
     # ── open proposals ──
-    proposals = db.query(
-        "SELECT number || '-' || slug FROM proposals WHERE status='OPEN'"
-    )
+    proposals = db.query("SELECT number || '-' || slug FROM proposals WHERE status='OPEN'")
     if proposals:
         print()
         print(f"Open proposals: {len(proposals)}")
 
     # ── dispatcher ──
-    pid = _pgrep("dispatcher")
+    dispatcher_sess = f"{prefix}-dispatcher"
     print()
-    if pid:
-        print(f"  dispatcher: running (pid {pid})")
+    if _tmux_has_session(dispatcher_sess):
+        print(f"  dispatcher: running ({dispatcher_sess})")
     else:
-        running = any(_tmux_has_session(f"{prefix}-{n}") for (n,) in db.query("SELECT name FROM sessions WHERE name != 'all'"))
+        running = any(
+            _tmux_has_session(f"{prefix}-{n}") for (n,) in db.query("SELECT name FROM sessions WHERE name != 'all'")
+        )
         if running:
             print("  dispatcher: NOT RUNNING — run: cnb dispatcher")
         else:
@@ -258,9 +246,9 @@ def cmd_dashboard(db: BoardDB) -> None:
         print(f"  {name:<7s} {status:<8s}{inbox_str}")
         print(f"         {task}")
     print()
-    pid = _pgrep("dispatcher")
-    if pid:
-        print(f"  dispatcher: running (PID {pid})")
+    dispatcher_sess = f"{prefix}-dispatcher"
+    if _tmux_has_session(dispatcher_sess):
+        print(f"  dispatcher: running ({dispatcher_sess})")
     else:
         print("  dispatcher: NOT RUNNING")
 

package/lib/concerns/__init__.py

@@ -5,20 +5,13 @@ Each concern is a self-contained module with its own check interval.
 
 from .adaptive_throttle import AdaptiveThrottle
 from .base import Concern
-from .bug_sla_checker import BugSLAChecker
 from .config import DispatcherConfig
-from .coral_manager import CoralManager
-from .coral_poker import CoralPoker
+from .coral import CoralManager, CoralPoker
 from .file_watcher import FileWatcher
-from .health_checker import HealthChecker
+from .health import HealthChecker, ResourceMonitor, SessionKeepAlive
 from .helpers import log, tmux_ok, warn
-from .idle_detector import IdleDetector
-from .idle_killer import IdleKiller
-from .idle_nudger import IdleNudger
-from .inbox_nudger import InboxNudger
-from .resource_monitor import ResourceMonitor
-from .session_keepalive import SessionKeepAlive
-from .time_announcer import TimeAnnouncer
+from .idle import IdleDetector, IdleKiller, IdleNudger
+from .notifications import BugSLAChecker, InboxNudger, TimeAnnouncer
 
 __all__ = [
     "AdaptiveThrottle",

package/lib/concerns/{coral_manager.py → coral.py}

@@ -1,12 +1,13 @@
-"""CoralManager — ensure dispatcher Claude session is running."""
+"""Coral: dispatcher session lifecycle management and heartbeat."""
 
+import re
 import time
 
 from lib.common import is_suspended
 
 from .base import Concern
 from .config import DispatcherConfig
-from .helpers import is_claude_running, log, tmux, tmux_send
+from .helpers import db, is_claude_running, log, pane_md5, tmux, tmux_ok, tmux_send
 
 
 class CoralManager(Concern):
@@ -49,8 +50,8 @@ class CoralManager(Concern):
         self._wait_until_ready()
 
     def _wait_until_ready(self) -> None:
-        """Poll until the Claude process is running, or timeout after BOOT_WAIT."""
         import time as _time
+
         deadline = _time.monotonic() + self.BOOT_WAIT
         while _time.monotonic() < deadline:
             if is_claude_running(self.cfg.coral_sess):
@@ -59,3 +60,52 @@ class CoralManager(Concern):
                 return
             _time.sleep(1)
         log(f"WARNING: Coral not ready after {self.BOOT_WAIT}s, will retry next tick")
+
+
+class CoralPoker(Concern):
+    interval = 120
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_poke: int = int(time.time())
+
+    def poke(self, msg: str) -> bool:
+        if not tmux_ok("has-session", "-t", self.cfg.coral_sess) or not is_claude_running(self.cfg.coral_sess):
+            return False
+
+        content = tmux("capture-pane", "-t", self.cfg.coral_sess, "-p") or ""
+        prompts = [l for l in content.splitlines() if l.startswith("❯")]
+        if prompts and re.match(r"^❯ .{3,}", prompts[-1]):
+            log("Coral: skip (typing)")
+            return False
+
+        h1 = pane_md5(self.cfg.coral_sess)
+        time.sleep(1)
+        if h1 != pane_md5(self.cfg.coral_sess):
+            log("Coral: skip (busy)")
+            return False
+
+        log("Coral: poking")
+        tmux_send(self.cfg.coral_sess, msg)
+        self.last_poke = int(time.time())
+        return True
+
+    def tick(self, now: int) -> None:
+        unread = 0
+        if self.cfg.board_db.exists():
+            try:
+                unread = (
+                    db(self.cfg).scalar(
+                        "SELECT COUNT(*) FROM inbox WHERE session=? AND read=0",
+                        (self.cfg.dispatcher_session,),
+                    )
+                    or 0
+                )
+            except Exception:
+                pass
+
+        if unread > 0:
+            self.poke(f"[Dispatcher] 你有 {unread} 条未读消息")
+        elif (now - self.last_poke) >= self.interval:
+            self.poke(f"[Dispatcher] heartbeat {time.strftime('%H:%M:%S')}")

package/lib/concerns/file_watcher.py

@@ -8,7 +8,7 @@ from lib.common import is_suspended
 from .base import Concern
 from .config import DispatcherConfig
 from .helpers import log
-from .inbox_nudger import InboxNudger
+from .notifications import InboxNudger
 
 
 class FileWatcher(Concern):

package/lib/concerns/health.py

@@ -0,0 +1,136 @@
+"""Health monitoring: session keepalive, periodic health checks, resource monitoring."""
+
+import time
+
+from lib.common import date_to_epoch, is_suspended
+from lib.resources import check_battery, check_cpu, check_memory
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralManager, CoralPoker
+from .helpers import (
+    board_send,
+    db,
+    get_dev_sessions,
+    is_claude_running,
+    log,
+    tmux_ok,
+    tmux_send,
+)
+
+
+class SessionKeepAlive(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if tmux_ok("has-session", "-t", sess) and not is_claude_running(sess):
+                log(f"{name}: agent exited, NOT restarting (idle policy)")
+
+
+class HealthChecker(Concern):
+    INITIAL = 600
+    MAX = 3600
+    IDLE_THRESHOLD = 1800
+
+    def __init__(self, cfg: DispatcherConfig, poker: CoralPoker, coral: CoralManager) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.interval = self.INITIAL
+        self.poker = poker
+        self.coral = coral
+        self.last_idle_alert: int = 0
+
+    def tick(self, now: int) -> None:
+        parts = []
+        for name in get_dev_sessions(self.cfg):
+            on = "on" if tmux_ok("has-session", "-t", f"{self.cfg.prefix}-{name}") else "off"
+            parts.append(f"{name}:{on}")
+        status = " ".join(parts)
+
+        log(f"Health check (interval:{self.interval}s): {status}")
+        self.poker.poke(f"[Dispatcher] 健康巡检 {time.strftime('%H:%M:%S')}: {status}")
+        self.interval = min(self.interval * 2, self.MAX)
+        self._check_team_idle(now)
+
+    def _check_team_idle(self, now: int) -> None:
+        if not self.cfg.board_db.exists():
+            return
+        idle_list: list[str] = []
+        total = 0
+        d = db(self.cfg)
+
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                continue
+            if self.coral.in_grace_period(name, now):
+                continue
+
+            total += 1
+            try:
+                updated = d.scalar("SELECT updated_at FROM sessions WHERE name=?", (name,)) or ""
+            except Exception:
+                continue
+            if updated:
+                age = now - date_to_epoch(updated)
+                if age > self.IDLE_THRESHOLD:
+                    idle_list.append(f"{name}({age}s)")
+
+        if idle_list and len(idle_list) == total and (now - self.last_idle_alert) > 3600:
+            log(f"All sessions idle: {' '.join(idle_list)}")
+            board_send(
+                self.cfg,
+                "lead",
+                f"[Dispatcher] 全员空闲超过 {self.IDLE_THRESHOLD // 60} 分钟:{' '.join(idle_list)}。可能需要分配工作。",
+            )
+            self.last_idle_alert = now
+
+
+class ResourceMonitor(Concern):
+    interval = 60
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_state = ""
+
+    def tick(self, now: int) -> None:
+        batt = check_battery()
+        mem = check_memory()
+        cpu = check_cpu()
+
+        state = f"{batt.status}|{batt.pct}|{mem.status}|{mem.pressure}|{cpu.status}|{cpu.usage}"
+        if state == self.last_state:
+            return
+        self.last_state = state
+
+        if batt.status == "CRITICAL":
+            log(f"RESOURCE: Battery CRITICAL ({batt.pct}%)")
+            board_send(self.cfg, "All", f"[Resource] 电池严重不足 ({batt.pct}%)，暂停非关键 session。")
+            for name in get_dev_sessions(self.cfg):
+                sess = f"{self.cfg.prefix}-{name}"
+                if is_claude_running(sess):
+                    tmux_send(sess, "[系统] 电池严重不足，请立即保存状态。")
+        elif batt.status == "LOW":
+            log(f"RESOURCE: Battery LOW ({batt.pct}%)")
+            board_send(self.cfg, "All", f"[Resource] 电池低 ({batt.pct}%)，建议减少活跃 session 到 2-3 个。")
+
+        if mem.status == "CRITICAL":
+            log("RESOURCE: Memory pressure CRITICAL")
+            board_send(self.cfg, "All", "[Resource] 内存压力严重！建议重启最大的 session 释放内存。")
+        elif mem.status == "WARNING":
+            log("RESOURCE: Memory pressure WARNING")
+            board_send(self.cfg, "All", "[Resource] 内存压力升高，关注中。")
+
+        if cpu.status == "SATURATED":
+            log(f"RESOURCE: CPU saturated ({cpu.usage}%)")

package/lib/concerns/helpers.py

@@ -70,11 +70,7 @@ def get_dev_sessions(cfg: DispatcherConfig) -> list[str]:
         return []
     pfx = f"{cfg.prefix}-"
     protected = {"dispatcher", "lead"}
-    return [
-        line[len(pfx) :]
-        for line in raw.splitlines()
-        if line.startswith(pfx) and line[len(pfx) :] not in protected
-    ]
+    return [line[len(pfx) :] for line in raw.splitlines() if line.startswith(pfx) and line[len(pfx) :] not in protected]
 
 
 def pane_md5(sess: str) -> str:

package/lib/concerns/idle.py

@@ -0,0 +1,130 @@
+"""Idle detection, nudging, and killing for dispatcher sessions."""
+
+import re
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralManager
+from .helpers import (
+    board_send,
+    get_dev_sessions,
+    has_tool_process,
+    is_claude_running,
+    log,
+    pane_md5,
+    tmux,
+    tmux_ok,
+    tmux_send,
+)
+
+
+class IdleDetector(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.cache: dict[str, str] = {}  # sess -> "idle" | "busy"
+        self._prev_snap: dict[str, str] = {}  # sess -> md5 from previous tick
+
+    def is_idle(self, sess: str) -> bool:
+        return self.cache.get(sess) == "idle"
+
+    def tick(self, now: int) -> None:
+        self.cache.clear()
+        raw = tmux("list-sessions", "-F", "#{session_name}")
+        if not raw:
+            self._prev_snap.clear()
+            return
+
+        all_sessions = [s for s in raw.splitlines() if s.startswith(f"{self.cfg.prefix}-")]
+        need_snapshot: list[str] = []
+
+        for sess in all_sessions:
+            pane = tmux("capture-pane", "-t", sess, "-p") or ""
+            prompts = [l for l in pane.splitlines() if l.startswith("❯")]
+            if prompts and re.match(r"^❯ .{3,}", prompts[-1]):
+                self.cache[sess] = "busy"
+                continue
+            if has_tool_process(sess):
+                self.cache[sess] = "busy"
+                continue
+            need_snapshot.append(sess)
+
+        current_snap: dict[str, str] = {}
+        for sess in need_snapshot:
+            md5 = pane_md5(sess)
+            current_snap[sess] = md5
+            if sess in self._prev_snap and self._prev_snap[sess] == md5:
+                self.cache[sess] = "idle"
+            else:
+                self.cache[sess] = "busy"
+
+        self._prev_snap = {s: pane_md5(s) for s in all_sessions if s not in self.cache or self.cache[s] != "busy"}
+        self._prev_snap.update(current_snap)
+
+
+class IdleKiller(Concern):
+    interval = 5
+    THRESHOLD = 1800
+
+    def __init__(self, cfg: DispatcherConfig, idle: IdleDetector, coral: CoralManager) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self.coral = coral
+        self.idle_since: dict[str, int] = {}
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                self.idle_since.pop(name, None)
+                continue
+
+            if name not in self.coral.boot_times:
+                self.coral.record_boot(name)
+            if self.coral.in_grace_period(name, now):
+                continue
+
+            if self.idle.is_idle(sess):
+                since = self.idle_since.setdefault(name, now)
+                if (now - since) >= self.THRESHOLD:
+                    log(f"{name}: idle {now - since}s (>30min), killing session")
+                    tmux("kill-session", "-t", sess)
+                    self.idle_since.pop(name, None)
+                    board_send(self.cfg, "All", f"[Dispatcher] {name} 闲置超过 30 分钟，已终止。")
+            else:
+                self.idle_since.pop(name, None)
+
+
+class IdleNudger(Concern):
+    interval = 5
+    COOLDOWN = 300
+
+    def __init__(self, cfg: DispatcherConfig, idle: IdleDetector) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self.last_nudge: dict[str, int] = {}
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+                continue
+            if not self.idle.is_idle(sess):
+                continue
+            if (now - self.last_nudge.get(name, 0)) < self.COOLDOWN:
+                continue
+
+            log(f"{name}: idle, nudging autonomous loop")
+            tmux_send(
+                sess,
+                f"继续工作。检查你的 OKR ({self.cfg.okr_dir}/{name}.md)，推进你的活跃 KR。自己决定优先级。",
+            )
+            self.last_nudge[name] = now

package/lib/concerns/notifications.py

@@ -0,0 +1,90 @@
+"""Notifications: inbox nudging, time announcements, bug SLA checks."""
+
+import subprocess
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral import CoralPoker
+from .helpers import board_send, db, get_dev_sessions, is_claude_running, log, tmux_ok, tmux_send
+
+
+class InboxNudger(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+
+    def nudge_if_unread(self, name: str) -> None:
+        if not self.cfg.board_db.exists():
+            return
+        try:
+            unread = db(self.cfg).scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,)) or 0
+        except Exception:
+            return
+        if unread <= 0:
+            return
+
+        sess = f"{self.cfg.prefix}-{name}"
+        if not tmux_ok("has-session", "-t", sess) or not is_claude_running(sess):
+            return
+
+        log(f"INBOX: {name} has {unread} unread -> nudging")
+        tmux_send(sess, f"./board --as {name} inbox")
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            self.nudge_if_unread(name)
+
+
+class TimeAnnouncer(Concern):
+    interval = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_hour = -1
+
+    def tick(self, now: int) -> None:
+        from datetime import datetime as dt
+
+        d = dt.now()
+        if d.minute != 0 or d.hour == self.last_hour:
+            return
+        self.last_hour = d.hour
+        ts = d.strftime("%Y-%m-%d %H:%M")
+
+        if d.hour == 9:
+            board_send(
+                self.cfg,
+                "All",
+                f"[Clock] {ts} ({d.strftime('%A')}) — 新一天。检查 KR 列表，确认优先级。",
+            )
+            log("Daily announcement sent")
+        else:
+            board_send(self.cfg, "All", f"[Clock] 现在是 {ts}。")
+            log(f"Hourly announcement: {d.hour}:00")
+
+
+class BugSLAChecker(Concern):
+    interval = 600
+
+    def __init__(self, cfg: DispatcherConfig, poker: CoralPoker) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.poker = poker
+
+    def tick(self, now: int) -> None:
+        try:
+            r = subprocess.run(
+                [self.cfg.board_sh, "bug", "overdue"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            overdue = r.stdout.strip()
+        except Exception:
+            return
+        if overdue and "No overdue" not in overdue:
+            log(f"Bug SLA alert: {overdue}")
+            self.poker.poke(f"[Dispatcher] Bug SLA 超时: {overdue}")

package/lib/migrate.py

@@ -83,6 +83,7 @@ def run_migrations(db_path: Path, claudes_home: Path) -> int:
 # CLI
 # ---------------------------------------------------------------------------
 
+
 def main() -> None:
     """Run pending migrations. Called from init and doctor."""
     # Resolve CLAUDES_HOME relative to this file