claude-nb 0.3.0 → 0.4.0

package/bin/swarm

@@ -1,895 +1,76 @@
 #!/usr/bin/env python3
-"""swarm — Launch and manage multi-agent sessions in tmux or screen.
+"""swarm — Launch and manage multi-agent sessions.
 
-Auto-detects: prefers tmux (truecolor support), falls back to screen.
-Override with SWARM_MODE=tmux|screen or SWARM_AGENT=claude|trae|qwen.
+Thin CLI wrapper; core logic lives in lib/swarm.py.
 """
 
-import os
-import re
-import shutil
-import subprocess
 import sys
-import threading
-import time
-from datetime import datetime
 from pathlib import Path
 
-# ---------------------------------------------------------------------------
-# Resolve CLAUDES_HOME and load shared environment
-# ---------------------------------------------------------------------------
-_self = Path(__file__).resolve()
-CLAUDES_HOME = _self.parent.parent
+CLAUDES_HOME = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(CLAUDES_HOME))
 
-# Add lib/ to path so we can import common
-sys.path.insert(0, str(CLAUDES_HOME / "lib"))
-from common import ClaudesEnv, is_suspended
+from lib.swarm import SwarmConfig, SwarmManager
 
-# Module state — initialized by _load(), not at import time.
-PREFIX: str = ""
-SUSPENDED_FILE: Path = Path()
-LOG_DIR: Path = Path()
-SESSIONS: list[str] = []
-PROJECT_ROOT: Path = Path()
-CLAUDES_DIR: Path = Path()
-SESSIONS_DIR: Path = Path()
-CV_DIR: Path = Path()
-ATTENDANCE_LOG: Path = Path()
-SWARM_AGENT: str = ""
-DEEPSEEK_SESSIONS: str = ""
-ROSTER_FILE: Path = Path()
 
-_loaded = False
-
-
-def _load() -> None:
-    global _loaded, PREFIX, SUSPENDED_FILE, LOG_DIR, SESSIONS, PROJECT_ROOT
-    global CLAUDES_DIR, SESSIONS_DIR, CV_DIR, ATTENDANCE_LOG
-    global SWARM_AGENT, DEEPSEEK_SESSIONS, ROSTER_FILE, MODE
-    if _loaded:
-        return
-    env = ClaudesEnv.load()
-    PREFIX = env.prefix
-    SUSPENDED_FILE = env.suspended_file
-    LOG_DIR = env.log_dir
-    SESSIONS = env.sessions
-    PROJECT_ROOT = env.project_root
-    CLAUDES_DIR = env.claudes_dir
-    SESSIONS_DIR = env.sessions_dir
-    CV_DIR = env.cv_dir
-    ATTENDANCE_LOG = env.attendance_log
-    SWARM_AGENT = os.environ.get("SWARM_AGENT", "claude")
-    DEEPSEEK_SESSIONS = ""
-    ROSTER_FILE = CLAUDES_DIR / "ROSTER.md"
-    MODE = detect_mode()
-    LOG_DIR.mkdir(parents=True, exist_ok=True)
-    _loaded = True
-
-
-# ---------------------------------------------------------------------------
-# Mode detection
-# ---------------------------------------------------------------------------
-
-
-def detect_mode() -> str:
-    override = os.environ.get("SWARM_MODE", "")
-    if override:
-        return override
-    if shutil.which("tmux"):
-        return "tmux"
-    if shutil.which("screen"):
-        return "screen"
-    return "none"
-
-
-MODE: str = ""
-
-
-# ---------------------------------------------------------------------------
-# Attendance (打卡)
-# ---------------------------------------------------------------------------
-
-
-def clock_in(name: str) -> None:
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    with open(ATTENDANCE_LOG, "a") as f:
-        f.write(f"{ts} | {name} | clock-in\n")
-
-
-def clock_out(name: str) -> None:
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    with open(ATTENDANCE_LOG, "a") as f:
-        f.write(f"{ts} | {name} | clock-out\n")
-
-
-def do_attendance() -> None:
-    if not ATTENDANCE_LOG.exists():
-        print("No attendance records yet.")
-        return
-    today = datetime.now().strftime("%Y-%m-%d")
-    lines = ATTENDANCE_LOG.read_text().splitlines()
-    print(f"=== 出勤记录 (今日: {today}) ===")
-    print()
-    for name in SESSIONS:
-        today_ins = [l for l in lines if f"| {name} | clock-in" in l and l.startswith(today)]
-        today_outs = [l for l in lines if f"| {name} | clock-out" in l and l.startswith(today)]
-        last_in = today_ins[-1].split("|")[0].strip() if today_ins else ""
-        last_out = today_outs[-1].split("|")[0].strip() if today_outs else ""
-        if last_in and not last_out:
-            print(f"  {name}: 在岗 (上班 {last_in})")
-        elif last_out:
-            print(f"  {name}: 已下班 (最后 {last_out})")
-        else:
-            print(f"  {name}: 今日未上班")
-    print()
-    print(f"历史记录: {ATTENDANCE_LOG}")
-
-
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
-
-
-def log_startup(name: str) -> None:
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    msg = f"[{ts}] Starting {name} with agent: {SWARM_AGENT}\n"
-    with open(LOG_DIR / "swarm.log", "a") as f:
-        f.write(msg)
-    with open(LOG_DIR / f"{name}.log", "a") as f:
-        f.write(msg)
-
-
-# ---------------------------------------------------------------------------
-# Agent command builder
-# ---------------------------------------------------------------------------
-
-
-def is_deepseek_session(name: str) -> bool:
-    return name in DEEPSEEK_SESSIONS.split()
-
-
-def _worker_system_prompt(name: str) -> str:
-    board = f"{CLAUDES_HOME}/bin/board"
-    return (
-        f"你是 {name}，cnb 团队的一员。你在后台工作，通过消息板与组长和同学协作。\n"
-        f"协作命令：\n"
-        f"  {board} --as {name} inbox          # 查看收件箱\n"
-        f"  {board} --as {name} ack            # 清空收件箱\n"
-        f'  {board} --as {name} send <to> "msg" # 发消息\n'
-        f'  {board} --as {name} status "desc"  # 更新状态\n'
-        f"  {board} --as {name} task done      # 完成当前任务\n"
-        f"规则：启动时先 inbox，完成任务后再 inbox，有进展随时汇报给发任务的人。\n"
-        f"你可以直接 send 给任何同学协作，不用什么都通过一个人转。"
-    )
-
-
-def build_agent_cmd(name: str) -> str:
-    env_prefix = ""
-    if is_deepseek_session(name):
-        env_prefix = "ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic ANTHROPIC_API_KEY=$DEEPSEEK_API_KEY "
-    prompt = _worker_system_prompt(name)
-    escaped_prompt = prompt.replace("'", "'\\''")
-    if SWARM_AGENT == "claude":
-        if is_deepseek_session(name):
-            return (
-                f"{env_prefix}claude --model deepseek-v4-pro[1m] --name '{name}' "
-                f"--append-system-prompt '{escaped_prompt}'"
-            )
-        else:
-            return f"claude --name '{name}' --dangerously-skip-permissions --append-system-prompt '{escaped_prompt}'"
-    elif SWARM_AGENT == "trae":
-        return "trae-cli"
-    elif SWARM_AGENT == "qwen":
-        return "qwen"
-    else:
-        print(f"Unknown agent: {SWARM_AGENT}", file=sys.stderr)
-        sys.exit(1)
-
-
-def needs_prompt_injection() -> bool:
-    return SWARM_AGENT in ("trae", "qwen")
-
-
-def get_initial_prompt(name: str) -> str:
-    engine_labels = {"trae": "Trae CLI", "qwen": "Qwen Code"}
-    engine_label = engine_labels.get(SWARM_AGENT, SWARM_AGENT)
-    return (
-        f"你是 {name}。你正在使用 {engine_label} 引擎。"
-        f"按 CLAUDE.md 的启动流程执行："
-        f"1. 读取 {SESSIONS_DIR}/{name}.md，"
-        f"2. 读取 {CV_DIR}/{name}.md（如果存在），"
-        f"3. 用 '{CLAUDES_HOME}/bin/board' --as {name} inbox 检查未读消息，"
-        f"4. 根据 session 文件中的下一步继续工作，"
-        f"如果没有明确任务，读 ROADMAP.md 自主找活干。"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Role filtering
-# ---------------------------------------------------------------------------
-
-
-def get_role(name: str) -> str:
-    if not ROSTER_FILE.exists():
-        return "unknown"
-    try:
-        text = ROSTER_FILE.read_text()
-    except OSError:
-        return "unknown"
-    for line in text.splitlines():
-        if re.search(rf"\| \*\*{re.escape(name)}\*\*", line, re.IGNORECASE):
-            lower = line.lower()
-            if "实习生" in lower:
-                return "intern"
-            if "调度员" in lower:
-                return "dispatcher"
-            if "lead" in lower:
-                return "lead"
-            return "dev"
-    return "unknown"
-
-
-def filter_by_role(role_filter: str, exclude_filter: str) -> list[str]:
-    result: list[str] = []
-    for name in SESSIONS:
-        role = get_role(name)
-        if exclude_filter and role == exclude_filter:
-            continue
-        if role_filter and role != role_filter:
-            continue
-        result.append(name)
-    return result
-
-
-def is_valid_session(name: str) -> bool:
-    return name in SESSIONS
-
-
-# ---------------------------------------------------------------------------
-# tmux backend
-# ---------------------------------------------------------------------------
-
-
-def tmux_is_running(name: str) -> bool:
-    sess = f"{PREFIX}-{name}"
-    r = subprocess.run(
-        ["tmux", "has-session", "-t", sess],
-        capture_output=True,
-    )
-    return r.returncode == 0
-
-
-def _inject_initial_prompt(name: str, sess: str) -> None:
-    """Wait for Claude Code prompt to appear, then inject startup message."""
-    initial_prompt = get_initial_prompt(name)
-    waited = 0
-    while waited < 60:
-        r = subprocess.run(
-            ["tmux", "capture-pane", "-t", sess, "-p"],
-            capture_output=True,
-            text=True,
-        )
-        pane_text = r.stdout if r.returncode == 0 else ""
-        if "❯" in pane_text:
-            time.sleep(1)  # small buffer after prompt appears
-            subprocess.run(["tmux", "send-keys", "-t", sess, "-l", initial_prompt])
-            subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"])
-            return
-        time.sleep(2)
-        waited += 2
-    # Timeout — log warning
-    with open(LOG_DIR / f"{name}.log", "a") as f:
-        f.write(f"[WARN] {name}: prompt not detected after 60s, skipping injection\n")
-
-
-def _auto_accept_trust(name: str, sess: str) -> None:
-    waited = 0
-    while waited < 60:
-        r = subprocess.run(["tmux", "capture-pane", "-t", sess, "-p"], capture_output=True, text=True)
-        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
-
-
-_pending_threads: list[threading.Thread] = []
-
-
-def _wait_for_shell(sess: str, timeout: int = 15) -> bool:
-    """Poll tmux pane until a shell prompt appears."""
-    waited = 0
-    while waited < timeout:
-        r = subprocess.run(["tmux", "capture-pane", "-t", sess, "-p"], capture_output=True, text=True)
-        if r.returncode == 0 and ("$" in r.stdout or "%" in r.stdout or "❯" in r.stdout):
-            return True
-        time.sleep(1)
-        waited += 1
-    return False
-
-
-def _ensure_registered(names: list[str]) -> None:
-    """Auto-register unknown session names in DB and config.toml."""
-    import sqlite3 as _sqlite3
-
-    db_path = CLAUDES_DIR / "board.db"
-    if not db_path.exists():
-        return
-    conn = _sqlite3.connect(str(db_path))
-    conn.execute("PRAGMA journal_mode=WAL;")
-    existing = {r[0] for r in conn.execute("SELECT name FROM sessions").fetchall()}
-    new_names = [n for n in names if n not in existing]
-    if not new_names:
-        conn.close()
-        return
-    for n in new_names:
-        conn.execute("INSERT OR IGNORE INTO sessions(name, persona) VALUES (?, ?)", (n, ""))
-        md = SESSIONS_DIR / f"{n}.md"
-        if not md.exists():
-            md.write_text(f"# {n}\n\n## Current task\n(none)\n\n## @inbox\n")
-    conn.commit()
-    conn.close()
-
-    config_path = CLAUDES_DIR / "config.toml"
-    if config_path.exists():
-        text = config_path.read_text()
-        for n in new_names:
-            if f'"{n}"' not in text:
-                text = text.replace("sessions = [", f'sessions = ["{n}", ', 1)
-                text += f'\n[session.{n}]\npersona = ""\n'
-        config_path.write_text(text)
-    SESSIONS.extend(new_names)
-
-
-def tmux_start_one(name: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if tmux_is_running(name):
-        print(f"  {name}: already running")
-        return
-
-    log_startup(name)
-
-    subprocess.run(["tmux", "new-session", "-d", "-s", sess, "-x", "200", "-y", "50"])
-
-    _wait_for_shell(sess, timeout=10)
-    subprocess.run(
-        [
-            "tmux",
-            "send-keys",
-            "-t",
-            sess,
-            f"source ~/.zprofile 2>/dev/null; source ~/.zshrc 2>/dev/null; cd '{PROJECT_ROOT}'",
-            "Enter",
-        ]
-    )
-
-    _wait_for_shell(sess, timeout=10)
-
-    if is_deepseek_session(name):
-        subprocess.run(["tmux", "send-keys", "-t", sess, "claude /logout 2>/dev/null; true", "Enter"])
-        time.sleep(1)
-
-    agent_cmd = build_agent_cmd(name)
-    subprocess.run(["tmux", "send-keys", "-t", sess, agent_cmd, "Enter"])
-
-    t_trust = threading.Thread(target=_auto_accept_trust, args=(name, sess))
-    t_trust.start()
-    _pending_threads.append(t_trust)
-
-    t = threading.Thread(target=_inject_initial_prompt, args=(name, sess))
-    t.start()
-    _pending_threads.append(t)
-
-    print(f"  {name}: started (tmux: {sess}, agent: {SWARM_AGENT})")
-
-
-def tmux_stop_one(name: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if not tmux_is_running(name):
-        print(f"  {name}: not running")
-        return
-
-    # Ask session to save state before exiting
-    save_cmd = (
-        f"git add -A && git commit -m '[WIP][{name}] auto-save before shutdown' "
-        f"--allow-empty-message 2>/dev/null; "
-        f"'{CLAUDES_HOME}/bin/board' --as {name} status 'shutdown: state saved'"
-    )
-    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"])
-
-    # Wait up to 15s for graceful exit
-    waited = 0
-    while tmux_is_running(name) and waited < 15:
-        time.sleep(1)
-        waited += 1
-    if tmux_is_running(name):
-        subprocess.run(["tmux", "kill-session", "-t", sess])
-        print(f"  {name}: force killed (after {waited}s)")
-    else:
-        print(f"  {name}: exited gracefully")
-
-
-def tmux_status() -> None:
-    for name in SESSIONS:
-        if is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: SUSPENDED")
-        elif tmux_is_running(name):
-            print(f"  {name}: running (tmux, agent: {SWARM_AGENT})")
-        else:
-            print(f"  {name}: stopped")
-
-
-def tmux_attach(name: str) -> None:
-    os.execvp("tmux", ["tmux", "attach-session", "-t", f"{PREFIX}-{name}"])
-
-
-def tmux_inject(name: str, message: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if not tmux_is_running(name):
-        print(f"  {name}: not running")
-        sys.exit(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")
-
-
-# ---------------------------------------------------------------------------
-# screen backend
-# ---------------------------------------------------------------------------
-
-
-def screen_is_running(name: str) -> bool:
-    sess_tag = f".{PREFIX}-{name}"
-    r = subprocess.run(["screen", "-list"], capture_output=True, text=True)
-    output = r.stdout + r.stderr  # screen may write to stderr
-    return bool(re.search(rf"{re.escape(sess_tag)}\s", output))
-
-
-def screen_start_one(name: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if screen_is_running(name):
-        print(f"  {name}: already running")
-        return
-
-    log_startup(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)
-
-    agent_cmd = build_agent_cmd(name)
-    subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", agent_cmd])
-    subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
-
-    if needs_prompt_injection():
-        time.sleep(3)
-        initial_prompt = get_initial_prompt(name)
-        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", initial_prompt])
-        time.sleep(0.3)
-        subprocess.run(["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"])
-
-    print(f"  {name}: started (screen: {sess}, agent: {SWARM_AGENT})")
-
-
-def screen_stop_one(name: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if not screen_is_running(name):
-        print(f"  {name}: not running")
-        return
-
-    # Ask session to save state before exiting
-    save_cmd = (
-        f"git add -A && git commit -m '[WIP][{name}] auto-save before shutdown' "
-        f"--allow-empty-message 2>/dev/null; "
-        f"'{CLAUDES_HOME}/bin/board' --as {name} status 'shutdown: state saved'"
-    )
-    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"])
-
-    # Wait up to 15s for graceful exit
-    waited = 0
-    while screen_is_running(name) and waited < 15:
-        time.sleep(1)
-        waited += 1
-    if screen_is_running(name):
-        subprocess.run(["screen", "-S", sess, "-X", "quit"])
-        print(f"  {name}: force killed (after {waited}s)")
-    else:
-        print(f"  {name}: exited gracefully")
-
-
-def screen_status() -> None:
-    for name in SESSIONS:
-        if is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: SUSPENDED")
-        elif screen_is_running(name):
-            r = subprocess.run(["screen", "-list"], capture_output=True, text=True)
-            output = r.stdout + r.stderr
-            state = ""
-            for line in output.splitlines():
-                if f".{PREFIX}-{name}" in line:
-                    parts = line.strip().split()
-                    if parts:
-                        state = parts[-1]
-                    break
-            print(f"  {name}: running (screen, agent: {SWARM_AGENT}) {state}")
-        else:
-            print(f"  {name}: stopped")
-
-
-def screen_attach(name: str) -> None:
-    os.execvp("screen", ["screen", "-r", f"{PREFIX}-{name}"])
-
-
-def screen_inject(name: str, message: str) -> None:
-    sess = f"{PREFIX}-{name}"
-    if not screen_is_running(name):
-        print(f"  {name}: not running")
-        sys.exit(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")
-
-
-# ---------------------------------------------------------------------------
-# Backend dispatch helpers
-# ---------------------------------------------------------------------------
-
-
-def backend_is_running(name: str) -> bool:
-    if MODE == "tmux":
-        return tmux_is_running(name)
-    return screen_is_running(name)
-
-
-def backend_start_one(name: str) -> None:
-    if MODE == "tmux":
-        tmux_start_one(name)
-    else:
-        screen_start_one(name)
-
-
-def backend_stop_one(name: str) -> None:
-    if MODE == "tmux":
-        tmux_stop_one(name)
-    else:
-        screen_stop_one(name)
-
-
-def backend_status() -> None:
-    if MODE == "tmux":
-        tmux_status()
-    else:
-        screen_status()
-
-
-def backend_attach(name: str) -> None:
-    if MODE == "tmux":
-        tmux_attach(name)
-    else:
-        screen_attach(name)
-
-
-# ---------------------------------------------------------------------------
-# High-level commands
-# ---------------------------------------------------------------------------
-
-
-def do_start(args: list[str]) -> None:
-    role_filter = ""
-    exclude_filter = ""
-    dry_run = False
+def _parse_start_args(args: list[str]) -> tuple[list[str], dict]:
     names: list[str] = []
+    kwargs: dict = {"dry_run": False, "role": "", "exclude": ""}
     for arg in args:
         if arg == "--dry-run":
-            dry_run = True
+            kwargs["dry_run"] = True
         elif arg.startswith("--role="):
-            role_filter = arg.split("=", 1)[1]
+            kwargs["role"] = arg.split("=", 1)[1]
         elif arg.startswith("--exclude="):
-            exclude_filter = arg.split("=", 1)[1]
+            kwargs["exclude"] = arg.split("=", 1)[1]
         else:
             names.append(arg)
+    return names, kwargs
 
-    if not names:
-        if role_filter or exclude_filter:
-            targets = filter_by_role(role_filter, exclude_filter)
-        else:
-            targets = list(SESSIONS)
-    else:
-        targets = names
 
-    if dry_run:
-        print(f"=== DRY RUN: would start {len(targets)} session(s) ===")
-        for name in targets:
-            if is_suspended(name, SUSPENDED_FILE):
-                print(f"  {name}: SUSPENDED (would skip)")
-            elif backend_is_running(name):
-                print(f"  {name}: already running (would skip)")
-            else:
-                print(f"  {name}: would start (mode: {MODE}, agent: {SWARM_AGENT})")
-        return
-
-    _ensure_registered(targets)
-
-    if MODE == "tmux":
-        subprocess.run(["tmux", "set", "-g", "mouse", "on"], capture_output=True)
-
-    started = 0
-    for name in targets:
-        if is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: SUSPENDED (use './swarm resume {name}' to reactivate)")
-            continue
-        backend_start_one(name)
-        clock_in(name)
-        started += 1
-
-    for t in _pending_threads:
-        t.join(timeout=90)
-    _pending_threads.clear()
-
-    print()
-    print(f"Mode: {MODE} | Agent: {SWARM_AGENT} | Started: {started}")
-    print(f"Logs: {LOG_DIR}")
-    if MODE == "tmux":
-        print(f"  tmux attach -t {PREFIX}-<name>   # attach (Ctrl-B D to detach)")
-    else:
-        print(f"  screen -r {PREFIX}-<name>        # attach (Ctrl-A D to detach)")
-    print("  ./swarm status                 # who's running")
-
-
-def do_status() -> None:
-    print(f"=== Swarm Status (mode: {MODE}, agent: {SWARM_AGENT}) ===")
-    backend_status()
-
-
-def do_stop(args: list[str]) -> None:
-    dry_run = False
-    force = False
+def _parse_stop_args(args: list[str]) -> tuple[list[str], dict]:
     names: list[str] = []
+    kwargs: dict = {"dry_run": False, "force": False}
     for arg in args:
-        if arg in ("--dry-run",):
-            dry_run = True
+        if arg == "--dry-run":
+            kwargs["dry_run"] = True
         elif arg in ("--force", "--yes", "-y"):
-            force = True
+            kwargs["force"] = True
         else:
             names.append(arg)
-
-    if not names:
-        targets = list(SESSIONS)
-    else:
-        targets = names
-
-    if dry_run:
-        print(f"=== DRY RUN: would stop {len(targets)} session(s) ===")
-        for name in targets:
-            if backend_is_running(name):
-                print(f"  {name}: would stop (running)")
-            else:
-                print(f"  {name}: not running (would skip)")
-        return
-
-    # Confirmation when stopping all sessions
-    if not names and not force:
-        running_count = sum(1 for n in targets if backend_is_running(n))
-        if running_count > 0:
-            print(f"About to stop ALL sessions ({running_count} running).")
-            try:
-                answer = input("Continue? [y/N] ").strip().lower()
-            except (EOFError, KeyboardInterrupt):
-                print("\nCancelled.")
-                return
-            if answer not in ("y", "yes"):
-                print("Cancelled.")
-                return
-
-    for name in targets:
-        backend_stop_one(name)
-        clock_out(name)
-
-    # If stopping all sessions, also kill dispatcher by PID file
-    if not names:
-        for pidname in ("dispatcher.pid", "dispatcher-watchdog.pid"):
-            pidfile = CLAUDES_DIR / pidname
-            if pidfile.exists():
-                try:
-                    pid = int(pidfile.read_text().strip())
-                    os.kill(pid, 0)  # check alive
-                    os.kill(pid, 15)  # SIGTERM
-                except (ValueError, ProcessLookupError, PermissionError):
-                    pass
-                pidfile.unlink(missing_ok=True)
-
-
-def do_attach(args: list[str]) -> None:
-    if not args:
-        print("Usage: ./swarm attach <name>", file=sys.stderr)
-        sys.exit(1)
-    backend_attach(args[0])
-
-
-def do_suspend(args: list[str]) -> None:
-    if not args:
-        print("Usage: ./swarm suspend <name> [names...]", file=sys.stderr)
-        sys.exit(1)
-    for name in args:
-        if not is_valid_session(name):
-            print(f"  {name}: unknown session (valid: {' '.join(SESSIONS)})", file=sys.stderr)
-            continue
-        if is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: already suspended")
-            continue
-        with open(SUSPENDED_FILE, "a") as f:
-            f.write(name + "\n")
-        if backend_is_running(name):
-            backend_stop_one(name)
-            clock_out(name)
-        print(f"  {name}: suspended")
-
-
-def do_resume(args: list[str]) -> None:
-    if not args:
-        print("Usage: ./swarm resume <name> [names...]", file=sys.stderr)
-        sys.exit(1)
-    for name in args:
-        if not is_valid_session(name):
-            print(f"  {name}: unknown session (valid: {' '.join(SESSIONS)})", file=sys.stderr)
-            continue
-        if not is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: not suspended")
-            continue
-        # Remove from suspended list
-        if SUSPENDED_FILE.exists():
-            lines = [l for l in SUSPENDED_FILE.read_text().splitlines() if l != name]
-            SUSPENDED_FILE.write_text("\n".join(lines) + "\n" if lines else "")
-        backend_start_one(name)
-        time.sleep(1)
-        if backend_is_running(name):
-            clock_in(name)
-            print(f"  {name}: resumed + started")
-        else:
-            print(
-                f"  {name}: resumed but FAILED to start (check tmux/claude availability)",
-                file=sys.stderr,
-            )
-
-
-def do_restart(args: list[str]) -> None:
-    if not args:
-        targets = [n for n in SESSIONS if not is_suspended(n, SUSPENDED_FILE)]
-    else:
-        targets = args
-
-    print(f"=== Restarting {len(targets)} session(s) ===")
-    for name in targets:
-        if is_suspended(name, SUSPENDED_FILE):
-            print(f"  {name}: SUSPENDED (use './swarm resume {name}' to reactivate)")
-            continue
-        backend_stop_one(name)
-        time.sleep(1)
-        backend_start_one(name)
-        print(f"  {name}: restarted")
-
-
-def do_morning() -> None:
-    print("=== Morning startup (all non-intern, non-dispatcher) ===")
-    targets: list[str] = []
-    for name in SESSIONS:
-        role = get_role(name)
-        if role in ("intern", "dispatcher"):
-            continue
-        targets.append(name)
-
-    resumed = 0
-    started = 0
-    failed = 0
-    for name in targets:
-        if is_suspended(name, SUSPENDED_FILE):
-            # Remove from suspended list
-            if SUSPENDED_FILE.exists():
-                lines = [l for l in SUSPENDED_FILE.read_text().splitlines() if l != name]
-                SUSPENDED_FILE.write_text("\n".join(lines) + "\n" if lines else "")
-            resumed += 1
-        backend_start_one(name)
-        clock_in(name)
-        if backend_is_running(name):
-            started += 1
-        else:
-            failed += 1
-            print(f"  WARNING: {name} failed to start")
-
-    print()
-    print(f"Results: {started} started, {resumed} resumed from suspend, {failed} failed")
-    print("Skipped roles: intern, dispatcher")
-    print()
-    print("To also start interns: ./swarm start --role=intern")
-    print("To start dispatcher:   ./swarm start <dispatcher>")
-
-
-def cmd_help() -> None:
-    print(f"""\
-swarm — manage multi-agent session swarm
-
-Mode: {MODE} (override with SWARM_MODE=tmux|screen)
-Agent: {SWARM_AGENT} (override with SWARM_AGENT=claude|trae|qwen)
-
-  start [names...]    Launch sessions (default: all non-suspended)
-  start --role=dev    Launch only sessions with matching role
-  start --exclude=intern  Launch all except matching role
-  status              Who's running
-  stop [names...]     Gracefully stop sessions (default: all)
-  restart [names...]  Stop + start (default: all non-suspended)
-  suspend <names...>  Suspend sessions (stop + skip on future starts)
-  resume <names...>   Resume suspended sessions (remove from list + start)
-  morning             Resume + start all dev sessions (excludes intern/dispatcher)
-  attach <name>       Attach to session
-  help                This message
-
-Roles (from ROSTER.md): lead, dev, intern, dispatcher
-
-Examples:
-  ./swarm start                           # launch all with Claude (default)
-  SWARM_AGENT=trae ./swarm start          # launch all with Trae
-  SWARM_AGENT=qwen ./swarm start          # launch all with Qwen
-  SWARM_AGENT=qwen ./swarm start alice bob  # launch specific sessions with Qwen
-  ./swarm start alice bob                 # launch two with default agent
-  ./swarm attach alice                     # interactive access
-  ./swarm stop bob                       # stop one
-  SWARM_MODE=screen ./swarm start         # force screen mode""")
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
+    return names, kwargs
 
 
 def main() -> None:
-    _load()
-    if MODE == "none":
-        print(
-            "ERROR: neither tmux nor screen found. Install one: brew install tmux",
-            file=sys.stderr,
-        )
-        sys.exit(1)
+    cfg = SwarmConfig.load()
+    mgr = SwarmManager(cfg)
 
     cmd = sys.argv[1] if len(sys.argv) > 1 else "help"
     rest = sys.argv[2:]
 
-    commands = {
-        "start": lambda: do_start(rest),
-        "status": lambda: do_status(),
-        "stop": lambda: do_stop(rest),
-        "restart": lambda: do_restart(rest),
-        "suspend": lambda: do_suspend(rest),
-        "resume": lambda: do_resume(rest),
-        "morning": lambda: do_morning(),
-        "attach": lambda: do_attach(rest),
-        "attendance": lambda: do_attendance(),
-        "help": cmd_help,
-        "-h": cmd_help,
-        "--help": cmd_help,
-    }
-
-    handler = commands.get(cmd)
-    if handler:
-        handler()
+    if cmd == "start":
+        names, kwargs = _parse_start_args(rest)
+        mgr.start(names, **kwargs)
+    elif cmd == "stop":
+        names, kwargs = _parse_stop_args(rest)
+        mgr.stop(names, **kwargs)
+    elif cmd == "status":
+        mgr.status()
+    elif cmd == "restart":
+        mgr.restart(rest)
+    elif cmd == "suspend":
+        mgr.suspend(rest)
+    elif cmd == "resume":
+        mgr.resume(rest)
+    elif cmd == "attach":
+        mgr.attach(rest[0] if rest else "")
+    elif cmd == "attendance":
+        mgr.attendance()
+    elif cmd in ("help", "-h", "--help"):
+        mgr.help()
     else:
-        print(f"Unknown: {cmd} (try ./swarm help)", file=sys.stderr)
-        sys.exit(1)
+        print(f"Unknown: {cmd} (try swarm help)")
+        raise SystemExit(1)
 
 
 if __name__ == "__main__":