@team-agent/installer 0.2.2 → 0.2.4

package/src/team_agent/message_store/core.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import json
 import sqlite3
+import time
 import uuid
 from contextlib import closing
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from . import agent_health as _agent_health
 from . import result_watchers as _result_watchers
@@ -15,6 +16,28 @@ from team_agent.paths import runtime_dir
 from team_agent.spec import validate_result_envelope
 
 
+def _is_sqlite_locked(exc: sqlite3.OperationalError) -> bool:
+    message = str(exc).lower()
+    return (
+        "database is locked" in message
+        or "database table is locked" in message
+        or "database schema is locked" in message
+    )
+
+
+def _with_sqlite_busy_retry(action: Callable[[], None]) -> None:
+    delay = 0.05
+    for attempt in range(6):
+        try:
+            action()
+            return
+        except sqlite3.OperationalError as exc:
+            if not _is_sqlite_locked(exc) or attempt == 5:
+                raise
+            time.sleep(delay)
+            delay *= 2
+
+
 class MessageStore:
     SCHEMA_VERSION = SCHEMA_VERSION
 
@@ -27,13 +50,16 @@ class MessageStore:
     def connect(self) -> sqlite3.Connection:
         conn = sqlite3.connect(self.path, timeout=30.0, isolation_level=None)
         conn.row_factory = sqlite3.Row
-        conn.execute("PRAGMA journal_mode=WAL")
         conn.execute("PRAGMA busy_timeout=30000")
+        conn.execute("PRAGMA journal_mode=WAL")
         return conn
 
     def _init(self) -> None:
-        with closing(self.connect()) as conn:
-            initialize_schema(conn)
+        def initialize() -> None:
+            with closing(self.connect()) as conn:
+                initialize_schema(conn)
+
+        _with_sqlite_busy_retry(initialize)
 
     def create_message(
         self,
@@ -331,17 +357,17 @@ class MessageStore:
         return counts
 
     def add_result(self, envelope: dict[str, Any], owner_team_id: str | None = None) -> str:
-        _ = owner_team_id
         validate_result_envelope(envelope)
         result_id = f"res_{uuid.uuid4().hex[:12]}"
         with closing(self.connect()) as conn:
             with conn:
                 conn.execute(
                     """
-                    insert into results(result_id, task_id, agent_id, envelope, status, created_at)
-                    values (?, ?, ?, ?, ?, ?)
+                    insert into results(owner_team_id, result_id, task_id, agent_id, envelope, status, created_at)
+                    values (?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
+                        owner_team_id,
                         result_id,
                         envelope["task_id"],
                         envelope["agent_id"],
@@ -423,16 +449,17 @@ class MessageStore:
         return dict(row) if row else None
 
     def latest_results(self, limit: int = 5, owner_team_id: str | None = None) -> list[dict[str, Any]]:
-        _ = owner_team_id
+        owner_clause = "and owner_team_id = ?" if owner_team_id else ""
+        args: tuple[Any, ...] = (owner_team_id, limit) if owner_team_id else (limit,)
         with closing(self.connect()) as conn:
             rows = conn.execute(
-                """
+                f"""
                 select * from results
-                where status != 'invalid'
+                where status != 'invalid' {owner_clause}
                 order by created_at desc
                 limit ?
                 """,
-                (limit,),
+                args,
             ).fetchall()
         return [dict(row) for row in reversed(rows)]
 

package/src/team_agent/message_store/leader_notification_log.py

@@ -11,9 +11,20 @@ from __future__ import annotations
 
 from contextlib import closing
 from datetime import datetime, timedelta, timezone
+import sqlite3
+import time
 from typing import Any
 
 
+def _sqlite_locked(exc: sqlite3.OperationalError) -> bool:
+    message = str(exc).lower()
+    return (
+        "database is locked" in message
+        or "database table is locked" in message
+        or "database schema is locked" in message
+    )
+
+
 def claim_leader_notification_delivery(
     store: Any,
     *,
@@ -28,32 +39,42 @@ def claim_leader_notification_delivery(
     rowcount=0 means a prior row exists for (result_id, leader_session_uuid); SELECT
     it and return so the caller can decide to suppress (same envelope_hash) or surface
     legitimate-duplicate (different envelope_hash)."""
-    now = datetime.now(timezone.utc).isoformat()
-    with closing(store.connect()) as conn:
-        with conn:
-            cur = conn.execute(
-                "insert or ignore into leader_notification_log("
-                "  result_id, leader_session_uuid, notified_message_id, notified_at,"
-                "  leader_pane_id_at_notify, envelope_content_hash, owner_team_id"
-                ") values (?, ?, ?, ?, ?, ?, ?)",
-                (
-                    result_id, leader_session_uuid, proposed_message_id, now,
-                    pane_id, envelope_hash, owner_team_id,
-                ),
-            )
-            if cur.rowcount == 1:
-                return {
-                    "status": "claimed_by_you",
-                    "notified_message_id": proposed_message_id,
-                    "notified_at": now,
-                    "envelope_content_hash": envelope_hash,
-                }
-            row = conn.execute(
-                "select notified_message_id, notified_at, envelope_content_hash, "
-                "leader_pane_id_at_notify from leader_notification_log "
-                "where result_id = ? and leader_session_uuid = ?",
-                (result_id, leader_session_uuid),
-            ).fetchone()
+    delay = 0.05
+    row = None
+    for attempt in range(6):
+        now = datetime.now(timezone.utc).isoformat()
+        try:
+            with closing(store.connect()) as conn:
+                with conn:
+                    cur = conn.execute(
+                        "insert or ignore into leader_notification_log("
+                        "  result_id, leader_session_uuid, notified_message_id, notified_at,"
+                        "  leader_pane_id_at_notify, envelope_content_hash, owner_team_id"
+                        ") values (?, ?, ?, ?, ?, ?, ?)",
+                        (
+                            result_id, leader_session_uuid, proposed_message_id, now,
+                            pane_id, envelope_hash, owner_team_id,
+                        ),
+                    )
+                    if cur.rowcount == 1:
+                        return {
+                            "status": "claimed_by_you",
+                            "notified_message_id": proposed_message_id,
+                            "notified_at": now,
+                            "envelope_content_hash": envelope_hash,
+                        }
+                    row = conn.execute(
+                        "select notified_message_id, notified_at, envelope_content_hash, "
+                        "leader_pane_id_at_notify from leader_notification_log "
+                        "where result_id = ? and leader_session_uuid = ?",
+                        (result_id, leader_session_uuid),
+                    ).fetchone()
+            break
+        except sqlite3.OperationalError as exc:
+            if not _sqlite_locked(exc) or attempt == 5:
+                raise
+            time.sleep(delay)
+            delay *= 2
     if row is None:
         # Should not happen (INSERT OR IGNORE returned 0 → row must exist), but be defensive.
         return {"status": "claimed_by_you", "notified_message_id": proposed_message_id,

package/src/team_agent/message_store/schema.py

@@ -22,7 +22,7 @@ MESSAGE_COLUMNS = {
     "error",
     "delivery_attempts",
 }
-RESULT_COLUMNS = {"result_id", "task_id", "agent_id", "envelope", "status", "created_at"}
+RESULT_COLUMNS = {"owner_team_id", "result_id", "task_id", "agent_id", "envelope", "status", "created_at"}
 SCHEDULED_EVENT_COLUMNS = {
     "id",
     "owner_team_id",
@@ -125,6 +125,7 @@ def initialize_schema(conn: sqlite3.Connection) -> None:
             """
             create table if not exists results (
               result_id text primary key,
+              owner_team_id text,
               task_id text not null,
               agent_id text not null,
               envelope text not null,
@@ -215,7 +216,12 @@ def initialize_schema(conn: sqlite3.Connection) -> None:
                 "owner_team_id": "alter table messages add column owner_team_id text",
             },
         )
-        _ensure_table_columns(conn, "results", RESULT_COLUMNS)
+        _ensure_table_columns(
+            conn,
+            "results",
+            RESULT_COLUMNS,
+            {"owner_team_id": "alter table results add column owner_team_id text"},
+        )
         _ensure_table_columns(
             conn,
             "scheduled_events",

package/src/team_agent/messaging/delivery.py

@@ -10,15 +10,62 @@ from team_agent.messaging.deps import (
     core_render_message,
 )
 
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
+
+def _tmux_pane_width(target: str) -> dict[str, Any]:
+    """Query the tmux pane width (display columns) for ``target``.
+
+    Live wiring seam for the trust-prompt truncation matcher: returns
+    ``{"ok": True, "pane_width": <int>}`` on success or
+    ``{"ok": False, "error": "..."}`` on any failure / timeout / unparseable
+    output. Fail-safe by design: NEVER returns a default width. Callers must
+    treat failure as "no boundary signal" and let the workspace matcher fall
+    back to exact equality, so a hard-truncated prompt is never auto-answered
+    on guesswork.
+    """
+    from team_agent.messaging.deps import run_cmd
+    try:
+        proc = run_cmd(
+            ["tmux", "display-message", "-p", "-t", str(target), "-F", "#{pane_width}"],
+            timeout=2,
+        )
+    except Exception as exc:  # pragma: no cover - defensive; tmux not present, timeout, etc.
+        return {"ok": False, "error": f"tmux_query_failed:{exc.__class__.__name__}"}
+    if getattr(proc, "returncode", 1) != 0:
+        err = (getattr(proc, "stderr", "") or "").strip().splitlines()
+        return {"ok": False, "error": err[0] if err else "tmux_query_nonzero"}
+    text = (getattr(proc, "stdout", "") or "").strip()
+    if not text:
+        return {"ok": False, "error": "empty_output"}
+    try:
+        width = int(text.splitlines()[0].strip())
+    except (ValueError, IndexError):
+        return {"ok": False, "error": "unparseable_output"}
+    if width <= 0:
+        return {"ok": False, "error": "non_positive_width"}
+    return {"ok": True, "pane_width": width}
+
+
+# Spark MEDIUM sweep #3 (2026-05-26): retry_needed bounded backoff. Each entry is
+# the delay (seconds) BEFORE the attempt with that number runs; attempt 1 was the
+# original delivery, attempt 2 fires 5s after retry_needed, attempt 3 fires 15s
+# after the previous, attempt 4 fires 30s after the previous. _TRUST_RETRY_MAX_ATTEMPTS
+# bounds the total — the 4th retry_needed is terminal and emits
+# leader_panes.trust_auto_answer_exhausted.
+_TRUST_RETRY_BACKOFF_SECONDS = {2: 5, 3: 15, 4: 30}
+_TRUST_RETRY_MAX_ATTEMPTS = 4
+
 def _deliver_pending_message(
     workspace: Path,
     state: dict[str, Any],
     message_id: str,
     wait_visible: bool = True,
     timeout: float = 30.0,
+    *,
+    _trust_retry_attempt: int = 1,
 ) -> dict[str, Any]:
     store = MessageStore(workspace)
     row = next((m for m in store.messages() if m["message_id"] == message_id), None)
@@ -65,9 +112,58 @@ def _deliver_pending_message(
         attempts=3 if wait_visible else 1,
         provider=agent_state.get("provider", "fake"),
     )
+    if not injection.get("ok") and injection.get("detected") == "codex_trust_prompt":
+        # Gap 29 (Stage 2): opt-in trust auto-answer. The helper enforces both the
+        # opt-in flag and a workspace-dir match before sending '1'+Enter, then we
+        # retry the original paste once the prompt has actually been dismissed.
+        # Bypassed entirely when opt-out (default) — the existing failed envelope
+        # is preserved.
+        from team_agent.messaging.leader_panes import attempt_trust_auto_answer
+        pane_target = injection.get("pane_id") or target
+        # Live wiring: query the tmux pane width now and hand it to the trust
+        # matcher via state["pane_width"]. On failure we leave pane_width
+        # absent so the matcher falls back to exact equality (fail-safe — a
+        # right-edge truncated prefix is never auto-answered on guesswork).
+        width_query = _tmux_pane_width(pane_target)
+        trust_state = dict(state) if isinstance(state, dict) else {}
+        if width_query.get("ok"):
+            trust_state["pane_width"] = width_query["pane_width"]
+        answer = attempt_trust_auto_answer(
+            workspace,
+            pane_target,
+            injection.get("pane_capture_tail") or "",
+            EventLog(workspace),
+            state=trust_state,
+        )
+        if answer.get("answered"):
+            # Spark MEDIUM #4 (2026-05-26): replace the fixed 0.3s sleep with a
+            # bounded poll. Slow terminals can take well over a second to clear
+            # the trust prompt; sleeping a fixed amount races dismissal and
+            # leaves the retry hitting the same codex_trust_prompt state. We
+            # poll for prompt dismissal up to 3s; if still present, return a
+            # retry_needed envelope and let the upstream scheduler decide
+            # whether to back off and try again later.
+            dismissed = _wait_for_trust_prompt_dismissal(
+                injection.get("pane_id") or target, timeout=3.0,
+            )
+            if not dismissed:
+                return _handle_trust_retry_needed(
+                    workspace, state, store, message_id, target, injection,
+                    attempt=_trust_retry_attempt,
+                )
+            injection = _tmux_inject_text(
+                target,
+                text,
+                "Enter",
+                f"team-agent-send-{message_id}-trust-retry",
+                attempts=3 if wait_visible else 1,
+                provider=agent_state.get("provider", "fake"),
+            )
     if injection["ok"]:
         store.mark(message_id, "submitted")
-        EventLog(workspace).write(
+        send_event_log = EventLog(workspace)
+        _stamp_first_send_at_if_leader_to_worker(state, row, send_event_log)
+        send_event_log.write(
             "send.submitted",
             message_id=message_id,
             target=target,
@@ -112,9 +208,248 @@ def _deliver_pending_message(
         "turn_verification": injection.get("turn_verification"),
         "paste_attempts": injection.get("attempts"),
         "submit_attempts": injection.get("submit_attempts"),
+        "detected": injection.get("detected"),
+        "pane_id": injection.get("pane_id"),
+        "pane_mode": injection.get("pane_mode"),
+        "pane_capture_tail": injection.get("pane_capture_tail"),
     }
 
 
+def _handle_trust_retry_needed(
+    workspace: Path,
+    state: dict[str, Any],
+    store: MessageStore,
+    message_id: str,
+    target: str,
+    injection: dict[str, Any],
+    *,
+    attempt: int,
+) -> dict[str, Any]:
+    """Spark MEDIUM sweep #3: replace the dead-end failed mark with a real
+    bounded-backoff consumer. attempt is the number of the delivery that JUST
+    failed (1 = the original delivery; 2..4 = the scheduler-fired retries).
+
+    Behaviour:
+      * attempt < _TRUST_RETRY_MAX_ATTEMPTS: schedule a trust_retry
+        scheduled_event for the message, holding the message in 'failed' status
+        so _deliver_pending_messages does not race the scheduler. Emit
+        leader_panes.trust_auto_answer_retry_scheduled. Return status='retry_scheduled'.
+      * attempt >= _TRUST_RETRY_MAX_ATTEMPTS: terminal. Mark the message failed
+        and emit leader_panes.trust_auto_answer_exhausted. Return
+        status='trust_auto_answer_exhausted'.
+    """
+    event_log = EventLog(workspace)
+    next_attempt = attempt + 1
+    if next_attempt > _TRUST_RETRY_MAX_ATTEMPTS:
+        store.mark(message_id, "failed", "trust_auto_answer_exhausted")
+        event_log.write(
+            "leader_panes.trust_auto_answer_exhausted",
+            message_id=message_id,
+            workspace=str(workspace),
+            attempts=attempt,
+            target=target,
+            pane_id=injection.get("pane_id"),
+            reason="trust_auto_answer_exhausted",
+        )
+        return {
+            "ok": False,
+            "status": "trust_auto_answer_exhausted",
+            "reason": "trust_auto_answer_exhausted",
+            "attempts": attempt,
+            "detected": injection.get("detected"),
+            "pane_id": injection.get("pane_id"),
+            "pane_mode": injection.get("pane_mode"),
+            "pane_capture_tail": injection.get("pane_capture_tail"),
+        }
+    backoff = _TRUST_RETRY_BACKOFF_SECONDS.get(next_attempt, _TRUST_RETRY_BACKOFF_SECONDS[_TRUST_RETRY_MAX_ATTEMPTS])
+    due_at = (datetime.now(timezone.utc) + timedelta(seconds=backoff)).isoformat()
+    owner_team_id = _message_owner_team_id(store, message_id)
+    event_id = store.add_scheduled_event(
+        due_at,
+        message_id,
+        "trust_retry",
+        {
+            "message_id": message_id,
+            "attempt": next_attempt,
+            "max_attempts": _TRUST_RETRY_MAX_ATTEMPTS,
+            "first_target": target,
+        },
+        owner_team_id=owner_team_id,
+    )
+    # Hold the message in 'failed' so _deliver_pending_messages does not race
+    # the scheduled retry. The scheduler consumer resets it to 'accepted' just
+    # before re-delivery.
+    store.mark(message_id, "failed", "trust_retry_scheduled")
+    event_log.write(
+        "leader_panes.trust_auto_answer_retry_needed",
+        message_id=message_id,
+        workspace=str(workspace),
+        pane_id=injection.get("pane_id") or target,
+        target=target,
+        reason="trust_prompt_not_dismissed_after_answer",
+        attempt=attempt,
+    )
+    event_log.write(
+        "leader_panes.trust_auto_answer_retry_scheduled",
+        message_id=message_id,
+        workspace=str(workspace),
+        scheduled_event_id=event_id,
+        due_at=due_at,
+        next_attempt=next_attempt,
+        max_attempts=_TRUST_RETRY_MAX_ATTEMPTS,
+        backoff_seconds=backoff,
+    )
+    return {
+        "ok": False,
+        "status": "retry_scheduled",
+        "reason": "trust_prompt_not_dismissed_after_answer",
+        "stage": "trust_auto_answer_dismissal_wait",
+        "verification": "trust_prompt_not_dismissed_after_answer",
+        "scheduled_event_id": event_id,
+        "scheduled_retry_at": due_at,
+        "next_attempt": next_attempt,
+        "max_attempts": _TRUST_RETRY_MAX_ATTEMPTS,
+        "detected": injection.get("detected"),
+        "pane_id": injection.get("pane_id"),
+        "pane_mode": injection.get("pane_mode"),
+        "pane_capture_tail": injection.get("pane_capture_tail"),
+    }
+
+
+def _message_owner_team_id(store: MessageStore, message_id: str) -> str | None:
+    row = _message_by_id(store, message_id)
+    if not row:
+        return None
+    owner = row.get("owner_team_id")
+    return str(owner) if owner else None
+
+
+def _execute_trust_retry(
+    workspace: Path,
+    store: MessageStore,
+    event_log: EventLog,
+    payload: dict[str, Any],
+    *,
+    owner_team_id: str | None = None,
+) -> dict[str, Any]:
+    """Scheduler-side consumer for kind='trust_retry'. Resets the message back
+    to 'accepted' so claim_for_delivery succeeds, re-runs _deliver_pending_message,
+    and either succeeds, escalates to a further retry (via _handle_trust_retry_needed),
+    or hits the terminal exhausted branch.
+    """
+    from team_agent.state import load_runtime_state
+    message_id = str(payload.get("message_id") or "")
+    if not message_id:
+        return {"ok": False, "reason": "trust_retry_missing_message_id"}
+    attempt = int(payload.get("attempt") or 1)
+    row = _message_by_id(store, message_id)
+    if not row:
+        event_log.write(
+            "leader_panes.trust_auto_answer_retry_skipped",
+            message_id=message_id,
+            reason="message_missing",
+            attempt=attempt,
+        )
+        return {"ok": False, "reason": "message_missing"}
+    # Reset to accepted so claim_for_delivery succeeds. The previous attempt
+    # left the row in 'failed' status with reason='trust_retry_scheduled'.
+    store.mark(message_id, "accepted", "trust_retry_resuming")
+    event_log.write(
+        "leader_panes.trust_auto_answer_retry_attempted",
+        message_id=message_id,
+        workspace=str(workspace),
+        attempt=attempt,
+        max_attempts=int(payload.get("max_attempts") or _TRUST_RETRY_MAX_ATTEMPTS),
+    )
+    state = load_runtime_state(workspace)
+    if owner_team_id and isinstance(state.get("teams"), dict):
+        scoped = state["teams"].get(owner_team_id)
+        if isinstance(scoped, dict):
+            state = scoped
+    delivery_result = _deliver_pending_message(
+        workspace, state, message_id,
+        wait_visible=True, timeout=30.0,
+        _trust_retry_attempt=attempt,
+    )
+    return delivery_result
+
+
+def _stamp_first_send_at_if_leader_to_worker(
+    state: dict[str, Any],
+    row: dict[str, Any],
+    event_log: EventLog | None = None,
+) -> None:
+    """Route B atomicity (2026-05-27): record the first time the leader
+    successfully sends work to each worker. The presence of this stamp drives
+    restart's resumability decision — a worker the leader has interacted with
+    has accumulated conversation state, so a missing session_id at restart
+    time IS an atomicity violation. A worker that has never received work
+    legitimately fresh-starts during restart.
+
+    Only stamped once per worker (idempotent across re-sends). Only fires on
+    leader -> worker sends; worker-to-worker peer messages do not count.
+    The mutation lives on the state dict the caller already saves
+    (`save_team_scoped_state` in send.py, or `save_runtime_state` after
+    coordinator_tick), so persistence is automatic.
+
+    C1 (cr verdict, 2026-05-27): when the stamp transitions null -> ts (the
+    one-time write), emit a `worker.first_interaction` audit event with
+    worker_id, first_send_at, message_id. Re-sends to the same worker hit the
+    idempotency guard above and do NOT re-emit. Worker-to-worker peer sends
+    short-circuit at the sender check and do NOT emit.
+    """
+    sender = str(row.get("sender") or "")
+    recipient = str(row.get("recipient") or "")
+    if not recipient:
+        return
+    leader_id = str((state.get("leader") or {}).get("id") or "leader")
+    if sender not in {"leader", "Leader", leader_id}:
+        return
+    agents = state.get("agents")
+    if not isinstance(agents, dict):
+        return
+    agent_state = agents.get(recipient)
+    if not isinstance(agent_state, dict):
+        return
+    if agent_state.get("first_send_at"):
+        return
+    stamp = datetime.now(timezone.utc).isoformat()
+    agent_state["first_send_at"] = stamp
+    if event_log is not None:
+        event_log.write(
+            "worker.first_interaction",
+            worker_id=recipient,
+            first_send_at=stamp,
+            message_id=str(row.get("message_id") or ""),
+        )
+
+
+def _wait_for_trust_prompt_dismissal(target: str, *, timeout: float = 3.0, poll_interval: float = 0.1) -> bool:
+    """Spark MEDIUM #4: bounded poll for trust prompt dismissal. Returns True once
+    the pane no longer matches detect_non_input_scrollback, False if the prompt
+    is still present after `timeout` seconds. Uses the same detector the inject
+    path uses so behaviour stays consistent."""
+    import time as _time
+    from team_agent.messaging.tmux_prompt import detect_non_input_scrollback
+    deadline = _time.monotonic() + max(timeout, 0.0)
+    while True:
+        capture = _capture_pane_tail(target)
+        detected = detect_non_input_scrollback(capture)
+        if detected != "codex_trust_prompt":
+            return True
+        if _time.monotonic() >= deadline:
+            return False
+        _time.sleep(poll_interval)
+
+
+def _capture_pane_tail(target: str) -> str:
+    from team_agent.messaging.deps import _capture_tmux_pane_text
+    capture = _capture_tmux_pane_text(target)
+    if not capture.get("ok"):
+        return ""
+    return str(capture.get("capture") or "")
+
+
 def _deliver_pending_messages(workspace: Path, state: dict[str, Any], event_log: EventLog) -> list[str]:
     store = MessageStore(workspace)
     delivered: list[str] = []

package/src/team_agent/messaging/leader.py

@@ -251,6 +251,19 @@ def _send_to_leader_receiver(
         f"team-agent-leader-receiver-{message_id}",
         provider=receiver.get("provider", "codex"),
     )
+    if not injection.get("ok") and injection.get("detected") == "codex_trust_prompt":
+        from team_agent.messaging.trust_auto_answer import retry_injection_after_trust_auto_answer
+        injection = retry_injection_after_trust_auto_answer(
+            workspace,
+            state,
+            event_log,
+            injection,
+            target,
+            text,
+            submit_key,
+            f"team-agent-leader-receiver-{message_id}-trust-retry",
+            receiver.get("provider", "codex"),
+        )
     if injection["ok"]:
         store.mark(message_id, "submitted")
         event_log.write(
@@ -466,10 +479,6 @@ def _format_team_agent_message(payload: dict[str, Any]) -> str:
 
 
 
-
-
-
-