claude-nb 0.4.0 → 0.5.1

package/lib/concerns/file_watcher.py

@@ -8,16 +8,16 @@ from lib.common import is_suspended
 from .base import Concern
 from .config import DispatcherConfig
 from .helpers import log
-from .notifications import InboxNudger
+from .nudge_coordinator import NudgeCoordinator
 
 
 class FileWatcher(Concern):
     interval = 1
 
-    def __init__(self, cfg: DispatcherConfig, inbox: InboxNudger) -> None:
+    def __init__(self, cfg: DispatcherConfig, nudge: NudgeCoordinator) -> None:
         super().__init__()
         self.cfg = cfg
-        self.inbox = inbox
+        self.nudge = nudge
         self._queue: list[str] = []
         self._lock = threading.Lock()
         self._stop = threading.Event()
@@ -41,77 +41,82 @@ class FileWatcher(Concern):
         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,
-        )
+        dir_fd = -1
         file_fds: dict[str, int] = {}
+        try:
+            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,
+            )
 
-        def refresh() -> None:
-            for f in os.listdir(watch_dir):
-                if not f.endswith(".md"):
+            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
+                    fd = -1
+                    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:
+                        if fd >= 0:
+                            os.close(fd)
+
+            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
-                path = os.path.join(watch_dir, f)
-                if path in file_fds:
+                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)
+        finally:
+            for fd in file_fds.values():
                 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
+                    os.close(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()
+            if dir_fd >= 0:
+                try:
+                    os.close(dir_fd)
+                except OSError:
+                    pass
+            kq.close()
 
     def stop(self) -> None:
         self._stop.set()
@@ -124,4 +129,4 @@ class FileWatcher(Concern):
             self._queue.clear()
         for name in names:
             if not is_suspended(name, self.cfg.suspended_file):
-                self.inbox.nudge_if_unread(name)
+                self.nudge.check_session(name, now)

package/lib/concerns/health.py

@@ -32,7 +32,7 @@ class SessionKeepAlive(Concern):
                 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)")
+                log(f"{name}: 同学已退出, NOT restarting (idle policy)")
 
 
 class HealthChecker(Concern):

package/lib/concerns/notification_push.py

@@ -0,0 +1,171 @@
+"""NotificationPushConcern — realtime notification delivery for mentions and issue activity."""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+
+from lib.notification_config import NotificationConfig
+from lib.notification_config import load as load_config
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import board_send, db, get_dev_sessions, log, warn
+
+MENTION_RE = re.compile(r"(?<![a-zA-Z0-9.])@([a-z][a-z0-9_-]*)", re.IGNORECASE)
+
+
+class NotificationPushConcern(Concern):
+    interval = 10
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self._config: NotificationConfig | None = None
+        self._config_mtime: float = 0
+        self._last_msg_id: int = 0
+        self._last_bug_check: str = ""
+        self._init_watermarks()
+
+    def _config_path(self) -> Path:
+        return self.cfg.claudes_dir / "notifications.toml"
+
+    def _load_config(self) -> NotificationConfig:
+        path = self._config_path()
+        try:
+            mtime = path.stat().st_mtime if path.exists() else 0
+        except OSError:
+            mtime = 0
+        if self._config is None or mtime != self._config_mtime:
+            self._config = load_config(path)
+            self._config_mtime = mtime
+        return self._config
+
+    def _init_watermarks(self) -> None:
+        try:
+            d = db(self.cfg)
+            row = d.query_one("SELECT MAX(id) FROM messages")
+            self._last_msg_id = (row[0] or 0) if row else 0
+            self._last_bug_check = time.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            pass
+
+    def _already_sent(self, notif_type: str, recipient: str, ref_id: str) -> bool:
+        try:
+            count = db(self.cfg).scalar(
+                "SELECT COUNT(*) FROM notification_log WHERE notif_type=? AND recipient=? AND ref_id=?",
+                (notif_type, recipient, ref_id),
+            )
+            return bool(count)
+        except Exception:
+            return False
+
+    def _record(self, notif_type: str, recipient: str, ref_type: str, ref_id: str, channel: str) -> None:
+        try:
+            with db(self.cfg).conn() as c:
+                c.execute(
+                    "INSERT INTO notification_log(notif_type, recipient, ref_type, ref_id, channel) VALUES(?,?,?,?,?)",
+                    (notif_type, recipient, ref_type, ref_id, channel),
+                )
+        except Exception as e:
+            warn(f"notification_log insert: {e}")
+
+    def _deliver(self, config: NotificationConfig, recipient: str, notif_type: str, message: str, ref_id: str) -> None:
+        channel = config.channel_for(recipient)
+        if channel == "board-inbox":
+            board_send(self.cfg, recipient, message)
+        else:
+            log(f"[notify] {channel} delivery not yet implemented for {recipient}: {message[:60]}")
+        self._record(notif_type, recipient, "message" if notif_type == "mention" else "bug", ref_id, channel)
+
+    def _scan_mentions(self, config: NotificationConfig) -> None:
+        try:
+            rows = db(self.cfg).query(
+                "SELECT id, sender, recipient, body FROM messages WHERE id > ?",
+                (self._last_msg_id,),
+            )
+        except Exception:
+            return
+        if not rows:
+            return
+
+        members = [s for s in get_dev_sessions(self.cfg)]
+        max_id = self._last_msg_id
+
+        for row in rows:
+            msg_id, sender, _recipient, body = row[0], row[1], row[2], row[3]
+            if msg_id > max_id:
+                max_id = msg_id
+            mentioned = set(m.lower() for m in MENTION_RE.findall(body))
+            for name in mentioned:
+                if name == sender.lower():
+                    continue
+                if not config.is_subscribed(name, "mention"):
+                    continue
+                if name not in members and name != "human":
+                    continue
+                ref = f"msg-{msg_id}"
+                if self._already_sent("mention", name, ref):
+                    continue
+                preview = body[:80].replace("\n", " ")
+                self._deliver(config, name, "mention", f"[通知] {sender} 提到了你: {preview}", ref)
+
+        self._last_msg_id = max_id
+
+    def _scan_bugs(self, config: NotificationConfig) -> None:
+        try:
+            rows = db(self.cfg).query(
+                "SELECT id, severity, reporter, assignee, status, description, reported_at FROM bugs WHERE reported_at > ?",
+                (self._last_bug_check,),
+            )
+        except Exception:
+            return
+
+        members = [s for s in get_dev_sessions(self.cfg)]
+        now_ts = time.strftime("%Y-%m-%d %H:%M:%S")
+
+        for row in rows:
+            bug_id, severity, reporter, assignee, _status, desc, _reported = (
+                row[0],
+                row[1],
+                row[2],
+                row[3],
+                row[4],
+                row[5],
+                row[6],
+            )
+            ref = f"bug-{bug_id}"
+
+            for name in members:
+                if not config.is_subscribed(name, "issue-activity"):
+                    continue
+                if self._already_sent("issue-activity", name, ref):
+                    continue
+                preview = desc[:60].replace("\n", " ")
+                self._deliver(
+                    config,
+                    name,
+                    "issue-activity",
+                    f"[Bug {severity}] {reporter} 报告: {preview}",
+                    ref,
+                )
+
+            if assignee and assignee.lower() in [m.lower() for m in members]:
+                target = assignee.lower()
+                assign_ref = f"bug-assign-{bug_id}"
+                if not self._already_sent("mention", target, assign_ref):
+                    self._deliver(
+                        config,
+                        target,
+                        "mention",
+                        f"[通知] 你被指派了 Bug {bug_id} ({severity}): {desc[:60]}",
+                        assign_ref,
+                    )
+
+        self._last_bug_check = now_ts
+
+    def tick(self, now: int) -> None:
+        config = self._load_config()
+        self._scan_mentions(config)
+        self._scan_bugs(config)

package/lib/concerns/notifications.py

@@ -1,11 +1,11 @@
-"""Notifications: inbox nudging, time announcements, bug SLA checks."""
+"""Notifications: inbox nudging, time announcements, bug SLA checks, queued message flushing."""
 
 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
+from .helpers import board_send, db, get_dev_sessions, is_claude_running, log, tmux, tmux_ok, tmux_send
 
 
 class InboxNudger(Concern):
@@ -43,7 +43,20 @@ class TimeAnnouncer(Concern):
     def __init__(self, cfg: DispatcherConfig) -> None:
         super().__init__()
         self.cfg = cfg
-        self.last_hour = -1
+        from datetime import datetime as dt
+
+        self.last_hour = dt.now().hour
+
+    def _already_sent(self, hour_ts: str) -> bool:
+        """Check DB for a clock message already sent this hour (prevents duplicate announcements)."""
+        try:
+            count = db(self.cfg).scalar(
+                "SELECT COUNT(*) FROM messages WHERE sender='dispatcher' AND body LIKE '%[Clock]%' AND ts LIKE ?",
+                (f"{hour_ts}%",),
+            )
+            return bool(count)
+        except Exception:
+            return False
 
     def tick(self, now: int) -> None:
         from datetime import datetime as dt
@@ -54,6 +67,10 @@ class TimeAnnouncer(Concern):
         self.last_hour = d.hour
         ts = d.strftime("%Y-%m-%d %H:%M")
 
+        if self._already_sent(ts):
+            log(f"Hourly announcement: {d.hour}:00 (already sent, skipping)")
+            return
+
         if d.hour == 9:
             board_send(
                 self.cfg,
@@ -66,6 +83,44 @@ class TimeAnnouncer(Concern):
             log(f"Hourly announcement: {d.hour}:00")
 
 
+class QueuedMessageFlusher(Concern):
+    """Detect queued messages in idle agent panes and send Enter to flush them.
+
+    When nudge injects a command while Claude Code is busy, it gets queued.
+    The pane shows 'queued message' and waits for Enter. This concern
+    auto-flushes that queue when the agent becomes idle.
+    """
+
+    interval = 5
+    COOLDOWN = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_flush: 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):
+                continue
+            if (now - self.last_flush.get(name, 0)) < self.COOLDOWN:
+                continue
+
+            content = tmux("capture-pane", "-t", sess, "-p") or ""
+            if "queued message" not in content.lower():
+                continue
+
+            lines = content.splitlines()[-5:]
+            has_empty_prompt = any(line.rstrip() == "❯" for line in lines)
+            if not has_empty_prompt:
+                continue
+
+            log(f"{name}: flushing queued message")
+            subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], capture_output=True, timeout=5)
+            self.last_flush[name] = now
+
+
 class BugSLAChecker(Concern):
     interval = 600
 

package/lib/concerns/nudge_coordinator.py

@@ -0,0 +1,148 @@
+"""NudgeCoordinator — unified nudge orchestrator replacing InboxNudger, QueuedMessageFlusher, IdleNudger.
+
+Consolidates all nudge decisions into a single Concern with:
+  - per-session cooldown across all nudge types
+  - nudge-type priority: inbox > queued_flush > idle
+  - post-nudge effectiveness tracking with backoff
+  - cached session status checks (one tmux call per session per tick)
+"""
+
+from dataclasses import dataclass
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import db, get_dev_sessions, is_claude_running, log, tmux, tmux_ok, tmux_send
+
+
+@dataclass
+class NudgeRecord:
+    time: int = 0
+    nudge_type: str = ""
+    consecutive_ineffective: int = 0
+
+
+class NudgeCoordinator(Concern):
+    interval = 5
+    COOLDOWN = 15
+    MAX_BACKOFF_MULTIPLIER = 8
+
+    def __init__(self, cfg: DispatcherConfig, idle) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.idle = idle
+        self._records: dict[str, NudgeRecord] = {}
+        self._session_ok: dict[str, bool] = {}
+        self._cache_tick: int = 0
+
+    def _session_ready(self, name: str, now: int) -> bool:
+        if now != self._cache_tick:
+            self._session_ok.clear()
+            self._cache_tick = now
+        if name not in self._session_ok:
+            sess = f"{self.cfg.prefix}-{name}"
+            self._session_ok[name] = tmux_ok("has-session", "-t", sess) and is_claude_running(sess)
+        return self._session_ok[name]
+
+    def _effective_cooldown(self, name: str) -> int:
+        rec = self._records.get(name)
+        if not rec or rec.consecutive_ineffective <= 1:
+            return self.COOLDOWN
+        backoff_exp = min(rec.consecutive_ineffective - 1, 3)
+        return int(self.COOLDOWN * min(2**backoff_exp, self.MAX_BACKOFF_MULTIPLIER))
+
+    def _can_nudge(self, name: str, now: int) -> bool:
+        rec = self._records.get(name)
+        if not rec:
+            return True
+        return (now - rec.time) >= self._effective_cooldown(name)
+
+    def _check_effectiveness(self, name: str) -> None:
+        rec = self._records.get(name)
+        if not rec:
+            return
+        sess = f"{self.cfg.prefix}-{name}"
+        if self.idle.is_idle(sess):
+            rec.consecutive_ineffective += 1
+        else:
+            rec.consecutive_ineffective = 0
+
+    def _record(self, name: str, nudge_type: str, now: int) -> None:
+        rec = self._records.get(name)
+        old_ineffective = rec.consecutive_ineffective if rec else 0
+        self._records[name] = NudgeRecord(time=now, nudge_type=nudge_type, consecutive_ineffective=old_ineffective)
+        log(f"NUDGE [{nudge_type}] {name}")
+
+    def _try_inbox(self, name: str) -> bool:
+        if not self.cfg.board_db.exists():
+            return False
+        try:
+            unread = db(self.cfg).scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,)) or 0
+        except Exception:
+            return False
+        if unread <= 0:
+            return False
+        sess = f"{self.cfg.prefix}-{name}"
+        tmux_send(sess, f"./board --as {name} inbox")
+        return True
+
+    def _try_queued_flush(self, name: str) -> bool:
+        sess = f"{self.cfg.prefix}-{name}"
+        content = tmux("capture-pane", "-t", sess, "-p") or ""
+        if "queued message" not in content.lower():
+            return False
+        lines = content.splitlines()[-5:]
+        if not any(line.rstrip() == "❯" for line in lines):
+            return False
+        tmux_send(sess, "")
+        return True
+
+    def _try_idle(self, name: str) -> bool:
+        sess = f"{self.cfg.prefix}-{name}"
+        if not self.idle.is_idle(sess):
+            return False
+        tmux_send(
+            sess,
+            f"继续工作。检查你的 OKR ({self.cfg.okr_dir}/{name}.md)，推进你的活跃 KR。自己决定优先级。",
+        )
+        return True
+
+    def get_nudge_stats(self, name: str) -> dict:
+        rec = self._records.get(name)
+        if not rec:
+            return {"consecutive_ineffective": 0, "last_nudge_type": "", "last_nudge_time": 0}
+        return {
+            "consecutive_ineffective": rec.consecutive_ineffective,
+            "last_nudge_type": rec.nudge_type,
+            "last_nudge_time": rec.time,
+        }
+
+    def _process_session(self, name: str, now: int) -> None:
+        if is_suspended(name, self.cfg.suspended_file):
+            return
+        if not self._session_ready(name, now):
+            return
+
+        if name in self._records:
+            self._check_effectiveness(name)
+
+        if not self._can_nudge(name, now):
+            return
+
+        for nudge_type, try_fn in [
+            ("inbox", self._try_inbox),
+            ("flush", self._try_queued_flush),
+            ("idle", self._try_idle),
+        ]:
+            if try_fn(name):
+                self._record(name, nudge_type, now)
+                break
+
+    def check_session(self, name: str, now: int) -> None:
+        """Check and nudge a specific session (used by FileWatcher for instant inbox detection)."""
+        self._process_session(name, now)
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            self._process_session(name, now)

package/lib/digest.py

@@ -0,0 +1,62 @@
+"""digest — generate daily/weekly activity summaries from board data."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from lib.board_db import BoardDB
+
+
+def generate_daily_digest(board: BoardDB, since: datetime | None = None) -> str:
+    if since is None:
+        since = datetime.now() - timedelta(hours=24)
+    since_str = since.strftime("%Y-%m-%d %H:%M:%S")
+
+    sections: list[str] = []
+
+    msg_count = board.scalar("SELECT COUNT(*) FROM messages WHERE ts > ?", (since_str,)) or 0
+    if msg_count:
+        top_senders = board.query(
+            "SELECT sender, COUNT(*) as cnt FROM messages WHERE ts > ? GROUP BY sender ORDER BY cnt DESC LIMIT 5",
+            (since_str,),
+        )
+        sender_str = ", ".join(f"{r[0]}({r[1]})" for r in (top_senders or []))
+        sections.append(f"消息: {msg_count} 条 — {sender_str}")
+
+    bugs_opened = board.query(
+        "SELECT id, severity, reporter, description FROM bugs WHERE reported_at > ? AND status='OPEN'",
+        (since_str,),
+    )
+    if bugs_opened:
+        bug_lines = [f"  {r[0]} [{r[1]}] {r[3][:40]}" for r in bugs_opened]
+        sections.append(f"新 Bug: {len(bugs_opened)} 个\n" + "\n".join(bug_lines))
+
+    bugs_fixed = board.query(
+        "SELECT id, severity, assignee FROM bugs WHERE fixed_at > ?",
+        (since_str,),
+    )
+    if bugs_fixed:
+        fix_lines = [f"  {r[0]} [{r[1]}] by {r[2]}" for r in bugs_fixed]
+        sections.append(f"修复: {len(bugs_fixed)} 个\n" + "\n".join(fix_lines))
+
+    tasks_done = board.query(
+        "SELECT session, description FROM tasks WHERE done_at > ? AND status='done'",
+        (since_str,),
+    )
+    if tasks_done:
+        task_lines = [f"  {r[0]}: {r[1][:50]}" for r in tasks_done]
+        sections.append(f"完成任务: {len(tasks_done)} 个\n" + "\n".join(task_lines))
+
+    kudos_list = board.query(
+        "SELECT sender, target, reason FROM kudos WHERE ts > ?",
+        (since_str,),
+    )
+    if kudos_list:
+        kudos_lines = [f"  {r[0]} → {r[1]}: {r[2][:40]}" for r in kudos_list]
+        sections.append(f"Kudos: {len(kudos_list)} 个\n" + "\n".join(kudos_lines))
+
+    if not sections:
+        return "[Daily Digest] 过去 24h 无活动。"
+
+    header = f"[Daily Digest] {datetime.now().strftime('%Y-%m-%d')} 活动摘要"
+    return header + "\n" + "\n".join(sections)

package/lib/health.py

@@ -110,8 +110,8 @@ def print_health_report() -> None:
     sessions = get_sessions(prefix)
 
     print()
-    print("  Session\t\tStatus\t\tRestarts\tUptime\t\tAgent")
-    print("  -------\t\t------\t\t--------\t------\t\t-----")
+    print("  Session\t\tStatus\t\tRestarts\tUptime\t\tEngine")
+    print("  -------\t\t------\t\t--------\t------\t\t------")
 
     total = 0
     alive = 0

package/lib/inject.py

@@ -129,7 +129,7 @@ def inject(target: str, message: str, prefix: str | None = None, sessions: list
     mode = detect_mode(prefix)
     if mode == "none":
         print("ERROR: neither tmux nor screen found", file=sys.stderr)
-        sys.exit(1)
+        raise SystemExit(1)
 
     send_fn = send_tmux if mode == "tmux" else send_screen
     target_lower = target.lower()
@@ -153,7 +153,7 @@ def main() -> None:
             '  ./inject.py alice "what\'s blocking P0?"\n'
             '  ./inject.py all "everyone check inbox"',
         )
-        sys.exit(1)
+        raise SystemExit(1)
 
     target = sys.argv[1]
     message = " ".join(sys.argv[2:])