@team-agent/installer 0.2.3 → 0.2.5

package/src/team_agent/display/tiling.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import shlex
+from typing import Any, Callable
+
+
+DISPLAY_PANES_PER_WINDOW = 3
+
+
+def display_window_name(index: int) -> str:
+    return "overview" if index == 0 else f"overview-{index + 1}"
+
+
+def grouped_display_jobs(
+    jobs: list[tuple[str, dict[str, Any], str]],
+    panes_per_window: int = DISPLAY_PANES_PER_WINDOW,
+) -> list[tuple[int, str, list[tuple[str, dict[str, Any], str]]]]:
+    groups: list[tuple[int, str, list[tuple[str, dict[str, Any], str]]]] = []
+    for window_index, start in enumerate(range(0, len(jobs), panes_per_window)):
+        groups.append((window_index, display_window_name(window_index), jobs[start : start + panes_per_window]))
+    return groups
+
+
+def team_scoped_display_window_name(session_name: str, index: int) -> str:
+    return f"team-agent:{session_name}:{display_window_name(index)}"
+
+
+def tmux_stdout_last_line(stdout: str) -> str | None:
+    lines = [line.strip() for line in stdout.splitlines() if line.strip()]
+    return lines[-1] if lines else None
+
+
+def tmux_attach_pane_command(linked_session: str) -> str:
+    return f"TMUX= tmux attach-session -t {shlex.quote(linked_session)}"
+
+
+def display_pane_title(agent: dict[str, Any]) -> str:
+    return f"team-agent:{agent['id']}:{agent.get('role', '')}"
+
+
+def set_tmux_display_pane_title(pane_id: str, title: str, reason: str) -> dict[str, Any]:
+    from team_agent.runtime import run_cmd
+    proc = run_cmd(["tmux", "select-pane", "-t", pane_id, "-T", title], timeout=10)
+    if proc.returncode != 0:
+        return {"ok": False, "reason": reason, "error": proc.stderr.strip()}
+    return {"ok": True}
+
+
+def prepare_tmux_attached_panes(
+    host_session: str,
+    linked_jobs: list[tuple[str, dict[str, Any], str]],
+    *,
+    window_name_for_index: Callable[[int], str],
+    create_first_as_session: bool,
+    panes_per_window: int = DISPLAY_PANES_PER_WINDOW,
+    reason_map: dict[str, str] | None = None,
+    stderr_reason_allowlist: set[str] | None = None,
+    cleanup_session: str | None = None,
+    enable_mouse: bool = False,
+    select_first_window: bool = False,
+) -> dict[str, Any]:
+    from team_agent.runtime import run_cmd
+
+    reasons = reason_map or {}
+
+    def reason(key: str) -> str:
+        return reasons.get(key, key)
+
+    def fail(key: str, proc: Any | None = None, target: str | None = None) -> dict[str, Any]:
+        if cleanup_session:
+            run_cmd(["tmux", "kill-session", "-t", cleanup_session], timeout=10)
+        result = {"ok": False, "reason": reason(key)}
+        if proc is not None:
+            detail = (proc.stderr or proc.stdout or "").strip()
+            if stderr_reason_allowlist and detail in stderr_reason_allowlist:
+                result["reason"] = detail
+            result["error"] = detail
+        if target:
+            result["target"] = target
+        return result
+
+    panes: list[dict[str, Any]] = []
+    for window_index, _base_window_name, window_jobs in grouped_display_jobs(linked_jobs, panes_per_window):
+        window_name = window_name_for_index(window_index)
+        first_agent_id, first_agent, first_linked_session = window_jobs[0]
+        if create_first_as_session and window_index == 0:
+            command = [
+                "tmux", "new-session", "-d", "-P", "-F", "#{pane_id}",
+                "-s", host_session, "-n", window_name, tmux_attach_pane_command(first_linked_session),
+            ]
+            fail_key = "create_session"
+        else:
+            command = [
+                "tmux", "new-window", "-t", host_session, "-n", window_name,
+                "-P", "-F", "#{pane_id}", tmux_attach_pane_command(first_linked_session),
+            ]
+            fail_key = "create_window"
+        proc = run_cmd(command, timeout=10)
+        if proc.returncode != 0:
+            return fail(fail_key, proc, f"{host_session}:{window_name}")
+
+        first_pane_id = tmux_stdout_last_line(proc.stdout) or f"{host_session}:{window_name}.0"
+        title = display_pane_title(first_agent)
+        title_result = set_tmux_display_pane_title(first_pane_id, title, reason("title"))
+        if not title_result["ok"]:
+            return fail(title_result["reason"], target=first_pane_id)
+        panes.append(
+            {
+                "agent_id": first_agent_id,
+                "pane_id": first_pane_id,
+                "title": title,
+                "linked_session": first_linked_session,
+                "window_name": window_name,
+            }
+        )
+
+        proc = run_cmd(["tmux", "set-window-option", "-t", f"{host_session}:{window_name}", "remain-on-exit", "on"], timeout=10)
+        if proc.returncode != 0:
+            return fail("remain", proc, f"{host_session}:{window_name}")
+
+        for index, (agent_id, agent, linked_session) in enumerate(window_jobs[1:], start=1):
+            proc = run_cmd(
+                [
+                    "tmux", "split-window", "-t", f"{host_session}:{window_name}",
+                    "-h", "-P", "-F", "#{pane_id}", tmux_attach_pane_command(linked_session),
+                ],
+                timeout=10,
+            )
+            if proc.returncode != 0:
+                return fail("split", proc, f"{host_session}:{window_name}")
+            pane_id = tmux_stdout_last_line(proc.stdout) or f"{host_session}:{window_name}.{index}"
+            title = display_pane_title(agent)
+            title_result = set_tmux_display_pane_title(pane_id, title, reason("title"))
+            if not title_result["ok"]:
+                return fail(title_result["reason"], target=pane_id)
+            panes.append(
+                {
+                    "agent_id": agent_id,
+                    "pane_id": pane_id,
+                    "title": title,
+                    "linked_session": linked_session,
+                    "window_name": window_name,
+                }
+            )
+
+        proc = run_cmd(["tmux", "select-layout", "-t", f"{host_session}:{window_name}", "even-horizontal"], timeout=10)
+        if proc.returncode != 0:
+            return fail("layout", proc, f"{host_session}:{window_name}")
+
+    if enable_mouse:
+        proc = run_cmd(["tmux", "set-option", "-t", host_session, "mouse", "on"], timeout=10)
+        if proc.returncode != 0:
+            return fail("mouse", proc)
+    if select_first_window:
+        run_cmd(["tmux", "select-window", "-t", f"{host_session}:{window_name_for_index(0)}"], timeout=10)
+    return {"ok": True, "host_session": host_session, "panes": panes}

package/src/team_agent/display/worker_window.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any
 
 from team_agent.events import EventLog
+from team_agent.display.adaptive import open_adaptive_display
 from team_agent.display.ghostty import (
     ghostty_app_exists,
     ghostty_attach_args,
@@ -21,9 +22,12 @@ def open_worker_displays(
     jobs: list[tuple[str, dict[str, Any]]],
     event_log: EventLog,
     display_backend: str = "ghostty_window",
+    capability_probe: dict[str, Any] | None = None,
 ) -> dict[str, dict[str, Any]]:
     if not jobs:
         return {}
+    if display_backend == "adaptive":
+        return open_adaptive_display(workspace, session_name, jobs, event_log, capability_probe=capability_probe)
     if display_backend == "ghostty_workspace":
         return open_ghostty_workspace(workspace, session_name, jobs, event_log)
     if len(jobs) == 1:

package/src/team_agent/display/workspace.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import hashlib
 import re
-import shlex
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any
 
@@ -14,14 +13,18 @@ from team_agent.display.ghostty import (
     ghostty_pids_by_title,
     prepare_ghostty_display_session,
 )
+from team_agent.display.tiling import (
+    DISPLAY_PANES_PER_WINDOW,
+    display_pane_title,
+    display_window_name,
+    prepare_tmux_attached_panes,
+    set_tmux_display_pane_title,
+    tmux_attach_pane_command,
+    tmux_stdout_last_line as _tmux_stdout_last_line,
+)
 
 
-GHOSTTY_WORKSPACE_PANES_PER_WINDOW = 3
-
-
-def _tmux_stdout_last_line(stdout: str) -> str | None:
-    lines = [line.strip() for line in stdout.splitlines() if line.strip()]
-    return lines[-1] if lines else None
+GHOSTTY_WORKSPACE_PANES_PER_WINDOW = DISPLAY_PANES_PER_WINDOW
 
 
 def open_ghostty_workspace(
@@ -152,15 +155,15 @@ def ghostty_workspace_aggregator_name(session_name: str) -> str:
 
 
 def ghostty_workspace_window_name(index: int) -> str:
-    return "overview" if index == 0 else f"overview-{index + 1}"
+    return display_window_name(index)
 
 
 def ghostty_workspace_pane_command(linked_session: str) -> str:
-    return f"TMUX= tmux attach-session -t {shlex.quote(linked_session)}"
+    return tmux_attach_pane_command(linked_session)
 
 
 def ghostty_workspace_pane_title(agent: dict[str, Any]) -> str:
-    return f"team-agent:{agent['id']}:{agent.get('role', '')}"
+    return display_pane_title(agent)
 
 
 def prepare_ghostty_workspace_linked_sessions(
@@ -203,126 +206,32 @@ def prepare_ghostty_workspace_aggregator(
         proc = run_cmd(["tmux", "kill-session", "-t", aggregator_session], timeout=10)
         if proc.returncode != 0:
             return {"ok": False, "reason": "display_session_cleanup_failed", "error": proc.stderr.strip()}
-
-    def fail(reason: str, proc: Any | None = None, target: str | None = None) -> dict[str, Any]:
-        run_cmd(["tmux", "kill-session", "-t", aggregator_session], timeout=10)
-        result = {"ok": False, "reason": reason}
-        if proc is not None:
-            result["error"] = proc.stderr.strip()
-        if target:
-            result["target"] = target
-        return result
-
-    panes: list[dict[str, Any]] = []
-    for window_index, start in enumerate(range(0, len(linked_jobs), GHOSTTY_WORKSPACE_PANES_PER_WINDOW)):
-        window_name = ghostty_workspace_window_name(window_index)
-        window_jobs = linked_jobs[start : start + GHOSTTY_WORKSPACE_PANES_PER_WINDOW]
-        first_agent_id, first_agent, first_linked_session = window_jobs[0]
-        if window_index == 0:
-            proc = run_cmd(
-                [
-                    "tmux",
-                    "new-session",
-                    "-d",
-                    "-P",
-                    "-F",
-                    "#{pane_id}",
-                    "-s",
-                    aggregator_session,
-                    "-n",
-                    window_name,
-                    ghostty_workspace_pane_command(first_linked_session),
-                ],
-                timeout=10,
-            )
-            if proc.returncode != 0:
-                return {"ok": False, "reason": "display_session_create_failed", "error": proc.stderr.strip()}
-        else:
-            proc = run_cmd(
-                [
-                    "tmux",
-                    "new-window",
-                    "-t",
-                    aggregator_session,
-                    "-n",
-                    window_name,
-                    "-P",
-                    "-F",
-                    "#{pane_id}",
-                    ghostty_workspace_pane_command(first_linked_session),
-                ],
-                timeout=10,
-            )
-            if proc.returncode != 0:
-                return fail("display_session_window_create_failed", proc, first_linked_session)
-        first_pane_id = _tmux_stdout_last_line(proc.stdout) or f"{aggregator_session}:{window_name}.0"
-        first_title = ghostty_workspace_pane_title(first_agent)
-        title_result = set_ghostty_workspace_pane_title(first_pane_id, first_title)
-        if not title_result["ok"]:
-            return fail(title_result["reason"], target=first_pane_id)
-        panes.append(
-            {
-                "agent_id": first_agent_id,
-                "pane_id": first_pane_id,
-                "title": first_title,
-                "linked_session": first_linked_session,
-                "window_name": window_name,
-            }
-        )
-
-        proc = run_cmd(["tmux", "set-window-option", "-t", f"{aggregator_session}:{window_name}", "remain-on-exit", "on"], timeout=10)
-        if proc.returncode != 0:
-            return fail("display_session_remain_on_exit_failed", proc)
-
-        for index, (agent_id, agent, linked_session) in enumerate(window_jobs[1:], start=1):
-            proc = run_cmd(
-                [
-                    "tmux",
-                    "split-window",
-                    "-t",
-                    f"{aggregator_session}:{window_name}",
-                    "-h",
-                    "-P",
-                    "-F",
-                    "#{pane_id}",
-                    ghostty_workspace_pane_command(linked_session),
-                ],
-                timeout=10,
-            )
-            if proc.returncode != 0:
-                return fail("display_session_split_failed", proc, linked_session)
-            pane_id = _tmux_stdout_last_line(proc.stdout) or f"{aggregator_session}:{window_name}.{index}"
-            title = ghostty_workspace_pane_title(agent)
-            title_result = set_ghostty_workspace_pane_title(pane_id, title)
-            if not title_result["ok"]:
-                return fail(title_result["reason"], target=pane_id)
-            panes.append(
-                {
-                    "agent_id": agent_id,
-                    "pane_id": pane_id,
-                    "title": title,
-                    "linked_session": linked_session,
-                    "window_name": window_name,
-                }
-            )
-
-        proc = run_cmd(["tmux", "select-layout", "-t", f"{aggregator_session}:{window_name}", "even-horizontal"], timeout=10)
-        if proc.returncode != 0:
-            return fail("display_session_layout_failed", proc)
-
-    proc = run_cmd(["tmux", "set-option", "-t", aggregator_session, "mouse", "on"], timeout=10)
-    if proc.returncode != 0:
-        return fail("display_session_mouse_failed", proc)
-    run_cmd(["tmux", "select-window", "-t", f"{aggregator_session}:{ghostty_workspace_window_name(0)}"], timeout=10)
-    return {"ok": True, "aggregator_session": aggregator_session, "panes": panes}
+    prepared = prepare_tmux_attached_panes(
+        aggregator_session,
+        linked_jobs,
+        window_name_for_index=ghostty_workspace_window_name,
+        create_first_as_session=True,
+        panes_per_window=GHOSTTY_WORKSPACE_PANES_PER_WINDOW,
+        cleanup_session=aggregator_session,
+        enable_mouse=True,
+        select_first_window=True,
+        reason_map={
+            "create_session": "display_session_create_failed",
+            "create_window": "display_session_window_create_failed",
+            "title": "display_session_pane_title_failed",
+            "remain": "display_session_remain_on_exit_failed",
+            "split": "display_session_split_failed",
+            "layout": "display_session_layout_failed",
+            "mouse": "display_session_mouse_failed",
+        },
+    )
+    if prepared.get("ok"):
+        prepared["aggregator_session"] = aggregator_session
+    return prepared
 
 
 def set_ghostty_workspace_pane_title(pane_id: str, title: str) -> dict[str, Any]:
-    from team_agent.runtime import run_cmd
-    proc = run_cmd(["tmux", "select-pane", "-t", pane_id, "-T", title], timeout=10)
-    if proc.returncode != 0:
-        return {"ok": False, "reason": "display_session_pane_title_failed", "error": proc.stderr.strip()}
-    return {"ok": True}
+    return set_tmux_display_pane_title(pane_id, title, "display_session_pane_title_failed")
 
 
 def open_ghostty_workspace_agent_display(

package/src/team_agent/idle_predicate.py

@@ -0,0 +1,200 @@
+"""Provider-neutral take-over reminder predicate (Gap 32 §3).
+
+Consumes already-classified node states only. Contains no provider knowledge.
+Rules: arm only after a worker has opened a turn (C1); fire one neutral ping when
+every node is idle for a monotonic debounce window (C2/C11); idle_interrupted
+counts as idle but is annotated (C12); re-arm on a real turn-open edge (C3).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+_IDLE_STATES = {"idle", "idle_interrupted"}
+_DELEGATED_STATES = {"working", "blocked_on_human", "idle_interrupted", "abnormal"}
+
+_ARM_KEY = "opened_worker_turn_since_ack"
+_SUPPRESS_KEY = "suppressed"
+
+
+def evaluate_takeover_reminder(
+    nodes: list[dict[str, Any]],
+    *,
+    monitor_state: dict[str, Any] | None,
+    now_monotonic: float,
+    debounce_seconds: float,
+    suspend_intervals: list[tuple[float, float]] | None = None,
+    event_sink: Any = None,
+) -> dict[str, Any]:
+    state = dict(monitor_state or {})
+    state.setdefault(_ARM_KEY, False)
+    state.setdefault(_SUPPRESS_KEY, False)
+    state.setdefault("all_idle_since", None)
+    state.setdefault("pinged_for_episode", None)
+
+    # C1: a WORKER turn-open (working / blocked / interrupted / faulted) is the
+    # only thing that arms the watch. Leader-only activity never arms it.
+    for node in nodes:
+        if _role(node) == "leader":
+            continue
+        if node.get("state") in _DELEGATED_STATES:
+            state[_ARM_KEY] = True
+
+    # Any non-idle node blocks the ping; report which kind (C5 unknown / C14 working).
+    for node in nodes:
+        node_state = node.get("state")
+        if node_state not in _IDLE_STATES:
+            state["all_idle_since"] = None
+            state["pinged_for_episode"] = None
+            return _result(False, None, f"node_{node_state or 'unknown'}", _interrupted(nodes), state)
+
+    if not nodes:
+        return _result(False, None, "no_nodes", [], state)
+
+    if state.get("all_idle_since") is None:
+        state["all_idle_since"] = now_monotonic
+        state["pinged_for_episode"] = None
+    elapsed = _active_elapsed(state["all_idle_since"], now_monotonic, suspend_intervals)
+    interrupted = _interrupted(nodes)
+
+    if not state.get(_ARM_KEY):
+        return _result(False, None, "not_armed_no_worker_turn", interrupted, state)
+    if state.get(_SUPPRESS_KEY):
+        return _result(False, None, "acknowledged", interrupted, state)
+    if elapsed < debounce_seconds:
+        return _result(False, None, "debounce_active", interrupted, state)
+    if state.get("pinged_for_episode") == state.get("all_idle_since"):
+        return _result(False, None, "already_pinged_this_episode", interrupted, state)
+
+    state["pinged_for_episode"] = state["all_idle_since"]
+    message = _neutral_message(len(nodes), elapsed, interrupted)
+    _emit(event_sink, "idle_takeover.ping", nodes=len(nodes), elapsed_seconds=int(elapsed), interrupted=[i["node_id"] for i in interrupted])
+    return _result(True, message, "all_idle_debounce_elapsed", interrupted, state)
+
+
+def record_turn_open_after_delivery(
+    monitor_state: dict[str, Any] | None,
+    *,
+    node_id: str,
+    turn_id: str | None,
+    delivered_message_id: str | None,
+    now_monotonic: float,
+    event_sink: Any = None,
+) -> dict[str, Any]:
+    """A delivered inbound message produced a real turn-open edge (C3).
+
+    Re-arms a previously acknowledged watch so delivered-but-unprocessed work
+    can never leave it permanently suppressed. Returns the updated monitor_state
+    directly (with the re-arm flags set).
+    """
+    state = dict(monitor_state or {})
+    state[_ARM_KEY] = True
+    state[_SUPPRESS_KEY] = False
+    state["all_idle_since"] = None
+    state["pinged_for_episode"] = None
+    state["last_turn_open"] = {
+        "node_id": node_id,
+        "turn_id": turn_id,
+        "delivered_message_id": delivered_message_id,
+        "at": now_monotonic,
+    }
+    state["ok"] = True
+    state["rearmed"] = True
+    _emit(event_sink, "idle_takeover.turn_open_rearmed", node_id=node_id, turn_id=turn_id, delivered_message_id=delivered_message_id)
+    return state
+
+
+def _role(node: dict[str, Any]) -> str:
+    return str(node.get("role") or ("leader" if node.get("is_leader") else "worker"))
+
+
+def _interrupted(nodes: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        {
+            "node_id": n.get("node_id"),
+            "node": n.get("node_id"),
+            "state": "idle_interrupted",
+            "reason": "interrupted",
+            "interrupted": True,
+            "kind": "interrupted",
+            "type": "interrupted",
+            "annotation": "interrupted",
+        }
+        for n in nodes
+        if n.get("state") == "idle_interrupted"
+    ]
+
+
+def _active_elapsed(start: float, now: float, suspend_intervals: list[tuple[float, float]] | None) -> float:
+    elapsed = max(0.0, now - start)
+    if not suspend_intervals:
+        return elapsed
+    # C11: clip each window to [start, now], then MERGE overlapping/duplicate
+    # windows before subtracting, so an overlap is never counted twice.
+    clipped: list[tuple[float, float]] = []
+    for interval in suspend_intervals:
+        try:
+            s, e = float(interval[0]), float(interval[1])
+        except (TypeError, ValueError, IndexError):
+            continue
+        lo = max(s, start)
+        hi = min(e, now)
+        if hi > lo:
+            clipped.append((lo, hi))
+    suspended = 0.0
+    for lo, hi in _merge_intervals(clipped):
+        suspended += hi - lo
+    return max(0.0, elapsed - suspended)
+
+
+def _merge_intervals(intervals: list[tuple[float, float]]) -> list[tuple[float, float]]:
+    if not intervals:
+        return []
+    ordered = sorted(intervals)
+    merged: list[tuple[float, float]] = [ordered[0]]
+    for lo, hi in ordered[1:]:
+        last_lo, last_hi = merged[-1]
+        if lo <= last_hi:  # overlapping or touching → merge
+            merged[-1] = (last_lo, max(last_hi, hi))
+        else:
+            merged.append((lo, hi))
+    return merged
+
+
+def _neutral_message(node_count: int, elapsed: float, interrupted: list[dict[str, Any]]) -> str:
+    minutes = max(1, int(round(elapsed / 60.0)))
+    base = (
+        f"All nodes idle: {node_count} team nodes have had every turn closed for "
+        f"about {minutes} min. If this idle state is intentional, run "
+        f"team-agent acknowledge-idle to confirm it."
+    )
+    if interrupted:
+        ids = ", ".join(str(i["node_id"]) for i in interrupted)
+        base += f" Interrupted nodes: {ids}."
+    return base
+
+
+def _result(should_ping: bool, message: str | None, reason: str, annotations: list[dict[str, Any]], state: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "should_ping": should_ping,
+        "message": message,
+        "reason": reason,
+        "annotations": list(annotations),
+        "interrupted_nodes": [a.get("node_id") for a in annotations],
+        "interrupted": [a.get("node_id") for a in annotations],
+        "monitor_state": state,
+    }
+
+
+def _emit(event_sink: Any, name: str, **fields: Any) -> None:
+    if event_sink is None:
+        return
+    try:
+        event_sink(name, fields)
+    except TypeError:
+        try:
+            event_sink({"event": name, **fields})
+        except Exception:
+            pass
+    except Exception:
+        pass

package/src/team_agent/idle_takeover.py

@@ -0,0 +1,59 @@
+"""Gap 32 idle/take-over public facade.
+
+Thin surface that the runtime + acceptance contract import. Provider dispatch
+lives in ``provider_state``; the predicate / abnormal / wake logic lives in the
+provider-neutral modules. This module only wires them together.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from team_agent.abnormal_track import detect_whole_team_gone, process_abnormal_records
+from team_agent.idle_predicate import evaluate_takeover_reminder, record_turn_open_after_delivery
+from team_agent.provider_state import read_turn_state
+from team_agent.provider_state.registry import get_provider_registry
+
+
+def classify_provider_turn_state(
+    provider: str,
+    session_log_text: str,
+    *,
+    process: Any = None,
+    file_silence_seconds: float = 0,
+    registry: Any = None,
+    event_sink: Any = None,
+) -> dict[str, Any]:
+    """Classify one node's turn state from its provider session-log text."""
+    result = read_turn_state(
+        provider,
+        session_log_text,
+        process=process,
+        file_silence_seconds=file_silence_seconds,
+        registry=registry,
+    )
+    if event_sink is not None and result.get("state") in {"unknown", "abnormal"}:
+        _emit(event_sink, "idle_takeover.classify", provider=provider, state=result.get("state"), reason=result.get("reason"))
+    return result
+
+
+__all__ = [
+    "classify_provider_turn_state",
+    "evaluate_takeover_reminder",
+    "record_turn_open_after_delivery",
+    "process_abnormal_records",
+    "detect_whole_team_gone",
+    "get_provider_registry",
+]
+
+
+def _emit(event_sink: Any, name: str, **fields: Any) -> None:
+    try:
+        event_sink(name, fields)
+    except TypeError:
+        try:
+            event_sink({"event": name, **fields})
+        except Exception:
+            pass
+    except Exception:
+        pass