claude-nb 0.3.0 → 0.4.0

package/lib/swarm_backend.py

@@ -0,0 +1,266 @@
+"""swarm_backend — terminal multiplexer backends (tmux, screen)."""
+
+import os
+import re
+import shutil
+import subprocess
+import time
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class SessionBackend(ABC):
+    """Abstract base for terminal multiplexer backends."""
+
+    @abstractmethod
+    def is_running(self, prefix: str, name: str) -> bool: ...
+
+    @abstractmethod
+    def start_session(
+        self,
+        prefix: str,
+        name: str,
+        project_root: Path,
+        agent_cmd: str,
+    ) -> str: ...
+
+    @abstractmethod
+    def stop_session(self, prefix: str, name: str, save_cmd: str) -> None: ...
+
+    @abstractmethod
+    def status_line(self, prefix: str, name: str, agent: str) -> str: ...
+
+    @abstractmethod
+    def attach(self, prefix: str, name: str) -> None: ...
+
+    @abstractmethod
+    def inject(self, prefix: str, name: str, message: str) -> None: ...
+
+    @abstractmethod
+    def capture_pane(self, prefix: str, name: str) -> str: ...
+
+
+class TmuxBackend(SessionBackend):
+    def _sess(self, prefix: str, name: str) -> str:
+        return f"{prefix}-{name}"
+
+    def is_running(self, prefix: str, name: str) -> bool:
+        r = subprocess.run(
+            ["tmux", "has-session", "-t", self._sess(prefix, name)],
+            capture_output=True,
+            timeout=5,
+        )
+        return r.returncode == 0
+
+    def capture_pane(self, prefix: str, name: str) -> str:
+        r = subprocess.run(
+            ["tmux", "capture-pane", "-t", self._sess(prefix, name), "-p"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return r.stdout if r.returncode == 0 else ""
+
+    def wait_for_shell(self, prefix: str, name: str, timeout: int = 15) -> bool:
+        waited = 0
+        while waited < timeout:
+            text = self.capture_pane(prefix, name)
+            if "$" in text or "%" in text or "❯" in text:
+                return True
+            time.sleep(1)
+            waited += 1
+        return False
+
+    def wait_for_prompt(self, prefix: str, name: str, timeout: int = 60) -> bool:
+        waited = 0
+        while waited < timeout:
+            text = self.capture_pane(prefix, name)
+            if "❯" in text:
+                return True
+            time.sleep(2)
+            waited += 2
+        return False
+
+    def auto_accept_trust(self, prefix: str, name: str) -> None:
+        sess = self._sess(prefix, name)
+        waited = 0
+        while waited < 60:
+            r = subprocess.run(
+                ["tmux", "capture-pane", "-t", sess, "-p"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if "I trust" in r.stdout or "trust this folder" in r.stdout.lower():
+                time.sleep(0.5)
+                subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"])
+                return
+            time.sleep(2)
+            waited += 2
+
+    def start_session(
+        self,
+        prefix: str,
+        name: str,
+        project_root: Path,
+        agent_cmd: str,
+    ) -> str:
+        sess = self._sess(prefix, name)
+        subprocess.run(["tmux", "new-session", "-d", "-s", sess, "-x", "200", "-y", "50"])
+        self.wait_for_shell(prefix, name, timeout=10)
+        subprocess.run(
+            [
+                "tmux",
+                "send-keys",
+                "-t",
+                sess,
+                f"source ~/.zprofile 2>/dev/null; source ~/.zshrc 2>/dev/null; cd '{project_root}'",
+                "Enter",
+            ]
+        )
+        self.wait_for_shell(prefix, name, timeout=10)
+        subprocess.run(["tmux", "send-keys", "-t", sess, agent_cmd, "Enter"])
+        return sess
+
+    def stop_session(self, prefix: str, name: str, save_cmd: str) -> None:
+        sess = self._sess(prefix, name)
+        subprocess.run(["tmux", "send-keys", "-t", sess, "C-c"])
+        time.sleep(1)
+        subprocess.run(["tmux", "send-keys", "-t", sess, f"! {save_cmd}", "Enter"])
+        time.sleep(3)
+        subprocess.run(["tmux", "send-keys", "-t", sess, "/exit", "Enter"])
+
+        waited = 0
+        while self.is_running(prefix, name) and waited < 15:
+            time.sleep(1)
+            waited += 1
+        if self.is_running(prefix, name):
+            subprocess.run(["tmux", "kill-session", "-t", sess])
+            print(f"  {name}: force killed (after {waited}s)")
+        else:
+            print(f"  {name}: exited gracefully")
+
+    def status_line(self, prefix: str, name: str, agent: str) -> str:
+        return f"running (tmux, agent: {agent})"
+
+    def attach(self, prefix: str, name: str) -> None:
+        os.execvp("tmux", ["tmux", "attach-session", "-t", self._sess(prefix, name)])
+
+    def inject(self, prefix: str, name: str, message: str) -> None:
+        sess = self._sess(prefix, name)
+        if not self.is_running(prefix, name):
+            print(f"  {name}: not running")
+            raise SystemExit(1)
+        oneline = message.replace("\n", " ")
+        subprocess.run(["tmux", "send-keys", "-t", sess, "-l", oneline])
+        subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"])
+        print(f"  {name}: injected")
+
+    def inject_initial_prompt(self, prefix: str, name: str, prompt: str, log_dir: Path) -> None:
+        if self.wait_for_prompt(prefix, name, timeout=60):
+            sess = self._sess(prefix, name)
+            time.sleep(1)
+            subprocess.run(["tmux", "send-keys", "-t", sess, "-l", prompt])
+            subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"])
+        else:
+            with open(log_dir / f"{name}.log", "a") as f:
+                f.write(f"[WARN] {name}: prompt not detected after 60s, skipping injection\n")
+
+    def enable_mouse(self) -> None:
+        subprocess.run(["tmux", "set", "-g", "mouse", "on"], capture_output=True)
+
+
+class ScreenBackend(SessionBackend):
+    def _sess(self, prefix: str, name: str) -> str:
+        return f"{prefix}-{name}"
+
+    def is_running(self, prefix: str, name: str) -> bool:
+        sess_tag = f".{self._sess(prefix, name)}"
+        r = subprocess.run(["screen", "-list"], capture_output=True, text=True, timeout=5)
+        output = r.stdout + r.stderr
+        return bool(re.search(rf"{re.escape(sess_tag)}\s", output))
+
+    def capture_pane(self, prefix: str, name: str) -> str:
+        return ""
+
+    def start_session(
+        self,
+        prefix: str,
+        name: str,
+        project_root: Path,
+        agent_cmd: str,
+    ) -> str:
+        sess = self._sess(prefix, name)
+        subprocess.run(["screen", "-dmS", sess])
+        time.sleep(1)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", f"cd '{project_root}'"])
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
+        time.sleep(0.5)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", agent_cmd])
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
+        return sess
+
+    def stop_session(self, prefix: str, name: str, save_cmd: str) -> None:
+        sess = self._sess(prefix, name)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\x03"])
+        time.sleep(1)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", f"! {save_cmd}\r"])
+        time.sleep(3)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "/exit\r"])
+
+        waited = 0
+        while self.is_running(prefix, name) and waited < 15:
+            time.sleep(1)
+            waited += 1
+        if self.is_running(prefix, name):
+            subprocess.run(["screen", "-S", sess, "-X", "quit"])
+            print(f"  {name}: force killed (after {waited}s)")
+        else:
+            print(f"  {name}: exited gracefully")
+
+    def status_line(self, prefix: str, name: str, agent: str) -> str:
+        r = subprocess.run(["screen", "-list"], capture_output=True, text=True, timeout=5)
+        output = r.stdout + r.stderr
+        state = ""
+        for line in output.splitlines():
+            if f".{self._sess(prefix, name)}" in line:
+                parts = line.strip().split()
+                if parts:
+                    state = parts[-1]
+                break
+        return f"running (screen, agent: {agent}) {state}"
+
+    def attach(self, prefix: str, name: str) -> None:
+        os.execvp("screen", ["screen", "-r", self._sess(prefix, name)])
+
+    def inject(self, prefix: str, name: str, message: str) -> None:
+        sess = self._sess(prefix, name)
+        if not self.is_running(prefix, name):
+            print(f"  {name}: not running")
+            raise SystemExit(1)
+        oneline = message.replace("\n", " ")
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", oneline])
+        time.sleep(0.3)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
+        print(f"  {name}: injected")
+
+    def inject_initial_prompt(self, prefix: str, name: str, prompt: str, log_dir: Path) -> None:
+        time.sleep(3)
+        sess = self._sess(prefix, name)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", prompt])
+        time.sleep(0.3)
+        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
+
+
+def detect_backend() -> SessionBackend:
+    override = os.environ.get("SWARM_MODE", "")
+    if override == "tmux":
+        return TmuxBackend()
+    if override == "screen":
+        return ScreenBackend()
+    if shutil.which("tmux"):
+        return TmuxBackend()
+    if shutil.which("screen"):
+        return ScreenBackend()
+    print("ERROR: neither tmux nor screen found. Install one: brew install tmux")
+    raise SystemExit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-nb",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Multi-agent coordination framework for Claude Code sessions",
   "bin": {
     "cnb": "./bin/cnb.js"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-nb"
-version = "0.3.0"
+version = "0.4.0"
 description = "Multi-agent coordination framework for Claude Code sessions"
 requires-python = ">=3.11"
 license = "OpenAll-1.0"

package/registry/pubkeys.json

@@ -1,5 +1,6 @@
 {
   "meridian": "3f9baebbfe2ddd36e0ccd6f98301fd1bdc57aa82f395791a769864078181c43c",
   "musk": "16e74dfbbd797fe17a8e44d99b71d207c8e3aa1b36ffbf2dfe88420dc54bf37c",
-  "lead": "51b6ebbbe720745bcb9386e1d997481bd265beac45d183fc2ac11fae9824c43a"
+  "lead": "51b6ebbbe720745bcb9386e1d997481bd265beac45d183fc2ac11fae9824c43a",
+  "sutskever": "e00b9ede0b97993105ec9f6f7ff40aebe545081534050d2d719623cf1f8fd946"
 }

package/lib/concerns/bug_sla_checker.py

@@ -1,32 +0,0 @@
-"""BugSLAChecker — check overdue bugs."""
-
-import subprocess
-
-from .base import Concern
-from .config import DispatcherConfig
-from .coral_poker import CoralPoker
-from .helpers import log
-
-
-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/concerns/coral_poker.py

@@ -1,57 +0,0 @@
-"""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/health_checker.py

@@ -1,72 +0,0 @@
-"""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/idle_detector.py

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

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

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

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

@@ -1,47 +0,0 @@
-"""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}%)")