claude-nb 0.4.0 → 0.5.1

package/bin/dispatcher

@@ -6,8 +6,7 @@ Concerns (each with independent check intervals):
   SessionKeepAlive   — detect dead dev sessions
   IdleDetector       — batch screen snapshot comparison
   IdleKiller         — kill sessions idle >30min
-  IdleNudger         — nudge idle sessions to continue working
-  InboxNudger        — detect unread inboxes, nudge sessions
+  NudgeCoordinator   — unified nudge orchestrator (inbox/queued/idle)
   CoralPoker         — periodic heartbeat to dispatcher session
   HealthChecker      — periodic full status report + team idle detection
   BugSLAChecker      — check overdue bugs
@@ -39,8 +38,7 @@ from lib.concerns import (
     HealthChecker,
     IdleDetector,
     IdleKiller,
-    IdleNudger,
-    InboxNudger,
+    NudgeCoordinator,
     ResourceMonitor,
     SessionKeepAlive,
     TimeAnnouncer,
@@ -86,25 +84,39 @@ if not Path(cfg.board_sh).exists():
 # ---------------------------------------------------------------------------
 
 
+def _acquire_pidlock() -> Path:
+    pidfile = cfg.claudes_dir / "dispatcher.pid"
+    if pidfile.exists():
+        try:
+            old_pid = int(pidfile.read_text().strip())
+            os.kill(old_pid, 0)
+            print(f"FATAL: dispatcher already running (pid {old_pid})", file=sys.stderr)
+            sys.exit(1)
+        except (ValueError, ProcessLookupError, PermissionError):
+            pass
+    pidfile.write_text(str(os.getpid()))
+    return pidfile
+
+
 def main() -> None:
+    pidfile = _acquire_pidlock()
     base_interval = 2
 
     coral = CoralManager(cfg)
     idle = IdleDetector(cfg)
     poker = CoralPoker(cfg)
-    inbox = InboxNudger(cfg)
+    nudge = NudgeCoordinator(cfg, idle)
     throttle = AdaptiveThrottle()
-    file_watcher = FileWatcher(cfg, inbox)
+    file_watcher = FileWatcher(cfg, nudge)
 
-    # Order matters: idle must tick before idle_killer / idle_nudger
+    # Order matters: idle must tick before idle_killer / nudge_coordinator
     concerns: list[Concern] = [
         coral,
         TimeAnnouncer(cfg),
         idle,
         SessionKeepAlive(cfg),
         IdleKiller(cfg, idle, coral),
-        inbox,
-        IdleNudger(cfg, idle),
+        nudge,
         poker,
         BugSLAChecker(cfg, poker),
         HealthChecker(cfg, poker, coral),
@@ -131,8 +143,9 @@ def main() -> None:
         while running:
             now = int(time.time())
 
-            if not tmux_ok("has-session", "-t", cfg.coral_sess):
-                log("Coral session gone. Shutting down.")
+            any_alive = any(tmux_ok("has-session", "-t", f"{cfg.prefix}-{s}") for s in cfg.dev_sessions)
+            if not any_alive:
+                log("No dev sessions alive. Shutting down.")
                 break
 
             for c in concerns:
@@ -144,6 +157,7 @@ def main() -> None:
     finally:
         log("Shutting down...")
         file_watcher.stop()
+        pidfile.unlink(missing_ok=True)
         log("Stopped.")
 
 

package/bin/doctor

@@ -103,9 +103,7 @@ def check_foreign_keys(path: Path) -> bool:
     try:
         conn = sqlite3.connect(str(path))
         # PRAGMA foreign_keys is connection-level; check table definitions instead
-        rows = conn.execute(
-            "SELECT sql FROM sqlite_master WHERE type='table' AND sql LIKE '%REFERENCES%'"
-        ).fetchall()
+        rows = conn.execute("SELECT sql FROM sqlite_master WHERE type='table' AND sql LIKE '%REFERENCES%'").fetchall()
         conn.close()
         if rows:
             _ok(f"Foreign keys defined ({len(rows)} tables)")
@@ -288,7 +286,7 @@ def main() -> None:
         check_git()
         check_claude_cli()
         print("\nResult: project not initialized — run 'cnb init' first")
-        sys.exit(1)
+        raise SystemExit(1)
 
     print("=== cnb Doctor ===\n")
 
@@ -321,7 +319,7 @@ def main() -> None:
         print("✓ All checks passed.")
     else:
         print("⚠ Some checks failed — review warnings above.")
-        sys.exit(1)
+        raise SystemExit(1)
 
 
 if __name__ == "__main__":

package/bin/init

@@ -115,12 +115,11 @@ def _update_claude_md(project_dir: Path, snippet: str) -> None:
 
 
 def _hook_command(claudes_home: Path) -> str:
-    board = f"{claudes_home}/bin/board"
     return (
-        f'if [ -n "$CLAUDE_SESSION_NAME" ]; then '
-        f"unread=$({board} --as $CLAUDE_SESSION_NAME inbox 2>/dev/null "
-        f"| grep -oE '[0-9]+ 条未读' | head -1); "
-        f'[ -n "$unread" ] && echo "[inbox] $unread" || true; fi'
+        'if [ -n "$CLAUDE_SESSION_NAME" ] && [ -n "$CNB_PROJECT" ]; then '
+        "BOARD=$(grep '^claudes_home' \"$CNB_PROJECT/.claudes/config.toml\" 2>/dev/null "
+        "| cut -d'\"' -f2)/bin/board; "
+        '[ -x "$BOARD" ] && $BOARD --as $CLAUDE_SESSION_NAME pulse 2>/dev/null; fi'
     )
 
 
@@ -148,7 +147,8 @@ def _update_settings(project_dir: Path, claudes_home: Path) -> None:
     already = any(
         isinstance(h, dict)
         and any(
-            "board" in sub.get("command", "") and "inbox" in sub.get("command", "")
+            "board" in sub.get("command", "")
+            and ("pulse" in sub.get("command", "") or "inbox" in sub.get("command", ""))
             for sub in h.get("hooks", [])
             if isinstance(sub, dict)
         )
@@ -252,7 +252,7 @@ def main() -> None:
         (claudes_dir / "sessions" / f"{n}.md").write_text(md_content)
     conn.execute("INSERT OR IGNORE INTO meta(key, value) VALUES ('dispatcher_session', 'dispatcher')")
     # Record schema version so migration runner knows where we are
-    conn.execute("INSERT OR IGNORE INTO meta(key, value) VALUES ('schema_version', '2')")
+    conn.execute("INSERT OR IGNORE INTO meta(key, value) VALUES ('schema_version', '4')")
     conn.commit()
     conn.close()
 
@@ -264,7 +264,7 @@ def main() -> None:
         print(f"Applied {applied} schema migration(s).")
 
     # .gitignore for generated stuff
-    gitignore_content = "board.db\nboard.db-shm\nboard.db-wal\nlogs/\n"
+    gitignore_content = "board.db\nboard.db-shm\nboard.db-wal\nlogs/\ndispatcher.pid\n"
     (claudes_dir / ".gitignore").write_text(gitignore_content)
 
     # Update .claude/settings.json (merge hooks if exists, create if not)

package/bin/notify

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""notify — notification subscription management and manual trigger CLI.
+
+Usage:
+  notify status                   Show current notification config
+  notify subscriptions [member]   Show subscriptions for member (or all)
+  notify test <member> <type>     Send a test notification
+  notify digest [--send]          Generate daily digest (--send to deliver)
+  notify log [--limit N]          Show recent notification log
+"""
+
+import sys
+from pathlib import Path
+
+CLAUDES_HOME = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(CLAUDES_HOME))
+
+from lib.board_db import BoardDB
+from lib.common import ClaudesEnv
+from lib.digest import generate_daily_digest
+from lib.notification_config import BUILTIN_DEFAULTS, NOTIFICATION_TYPES, load
+
+
+def _env() -> ClaudesEnv:
+    return ClaudesEnv.load()
+
+
+def _config_path(env: ClaudesEnv) -> Path:
+    return Path(env.claudes_dir) / "notifications.toml"
+
+
+def cmd_status() -> None:
+    env = _env()
+    path = _config_path(env)
+    config = load(path)
+
+    print(f"配置文件: {path}")
+    print(f"  存在: {'是' if path.exists() else '否（使用默认值）'}")
+    print(f"  人类通道: {config.human_channel}")
+    print(f"  队友通道: {config.teammate_channel}")
+    print()
+    print("默认订阅:")
+    for t in NOTIFICATION_TYPES:
+        default = config.defaults.get(t, BUILTIN_DEFAULTS.get(t, False))
+        print(f"  {t}: {'✓' if default else '✗'}")
+    if config.overrides:
+        print()
+        print("个人覆盖:")
+        for member, prefs in config.overrides.items():
+            overrides_str = ", ".join(f"{k}={'✓' if v else '✗'}" for k, v in prefs.items())
+            print(f"  {member}: {overrides_str}")
+    if config.human:
+        print()
+        print(f"人类: {config.human.name} <{config.human.email}>")
+        if config.human.subscriptions:
+            subs = ", ".join(f"{k}={'✓' if v else '✗'}" for k, v in config.human.subscriptions.items())
+            print(f"  订阅: {subs}")
+
+
+def cmd_subscriptions(member: str | None = None) -> None:
+    env = _env()
+    config = load(_config_path(env))
+
+    if member:
+        print(f"{member} 的订阅:")
+        for t in NOTIFICATION_TYPES:
+            subscribed = config.is_subscribed(member, t)
+            channel = config.channel_for(member)
+            print(f"  {t}: {'✓' if subscribed else '✗'} (via {channel})")
+    else:
+        db_path = Path(env.claudes_dir) / "board.db"
+        if not db_path.exists():
+            print("ERROR: board.db 不存在")
+            raise SystemExit(1)
+        board = BoardDB(db_path)
+        sessions = board.query("SELECT name FROM sessions ORDER BY name")
+        if not sessions:
+            print("无会话")
+            return
+        for row in sessions:
+            name = row[0]
+            subs = [t for t in NOTIFICATION_TYPES if config.is_subscribed(name, t)]
+            channel = config.channel_for(name)
+            subs_str = ", ".join(subs) if subs else "无"
+            print(f"  {name}: {subs_str} (via {channel})")
+
+
+def cmd_test(member: str, notif_type: str) -> None:
+    if notif_type not in NOTIFICATION_TYPES:
+        print(f"ERROR: 未知通知类型 '{notif_type}'")
+        print(f"可用类型: {', '.join(NOTIFICATION_TYPES)}")
+        raise SystemExit(1)
+
+    env = _env()
+    config = load(_config_path(env))
+    channel = config.channel_for(member)
+    subscribed = config.is_subscribed(member, notif_type)
+
+    print(f"测试通知: {notif_type} → {member}")
+    print(f"  通道: {channel}")
+    print(f"  已订阅: {'是' if subscribed else '否'}")
+
+    if channel == "board-inbox":
+        import subprocess
+
+        board_sh = str(CLAUDES_HOME / "bin" / "board")
+        msg = f"[测试通知] 类型: {notif_type} — 这是一条测试消息"
+        try:
+            subprocess.run([board_sh, "--as", "dispatcher", "send", member, msg], capture_output=True, timeout=10)
+            print("OK 测试通知已发送")
+        except Exception as e:
+            print(f"ERROR: 发送失败: {e}")
+            raise SystemExit(1)
+    else:
+        print(f"通道 {channel} 尚未实现投递")
+
+
+def cmd_digest(send: bool = False) -> None:
+    env = _env()
+    db_path = Path(env.claudes_dir) / "board.db"
+    if not db_path.exists():
+        print("ERROR: board.db 不存在")
+        raise SystemExit(1)
+
+    board = BoardDB(db_path)
+    digest = generate_daily_digest(board)
+    print(digest)
+
+    if send:
+        config = load(_config_path(env))
+        sessions = board.query("SELECT name FROM sessions ORDER BY name")
+        members = [r[0] for r in (sessions or [])]
+        subscribers = config.subscribers_for("daily-digest", members)
+        if not subscribers:
+            print("\n无订阅者")
+            return
+
+        import subprocess
+
+        board_sh = str(CLAUDES_HOME / "bin" / "board")
+        sent = 0
+        for member in subscribers:
+            channel = config.channel_for(member)
+            if channel == "board-inbox":
+                try:
+                    subprocess.run(
+                        [board_sh, "--as", "dispatcher", "send", member, digest],
+                        capture_output=True,
+                        timeout=10,
+                    )
+                    sent += 1
+                except Exception:
+                    print(f"ERROR: 发送到 {member} 失败")
+            else:
+                print(f"  {member}: 通道 {channel} 尚未实现")
+        print(f"\nOK 已发送到 {sent}/{len(subscribers)} 订阅者")
+
+
+def cmd_log(limit: int = 20) -> None:
+    env = _env()
+    db_path = Path(env.claudes_dir) / "board.db"
+    if not db_path.exists():
+        print("ERROR: board.db 不存在")
+        raise SystemExit(1)
+
+    board = BoardDB(db_path)
+    try:
+        rows = board.query(
+            "SELECT sent_at, notif_type, recipient, channel, ref_id FROM notification_log ORDER BY id DESC LIMIT ?",
+            (limit,),
+        )
+    except Exception:
+        print("notification_log 表不存在，请运行 migration")
+        raise SystemExit(1)
+
+    if not rows:
+        print("通知记录为空")
+        return
+
+    print(f"最近 {len(rows)} 条通知记录:")
+    for row in rows:
+        sent_at, ntype, recipient, channel, ref_id = row
+        print(f"  {sent_at} | {ntype:16s} | {recipient:12s} | {channel:12s} | {ref_id}")
+
+
+def main() -> None:
+    args = sys.argv[1:]
+    if not args:
+        print(__doc__.strip())
+        raise SystemExit(1)
+
+    cmd = args[0]
+
+    if cmd == "status":
+        cmd_status()
+    elif cmd == "subscriptions":
+        member = args[1] if len(args) > 1 else None
+        cmd_subscriptions(member)
+    elif cmd == "test":
+        if len(args) < 3:
+            print("Usage: notify test <member> <type>")
+            raise SystemExit(1)
+        cmd_test(args[1], args[2])
+    elif cmd == "digest":
+        send = "--send" in args
+        cmd_digest(send=send)
+    elif cmd == "log":
+        limit = 20
+        if "--limit" in args:
+            idx = args.index("--limit")
+            if idx + 1 < len(args):
+                try:
+                    limit = int(args[idx + 1])
+                except ValueError:
+                    pass
+        cmd_log(limit=limit)
+    else:
+        print(f"ERROR: 未知命令 '{cmd}'")
+        print(__doc__.strip())
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

package/bin/registry

@@ -32,7 +32,9 @@ def _content_hash(entry: dict) -> str:
 def _load_chain() -> list[dict]:
     entries = []
     for f in sorted(REGISTRY_DIR.glob("*.json")):
-        entries.append(json.loads(f.read_text()))
+        data = json.loads(f.read_text())
+        if "block" in data:
+            entries.append(data)
     entries.sort(key=lambda e: e["block"])
     return entries
 
@@ -279,21 +281,13 @@ def cmd_whois(args: list[str]) -> None:
     print(f"  Commits:      {contrib['commits']}")
 
 
-CHAIN_START = "<!-- chain:start -->"
-CHAIN_END = "<!-- chain:end -->"
-
-
 def _sync_readme() -> None:
-    readme = REGISTRY_DIR.parent / "README.md"
-    if not readme.exists():
-        return
-    text = readme.read_text()
-    if CHAIN_START not in text:
-        return
+    readme = REGISTRY_DIR / "README.md"
 
     chain = _load_chain()
     lines = [
-        CHAIN_START,
+        "# Registry Chain",
+        "",
         "| Block | Name | Role | Hash |",
         "|-------|------|------|------|",
     ]
@@ -303,17 +297,8 @@ def _sync_readme() -> None:
         role = entry.get("role", entry.get("type", ""))
         chain_hash = f"`{entry['chain']}`" if entry.get("chain") else "—"
         lines.append(f"| {block} | {name} | {role} | {chain_hash} |")
-    lines.append(CHAIN_END)
-
-    import re
-
-    text = re.sub(
-        rf"{re.escape(CHAIN_START)}.*?{re.escape(CHAIN_END)}",
-        "\n".join(lines),
-        text,
-        flags=re.DOTALL,
-    )
-    readme.write_text(text)
+    lines.append("")
+    readme.write_text("\n".join(lines))
 
 
 def main() -> None:

package/bin/sync-version

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""sync-version — sync VERSION to package.json and pyproject.toml.
+
+Reads the canonical version from VERSION file and updates:
+  - package.json: "version" field
+  - pyproject.toml: version field (PEP 440 format: X.Y.Z.dev0)
+Also syncs the license from pyproject.toml to package.json.
+
+Usage:
+    ./bin/sync-version          # sync + report
+    ./bin/sync-version --check  # check consistency only (exit 1 if drift)
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+
+
+def read_version() -> str:
+    return (ROOT / "VERSION").read_text().strip()
+
+
+def read_pyproject() -> tuple[str, str]:
+    """Return (version, license) from pyproject.toml."""
+    text = (ROOT / "pyproject.toml").read_text()
+    ver_m = re.search(r'^version\s*=\s*"([^"]+)"', text, re.MULTILINE)
+    lic_m = re.search(r'^license\s*=\s*"([^"]+)"', text, re.MULTILINE)
+    return (ver_m.group(1) if ver_m else ""), (lic_m.group(1) if lic_m else "")
+
+
+def read_package_json() -> tuple[str, str]:
+    """Return (version, license) from package.json."""
+    data = json.loads((ROOT / "package.json").read_text())
+    return data.get("version", ""), data.get("license", "")
+
+
+def canonical_to_pep440(ver: str) -> str:
+    """Convert '0.5.1-dev' to '0.5.1.dev0' (PEP 440)."""
+    return re.sub(r"-dev$", ".dev0", ver)
+
+
+def pep440_to_npm(ver: str) -> str:
+    """Convert '0.5.1.dev0' to '0.5.1-dev'."""
+    return re.sub(r"\.dev\d+$", "-dev", ver)
+
+
+def check() -> list[str]:
+    """Return list of inconsistency descriptions. Empty = all good."""
+    ver = read_version()
+    pep_ver, pep_lic = read_pyproject()
+    npm_ver, npm_lic = read_package_json()
+
+    expected_pep = canonical_to_pep440(ver)
+    errors = []
+
+    if pep_ver != expected_pep:
+        errors.append(f"pyproject.toml version '{pep_ver}' != expected '{expected_pep}' (from VERSION '{ver}')")
+    if npm_ver != ver:
+        errors.append(f"package.json version '{npm_ver}' != VERSION '{ver}'")
+    if pep_lic and npm_lic != pep_lic:
+        errors.append(f"package.json license '{npm_lic}' != pyproject.toml license '{pep_lic}'")
+
+    return errors
+
+
+def sync() -> None:
+    ver = read_version()
+    _, pep_lic = read_pyproject()
+
+    # Sync package.json
+    pkg_path = ROOT / "package.json"
+    pkg = json.loads(pkg_path.read_text())
+    changed = False
+    if pkg.get("version") != ver:
+        print(f"package.json version: '{pkg['version']}' -> '{ver}'")
+        pkg["version"] = ver
+        changed = True
+    if pep_lic and pkg.get("license") != pep_lic:
+        print(f"package.json license: '{pkg.get('license')}' -> '{pep_lic}'")
+        pkg["license"] = pep_lic
+        changed = True
+    if changed:
+        pkg_path.write_text(json.dumps(pkg, indent=2) + "\n")
+    else:
+        print("package.json: already in sync")
+
+    # Sync pyproject.toml version
+    pyp_path = ROOT / "pyproject.toml"
+    text = pyp_path.read_text()
+    expected_pep = canonical_to_pep440(ver)
+    new_text = re.sub(
+        r'^(version\s*=\s*")[^"]+"',
+        rf'\g<1>{expected_pep}"',
+        text,
+        count=1,
+        flags=re.MULTILINE,
+    )
+    if new_text != text:
+        pep_ver, _ = read_pyproject()
+        print(f"pyproject.toml version: '{pep_ver}' -> '{expected_pep}'")
+        pyp_path.write_text(new_text)
+    else:
+        print("pyproject.toml: already in sync")
+
+
+def main() -> None:
+    if "--check" in sys.argv:
+        errors = check()
+        if errors:
+            print("VERSION DRIFT DETECTED:")
+            for e in errors:
+                print(f"  - {e}")
+            raise SystemExit(1)
+        print("OK all versions and licenses consistent")
+        return
+
+    sync()
+    errors = check()
+    if errors:
+        print("\nWARNING: still inconsistent after sync:")
+        for e in errors:
+            print(f"  - {e}")
+        raise SystemExit(1)
+    print("\nOK all synced")
+
+
+if __name__ == "__main__":
+    main()

package/lib/board_admin.py

@@ -4,9 +4,12 @@ import subprocess
 import time
 
 from lib.board_db import BoardDB, ts
+from lib.common import validate_identity
 
 
 def cmd_suspend(db: BoardDB, identity: str, args: list[str]) -> None:
+    assert db.env is not None
+    validate_identity(db, identity)
     name = identity.lower()
     if not args:
         print("Usage: ./board --as <name> suspend <session>")
@@ -35,15 +38,19 @@ def cmd_suspend(db: BoardDB, identity: str, args: list[str]) -> None:
 
     prefix = db.env.prefix
     sess = f"{prefix}-{target}"
-    r = subprocess.run(["tmux", "has-session", "-t", sess], capture_output=True)
-    if r.returncode == 0:
-        subprocess.run(
-            ["tmux", "send-keys", "-t", sess, "/exit", "Enter"],
-            capture_output=True,
-        )
-        time.sleep(2)
-        subprocess.run(["tmux", "kill-session", "-t", sess], capture_output=True)
-        print(f"{target}: tmux session 已关闭")
+    try:
+        r = subprocess.run(["tmux", "has-session", "-t", sess], capture_output=True, timeout=5)
+        if r.returncode == 0:
+            subprocess.run(
+                ["tmux", "send-keys", "-t", sess, "/exit", "Enter"],
+                capture_output=True,
+                timeout=5,
+            )
+            time.sleep(2)
+            subprocess.run(["tmux", "kill-session", "-t", sess], capture_output=True, timeout=5)
+            print(f"{target}: tmux session 已关闭")
+    except (subprocess.TimeoutExpired, OSError):
+        pass
 
     now = ts()
     db.execute(
@@ -53,6 +60,8 @@ def cmd_suspend(db: BoardDB, identity: str, args: list[str]) -> None:
 
 
 def cmd_resume(db: BoardDB, identity: str, args: list[str]) -> None:
+    assert db.env is not None
+    validate_identity(db, identity)
     name = identity.lower()
     if not args:
         print("Usage: ./board --as <name> resume <session>")
@@ -80,6 +89,7 @@ def cmd_resume(db: BoardDB, identity: str, args: list[str]) -> None:
 
 
 def cmd_kudos(db: BoardDB, identity: str, args: list[str]) -> None:
+    validate_identity(db, identity)
     name = identity.lower()
     if len(args) < 2:
         print("Usage: ./board --as <name> kudos <target> <reason> [--evidence <commit/link>]")