@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/messaging/deps.py

@@ -1,247 +0,0 @@
-from __future__ import annotations
-
-import copy
-import json
-import os
-import re
-import subprocess
-import time
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from team_agent import runtime as _runtime
-from team_agent.errors import RuntimeError, ValidationError
-from team_agent.events import EventLog
-from team_agent.message_store import MessageStore
-from team_agent.paths import runtime_dir
-from team_agent.permissions import missing_tools
-from team_agent.routing import route_task
-from team_agent.spec import load_spec, validate_result_envelope
-from team_agent.state import (
-    ambiguous_team_target_result,
-    check_team_owner,
-    load_runtime_state,
-    save_runtime_state,
-    save_team_scoped_state,
-    select_runtime_state,
-    team_state_key,
-    write_team_state,
-)
-from team_agent.task_graph import update_task_status
-
-# Explicit runtime dependency surface for messaging extraction. Wrappers keep
-# runtime monkeypatch points stable while avoiding module-wide globals sync.
-_RUNTIME_CONSTANTS = (
-    "DELIVERY_CAPTURE_LINES",
-    "PASTED_CONTENT_PROMPT_RE",
-    "TMUX_PANE_FORMAT",
-    "TMUX_PASTE_BYTES_PER_SECOND",
-    "TMUX_PASTE_MAX_READY_TIMEOUT",
-    "TMUX_PASTE_MIN_READY_TIMEOUT",
-    "TMUX_STDIN_BUFFER_THRESHOLD",
-    "TMUX_SUBMIT_BYTES_PER_SECOND",
-    "TMUX_SUBMIT_MAX_SETTLE_TIMEOUT",
-    "TMUX_SUBMIT_MIN_SETTLE_TIMEOUT",
-)
-_RUNTIME_PATCH_POINTS = (
-    "_capture_has_pasted_content_prompt",
-    "_capture_missing_sessions",
-    "_capture_tmux_pane_text",
-    "_choose_leader_submit_key",
-    "_current_task_for_agent",
-    "_deliver_pending_message",
-    "_deliver_pending_messages",
-    "_find_agent",
-    "_find_task",
-    "_find_task_or_none",
-    "_format_team_agent_message",
-    "_handle_provider_runtime_prompts",
-    "_handle_provider_startup_prompts",
-    "_is_leader_sender",
-    "_is_leader_target",
-    "_is_message_scoped_result",
-    "_is_runtime_team_agent",
-    "_leader_id",
-    "_leader_receiver_is_direct",
-    "_message_by_id",
-    "_message_payload",
-    "_mirror_peer_message_to_leader",
-    "_notify_leader_of_report_result",
-    "_rediscover_leader_receiver",
-    "_refresh_agent_runtime_statuses",
-    "_result_status_to_task_status",
-    "_runtime_lock",
-    "_runtime_team_agent_ids",
-    "_send_to_leader_receiver",
-    "_submit_worker_prompt",
-    "_tmux_inject_text",
-    "_tmux_load_buffer_stdin",
-    "_tmux_pane_info",
-    "_tmux_paste_ready_timeout",
-    "_tmux_set_buffer_text",
-    "_tmux_submit_settle_timeout",
-    "_tmux_window_exists",
-    "_validate_leader_receiver",
-    "_wait_for_message_ready",
-    "_wait_for_worker_message_ready",
-    "core_list_targets",
-    "core_render_message",
-    "run_cmd",
-    "send_message",
-    "start_coordinator",
-)
-for _name in (*_RUNTIME_CONSTANTS, *_RUNTIME_PATCH_POINTS):
-    if not hasattr(_runtime, _name):
-        raise ImportError(f"team_agent.runtime missing messaging dependency: {_name}")
-
-DELIVERY_CAPTURE_LINES = _runtime.DELIVERY_CAPTURE_LINES
-PASTED_CONTENT_PROMPT_RE = _runtime.PASTED_CONTENT_PROMPT_RE
-TMUX_PANE_FORMAT = _runtime.TMUX_PANE_FORMAT
-TMUX_PASTE_BYTES_PER_SECOND = _runtime.TMUX_PASTE_BYTES_PER_SECOND
-TMUX_PASTE_MAX_READY_TIMEOUT = _runtime.TMUX_PASTE_MAX_READY_TIMEOUT
-TMUX_PASTE_MIN_READY_TIMEOUT = _runtime.TMUX_PASTE_MIN_READY_TIMEOUT
-TMUX_STDIN_BUFFER_THRESHOLD = _runtime.TMUX_STDIN_BUFFER_THRESHOLD
-TMUX_SUBMIT_BYTES_PER_SECOND = _runtime.TMUX_SUBMIT_BYTES_PER_SECOND
-TMUX_SUBMIT_MAX_SETTLE_TIMEOUT = _runtime.TMUX_SUBMIT_MAX_SETTLE_TIMEOUT
-TMUX_SUBMIT_MIN_SETTLE_TIMEOUT = _runtime.TMUX_SUBMIT_MIN_SETTLE_TIMEOUT
-
-
-def _runtime_symbol(name: str) -> Any:
-    return getattr(_runtime, name)
-
-def _capture_has_pasted_content_prompt(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_capture_has_pasted_content_prompt")(*args, **kwargs)
-
-def _capture_missing_sessions(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_capture_missing_sessions")(*args, **kwargs)
-
-def _capture_tmux_pane_text(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_capture_tmux_pane_text")(*args, **kwargs)
-
-def _choose_leader_submit_key(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_choose_leader_submit_key")(*args, **kwargs)
-
-def _current_task_for_agent(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_current_task_for_agent")(*args, **kwargs)
-
-def _deliver_pending_message(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_deliver_pending_message")(*args, **kwargs)
-
-def _deliver_pending_messages(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_deliver_pending_messages")(*args, **kwargs)
-
-def _find_agent(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_find_agent")(*args, **kwargs)
-
-def _find_task(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_find_task")(*args, **kwargs)
-
-def _find_task_or_none(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_find_task_or_none")(*args, **kwargs)
-
-def _format_team_agent_message(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_format_team_agent_message")(*args, **kwargs)
-
-def _handle_provider_runtime_prompts(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_handle_provider_runtime_prompts")(*args, **kwargs)
-
-def _handle_provider_startup_prompts(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_handle_provider_startup_prompts")(*args, **kwargs)
-
-def _is_leader_sender(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_is_leader_sender")(*args, **kwargs)
-
-def _is_leader_target(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_is_leader_target")(*args, **kwargs)
-
-def _is_message_scoped_result(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_is_message_scoped_result")(*args, **kwargs)
-
-def _is_runtime_team_agent(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_is_runtime_team_agent")(*args, **kwargs)
-
-def _leader_id(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_leader_id")(*args, **kwargs)
-
-def _leader_receiver_is_direct(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_leader_receiver_is_direct")(*args, **kwargs)
-
-def _message_by_id(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_message_by_id")(*args, **kwargs)
-
-def _message_payload(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_message_payload")(*args, **kwargs)
-
-def _mirror_peer_message_to_leader(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_mirror_peer_message_to_leader")(*args, **kwargs)
-
-def _notify_leader_of_report_result(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_notify_leader_of_report_result")(*args, **kwargs)
-
-def _rediscover_leader_receiver(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_rediscover_leader_receiver")(*args, **kwargs)
-
-def _refresh_agent_runtime_statuses(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_refresh_agent_runtime_statuses")(*args, **kwargs)
-
-def _result_status_to_task_status(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_result_status_to_task_status")(*args, **kwargs)
-
-def _runtime_lock(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_runtime_lock")(*args, **kwargs)
-
-def _runtime_team_agent_ids(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_runtime_team_agent_ids")(*args, **kwargs)
-
-def _send_to_leader_receiver(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_send_to_leader_receiver")(*args, **kwargs)
-
-def _submit_worker_prompt(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_submit_worker_prompt")(*args, **kwargs)
-
-def _tmux_inject_text(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_inject_text")(*args, **kwargs)
-
-def _tmux_pane_info(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_pane_info")(*args, **kwargs)
-
-def _tmux_load_buffer_stdin(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_load_buffer_stdin")(*args, **kwargs)
-
-def _tmux_paste_ready_timeout(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_paste_ready_timeout")(*args, **kwargs)
-
-def _tmux_set_buffer_text(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_set_buffer_text")(*args, **kwargs)
-
-def _tmux_submit_settle_timeout(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_submit_settle_timeout")(*args, **kwargs)
-
-def _tmux_window_exists(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_tmux_window_exists")(*args, **kwargs)
-
-def _validate_leader_receiver(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_validate_leader_receiver")(*args, **kwargs)
-
-def _wait_for_message_ready(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_wait_for_message_ready")(*args, **kwargs)
-
-def _wait_for_worker_message_ready(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("_wait_for_worker_message_ready")(*args, **kwargs)
-
-def run_cmd(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("run_cmd")(*args, **kwargs)
-
-def core_list_targets(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("core_list_targets")(*args, **kwargs)
-
-def core_render_message(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("core_render_message")(*args, **kwargs)
-
-def send_message(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("send_message")(*args, **kwargs)
-
-def start_coordinator(*args: Any, **kwargs: Any) -> Any:
-    return _runtime_symbol("start_coordinator")(*args, **kwargs)
-
-__all__ = ['DELIVERY_CAPTURE_LINES', 'EventLog', 'MessageStore', 'PASTED_CONTENT_PROMPT_RE', 'RuntimeError', 'TMUX_PANE_FORMAT', 'TMUX_PASTE_BYTES_PER_SECOND', 'TMUX_PASTE_MAX_READY_TIMEOUT', 'TMUX_PASTE_MIN_READY_TIMEOUT', 'TMUX_STDIN_BUFFER_THRESHOLD', 'TMUX_SUBMIT_BYTES_PER_SECOND', 'TMUX_SUBMIT_MAX_SETTLE_TIMEOUT', 'TMUX_SUBMIT_MIN_SETTLE_TIMEOUT', 'ValidationError', '_capture_has_pasted_content_prompt', '_capture_missing_sessions', '_capture_tmux_pane_text', '_choose_leader_submit_key', '_current_task_for_agent', '_deliver_pending_message', '_deliver_pending_messages', '_find_agent', '_find_task', '_find_task_or_none', '_format_team_agent_message', '_handle_provider_runtime_prompts', '_handle_provider_startup_prompts', '_is_leader_sender', '_is_leader_target', '_is_message_scoped_result', '_is_runtime_team_agent', '_leader_id', '_leader_receiver_is_direct', '_message_by_id', '_message_payload', '_mirror_peer_message_to_leader', '_notify_leader_of_report_result', '_rediscover_leader_receiver', '_refresh_agent_runtime_statuses', '_result_status_to_task_status', '_runtime_lock', '_runtime_team_agent_ids', '_send_to_leader_receiver', '_submit_worker_prompt', '_tmux_inject_text', '_tmux_load_buffer_stdin', '_tmux_pane_info', '_tmux_paste_ready_timeout', '_tmux_set_buffer_text', '_tmux_submit_settle_timeout', '_tmux_window_exists', '_validate_leader_receiver', '_wait_for_message_ready', '_wait_for_worker_message_ready', 'ambiguous_team_target_result', 'check_team_owner', 'copy', 'core_list_targets', 'core_render_message', 'datetime', 'json', 'load_runtime_state', 'load_spec', 'missing_tools', 'os', 're', 'route_task', 'run_cmd', 'runtime_dir', 'save_runtime_state', 'save_team_scoped_state', 'select_runtime_state', 'send_message', 'start_coordinator', 'subprocess', 'team_state_key', 'time', 'timedelta', 'timezone', 'update_task_status', 'validate_result_envelope', 'write_team_state']

package/src/team_agent/messaging/idle_alerts.py

@@ -1,423 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.message_store import MessageStore
-from team_agent.messaging.deps import load_runtime_state, load_spec, save_runtime_state, team_state_key
-from team_agent.messaging.internal_delivery import deliver_stored_message
-
-
-_UNDELIVERED_MESSAGE_STATUSES = {
-    "pending",
-    "accepted",
-    "queued_until_idle",
-    "queued_until_start",
-    "queued_stopped",
-    "queued_pane_missing",
-    "failed",
-    "delivery_blocked",
-    "injected_unverified",
-}
-
-
-STABLE_IDLE_SECONDS = 120
-FIRE_DEBOUNCE_SECONDS = 300
-OBLIGATION_PENDING_MIN_AGE_SECONDS = 60
-
-# Event-log progress signal (Gap 32 §"Idle-Detector False Positive Continues Post Phase G hotfix-3"):
-# the team_last_progress_at calculation must also count leader-side sends and worker MCP calls
-# as recent team activity, not only agent_health.last_output_at. Without this, a worker that has
-# called MCP but not yet emitted a visible turn shows up as idle and the idle reminder fires
-# spuriously inside the stable-idle window.
-_PROGRESS_EVENT_TYPES = frozenset({
-    "send.deliver_attempt",
-    "leader_receiver.deliver_attempt",
-    "mcp.report_result",
-    "mcp.send_message",
-})
-_PROGRESS_EVENT_PREFIXES = ("mcp.read_",)
-_PROGRESS_EVENT_WINDOW_SECONDS = 300
-_PROGRESS_EVENT_TAIL_LIMIT = 1000
-
-
-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,
-    event_log: EventLog | None = None,
-    now: datetime | None = None,
-    workspace: Path | None = None,
-) -> tuple[datetime | None, str | None]:
-    sources: list[tuple[datetime, str]] = []
-    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:
-            sources.append((ts, "explicit_marker"))
-    elif isinstance(explicit, str):
-        ts = _parse_iso(explicit)
-        if ts:
-            sources.append((ts, "explicit_marker"))
-    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:
-            sources.append((ts, "agent_health.last_output_at"))
-    if event_log is not None:
-        # Spark MEDIUM #3 (d9f740d): in multi-team workspaces an unscoped progress event in
-        # team A's activity must NOT suppress team B's idle_fallback. require_team_scope=True
-        # when the workspace has more than one team so unscoped events are ignored. The
-        # team-scoped state passed in here does not carry the workspace-level `teams` dict, so
-        # we re-read the workspace state from disk to detect multi-team shape.
-        require_team_scope = False
-        teams = state.get("teams")
-        if isinstance(teams, dict) and len(teams) > 1:
-            require_team_scope = True
-        elif workspace is not None:
-            try:
-                ws_teams = (load_runtime_state(workspace).get("teams") or {})
-            except Exception:
-                ws_teams = {}
-            if isinstance(ws_teams, dict) and len(ws_teams) > 1:
-                require_team_scope = True
-        event_ts = _scan_event_progress_signals(
-            event_log, owner_team_id, now or datetime.now(timezone.utc),
-            require_team_scope=require_team_scope,
-        )
-        if event_ts:
-            sources.append((event_ts, "event_log"))
-    if not sources:
-        return None, None
-    sources.sort(key=lambda item: item[0], reverse=True)
-    return sources[0]
-
-
-# Stage 14 (Gap 36b) — mtime cache per (workspace_path, owner_team_id, require_team_scope).
-# Mac mini 2026-05-26 evidence: _scan_event_progress_signals was a 22% CPU hot path because
-# every 2-second coordinator tick parsed up to 1000 events from a 28 MB events.jsonl. With
-# the cache, the parse only re-runs when the file changes; quiet workspaces pay zero file
-# I/O between writes.
-_PROGRESS_SCAN_CACHE: dict[tuple[str, str, bool], tuple[float, datetime | None]] = {}
-
-
-def _scan_event_progress_signals(
-    event_log: EventLog,
-    owner_team_id: str,
-    now: datetime,
-    *,
-    require_team_scope: bool = False,
-) -> datetime | None:
-    cache_key = (str(event_log.path), owner_team_id, require_team_scope)
-    try:
-        current_mtime = event_log.path.stat().st_mtime
-    except FileNotFoundError:
-        _PROGRESS_SCAN_CACHE.pop(cache_key, None)
-        return None
-    cached = _PROGRESS_SCAN_CACHE.get(cache_key)
-    if cached is not None and cached[0] == current_mtime:
-        return cached[1]
-    window_start = now - timedelta(seconds=_PROGRESS_EVENT_WINDOW_SECONDS)
-    latest: datetime | None = None
-    for event in event_log.tail(_PROGRESS_EVENT_TAIL_LIMIT):
-        event_type = str(event.get("event") or "")
-        if event_type not in _PROGRESS_EVENT_TYPES and not any(
-            event_type.startswith(prefix) for prefix in _PROGRESS_EVENT_PREFIXES
-        ):
-            continue
-        event_team = event.get("team") or event.get("owner_team_id")
-        if event_team is None:
-            if require_team_scope:
-                continue
-        elif event_team != owner_team_id:
-            continue
-        ts = _parse_iso(event.get("ts"))
-        if not ts or ts < window_start:
-            continue
-        if latest is None or ts > latest:
-            latest = ts
-    _PROGRESS_SCAN_CACHE[cache_key] = (current_mtime, latest)
-    return latest
-
-
-def _reset_progress_scan_cache() -> None:
-    """Test-only hook to force re-scan."""
-    _PROGRESS_SCAN_CACHE.clear()
-
-
-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") 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") 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(
-                {
-                    "kind": "active_task",
-                    "task_id": task.get("id"),
-                    "assignee": task.get("assignee"),
-                    "status": task.get("status"),
-                }
-            )
-    return obligations
-
-
-def _all_workers_idle(
-    state: dict[str, Any],
-    store: MessageStore,
-    owner_team_id: str,
-) -> tuple[bool, list[str]]:
-    health = store.agent_health(owner_team_id=owner_team_id)
-    worker_ids = list(state.get("agents", {}).keys()) or list(health.keys())
-    if not worker_ids:
-        return False, []
-    idle: list[str] = []
-    for agent_id in worker_ids:
-        row = health.get(agent_id) or {}
-        status = str(row.get("status") or "").lower()
-        if status != "idle":
-            return False, []
-        idle.append(agent_id)
-    return True, idle
-
-
-def _register_unified_alert(
-    state: dict[str, Any],
-    owner_team_id: str,
-    agent_id: str,
-    alert_type: str,
-    snapshot: dict[str, Any],
-    suppressed_by: str,
-    now: datetime,
-) -> dict[str, Any]:
-    coordinator = state.setdefault("coordinator", {})
-    suppressed = coordinator.setdefault("suppressed_idle_alerts", {})
-    team_suppressions = suppressed.setdefault(owner_team_id, {})
-    agent_suppressions = team_suppressions.setdefault(agent_id, {})
-    entry = {
-        "suppressed_at": now.isoformat(),
-        "suppressed_by": suppressed_by,
-        "snapshot": snapshot,
-    }
-    agent_suppressions[alert_type] = entry
-    return entry
-
-
-def detect_idle_fallbacks(
-    workspace: Path,
-    state: dict[str, Any],
-    store: MessageStore,
-    event_log: EventLog,
-    now: datetime | None = None,
-) -> list[dict[str, Any]]:
-    from team_agent.messaging.scheduler import (
-        _ACTIVE_TASK_STATUSES,
-        _active_alert_suppression,
-        _agent_alert_snapshot,
-    )
-    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, 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, progress_source = _team_last_progress_at(
-        state, store, owner_team_id, event_log=event_log, now=now, workspace=workspace,
-    )
-    if last_progress and (now - last_progress) < timedelta(seconds=STABLE_IDLE_SECONDS):
-        reason = "recent_team_progress" if progress_source == "event_log" else "stable_idle_window"
-        event_log.write(
-            "coordinator.idle_fallback_skipped",
-            reason=reason,
-            team=owner_team_id,
-            stable_idle_seconds=STABLE_IDLE_SECONDS,
-            elapsed_seconds=int((now - last_progress).total_seconds()),
-            progress_source=progress_source,
-        )
-        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 {}
-    leader_id = state.get("leader", {}).get("id") or spec.get("leader", {}).get("id") or "leader"
-    alerts: list[dict[str, Any]] = []
-    for agent_id in idle_workers:
-        suppression = _active_alert_suppression(state, store, event_log, agent_id, "idle_fallback")
-        if suppression:
-            continue
-        snapshot = _agent_alert_snapshot(state, store, agent_id, owner_team_id)
-        _register_unified_alert(state, owner_team_id, agent_id, "idle_fallback", snapshot, "coordinator", now)
-        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, "
-        "or acknowledge that this idle state is intentional via team-agent acknowledge-idle."
-    )
-    try:
-        deliver_stored_message(
-            workspace,
-            leader_id,
-            content,
-            sender="coordinator",
-            requires_ack=False,
-            wait_visible=False,
-            team=owner_team_id,
-        )
-    except Exception as exc:
-        event_log.write("coordinator.idle_fallback_push_failed", error=str(exc), team=owner_team_id)
-    event_log.write(
-        "coordinator.idle_fallback",
-        team=owner_team_id,
-        idle_workers=idle_workers,
-        obligation_count=len(obligations),
-        alert_count=len(alerts),
-    )
-    return alerts
-
-
-def detect_cross_worker_deadlocks(
-    workspace: Path,
-    state: dict[str, Any],
-    store: MessageStore,
-    event_log: EventLog,
-    now: datetime | None = None,
-) -> list[dict[str, Any]]:
-    from team_agent.messaging.scheduler import (
-        _active_alert_suppression,
-        _agent_alert_snapshot,
-    )
-    now = now or datetime.now(timezone.utc)
-    owner_team_id = team_state_key(state)
-    health = store.agent_health(owner_team_id=owner_team_id)
-    candidate_recipients: dict[str, list[dict[str, Any]]] = {}
-    for message in store.messages(owner_team_id=owner_team_id):
-        if message.get("status") not in _UNDELIVERED_MESSAGE_STATUSES:
-            continue
-        recipient = message.get("recipient")
-        if not recipient:
-            continue
-        candidate_recipients.setdefault(str(recipient), []).append(message)
-    alerts: list[dict[str, Any]] = []
-    for agent_id, messages in candidate_recipients.items():
-        row = health.get(agent_id) or {}
-        status = str(row.get("status") or "").lower()
-        if status != "idle":
-            continue
-        suppression = _active_alert_suppression(state, store, event_log, agent_id, "cross_worker_deadlock")
-        if suppression:
-            continue
-        snapshot = _agent_alert_snapshot(state, store, agent_id, owner_team_id)
-        snapshot["pending_message_ids"] = sorted(str(m.get("message_id")) for m in messages)
-        _register_unified_alert(state, owner_team_id, agent_id, "cross_worker_deadlock", snapshot, "coordinator", now)
-        alerts.append(
-            {
-                "agent_id": agent_id,
-                "alert_type": "cross_worker_deadlock",
-                "pending_messages": snapshot["pending_message_ids"],
-            }
-        )
-    if not alerts:
-        return []
-    save_runtime_state(workspace, state)
-    event_log.write(
-        "coordinator.cross_worker_deadlock",
-        team=owner_team_id,
-        agent_ids=[alert["agent_id"] for alert in alerts],
-        alert_count=len(alerts),
-    )
-    return alerts