S13.1 Agent Teams：队友通过消息协作

workspace/
  .tasks/task_1234abcd.json
  .mailboxes/lead.jsonl
  .mailboxes/config.jsonl
  .mailboxes/tests.jsonl

{"from":"config","to":"lead","content":"配置任务完成，测试通过。","type":"result","ts":0,"metadata":{}}

def __init__(self):
    self._lock = threading.RLock()
    self._changed = threading.Condition(self._lock)

def _path(self, agent: str) -> Path:
    if not is_valid_agent_name(agent):
        raise ValueError(f"Invalid mailbox recipient: {agent!r}")
    path = (MAILBOX_DIR / f"{agent}.jsonl").resolve()
    if not path.is_relative_to(MAILBOX_ROOT):
        raise ValueError(f"Mailbox path escapes directory: {agent!r}")
    return path

def send(self, from_agent: str, to_agent: str, content: str,
         msg_type: str = "message", metadata: dict | None = None):
    msg = {"from": from_agent, "to": to_agent,
           "content": content, "type": msg_type,
           "ts": time.time(), "metadata": metadata or {}}
    with self._changed:
        MAILBOX_DIR.mkdir(parents=True, exist_ok=True)
        with self._path(to_agent).open("a", encoding="utf-8") as handle:
            handle.write(json.dumps(msg, ensure_ascii=True) + "\n")
        self._changed.notify_all()
    print(f"  [bus] {from_agent} -> {to_agent}: "
          f"({msg_type}) {content[:50]}")

def read_inbox(self, agent: str) -> list[dict]:
    with self._lock:
        return self._read_unlocked(agent)

def _read_unlocked(self, agent: str) -> list[dict]:
    inbox = self._path(agent)
    if not inbox.exists():
        return []
    msgs = [json.loads(line) for line in inbox.read_text(encoding="utf-8").splitlines()
            if line.strip()]
    inbox.unlink()
    return msgs

def peek(self, agent: str) -> bool:
    with self._lock:
        inbox = self._path(agent)
        return inbox.exists() and inbox.stat().st_size > 0

def wait_for_messages(self, agent: str,
                      timeout: float | None = None) -> list[dict]:
    """Block until the agent has messages or timeout expires."""
    deadline = None if timeout is None else time.monotonic() + timeout
    with self._changed:
        while not self.peek(agent):
            remaining = (None if deadline is None
                         else deadline - time.monotonic())
            if remaining is not None and remaining <= 0:
                return []
            self._changed.wait(remaining)
        return self._read_unlocked(agent)