@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/messaging/send.py

@@ -1,532 +0,0 @@
-from __future__ import annotations
-
-from team_agent.messaging.deps import (
-    EventLog,
-    MessageStore,
-    RuntimeError,
-    _capture_missing_sessions,
-    _current_task_for_agent,
-    _deliver_pending_message,
-    _find_agent,
-    _find_task,
-    _is_leader_sender,
-    _is_leader_target,
-    _is_runtime_team_agent,
-    _leader_id,
-    _message_by_id,
-    _mirror_peer_message_to_leader,
-    _runtime_lock,
-    _runtime_team_agent_ids,
-    _send_to_leader_receiver,
-    check_team_owner,
-    load_runtime_state,
-    load_spec,
-    missing_tools,
-    route_task,
-    save_team_scoped_state,
-    select_runtime_state,
-    ambiguous_team_target_result,
-    team_state_key,
-    update_task_status,
-)
-
-from pathlib import Path
-from typing import Any
-
-def send_message(
-    workspace: Path, target: str | list[str] | None, content: str, task_id: str | None = None,
-    sender: str = "leader", requires_ack: bool = True, confirm_human: bool = False,
-    wait_visible: bool = True, timeout: float = 30.0, lock_timeout: float = 5.0,
-    watch_result: bool = False, block_until_delivered: bool = True, team: str | None = None,
-) -> dict[str, Any]:
-    with _runtime_lock(workspace, "send", timeout=lock_timeout):
-        return _send_message_unlocked(
-            workspace,
-            target,
-            content,
-            task_id=task_id,
-            sender=sender,
-            requires_ack=requires_ack,
-            confirm_human=confirm_human,
-            wait_visible=wait_visible,
-            timeout=timeout,
-            watch_result=watch_result,
-            block_until_delivered=block_until_delivered,
-            team=team,
-        )
-
-
-def _send_message_unlocked(
-    workspace: Path, target: str | list[str] | None, content: str, task_id: str | None = None,
-    sender: str = "leader", requires_ack: bool = True, confirm_human: bool = False,
-    wait_visible: bool = True, timeout: float = 30.0, watch_result: bool = False,
-    block_until_delivered: bool = True, team: str | None = None,
-) -> dict[str, Any]:
-    if team is None:
-        ambiguous = ambiguous_team_target_result(load_runtime_state(workspace))
-        if ambiguous:
-            return ambiguous
-    state = select_runtime_state(workspace, team)
-    gate = check_team_owner(state)
-    spec_path = Path(state.get("spec_path") or workspace / "team.spec.yaml")
-    if not spec_path.exists() and state.get("team_dir"):
-        candidate = Path(str(state["team_dir"])) / "team.spec.yaml"
-        if candidate.exists():
-            spec_path = candidate
-    spec = load_spec(spec_path)
-    event_log = EventLog(workspace)
-    if gate:
-        from team_agent.messaging.owner_bypass import apply_worker_sender_bypass
-        if not apply_worker_sender_bypass(state, sender, target, task_id, event_log):
-            return gate
-    owner_team_id = team_state_key(state)
-    leader_id = _leader_id(state, spec)
-    _flag_rebind_required_when_unbound_plain_shell_leader(workspace, state, spec, sender, leader_id, event_log)
-
-    if isinstance(target, list):
-        if watch_result:
-            return {"ok": False, "status": "failed", "reason": "watch_result_not_supported_for_fanout", "to": target}
-        return _fanout_message_unlocked(
-            workspace,
-            state,
-            spec,
-            event_log,
-            target,
-            content,
-            task_id=task_id,
-            sender=sender,
-            requires_ack=requires_ack,
-            wait_visible=wait_visible,
-            timeout=timeout,
-            block_until_delivered=block_until_delivered,
-            owner_team_id=owner_team_id,
-        )
-
-    if target == "*":
-        if watch_result:
-            return {"ok": False, "status": "failed", "reason": "watch_result_not_supported_for_broadcast", "to": target}
-        return _broadcast_message_unlocked(
-            workspace,
-            state,
-            spec,
-            event_log,
-            content,
-            task_id=task_id,
-            sender=sender,
-            requires_ack=requires_ack,
-            wait_visible=wait_visible,
-            timeout=timeout,
-            block_until_delivered=block_until_delivered,
-            owner_team_id=owner_team_id,
-        )
-
-    return _send_single_message_unlocked(
-        workspace,
-        state,
-        spec,
-        event_log,
-        target,
-        content,
-        task_id=task_id,
-        sender=sender,
-        requires_ack=requires_ack,
-        confirm_human=confirm_human,
-        wait_visible=wait_visible,
-        timeout=timeout,
-        watch_result=watch_result,
-        block_until_delivered=block_until_delivered,
-        owner_team_id=owner_team_id,
-    )
-
-
-def _flag_rebind_required_when_unbound_plain_shell_leader(
-    workspace: Path,
-    state: dict[str, Any],
-    spec: dict[str, Any],
-    sender: str,
-    leader_id: str,
-    event_log: EventLog,
-) -> None:
-    # Gap 39 C5: a leader send from a plain shell (no $TMUX_PANE) must never self-bind
-    # the caller as the leader receiver. When the lease is fully unbound, flag a
-    # rebind_required so the message stays queued and the operator knows to reconnect
-    # from a real tmux leader pane. Only fires for an unbound lease + no caller pane.
-    import os
-    from team_agent.messaging.deps import _leader_receiver_is_direct
-    if not _is_leader_sender(sender, leader_id):
-        return
-    if isinstance(state.get("team_owner"), dict) and state["team_owner"].get("pane_id"):
-        return
-    if _leader_receiver_is_direct(state.get("leader_receiver")):
-        return
-    if os.environ.get("TEAM_AGENT_LEADER_PANE_ID") or os.environ.get("TMUX_PANE"):
-        return
-    event_log.write(
-        "leader_receiver.rebind_required",
-        reason="not_in_tmux_pane",
-        old_pane_id=(state.get("leader_receiver") or {}).get("pane_id"),
-        new_pane_id=None,
-        team_id=team_state_key(state),
-        recovery_action="run team-agent claim-leader --confirm from the leader's tmux pane",
-    )
-
-
-def _send_single_message_unlocked(
-    workspace: Path,
-    state: dict[str, Any],
-    spec: dict[str, Any],
-    event_log: EventLog,
-    target: str | None,
-    content: str,
-    *,
-    task_id: str | None = None,
-    sender: str = "leader",
-    requires_ack: bool = True,
-    confirm_human: bool = False,
-    wait_visible: bool = True,
-    timeout: float = 30.0,
-    watch_result: bool = False,
-    mirror_peer: bool = True,
-    route_task_id: bool = True,
-    block_until_delivered: bool = True,
-    owner_team_id: str | None = None,
-) -> dict[str, Any]:
-    leader_id = _leader_id(state, spec)
-
-    if _is_leader_target(target, leader_id) and not _is_leader_sender(sender, leader_id):
-        return _send_to_leader_receiver(workspace, state, leader_id, content, task_id, sender, requires_ack, event_log)
-
-    from team_agent.messaging.session_drift import session_drift_refusal
-    drift = session_drift_refusal(state, target, leader_id, sender, task_id, event_log)
-    if drift:
-        return drift
-
-    if task_id and route_task_id:
-        task = _find_task(state.get("tasks", []), task_id)
-        if task.get("human_confirmation") and not task.get("human_confirmed"):
-            if not confirm_human:
-                update_task_status(state["tasks"], task_id, "blocked", "human confirmation required before dispatch")
-                save_team_scoped_state(workspace, state)
-                event_log.write(
-                    "send.human_confirmation_required",
-                    task_id=task_id,
-                    requested_target=target,
-                )
-                return {
-                    "ok": False,
-                    "status": "blocked",
-                    "reason": "human_confirmation_required",
-                    "task_id": task_id,
-                }
-            task["human_confirmed"] = True
-            event_log.write("send.human_confirmation_granted", task_id=task_id, confirmed_by=sender)
-        route = route_task(spec, task)
-        routed_target = route["agent_id"]
-        requested_target = target
-        target = target or routed_target
-        task["assignee"] = target
-        event_log.write(
-            "routing.decision",
-            source="send",
-            task_id=task_id,
-            route_agent=routed_target,
-            selected_agent=target,
-            reason=route["reason"],
-            manual_override=bool(requested_target and requested_target != routed_target),
-        )
-        agent = _find_agent(spec, target)
-        if agent:
-            missing = missing_tools(agent, task)
-            if missing:
-                update_task_status(state["tasks"], task_id, "blocked", f"missing permissions: {', '.join(missing)}")
-                save_team_scoped_state(workspace, state)
-                event_log.write(
-                    "send.blocked_missing_permissions",
-                    task_id=task_id,
-                    agent_id=target,
-                    missing_tools=missing,
-                )
-                return {
-                    "ok": False,
-                    "status": "blocked",
-                    "task_id": task_id,
-                    "agent_id": target,
-                    "missing_tools": missing,
-                }
-
-    if not target:
-        raise RuntimeError("send requires target or --task")
-    if not _is_leader_target(target, leader_id) and not _is_runtime_team_agent(target, state, spec):
-        event_log.write("send.target_rejected", sender=sender, target=target, reason="target_not_in_team")
-        return {"ok": False, "status": "refused", "reason": "target_not_in_team", "from": sender, "to": target}
-    store = MessageStore(workspace)
-    message_id = store.create_message(task_id, sender, target, content, requires_ack=requires_ack, owner_team_id=owner_team_id)
-    if not block_until_delivered:
-        watch: dict[str, Any] | None = None
-        if watch_result:
-            watch_task_id = task_id or _current_task_for_agent(state.get("tasks", []), str(target))
-            watcher_id = store.create_result_watcher(watch_task_id, str(target), message_id, leader_id, owner_team_id=owner_team_id)
-            watch = {
-                "status": "registered",
-                "watcher_id": watcher_id,
-                "task_id": watch_task_id,
-                "agent_id": target,
-                "notice": (
-                    "Team Agent will deliver this message when the worker is available, "
-                    "then collect the result and notify the leader when this task reports completion."
-                ),
-            }
-            event_log.write(
-                "result_watcher.created",
-                watcher_id=watcher_id,
-                task_id=watch_task_id,
-                agent_id=target,
-                message_id=message_id,
-            )
-        _capture_missing_sessions(workspace, state, event_log, timeout_s=0.0, log_miss=False)
-        save_team_scoped_state(workspace, state)
-        event_log.write(
-            "send.durably_stored",
-            message_id=message_id,
-            target=target,
-            sender=sender,
-            task_id=task_id,
-        )
-        result = {
-            "ok": True,
-            "message_id": message_id,
-            "status": "queued",
-            "message_status": "accepted",
-            "to": target,
-            "queued": True,
-            "durably_stored": True,
-            "reason": "deferred_to_coordinator",
-            "visible": False,
-            "submitted": False,
-        }
-        if watch is not None:
-            result["watch_result"] = True
-            result["watch"] = watch
-        return result
-    delivered_result = _deliver_pending_message(workspace, state, message_id, wait_visible=wait_visible, timeout=timeout)
-    row = _message_by_id(store, message_id)
-    message_status = row["status"] if row else delivered_result.get("message_status", delivered_result.get("status", "accepted"))
-    if (
-        mirror_peer
-        and not _is_leader_sender(sender, leader_id)
-        and not _is_leader_target(target, leader_id)
-        and delivered_result.get("ok")
-        and not delivered_result.get("queued")
-    ):
-        _mirror_peer_message_to_leader(workspace, state, sender, target, content, task_id, event_log)
-    watch: dict[str, Any] | None = None
-    if watch_result and delivered_result.get("ok"):
-        watch_task_id = task_id or _current_task_for_agent(state.get("tasks", []), str(target))
-        watcher_id = store.create_result_watcher(watch_task_id, str(target), message_id, leader_id, owner_team_id=owner_team_id)
-        watch = {
-            "status": "registered",
-            "watcher_id": watcher_id,
-            "task_id": watch_task_id,
-            "agent_id": target,
-            "notice": (
-                "Team Agent will deliver this message when the worker is available, "
-                "then collect the result and notify the leader when this task reports completion."
-                if delivered_result.get("queued")
-                else "Team Agent will collect the result and notify the leader when this task reports completion."
-            ),
-        }
-        event_log.write(
-            "result_watcher.created",
-            watcher_id=watcher_id,
-            task_id=watch_task_id,
-            agent_id=target,
-            message_id=message_id,
-        )
-    _capture_missing_sessions(workspace, state, event_log, timeout_s=0.0, log_miss=False)
-    save_team_scoped_state(workspace, state)
-    result = {
-        "ok": bool(delivered_result.get("ok")),
-        "message_id": message_id,
-        "status": delivered_result.get("status", message_status),
-        "message_status": message_status,
-        "to": target,
-        "visible": message_status in {"visible", "submitted"},
-        "submitted": message_status in {"visible", "submitted", "submitted_unverified", "delivered", "acknowledged"},
-        "verification": delivered_result.get("verification"),
-        "submit_verification": delivered_result.get("submit_verification"),
-        "turn_verification": delivered_result.get("turn_verification"),
-    }
-    result.update({key: delivered_result[key] for key in ("reason", "stage") if delivered_result.get(key)})
-    result.update(_structured_delivery_refusal(delivered_result))
-    if delivered_result.get("queued"):
-        result["queued"] = True
-        result["reason"] = delivered_result.get("reason")
-    if delivered_result.get("warning"):
-        result["warning"] = delivered_result["warning"]
-    for key in ("paste_attempts", "submit_attempts"):
-        if key in delivered_result:
-            result[key] = delivered_result[key]
-    if watch is not None:
-        result["watch_result"] = True
-        result["watch"] = watch
-    return result
-
-
-def _broadcast_message_unlocked(
-    workspace: Path,
-    state: dict[str, Any],
-    spec: dict[str, Any],
-    event_log: EventLog,
-    content: str,
-    *,
-    task_id: str | None,
-    sender: str,
-    requires_ack: bool,
-    wait_visible: bool,
-    timeout: float,
-    block_until_delivered: bool = True,
-    owner_team_id: str | None = None,
-) -> dict[str, Any]:
-    targets = _broadcast_targets(state, spec, sender)
-    if not targets:
-        event_log.write("send.broadcast_skipped", sender=sender, reason="no_team_recipients")
-        return {"ok": False, "status": "failed", "reason": "no_team_recipients", "to": "*", "targets": []}
-    event_log.write("send.broadcast_start", sender=sender, targets=targets, task_id=task_id)
-    deliveries: list[dict[str, Any]] = []
-    for recipient in targets:
-        result = _send_single_message_unlocked(
-            workspace,
-            state,
-            spec,
-            event_log,
-            recipient,
-            content,
-            task_id=task_id,
-            sender=sender,
-            requires_ack=requires_ack,
-            confirm_human=False,
-            wait_visible=wait_visible,
-            timeout=timeout,
-            watch_result=False,
-            mirror_peer=False,
-            route_task_id=False,
-            block_until_delivered=block_until_delivered,
-            owner_team_id=owner_team_id,
-        )
-        deliveries.append(_compact_broadcast_delivery(result))
-    failed = [item for item in deliveries if not item.get("ok")]
-    status = "broadcast_delivered" if not failed else "broadcast_partial"
-    event_log.write(
-        "send.broadcast_complete",
-        sender=sender,
-        targets=targets,
-        status=status,
-        delivered_count=len(deliveries) - len(failed),
-        failed_count=len(failed),
-    )
-    return {
-        "ok": not failed,
-        "status": status,
-        "to": "*",
-        "targets": targets,
-        "delivered_count": len(deliveries) - len(failed),
-        "failed_count": len(failed),
-        "deliveries": deliveries,
-    }
-
-
-def _fanout_message_unlocked(
-    workspace: Path,
-    state: dict[str, Any],
-    spec: dict[str, Any],
-    event_log: EventLog,
-    targets: list[str],
-    content: str,
-    *,
-    task_id: str | None,
-    sender: str,
-    requires_ack: bool,
-    wait_visible: bool,
-    timeout: float,
-    block_until_delivered: bool = True,
-    owner_team_id: str | None = None,
-) -> dict[str, Any]:
-    raw_recipients = [target for target in targets if target]
-    recipients = list(dict.fromkeys(raw_recipients))
-    if not recipients:
-        return {"ok": False, "status": "failed", "reason": "no_fanout_recipients", "to": targets, "targets": []}
-    if len(raw_recipients) != len(recipients):
-        event_log.write("send.fanout_dedupe", sender=sender, task_id=task_id,
-            raw_targets=raw_recipients, deduped_targets=recipients,
-            duplicate_count=len(raw_recipients) - len(recipients))
-    event_log.write("send.fanout_start", sender=sender, targets=recipients, task_id=task_id)
-    deliveries: list[dict[str, Any]] = []
-    by_recipient: dict[str, dict[str, Any]] = {}
-    for recipient in recipients:
-        result = _send_single_message_unlocked(
-            workspace,
-            state,
-            spec,
-            event_log,
-            recipient,
-            content,
-            task_id=task_id,
-            sender=sender,
-            requires_ack=requires_ack,
-            confirm_human=False,
-            wait_visible=wait_visible,
-            timeout=timeout,
-            watch_result=False,
-            mirror_peer=False,
-            route_task_id=False,
-            block_until_delivered=block_until_delivered,
-            owner_team_id=owner_team_id,
-        )
-        compact = _compact_fanout_delivery(result)
-        deliveries.append(compact)
-        by_recipient[recipient] = compact
-    failed = [item for item in deliveries if not item.get("delivered")]
-    status = "fanout_delivered" if not failed else "fanout_partial"
-    aggregate = {
-        "ok": True,
-        "status": status,
-        "to": recipients,
-        "targets": recipients,
-        "delivered_count": len(deliveries) - len(failed),
-        "failed_count": len(failed),
-        "deliveries": deliveries,
-        "recipients": by_recipient,
-    }
-    event_log.write("send.fanout_status", **aggregate)
-    return aggregate
-
-
-def _broadcast_targets(state: dict[str, Any], spec: dict[str, Any], sender: str) -> list[str]:
-    leader_id = _leader_id(state, spec)
-    targets = [leader_id, *_runtime_team_agent_ids(state, spec)]
-    if _is_leader_sender(sender, leader_id):
-        excluded = {leader_id}
-    else:
-        excluded = {sender}
-    return [target for target in targets if target not in excluded]
-
-
-def _compact_broadcast_delivery(result: dict[str, Any]) -> dict[str, Any]:
-    keys = ["ok", "status", "message_id", "to", "reason", "channel", "detected", "pane_id", "pane_mode", "pane_capture_tail", "stage", "verification"]
-    return {key: result[key] for key in keys if key in result}
-
-
-def _compact_fanout_delivery(result: dict[str, Any]) -> dict[str, Any]:
-    compact = _compact_broadcast_delivery(result)
-    compact["delivered"] = bool(result.get("submitted") or result.get("visible") or result.get("status") in {"submitted", "visible", "delivered", "acknowledged"})
-    return compact
-
-
-def _structured_delivery_refusal(delivered_result: dict[str, Any]) -> dict[str, Any]:
-    attempts = delivered_result.get("paste_attempts")
-    if not isinstance(attempts, list):
-        return {}
-    for attempt in attempts:
-        if isinstance(attempt, dict) and attempt.get("reason") == "recipient_pane_in_non_input_mode":
-            return {key: attempt[key] for key in ("detected", "pane_id", "pane_mode", "pane_capture_tail") if key in attempt}
-    return {}

package/src/team_agent/messaging/session_drift.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import re
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-
-_UUID = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
-_RESUME_THREAD_RE = re.compile(
-    rf"(?:Switched to thread|resume|thread)\s+({_UUID})",
-    re.IGNORECASE,
-)
-
-
-def extract_thread_id_from_scrollback(scrollback: str) -> str | None:
-    if not scrollback:
-        return None
-    matches = _RESUME_THREAD_RE.findall(scrollback)
-    if not matches:
-        return None
-    return matches[-1].lower()
-
-
-def detect_session_drift(
-    workspace: Path,
-    state: dict[str, Any],
-    event_log: EventLog,
-    *,
-    agent_id: str,
-    agent_state: dict[str, Any],
-    scrollback: str,
-) -> dict[str, Any] | None:
-    provider = str(agent_state.get("provider") or "").lower()
-    if provider != "codex":
-        return None
-    stored = str(agent_state.get("session_id") or "").strip()
-    if not stored:
-        return None
-    if str(agent_state.get("status") or "").lower() == "session_drift":
-        return None
-    actual = extract_thread_id_from_scrollback(scrollback)
-    if not actual:
-        return None
-    if actual.lower() == stored.lower():
-        return None
-    now = datetime.now(timezone.utc).isoformat()
-    event = event_log.write(
-        "coordinator.session_drift_detected",
-        agent_id=agent_id,
-        stored_session_id=stored,
-        actual_thread_id=actual,
-        status="session_drift",
-        provider=provider,
-        ts=now,
-        remediation="team-agent reset-agent --discard-session <agent>",
-    )
-    agent_state["status"] = "session_drift"
-    agent_state["session_drift"] = {
-        "stored_session_id": stored,
-        "actual_thread_id": actual,
-        "detected_at": now,
-        "remediation": "team-agent reset-agent --discard-session <agent>",
-    }
-    return event
-
-
-def session_drift_refusal(state, target, leader_id, sender, task_id, event_log):
-    if not target or target == leader_id or target == "*":
-        return None
-    rs = (state.get("agents") or {}).get(target) or {}
-    if str(rs.get("status") or "").lower() != "session_drift":
-        return None
-    info = rs.get("session_drift") or {}
-    event_log.write(
-        "send.refused_session_drift",
-        target=target,
-        sender=sender,
-        task_id=task_id,
-        stored_session_id=info.get("stored_session_id"),
-        actual_thread_id=info.get("actual_thread_id"),
-    )
-    return {
-        "ok": False,
-        "status": "refused",
-        "reason": "session_drift",
-        "to": target,
-        "action": f"team-agent reset-agent --discard-session {target}",
-        "session_drift": info,
-    }
-
-
-__all__ = ["detect_session_drift", "extract_thread_id_from_scrollback", "session_drift_refusal"]