claude-nb 0.3.0

package/lib/concerns/coral_manager.py

@@ -0,0 +1,61 @@
+"""CoralManager — ensure dispatcher Claude session is running."""
+
+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
+
+
+class CoralManager(Concern):
+    interval = 5
+    BOOT_WAIT = 8
+    BOOT_GRACE = 120
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.boot_times: dict[str, int] = {}
+
+    def record_boot(self, name: str) -> None:
+        self.boot_times[name] = int(time.time())
+
+    def in_grace_period(self, name: str, now: int) -> bool:
+        bt = self.boot_times.get(name)
+        return bt is not None and (now - bt) < self.BOOT_GRACE
+
+    def tick(self, now: int) -> None:
+        dev_alive = any(is_claude_running(f"{self.cfg.prefix}-{s}") for s in self.cfg.dev_sessions)
+        if dev_alive and not is_suspended("dispatcher", self.cfg.suspended_file):
+            self._ensure()
+
+    def _ensure(self) -> None:
+        if is_claude_running(self.cfg.coral_sess):
+            return
+        log("Starting Coral...")
+        tmux("kill-session", "-t", self.cfg.coral_sess)
+        tmux("new-session", "-d", "-s", self.cfg.coral_sess, "-x", "200", "-y", "50")
+        tmux_send(self.cfg.coral_sess, f"cd '{self.cfg.project_root}'")
+        time.sleep(0.5)
+        tmux_send(
+            self.cfg.coral_sess,
+            "claude --name dispatcher --append-system-prompt "
+            "'你是 Coral。启动后运行 cat dispatcher-role.md，然后等指令。回复不超过3行。'",
+        )
+        self.record_boot("dispatcher")
+        log(f"Coral boot sent, waiting for Claude process (max {self.BOOT_WAIT}s)...")
+        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):
+                elapsed = self.BOOT_WAIT - (deadline - _time.monotonic())
+                log(f"Coral ready after {elapsed:.1f}s")
+                return
+            _time.sleep(1)
+        log(f"WARNING: Coral not ready after {self.BOOT_WAIT}s, will retry next tick")

package/lib/concerns/coral_poker.py

@@ -0,0 +1,57 @@
+"""CoralPoker — periodic heartbeat to dispatcher session."""
+
+import re
+import time
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import db, is_claude_running, log, pane_md5, tmux, tmux_ok, tmux_send
+
+
+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

@@ -0,0 +1,127 @@
+"""FileWatcher — kqueue-based instant inbox detection (background thread)."""
+
+import os
+import threading
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import log
+from .inbox_nudger import InboxNudger
+
+
+class FileWatcher(Concern):
+    interval = 1
+
+    def __init__(self, cfg: DispatcherConfig, inbox: InboxNudger) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.inbox = inbox
+        self._queue: list[str] = []
+        self._lock = threading.Lock()
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> bool:
+        try:
+            import select as sel
+
+            if not hasattr(sel, "kqueue"):
+                log("kqueue unavailable, using polling only")
+                return False
+        except ImportError:
+            return False
+        self._thread = threading.Thread(target=self._loop, daemon=True, name="file-watcher")
+        self._thread.start()
+        log("File watcher thread started")
+        return True
+
+    def _loop(self) -> None:
+        import select as sel
+
+        kq = sel.kqueue()
+        watch_dir = str(self.cfg.sessions_dir)
+        dir_fd = os.open(watch_dir, os.O_RDONLY)
+        kq.control(
+            [
+                sel.kevent(
+                    dir_fd,
+                    filter=sel.KQ_FILTER_VNODE,
+                    flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
+                    fflags=sel.KQ_NOTE_WRITE,
+                )
+            ],
+            0,
+        )
+        file_fds: dict[str, int] = {}
+
+        def refresh() -> None:
+            for f in os.listdir(watch_dir):
+                if not f.endswith(".md"):
+                    continue
+                path = os.path.join(watch_dir, f)
+                if path in file_fds:
+                    continue
+                try:
+                    fd = os.open(path, os.O_RDONLY)
+                    kq.control(
+                        [
+                            sel.kevent(
+                                fd,
+                                filter=sel.KQ_FILTER_VNODE,
+                                flags=sel.KQ_EV_ADD | sel.KQ_EV_CLEAR,
+                                fflags=sel.KQ_NOTE_WRITE | sel.KQ_NOTE_EXTEND,
+                            )
+                        ],
+                        0,
+                    )
+                    file_fds[path] = fd
+                except OSError:
+                    pass
+
+        refresh()
+        while not self._stop.is_set():
+            fd_to_path = {fd: p for p, fd in file_fds.items()}
+            try:
+                events = kq.control(None, 8, 2.0)
+            except (InterruptedError, OSError):
+                if self._stop.is_set():
+                    break
+                continue
+            if not events:
+                refresh()
+                continue
+            changed: set[str] = set()
+            for ev in events:
+                if ev.ident == dir_fd:
+                    refresh()
+                elif ev.ident in fd_to_path:
+                    changed.add(os.path.basename(fd_to_path[ev.ident]).replace(".md", ""))
+            if changed:
+                with self._lock:
+                    self._queue.extend(changed)
+
+        for fd in file_fds.values():
+            try:
+                os.close(fd)
+            except OSError:
+                pass
+        try:
+            os.close(dir_fd)
+        except OSError:
+            pass
+        kq.close()
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5)
+
+    def tick(self, now: int) -> None:
+        with self._lock:
+            names = list(self._queue)
+            self._queue.clear()
+        for name in names:
+            if not is_suspended(name, self.cfg.suspended_file):
+                self.inbox.nudge_if_unread(name)

package/lib/concerns/health_checker.py

@@ -0,0 +1,72 @@
+"""HealthChecker — periodic status report + team idle detection."""
+
+import time
+
+from lib.common import date_to_epoch, is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral_manager import CoralManager
+from .coral_poker import CoralPoker
+from .helpers import board_send, db, get_dev_sessions, is_claude_running, log, tmux_ok
+
+
+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

package/lib/concerns/helpers.py

@@ -0,0 +1,152 @@
+"""Shared helper functions for dispatcher concerns (tmux, board, etc.)."""
+
+import hashlib
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from lib.board_db import BoardDB
+
+from .config import DispatcherConfig
+
+# ── logging ──
+
+
+def log(msg: str) -> None:
+    print(f"[dispatcher] {time.strftime('%H:%M:%S')} {msg}", flush=True)
+
+
+def warn(msg: str) -> None:
+    print(f"[dispatcher] {time.strftime('%H:%M:%S')} WARN {msg}", flush=True, file=sys.stderr)
+
+
+# ── tmux ──
+
+TMUX_TIMEOUT = 8  # seconds
+
+
+def tmux(*args: str) -> str | None:
+    try:
+        r = subprocess.run(["tmux", *args], capture_output=True, text=True, timeout=TMUX_TIMEOUT)
+        return r.stdout.strip() if r.returncode == 0 else None
+    except (subprocess.TimeoutExpired, OSError) as e:
+        warn(f"tmux {' '.join(args)}: {e}")
+        return None
+
+
+def tmux_ok(*args: str) -> bool:
+    try:
+        return subprocess.run(["tmux", *args], capture_output=True, timeout=TMUX_TIMEOUT).returncode == 0
+    except (subprocess.TimeoutExpired, OSError) as e:
+        warn(f"tmux_ok {' '.join(args)}: {e}")
+        return False
+
+
+def tmux_send(sess: str, text: str) -> bool:
+    """Send keys to a tmux session. Returns True on success."""
+    try:
+        subprocess.run(["tmux", "send-keys", "-t", sess, "-l", text], timeout=TMUX_TIMEOUT, check=True)
+        subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], timeout=TMUX_TIMEOUT, check=True)
+        return True
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError) as e:
+        warn(f"tmux_send {sess}: {e}")
+        return False
+
+
+def is_claude_running(sess: str) -> bool:
+    if not tmux_ok("has-session", "-t", sess):
+        return False
+    cmd = tmux("list-panes", "-t", sess, "-F", "#{pane_current_command}")
+    if not cmd:
+        return False
+    first = cmd.splitlines()[0] if cmd else ""
+    return first not in ("zsh", "bash", "sh", "-zsh", "-bash", "")
+
+
+def get_dev_sessions(cfg: DispatcherConfig) -> list[str]:
+    raw = tmux("list-sessions", "-F", "#{session_name}")
+    if not raw:
+        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
+    ]
+
+
+def pane_md5(sess: str) -> str:
+    content = tmux("capture-pane", "-t", sess, "-p") or ""
+    return hashlib.md5(content.encode()).hexdigest()
+
+
+# ── board ──
+
+
+def board_send(cfg: DispatcherConfig, target: str, msg: str) -> None:
+    try:
+        subprocess.run(
+            [cfg.board_sh, "--as", "dispatcher", "send", target, msg],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError) as e:
+        warn(f"board_send {target}: {e}")
+
+
+_db_cache: dict[Path, BoardDB] = {}
+
+
+def db(cfg: DispatcherConfig) -> BoardDB:
+    if cfg.board_db not in _db_cache:
+        _db_cache[cfg.board_db] = BoardDB(cfg.board_db)
+    return _db_cache[cfg.board_db]
+
+
+# ── process inspection ──
+
+
+def has_tool_process(sess: str) -> bool:
+    """Check if Claude has spawned transient child processes (not caffeinate/uv)."""
+    pane_pid = tmux("display-message", "-t", sess, "-p", "#{pane_pid}")
+    if not pane_pid:
+        return False
+    try:
+        r = subprocess.run(
+            ["pgrep", "-P", pane_pid],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        claude_pid = (r.stdout.strip().splitlines() or [""])[0]
+        if not claude_pid:
+            return False
+        r2 = subprocess.run(
+            ["pgrep", "-P", claude_pid],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        for cpid in r2.stdout.strip().splitlines():
+            if not cpid:
+                continue
+            r3 = subprocess.run(
+                ["ps", "-p", cpid, "-o", "comm="],
+                capture_output=True,
+                text=True,
+                timeout=3,
+            )
+            name = r3.stdout.strip().rsplit("/", 1)[-1]
+            if name and name not in ("caffeinate", "uv", ""):
+                return True
+    except (subprocess.TimeoutExpired, OSError) as e:
+        warn(f"has_tool_process {sess}: {e}")
+    return False
+
+
+def is_pane_typing(sess: str) -> bool:
+    """Check if a pane has an active prompt with typing."""
+    content = tmux("capture-pane", "-t", sess, "-p") or ""
+    return any(l.startswith("❯ ") and len(l) > 3 for l in content.splitlines())

package/lib/concerns/idle_detector.py

@@ -0,0 +1,56 @@
+"""IdleDetector — batch screen snapshot comparison (non-blocking).
+
+Compares snapshots across consecutive ticks instead of sleeping mid-tick.
+"""
+
+import re
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import has_tool_process, pane_md5, tmux
+
+
+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)

package/lib/concerns/idle_killer.py

@@ -0,0 +1,41 @@
+"""IdleKiller — kill sessions idle >30min."""
+
+from .base import Concern
+from .config import DispatcherConfig
+from .coral_manager import CoralManager
+from .helpers import board_send, get_dev_sessions, is_claude_running, log, tmux, tmux_ok
+from .idle_detector import IdleDetector
+
+
+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)

package/lib/concerns/idle_nudger.py

@@ -0,0 +1,38 @@
+"""IdleNudger — nudge idle sessions to continue working."""
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import get_dev_sessions, is_claude_running, log, tmux_ok, tmux_send
+from .idle_detector import IdleDetector
+
+
+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/inbox_nudger.py

@@ -0,0 +1,34 @@
+"""InboxNudger — detect unread inboxes, nudge sessions."""
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import 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)

package/lib/concerns/resource_monitor.py

@@ -0,0 +1,47 @@
+"""ResourceMonitor — battery/memory/CPU."""
+
+from lib.resources import check_battery, check_cpu, check_memory
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import board_send, get_dev_sessions, is_claude_running, log, tmux_send
+
+
+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}%)")