@team-agent/installer 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",

package/src/team_agent/cli/__init__.py

@@ -56,6 +56,7 @@ from team_agent.cli.commands import (
     cmd_remove_agent,
     cmd_stuck_list,
     cmd_stuck_cancel,
+    cmd_acknowledge_idle,
     cmd_allow_peer_talk,
     cmd_advanced,
     cmd_install_skill,
@@ -122,6 +123,7 @@ __all__ = [
     'cmd_remove_agent',
     'cmd_stuck_list',
     'cmd_stuck_cancel',
+    'cmd_acknowledge_idle',
     'cmd_allow_peer_talk',
     'cmd_advanced',
     'cmd_install_skill',

package/src/team_agent/cli/commands.py

@@ -273,6 +273,10 @@ def cmd_stuck_cancel(args: argparse.Namespace) -> dict[str, Any]:
     )
 
 
+def cmd_acknowledge_idle(args: argparse.Namespace) -> dict[str, Any]:
+    return runtime.acknowledge_idle(Path(args.workspace).resolve(), team=args.team)
+
+
 def cmd_allow_peer_talk(args: argparse.Namespace) -> dict[str, Any]:
     return runtime.allow_peer_talk(Path(args.workspace).resolve(), args.agent_a, args.agent_b)
 

package/src/team_agent/cli/parser.py

@@ -46,6 +46,7 @@ from team_agent.cli.commands import (
     cmd_remove_agent,
     cmd_stuck_list,
     cmd_stuck_cancel,
+    cmd_acknowledge_idle,
     cmd_allow_peer_talk,
     cmd_advanced,
     cmd_install_skill,
@@ -372,6 +373,12 @@ def main(argv: list[str] | None = None) -> None:
     add_json(p)
     p.set_defaults(func=cmd_stuck_cancel)
 
+    p = sub.add_parser("acknowledge-idle", help="Suppress idle-fallback reminders for this team for a bounded window (default 30 minutes)")
+    p.add_argument("team", nargs="?", help="Explicit team/session target when a workspace has multiple teams")
+    p.add_argument("--workspace", default=".")
+    add_json(p)
+    p.set_defaults(func=cmd_acknowledge_idle)
+
     p = sub.add_parser("install-skill", help=argparse.SUPPRESS)
     p.add_argument("--target", choices=["codex", "claude", "all"], default="codex")
     p.add_argument("--dest", help="Explicit destination directory; overrides --target")
@@ -422,7 +429,7 @@ def main(argv: list[str] | None = None) -> None:
     sub._choices_actions = [  # type: ignore[attr-defined]
         action for action in sub._choices_actions if action.help != argparse.SUPPRESS  # type: ignore[attr-defined]
     ]
-    sub.metavar = "{codex,claude,quick-start,send,status,approvals,inbox,shutdown,restart,start-agent,stop-agent,reset-agent,add-agent,fork-agent,remove-agent,stuck-list,stuck-cancel,doctor}"
+    sub.metavar = "{codex,claude,quick-start,send,status,approvals,inbox,shutdown,restart,start-agent,stop-agent,reset-agent,add-agent,fork-agent,remove-agent,stuck-list,stuck-cancel,acknowledge-idle,doctor}"
 
     args = parser.parse_args(raw_argv)
     try:

package/src/team_agent/coordinator/lifecycle.py

@@ -265,6 +265,7 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         detect_idle_fallbacks,
     )
     from team_agent.messaging.activity_detector import detect_compaction_degradation
+    from team_agent.messaging.session_drift import detect_session_drift
     from team_agent.state import load_runtime_state, save_runtime_state
     state = load_runtime_state(workspace)
     event_log = EventLog(workspace)
@@ -304,6 +305,19 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         )
         if result.get("event") and result.get("event") != "compaction_threshold_crossed.none":
             compaction_results.append(result)
+    drift_results: list[dict[str, Any]] = []
+    for agent_id, agent_state in state.get("agents", {}).items():
+        if str(agent_state.get("provider") or "") != "codex":
+            continue
+        scrollback = str((captures.get(agent_id) or {}).get("scrollback") or "")
+        if not scrollback:
+            continue
+        drift = detect_session_drift(
+            workspace, state, event_log,
+            agent_id=agent_id, agent_state=agent_state, scrollback=scrollback,
+        )
+        if drift:
+            drift_results.append(drift)
     save_runtime_state(workspace, state)
     results = _collect_results_and_notify_watchers(workspace, event_log)
     return {
@@ -315,5 +329,6 @@ def coordinator_tick(workspace: Path) -> dict[str, Any]:
         "idle_alerts": idle_alerts,
         "deadlock_alerts": deadlock_alerts,
         "compaction": compaction_results,
+        "session_drift": drift_results,
         "results": results,
     }

package/src/team_agent/lifecycle/paste_buffer_hygiene.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from team_agent.events import EventLog
+
+_TEAM_AGENT_BUFFER_PREFIXES = ("team-agent-send-", "team-agent-leader-receiver-", "team-agent-")
+
+
+def _is_team_agent_buffer(name: str) -> bool:
+    return any(name.startswith(prefix) for prefix in _TEAM_AGENT_BUFFER_PREFIXES)
+
+
+def cleanup_stale_team_agent_buffers(workspace: Path, event_log: EventLog, *, context: str) -> dict[str, Any]:
+    from team_agent.runtime import run_cmd
+    proc = run_cmd(["tmux", "list-buffers", "-F", "#{buffer_name}"], timeout=5)
+    if proc.returncode != 0:
+        event_log.write("paste_buffer_hygiene.list_failed", context=context, stderr=proc.stderr.strip()[:200])
+        return {"ok": False, "deleted": [], "reason": "list_buffers_failed"}
+    names = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+    targets = [name for name in names if _is_team_agent_buffer(name)]
+    deleted: list[str] = []
+    for name in targets:
+        delete_proc = run_cmd(["tmux", "delete-buffer", "-b", name], timeout=5)
+        if delete_proc.returncode == 0:
+            deleted.append(name)
+    if deleted:
+        event_log.write(
+            "paste_buffer_hygiene.prevented_resume_injection",
+            context=context,
+            deleted_buffers=deleted,
+            scanned_count=len(names),
+            matched_count=len(targets),
+        )
+    return {"ok": True, "deleted": deleted, "scanned": len(names), "matched": len(targets)}
+
+
+__all__ = ["cleanup_stale_team_agent_buffers"]

package/src/team_agent/lifecycle/start.py

@@ -219,6 +219,8 @@ def _start_agent_unlocked(workspace: Path, agent_id: str, force: bool, open_disp
             reason="rollout_missing" if start_mode == "fresh_after_missing_rollout" else "session_id_missing",
         )
 
+    from team_agent.lifecycle.paste_buffer_hygiene import cleanup_stale_team_agent_buffers
+    cleanup_stale_team_agent_buffers(workspace, event_log, context=f"start_agent:{agent_id}")
     tmux_cmd, tmux_start_mode = _tmux_start_command_for_agent_window(session_name, agent_id, command)
     event_log.write(
         "start_agent.agent_start",
@@ -273,6 +275,7 @@ def _start_agent_unlocked(workspace: Path, agent_id: str, force: bool, open_disp
         )
         command = shell_command_for_agent(command_agent, workspace, mcp_config)
         start_mode = "fresh_after_missing_rollout" if missing_resume_rollout else "fresh"
+        cleanup_stale_team_agent_buffers(workspace, event_log, context=f"start_agent_fallback:{agent_id}")
         tmux_cmd, tmux_start_mode = _tmux_start_command_for_agent_window(session_name, agent_id, command)
         event_log.write(
             "start_agent.agent_start",

package/src/team_agent/messaging/delivery.py

@@ -121,6 +121,16 @@ def _deliver_pending_messages(workspace: Path, state: dict[str, Any], event_log:
     for row in store.messages():
         if row["status"] not in {"pending", "accepted"}:
             continue
+        agent_state = state.get("agents", {}).get(row["recipient"]) or {}
+        if str(agent_state.get("status") or "").lower() == "busy":
+            event_log.write(
+                "send.deferred_busy",
+                message_id=row["message_id"],
+                sender=row.get("sender"),
+                recipient=row["recipient"],
+                reason="recipient_busy",
+            )
+            continue
         result = _deliver_pending_message(workspace, state, row["message_id"], wait_visible=True, timeout=30.0)
         if result.get("ok"):
             delivered.append(row["message_id"])

package/src/team_agent/messaging/idle_alerts.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
@@ -23,33 +23,116 @@ _UNDELIVERED_MESSAGE_STATUSES = {
 }
 
 
+STABLE_IDLE_SECONDS = 120
+FIRE_DEBOUNCE_SECONDS = 300
+OBLIGATION_PENDING_MIN_AGE_SECONDS = 60
+
+
+def _parse_iso(text: Any) -> datetime | None:
+    if not isinstance(text, str) or not text:
+        return None
+    try:
+        dt = datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def record_team_progress(
+    state: dict[str, Any],
+    now: datetime | None = None,
+    *,
+    source: str = "",
+    owner_team_id: str | None = None,
+) -> None:
+    coordinator = state.setdefault("coordinator", {})
+    progress = coordinator.setdefault("team_last_progress_at", {})
+    key = owner_team_id or team_state_key(state)
+    if not key:
+        return
+    progress[key] = {
+        "at": (now or datetime.now(timezone.utc)).isoformat(),
+        "source": source,
+    }
+
+
+def _team_last_progress_at(
+    state: dict[str, Any],
+    store: MessageStore,
+    owner_team_id: str,
+) -> datetime | None:
+    candidates: list[datetime] = []
+    coordinator = state.get("coordinator") or {}
+    explicit = (coordinator.get("team_last_progress_at") or {}).get(owner_team_id)
+    if isinstance(explicit, dict):
+        ts = _parse_iso(explicit.get("at"))
+        if ts:
+            candidates.append(ts)
+    elif isinstance(explicit, str):
+        ts = _parse_iso(explicit)
+        if ts:
+            candidates.append(ts)
+    health = store.agent_health(owner_team_id=owner_team_id)
+    for row in health.values():
+        ts = _parse_iso(row.get("last_output_at"))
+        if ts:
+            candidates.append(ts)
+    return max(candidates) if candidates else None
+
+
+def _team_last_idle_fallback_fire_at(state: dict[str, Any], owner_team_id: str) -> datetime | None:
+    coordinator = state.get("coordinator") or {}
+    fires = coordinator.get("team_last_idle_fallback_fire_at") or {}
+    return _parse_iso(fires.get(owner_team_id))
+
+
+def _record_idle_fallback_fire(state: dict[str, Any], owner_team_id: str, now: datetime) -> None:
+    coordinator = state.setdefault("coordinator", {})
+    fires = coordinator.setdefault("team_last_idle_fallback_fire_at", {})
+    fires[owner_team_id] = now.isoformat()
+
+
 def _team_undelivered_obligations(
     state: dict[str, Any],
     store: MessageStore,
     owner_team_id: str,
     active_task_statuses: set[str],
+    *,
+    now: datetime | None = None,
 ) -> list[dict[str, Any]]:
+    now = now or datetime.now(timezone.utc)
+    min_age = timedelta(seconds=OBLIGATION_PENDING_MIN_AGE_SECONDS)
     obligations: list[dict[str, Any]] = []
     for message in store.messages(owner_team_id=owner_team_id):
-        if message.get("status") in _UNDELIVERED_MESSAGE_STATUSES:
-            obligations.append(
-                {
-                    "kind": "undelivered_message",
-                    "message_id": message.get("message_id"),
-                    "recipient": message.get("recipient"),
-                    "status": message.get("status"),
-                }
-            )
+        if message.get("status") not in _UNDELIVERED_MESSAGE_STATUSES:
+            continue
+        created_at = _parse_iso(message.get("created_at"))
+        if created_at and (now - created_at) < min_age:
+            continue
+        obligations.append(
+            {
+                "kind": "undelivered_message",
+                "message_id": message.get("message_id"),
+                "recipient": message.get("recipient"),
+                "status": message.get("status"),
+            }
+        )
     for watcher in store.retryable_result_watchers():
-        if watcher.get("status") in {"pending", "notify_failed"}:
-            obligations.append(
-                {
-                    "kind": "pending_result_watcher",
-                    "watcher_id": watcher.get("watcher_id"),
-                    "task_id": watcher.get("task_id"),
-                    "agent_id": watcher.get("agent_id"),
-                }
-            )
+        if watcher.get("status") not in {"pending", "notify_failed"}:
+            continue
+        created_at = _parse_iso(watcher.get("created_at"))
+        if created_at and (now - created_at) < min_age:
+            continue
+        obligations.append(
+            {
+                "kind": "pending_result_watcher",
+                "watcher_id": watcher.get("watcher_id"),
+                "task_id": watcher.get("task_id"),
+                "agent_id": watcher.get("agent_id"),
+            }
+        )
     for task in state.get("tasks", []):
         if task.get("status", "pending") in active_task_statuses and task.get("assignee"):
             obligations.append(
@@ -118,11 +201,33 @@ def detect_idle_fallbacks(
     )
     now = now or datetime.now(timezone.utc)
     owner_team_id = team_state_key(state)
-    obligations = _team_undelivered_obligations(state, store, owner_team_id, _ACTIVE_TASK_STATUSES)
+    obligations = _team_undelivered_obligations(state, store, owner_team_id, _ACTIVE_TASK_STATUSES, now=now)
     if not obligations:
         return []
     all_idle, idle_workers = _all_workers_idle(state, store, owner_team_id)
     if not all_idle:
+        record_team_progress(state, now, source="all_workers_idle:false", owner_team_id=owner_team_id)
+        save_runtime_state(workspace, state)
+        return []
+    last_progress = _team_last_progress_at(state, store, owner_team_id)
+    if last_progress and (now - last_progress) < timedelta(seconds=STABLE_IDLE_SECONDS):
+        event_log.write(
+            "coordinator.idle_fallback_skipped",
+            reason="stable_idle_window",
+            team=owner_team_id,
+            stable_idle_seconds=STABLE_IDLE_SECONDS,
+            elapsed_seconds=int((now - last_progress).total_seconds()),
+        )
+        return []
+    last_fire = _team_last_idle_fallback_fire_at(state, owner_team_id)
+    if last_fire and (now - last_fire) < timedelta(seconds=FIRE_DEBOUNCE_SECONDS):
+        event_log.write(
+            "coordinator.idle_fallback_skipped",
+            reason="fire_debounce",
+            team=owner_team_id,
+            fire_debounce_seconds=FIRE_DEBOUNCE_SECONDS,
+            elapsed_seconds=int((now - last_fire).total_seconds()),
+        )
         return []
     spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
     spec = load_spec(spec_path) if spec_path.exists() else {}
@@ -137,6 +242,7 @@ def detect_idle_fallbacks(
         alerts.append({"agent_id": agent_id, "alert_type": "idle_fallback", "obligations": obligations})
     if not alerts:
         return []
+    _record_idle_fallback_fire(state, owner_team_id, now)
     save_runtime_state(workspace, state)
     content = (
         "There is still unfinished work. Continue coordinating, deliver a result, "

package/src/team_agent/messaging/owner_bypass.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any
+
+from team_agent.events import EventLog
+from team_agent.state import worker_sender_bypasses_owner_gate
+
+
+def apply_worker_sender_bypass(
+    state: dict[str, Any],
+    sender: str | None,
+    target: Any,
+    task_id: str | None,
+    event_log: EventLog,
+) -> bool:
+    via = worker_sender_bypasses_owner_gate(state, sender)
+    if not via:
+        return False
+    event_log.write(
+        "send.bypassed_owner_gate_worker_sender",
+        sender=sender,
+        env_team_agent_id=via,
+        target=target if isinstance(target, str) else None,
+        task_id=task_id,
+    )
+    return True
+
+
+__all__ = ["apply_worker_sender_bypass"]

package/src/team_agent/messaging/scheduler.py

@@ -311,6 +311,16 @@ def _suppression_clear_reason(
     agent_id: str,
     entry: dict[str, Any],
 ) -> str | None:
+    if entry.get("manual_acknowledge"):
+        try:
+            expires_at = datetime.fromisoformat(str(entry.get("expires_at")))
+        except ValueError:
+            return "invalid_suppression_timestamp"
+        if expires_at.tzinfo is None:
+            expires_at = expires_at.replace(tzinfo=timezone.utc)
+        if datetime.now(timezone.utc) < expires_at:
+            return None
+        return "manual_acknowledge_expired"
     previous = entry.get("snapshot") if isinstance(entry.get("snapshot"), dict) else {}
     current = _agent_alert_snapshot(state, store, agent_id)
     if current.get("assigned_task_ids") != previous.get("assigned_task_ids"):

package/src/team_agent/messaging/send.py

@@ -85,11 +85,13 @@ def _send_message_unlocked(
             return ambiguous
     state = select_runtime_state(workspace, team)
     gate = check_team_owner(state)
-    if gate:
-        return gate
     spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
     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)
 
@@ -174,6 +176,11 @@ def _send_single_message_unlocked(
     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"):

package/src/team_agent/messaging/session_drift.py

@@ -0,0 +1,94 @@
+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"]

package/src/team_agent/runtime.py

@@ -220,6 +220,7 @@ from team_agent.state import (
     save_runtime_state,
     save_team_scoped_state,
     select_runtime_state,
+    team_state_key,
     write_spec,
     write_team_state,
 )
@@ -578,20 +579,27 @@ def remove_agent(
         return lifecycle_remove_agent(workspace, agent_id, from_spec=from_spec, confirm=confirm, force=force, team=team)
 
 
-def acknowledge_idle(workspace: Path, agent_id: str) -> dict[str, Any]:
+def acknowledge_idle(workspace: Path, agent_id: str | None = None, *, team: str | None = None) -> dict[str, Any]:
     with _runtime_lock(workspace, "acknowledge-idle"):
-        state = load_runtime_state(workspace)
+        try:
+            state = select_runtime_state(workspace, team)
+        except Exception as exc:
+            return {"ok": False, "status": "refused", "reason": "team_target_unresolved", "team": team, "error": str(exc)}
         gate = check_team_owner(state)
         if gate:
             return gate
-        now = datetime.now(timezone.utc).isoformat()
-        coordinator = state.setdefault("coordinator", {})
-        ack = coordinator.setdefault("idle_acknowledged", {})
-        ack[agent_id] = {"acknowledged_at": now}
-        save_runtime_state(workspace, state)
-        EventLog(workspace).write("coordinator.idle_acknowledged", agent_id=agent_id, acknowledged_at=now)
-        return {"ok": True, "agent_id": agent_id, "acknowledged_at": now}
-
+        now_dt = datetime.now(timezone.utc); now = now_dt.isoformat()
+        ttl_seconds = 1800
+        expires_at = (now_dt + timedelta(seconds=ttl_seconds)).isoformat()
+        owner_team_id = team_state_key(state); coordinator = state.setdefault("coordinator", {})
+        coordinator.setdefault("idle_acknowledged", {})[owner_team_id] = {"acknowledged_at": now, "expires_at": expires_at, "ttl_seconds": ttl_seconds}
+        team_suppressions = coordinator.setdefault("suppressed_idle_alerts", {}).setdefault(owner_team_id, {})
+        entry = {"suppressed_at": now, "suppressed_by": "manual_acknowledge", "manual_acknowledge": True, "expires_at": expires_at, "ttl_seconds": ttl_seconds}
+        for worker_id in state.get("agents", {}):
+            team_suppressions.setdefault(worker_id, {})["idle_fallback"] = dict(entry)
+        save_team_scoped_state(workspace, state)
+        EventLog(workspace).write("coordinator.idle_acknowledged", agent_id=agent_id, team=owner_team_id, acknowledged_at=now, expires_at=expires_at, ttl_seconds=ttl_seconds)
+        return {"ok": True, "team": owner_team_id, "agent_id": agent_id, "acknowledged_at": now, "expires_at": expires_at, "ttl_seconds": ttl_seconds}
 
 def takeover(workspace: Path, team: str | None = None, confirm: bool = False) -> dict[str, Any]:
     if not confirm:

package/src/team_agent/state.py

@@ -193,6 +193,20 @@ def check_team_owner(state: dict[str, Any]) -> dict[str, Any] | None:
     }
 
 
+def worker_sender_bypasses_owner_gate(state: dict[str, Any], sender: str | None) -> str | None:
+    if not sender:
+        return None
+    leader_id = (state.get("leader") or {}).get("id") or "leader"
+    if sender == leader_id or sender in {"leader", "Leader"}:
+        return None
+    if sender not in (state.get("agents") or {}):
+        return None
+    env_agent_id = os.environ.get("TEAM_AGENT_ID") or ""
+    if env_agent_id and env_agent_id != sender:
+        return None
+    return env_agent_id or sender
+
+
 def populate_team_owner_from_env(state: dict[str, Any], source: str = "autopopulate") -> dict[str, Any] | None:
     if state.get("team_owner"):
         return state["team_owner"]