agent-teams-cli 0.1.1__tar.gz

agent_teams_cli-0.1.1/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: agent-teams-cli
+Version: 0.1.1
+Summary: File-based agent team coordination for OpenClaw
+Author: Marcus
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# agent-teams
+
+File-based agent team coordination for [OpenClaw](https://github.com/nichochar/openclaw). Inspired by Claude Code's teams architecture.
+
+## Features
+
+- **Team management** — create/delete teams, add/remove members
+- **Mailbox IPC** — file-based inboxes with cursor-based polling
+- **Shared task list** — file-locked atomic task claims
+- **XML context injection** — poll output formatted for agent prompt injection
+- **Zero dependencies** — pure Python, no servers, no databases
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Create a team
+agent-teams create my-team --members lead researcher builder
+
+# Send a message
+agent-teams send lead@my-team researcher@my-team --text "Find papers on X"
+
+# Poll inbox (XML for context injection)
+agent-teams poll researcher@my-team
+
+# Create and manage tasks
+agent-teams task-create my-team -s "Research task" --assign-to researcher --assign-by lead
+agent-teams task-claim my-team 1 researcher
+agent-teams task-complete my-team 1 researcher -r "Done!"
+```
+
+See [SKILL.md](../../skills/agent-teams/SKILL.md) for full documentation.
+
+## License
+
+MIT

agent_teams_cli-0.1.1/README.md

@@ -0,0 +1,41 @@
+# agent-teams
+
+File-based agent team coordination for [OpenClaw](https://github.com/nichochar/openclaw). Inspired by Claude Code's teams architecture.
+
+## Features
+
+- **Team management** — create/delete teams, add/remove members
+- **Mailbox IPC** — file-based inboxes with cursor-based polling
+- **Shared task list** — file-locked atomic task claims
+- **XML context injection** — poll output formatted for agent prompt injection
+- **Zero dependencies** — pure Python, no servers, no databases
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Create a team
+agent-teams create my-team --members lead researcher builder
+
+# Send a message
+agent-teams send lead@my-team researcher@my-team --text "Find papers on X"
+
+# Poll inbox (XML for context injection)
+agent-teams poll researcher@my-team
+
+# Create and manage tasks
+agent-teams task-create my-team -s "Research task" --assign-to researcher --assign-by lead
+agent-teams task-claim my-team 1 researcher
+agent-teams task-complete my-team 1 researcher -r "Done!"
+```
+
+See [SKILL.md](../../skills/agent-teams/SKILL.md) for full documentation.
+
+## License
+
+MIT

agent_teams_cli-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-teams-cli"
+version = "0.1.1"
+description = "File-based agent team coordination for OpenClaw"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "Marcus"}]
+dependencies = []
+
+[project.scripts]
+agent-teams = "agent_teams.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

agent_teams_cli-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_teams_cli-0.1.1/src/agent_teams/__init__.py

@@ -0,0 +1,2 @@
+"""Agent Teams - file-based agent coordination for OpenClaw."""
+__version__ = "0.1.0"

agent_teams_cli-0.1.1/src/agent_teams/cli.py

@@ -0,0 +1,137 @@
+"""CLI for agent-teams."""
+
+import argparse
+import json
+import sys
+from . import core
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="agent-teams", description="Agent team coordination")
+    parser.add_argument("--json", action="store_true", help="JSON output")
+    sub = parser.add_subparsers(dest="command")
+
+    # team create
+    p = sub.add_parser("create", help="Create a team")
+    p.add_argument("team", help="Team name")
+    p.add_argument("--members", nargs="*", default=[], help="Initial members")
+
+    # team delete
+    p = sub.add_parser("delete", help="Delete a team")
+    p.add_argument("team")
+
+    # team list
+    sub.add_parser("list", help="List teams")
+
+    # team info
+    p = sub.add_parser("info", help="Team info")
+    p.add_argument("team")
+
+    # add-member
+    p = sub.add_parser("add-member", help="Add member to team")
+    p.add_argument("team")
+    p.add_argument("name")
+
+    # remove-member
+    p = sub.add_parser("remove-member", help="Remove member from team")
+    p.add_argument("team")
+    p.add_argument("name")
+
+    # send
+    p = sub.add_parser("send", help="Send a message")
+    p.add_argument("sender", help="sender@team")
+    p.add_argument("recipient", help="recipient@team")
+    p.add_argument("--text", "-t", required=True)
+    p.add_argument("--type", default="message", dest="msg_type")
+
+    # broadcast
+    p = sub.add_parser("broadcast", help="Broadcast to team")
+    p.add_argument("sender", help="sender@team")
+    p.add_argument("--text", "-t", required=True)
+
+    # poll
+    p = sub.add_parser("poll", help="Poll inbox for new messages")
+    p.add_argument("identity", help="agent@team")
+    p.add_argument("--format", choices=["xml", "json"], default="xml")
+
+    # inbox
+    p = sub.add_parser("inbox", help="Read full inbox")
+    p.add_argument("identity", help="agent@team")
+
+    # task create
+    p = sub.add_parser("task-create", help="Create a task")
+    p.add_argument("team")
+    p.add_argument("--subject", "-s", required=True)
+    p.add_argument("--description", "-d", default="")
+    p.add_argument("--assign-to", default="")
+    p.add_argument("--assign-by", default="")
+
+    # task claim
+    p = sub.add_parser("task-claim", help="Claim a task")
+    p.add_argument("team")
+    p.add_argument("task_id")
+    p.add_argument("agent")
+
+    # task complete
+    p = sub.add_parser("task-complete", help="Complete a task")
+    p.add_argument("team")
+    p.add_argument("task_id")
+    p.add_argument("agent")
+    p.add_argument("--result", "-r", default="")
+
+    # task list
+    p = sub.add_parser("task-list", help="List tasks")
+    p.add_argument("team")
+    p.add_argument("--status", choices=["pending", "in_progress", "completed"])
+
+    args = parser.parse_args()
+    use_json = args.json
+
+    def output(data):
+        if use_json:
+            print(json.dumps(data, indent=2))
+        else:
+            print(json.dumps(data, indent=2))
+
+    try:
+        if args.command == "create":
+            output(core.create_team(args.team, args.members))
+        elif args.command == "delete":
+            ok = core.delete_team(args.team)
+            output({"deleted": ok})
+        elif args.command == "list":
+            output(core.list_teams())
+        elif args.command == "info":
+            output(core.team_info(args.team))
+        elif args.command == "add-member":
+            output(core.add_member(args.team, args.name))
+        elif args.command == "remove-member":
+            output(core.remove_member(args.team, args.name))
+        elif args.command == "send":
+            output(core.send_message(args.sender, args.recipient, args.text, args.msg_type))
+        elif args.command == "broadcast":
+            output(core.broadcast(args.sender, args.text))
+        elif args.command == "poll":
+            result = core.poll_inbox(args.identity, args.format)
+            if result:
+                print(result)
+        elif args.command == "inbox":
+            output(core.read_inbox(args.identity))
+        elif args.command == "task-create":
+            output(core.create_task(args.team, args.subject, args.description, args.assign_to, args.assign_by))
+        elif args.command == "task-claim":
+            output(core.claim_task(args.team, args.task_id, args.agent))
+        elif args.command == "task-complete":
+            output(core.complete_task(args.team, args.task_id, args.agent, args.result))
+        elif args.command == "task-list":
+            output(core.list_tasks(args.team, args.status))
+        else:
+            parser.print_help()
+            sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

agent_teams_cli-0.1.1/src/agent_teams/core.py

@@ -0,0 +1,303 @@
+"""Core library for agent-teams: team management, mailbox IPC, task coordination."""
+
+import json
+import os
+import fcntl
+import time
+import uuid
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Optional
+
+TEAMS_ROOT = Path.home() / ".openclaw" / "teams"
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+def _parse_identity(identity: str) -> tuple[str, str]:
+    """Parse 'name@team' into (name, team)."""
+    if "@" not in identity:
+        raise ValueError(f"Invalid identity '{identity}', expected name@team")
+    name, team = identity.split("@", 1)
+    return name, team
+
+def _team_dir(team: str) -> Path:
+    return TEAMS_ROOT / team
+
+def _inbox_path(team: str, agent: str) -> Path:
+    return _team_dir(team) / "inboxes" / f"{agent}.json"
+
+def _tasks_dir(team: str) -> Path:
+    return _team_dir(team) / "tasks"
+
+def _config_path(team: str) -> Path:
+    return _team_dir(team) / "config.json"
+
+def _cursor_path(team: str, agent: str) -> Path:
+    return _team_dir(team) / "inboxes" / f".{agent}.cursor"
+
+# ── Team Management ──
+
+def create_team(team: str, members: Optional[list[str]] = None) -> dict:
+    d = _team_dir(team)
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "inboxes").mkdir(exist_ok=True)
+    (d / "tasks").mkdir(exist_ok=True)
+    cp = _config_path(team)
+    if cp.exists():
+        # Don't overwrite existing team config
+        config = json.loads(cp.read_text())
+        # Merge in any new members
+        for m in (members or []):
+            if m not in config["members"]:
+                config["members"].append(m)
+        cp.write_text(json.dumps(config, indent=2))
+    else:
+        config = {"name": team, "members": members or [], "created": _now()}
+        cp.write_text(json.dumps(config, indent=2))
+    # Create inboxes for initial members
+    for m in (members or []):
+        _inbox_path(team, m).write_text("[]")
+    return config
+
+def delete_team(team: str) -> bool:
+    import shutil
+    d = _team_dir(team)
+    if d.exists():
+        shutil.rmtree(d)
+        return True
+    return False
+
+def add_member(team: str, name: str) -> dict:
+    cp = _config_path(team)
+    config = json.loads(cp.read_text())
+    if name not in config["members"]:
+        config["members"].append(name)
+        cp.write_text(json.dumps(config, indent=2))
+    _inbox_path(team, name).write_text("[]")
+    return config
+
+def remove_member(team: str, name: str) -> dict:
+    cp = _config_path(team)
+    config = json.loads(cp.read_text())
+    config["members"] = [m for m in config["members"] if m != name]
+    cp.write_text(json.dumps(config, indent=2))
+    inbox = _inbox_path(team, name)
+    if inbox.exists():
+        inbox.unlink()
+    cursor = _cursor_path(team, name)
+    if cursor.exists():
+        cursor.unlink()
+    return config
+
+def list_teams() -> list[dict]:
+    if not TEAMS_ROOT.exists():
+        return []
+    teams = []
+    for d in sorted(TEAMS_ROOT.iterdir()):
+        cp = d / "config.json"
+        if cp.exists():
+            teams.append(json.loads(cp.read_text()))
+    return teams
+
+def team_info(team: str) -> dict:
+    return json.loads(_config_path(team).read_text())
+
+# ── Mailbox ──
+
+def send_message(from_id: str, to_id: str, text: str, msg_type: str = "message") -> dict:
+    from_name, from_team = _parse_identity(from_id)
+    to_name, to_team = _parse_identity(to_id)
+    if from_team != to_team:
+        raise ValueError("Cross-team messaging not supported")
+    msg = {
+        "id": str(uuid.uuid4())[:8],
+        "from": from_name,
+        "to": to_name,
+        "type": msg_type,
+        "text": text,
+        "timestamp": _now(),
+    }
+    _append_to_inbox(to_team, to_name, msg)
+    return msg
+
+def broadcast(from_id: str, text: str, msg_type: str = "broadcast") -> list[dict]:
+    from_name, team = _parse_identity(from_id)
+    config = team_info(team)
+    msgs = []
+    for member in config["members"]:
+        if member != from_name:
+            msg = {
+                "id": str(uuid.uuid4())[:8],
+                "from": from_name,
+                "to": member,
+                "type": msg_type,
+                "text": text,
+                "timestamp": _now(),
+            }
+            _append_to_inbox(team, member, msg)
+            msgs.append(msg)
+    return msgs
+
+def _append_to_inbox(team: str, agent: str, msg: dict):
+    path = _inbox_path(team, agent)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # File-locked append
+    with open(path, "a+") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        try:
+            f.seek(0)
+            content = f.read().strip()
+            inbox = json.loads(content) if content else []
+            inbox.append(msg)
+            f.seek(0)
+            f.truncate()
+            f.write(json.dumps(inbox, indent=2))
+        finally:
+            fcntl.flock(f, fcntl.LOCK_UN)
+
+def poll_inbox(identity: str, format: str = "xml") -> str:
+    """Poll inbox for new messages since last read. Returns XML or JSON."""
+    name, team = _parse_identity(identity)
+    inbox_path = _inbox_path(team, name)
+    cursor_path = _cursor_path(team, name)
+    
+    if not inbox_path.exists():
+        return "" if format == "xml" else "[]"
+    
+    with open(inbox_path, "r") as f:
+        fcntl.flock(f, fcntl.LOCK_SH)
+        try:
+            content = f.read().strip()
+            messages = json.loads(content) if content else []
+        finally:
+            fcntl.flock(f, fcntl.LOCK_UN)
+    
+    # Read cursor (index of last read message)
+    cursor = 0
+    if cursor_path.exists():
+        cursor = int(cursor_path.read_text().strip())
+    
+    new_msgs = messages[cursor:]
+    # Update cursor
+    cursor_path.write_text(str(len(messages)))
+    
+    if not new_msgs:
+        return "" if format == "xml" else "[]"
+    
+    if format == "json":
+        return json.dumps(new_msgs, indent=2)
+    
+    # XML format for context injection
+    parts = []
+    for msg in new_msgs:
+        parts.append(
+            f'<teammate-message from="{msg.get("from", "unknown")}" '
+            f'team="{team}" type="{msg.get("type", "message")}" '
+            f'timestamp="{msg.get("timestamp", "")}">\n'
+            f'{msg.get("text", "")}\n'
+            f'</teammate-message>'
+        )
+    return "\n".join(parts)
+
+def read_inbox(identity: str) -> list[dict]:
+    """Read all messages in inbox without advancing cursor."""
+    name, team = _parse_identity(identity)
+    path = _inbox_path(team, name)
+    if not path.exists():
+        return []
+    return json.loads(path.read_text() or "[]")
+
+# ── Tasks ──
+
+def create_task(team: str, subject: str, description: str = "", assigned_to: str = "", assigned_by: str = "") -> dict:
+    tasks_dir = _tasks_dir(team)
+    tasks_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = tasks_dir / ".lock"
+    
+    with open(lock_path, "w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        try:
+            existing = [f for f in tasks_dir.glob("*.json")]
+            task_id = str(len(existing) + 1)
+            task = {
+                "id": task_id,
+                "subject": subject,
+                "description": description,
+                "status": "pending",
+                "assigned_to": assigned_to or None,
+                "assigned_by": assigned_by or None,
+                "created": _now(),
+                "claimed_at": None,
+                "completed_at": None,
+                "result": None,
+            }
+            (tasks_dir / f"{task_id}.json").write_text(json.dumps(task, indent=2))
+        finally:
+            fcntl.flock(lock, fcntl.LOCK_UN)
+    
+    # If assigned, send task_assignment message
+    if assigned_to and assigned_by:
+        send_message(
+            f"{assigned_by}@{team}",
+            f"{assigned_to}@{team}",
+            json.dumps({"type": "task_assignment", "taskId": task_id, "subject": subject, "description": description}),
+            msg_type="task_assignment"
+        )
+    
+    return task
+
+def claim_task(team: str, task_id: str, agent: str) -> dict:
+    tasks_dir = _tasks_dir(team)
+    lock_path = tasks_dir / ".lock"
+    task_path = tasks_dir / f"{task_id}.json"
+    
+    if not task_path.exists():
+        raise ValueError(f"Task {task_id} not found")
+    
+    with open(lock_path, "w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        try:
+            task = json.loads(task_path.read_text())
+            if task["status"] != "pending":
+                raise ValueError(f"Task {task_id} is {task['status']}, cannot claim")
+            task["status"] = "in_progress"
+            task["assigned_to"] = agent
+            task["claimed_at"] = _now()
+            task_path.write_text(json.dumps(task, indent=2))
+        finally:
+            fcntl.flock(lock, fcntl.LOCK_UN)
+    return task
+
+def complete_task(team: str, task_id: str, agent: str, result: str = "") -> dict:
+    tasks_dir = _tasks_dir(team)
+    lock_path = tasks_dir / ".lock"
+    task_path = tasks_dir / f"{task_id}.json"
+    
+    if not task_path.exists():
+        raise ValueError(f"Task {task_id} not found")
+    
+    with open(lock_path, "w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        try:
+            task = json.loads(task_path.read_text())
+            if task["status"] != "in_progress":
+                raise ValueError(f"Task {task_id} is {task['status']}, cannot complete")
+            task["status"] = "completed"
+            task["completed_at"] = _now()
+            task["result"] = result
+            task_path.write_text(json.dumps(task, indent=2))
+        finally:
+            fcntl.flock(lock, fcntl.LOCK_UN)
+    return task
+
+def list_tasks(team: str, status: Optional[str] = None) -> list[dict]:
+    tasks_dir = _tasks_dir(team)
+    if not tasks_dir.exists():
+        return []
+    tasks = []
+    for f in sorted(tasks_dir.glob("*.json")):
+        task = json.loads(f.read_text())
+        if status is None or task["status"] == status:
+            tasks.append(task)
+    return tasks

agent_teams_cli-0.1.1/src/agent_teams_cli.egg-info/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: agent-teams-cli
+Version: 0.1.1
+Summary: File-based agent team coordination for OpenClaw
+Author: Marcus
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# agent-teams
+
+File-based agent team coordination for [OpenClaw](https://github.com/nichochar/openclaw). Inspired by Claude Code's teams architecture.
+
+## Features
+
+- **Team management** — create/delete teams, add/remove members
+- **Mailbox IPC** — file-based inboxes with cursor-based polling
+- **Shared task list** — file-locked atomic task claims
+- **XML context injection** — poll output formatted for agent prompt injection
+- **Zero dependencies** — pure Python, no servers, no databases
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Create a team
+agent-teams create my-team --members lead researcher builder
+
+# Send a message
+agent-teams send lead@my-team researcher@my-team --text "Find papers on X"
+
+# Poll inbox (XML for context injection)
+agent-teams poll researcher@my-team
+
+# Create and manage tasks
+agent-teams task-create my-team -s "Research task" --assign-to researcher --assign-by lead
+agent-teams task-claim my-team 1 researcher
+agent-teams task-complete my-team 1 researcher -r "Done!"
+```
+
+See [SKILL.md](../../skills/agent-teams/SKILL.md) for full documentation.
+
+## License
+
+MIT

agent_teams_cli-0.1.1/src/agent_teams_cli.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/agent_teams/__init__.py
+src/agent_teams/cli.py
+src/agent_teams/core.py
+src/agent_teams_cli.egg-info/PKG-INFO
+src/agent_teams_cli.egg-info/SOURCES.txt
+src/agent_teams_cli.egg-info/dependency_links.txt
+src/agent_teams_cli.egg-info/entry_points.txt
+src/agent_teams_cli.egg-info/top_level.txt
+tests/test_core.py

agent_teams_cli-0.1.1/src/agent_teams_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_teams_cli-0.1.1/src/agent_teams_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-teams = agent_teams.cli:main

agent_teams_cli-0.1.1/src/agent_teams_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_teams

agent_teams_cli-0.1.1/tests/test_core.py

@@ -0,0 +1,147 @@
+"""Tests for agent-teams core functionality."""
+
+import json
+import os
+import tempfile
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+
+# Patch TEAMS_ROOT before importing core
+_tmpdir = tempfile.mkdtemp()
+import agent_teams.core as core
+core.TEAMS_ROOT = Path(_tmpdir) / "teams"
+
+
+def setup_function():
+    """Clean up between tests."""
+    import shutil
+    if core.TEAMS_ROOT.exists():
+        shutil.rmtree(core.TEAMS_ROOT)
+
+
+def test_create_and_info():
+    config = core.create_team("test-team", ["alice", "bob"])
+    assert config["name"] == "test-team"
+    assert set(config["members"]) == {"alice", "bob"}
+    info = core.team_info("test-team")
+    assert info["name"] == "test-team"
+
+
+def test_list_teams():
+    core.create_team("a-team")
+    core.create_team("b-team")
+    teams = core.list_teams()
+    assert len(teams) == 2
+
+
+def test_add_remove_member():
+    core.create_team("test-team", ["alice"])
+    core.add_member("test-team", "bob")
+    info = core.team_info("test-team")
+    assert "bob" in info["members"]
+    core.remove_member("test-team", "bob")
+    info = core.team_info("test-team")
+    assert "bob" not in info["members"]
+
+
+def test_delete_team():
+    core.create_team("doomed")
+    assert core.delete_team("doomed")
+    assert not core.delete_team("nonexistent")
+
+
+def test_send_and_poll():
+    core.create_team("msg-team", ["alice", "bob"])
+    core.send_message("alice@msg-team", "bob@msg-team", "hello bob")
+    core.send_message("alice@msg-team", "bob@msg-team", "second msg")
+
+    xml = core.poll_inbox("bob@msg-team", "xml")
+    assert '<teammate-message from="alice"' in xml
+    assert "hello bob" in xml
+    assert "second msg" in xml
+
+    # Second poll should return empty (cursor advanced)
+    xml2 = core.poll_inbox("bob@msg-team", "xml")
+    assert xml2 == ""
+
+
+def test_poll_json():
+    core.create_team("j-team", ["a", "b"])
+    core.send_message("a@j-team", "b@j-team", "test")
+    result = core.poll_inbox("b@j-team", "json")
+    msgs = json.loads(result)
+    assert len(msgs) == 1
+    assert msgs[0]["text"] == "test"
+
+
+def test_broadcast():
+    core.create_team("bc-team", ["lead", "w1", "w2"])
+    msgs = core.broadcast("lead@bc-team", "all hands")
+    assert len(msgs) == 2
+    # Both workers got the message
+    assert core.poll_inbox("w1@bc-team") != ""
+    assert core.poll_inbox("w2@bc-team") != ""
+    # Lead didn't get it
+    assert core.poll_inbox("lead@bc-team") == ""
+
+
+def test_task_lifecycle():
+    core.create_team("task-team", ["lead", "worker"])
+    task = core.create_task("task-team", "Do the thing", "details here")
+    assert task["status"] == "pending"
+    assert task["id"] == "1"
+
+    claimed = core.claim_task("task-team", "1", "worker")
+    assert claimed["status"] == "in_progress"
+
+    completed = core.complete_task("task-team", "1", "worker", "done!")
+    assert completed["status"] == "completed"
+    assert completed["result"] == "done!"
+
+
+def test_task_double_claim():
+    core.create_team("race-team", ["a", "b"])
+    core.create_task("race-team", "contested task")
+    core.claim_task("race-team", "1", "a")
+    with pytest.raises(ValueError, match="in_progress"):
+        core.claim_task("race-team", "1", "b")
+
+
+def test_task_list_filter():
+    core.create_team("filter-team", ["w"])
+    core.create_task("filter-team", "task 1")
+    core.create_task("filter-team", "task 2")
+    core.claim_task("filter-team", "1", "w")
+
+    all_tasks = core.list_tasks("filter-team")
+    assert len(all_tasks) == 2
+    pending = core.list_tasks("filter-team", "pending")
+    assert len(pending) == 1
+    in_prog = core.list_tasks("filter-team", "in_progress")
+    assert len(in_prog) == 1
+
+
+def test_task_assignment_sends_message():
+    core.create_team("assign-team", ["lead", "worker"])
+    core.create_task("assign-team", "assigned task", "do it", assigned_to="worker", assigned_by="lead")
+    xml = core.poll_inbox("worker@assign-team")
+    assert "task_assignment" in xml
+    assert "assigned task" in xml
+
+
+def test_message_types():
+    core.create_team("type-team", ["a", "b"])
+    core.send_message("a@type-team", "b@type-team", "shutting down", "shutdown_request")
+    xml = core.poll_inbox("b@type-team")
+    assert 'type="shutdown_request"' in xml
+
+
+def test_read_inbox():
+    core.create_team("read-team", ["a", "b"])
+    core.send_message("a@read-team", "b@read-team", "hey")
+    msgs = core.read_inbox("b@read-team")
+    assert len(msgs) == 1
+    # read_inbox doesn't advance cursor
+    xml = core.poll_inbox("b@read-team")
+    assert "hey" in xml