@team-agent/installer 0.2.8 → 0.2.9

package/package.json

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

package/src/team_agent/display/adaptive.py

@@ -245,34 +245,51 @@ def adaptive_blocked(
     return displays
 
 
-def close_adaptive_display(state: dict[str, Any], event_log: EventLog) -> None:
+def close_adaptive_display(state: dict[str, Any], event_log: EventLog) -> dict[str, Any]:
     displays = [
         (agent_id, agent_state.get("display") or {})
         for agent_id, agent_state in state.get("agents", {}).items()
         if (agent_state.get("display") or {}).get("backend") == "adaptive"
     ]
     if not displays:
-        return
+        return {"windows": [], "linked_sessions": [], "orphans_detected": {}}
     killed_windows: list[str] = []
     linked_sessions: list[str] = []
+    session_name = str(state.get("session_name") or "")
+    leader_session = _adaptive_leader_session(state, displays)
+    needs_named_fallback = False
     for _agent_id, display in displays:
         linked = display.get("linked_session")
         if linked:
             linked_sessions.append(str(linked))
+        if not linked or not display.get("leader_session") or not (display.get("workspace_window") or display.get("window")):
+            needs_named_fallback = True
     seen_targets: set[str] = set()
     for _agent_id, display in displays:
-        leader_session = str(display.get("leader_session") or "")
+        display_leader_session = str(display.get("leader_session") or "")
         window_name = str(display.get("workspace_window") or display.get("window") or "")
-        if not leader_session or not window_name:
+        if not display_leader_session or not window_name:
             continue
-        target = f"{leader_session}:{window_name}"
+        target = f"{display_leader_session}:{window_name}"
         if target in seen_targets:
             continue
         seen_targets.add(target)
         if kill_adaptive_window(target):
             killed_windows.append(target)
-    linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
-    event_log.write("display.adaptive_closed", windows=killed_windows, linked_sessions=linked_closed)
+    removed_orphans: dict[str, list[str]] = {}
+    if needs_named_fallback and leader_session and session_name:
+        named_windows = close_adaptive_windows(leader_session, session_name, event_log)
+        killed_windows.extend(named_windows)
+        linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
+        named_closed, named_failed = _kill_adaptive_named_display_sessions(session_name, [agent_id for agent_id, _display in displays])
+        linked_closed.extend(named_closed)
+        removed_orphans = _adaptive_orphan_summary(named_closed, named_windows)
+    else:
+        named_failed = []
+        linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
+    orphans = _adaptive_orphans(session_name, leader_session, [agent_id for agent_id, _display in displays], named_failed) if needs_named_fallback else {}
+    event_log.write("display.adaptive_closed", windows=killed_windows, linked_sessions=linked_closed, orphans_detected=orphans, orphans_removed=removed_orphans)
+    return {"windows": killed_windows, "linked_sessions": linked_closed, "orphans_detected": orphans, "orphans_removed": removed_orphans}
 
 
 def close_adaptive_windows(leader_session: str, session_name: str, event_log: EventLog | None = None) -> list[str]:
@@ -293,6 +310,75 @@ def close_adaptive_windows(leader_session: str, session_name: str, event_log: Ev
     return killed
 
 
+def _adaptive_leader_session(state: dict[str, Any], displays: list[tuple[str, dict[str, Any]]]) -> str:
+    for _agent_id, display in displays:
+        if display.get("leader_session"):
+            return str(display["leader_session"])
+    receiver = state.get("leader_receiver") if isinstance(state.get("leader_receiver"), dict) else {}
+    return str(receiver.get("session_name") or "")
+
+
+def _adaptive_named_display_sessions(session_name: str, agent_ids: list[str], fallback_exact: bool = True) -> list[str]:
+    from team_agent.runtime import run_cmd
+    if not session_name or not agent_ids:
+        return []
+    exact = [ghostty_display_session_name(session_name, agent_id) for agent_id in agent_ids]
+    proc = run_cmd(["tmux", "list-sessions", "-F", "#{session_name}"], timeout=10)
+    if proc.returncode != 0:
+        return exact if fallback_exact else []
+    prefixes = [ghostty_display_session_name(session_name, agent_id).rsplit("__", 1)[0] + "__" for agent_id in agent_ids]
+    matched = [name for name in proc.stdout.splitlines() if any(name.startswith(prefix) for prefix in prefixes)]
+    return matched or (exact if fallback_exact else [])
+
+
+def _kill_adaptive_named_display_sessions(session_name: str, agent_ids: list[str]) -> tuple[list[str], list[str]]:
+    from team_agent.runtime import run_cmd
+    killed: list[str] = []
+    failed: list[str] = []
+    for display_session in _adaptive_named_display_sessions(session_name, agent_ids):
+        proc = run_cmd(["tmux", "kill-session", "-t", display_session], timeout=10)
+        if proc.returncode == 0:
+            killed.append(display_session)
+        else:
+            failed.append(display_session)
+    return killed, failed
+
+
+def _adaptive_orphans(session_name: str, leader_session: str, agent_ids: list[str], failed_sessions: list[str]) -> dict[str, list[str]]:
+    display_sessions = sorted(set([*_adaptive_named_display_sessions(session_name, agent_ids, fallback_exact=False), *failed_sessions]))
+    windows: list[str] = []
+    if leader_session and session_name:
+        windows = _adaptive_window_orphans(leader_session, session_name)
+    if not display_sessions and not windows:
+        return {}
+    return {
+        "adaptive_display_sessions": sorted(set(display_sessions)),
+        "adaptive_overview_windows": sorted(set(windows)),
+    }
+
+
+def _adaptive_orphan_summary(display_sessions: list[str], windows: list[str]) -> dict[str, list[str]]:
+    if not display_sessions and not windows:
+        return {}
+    return {
+        "adaptive_display_sessions": sorted(set(display_sessions)),
+        "adaptive_overview_windows": sorted(set(windows)),
+    }
+
+
+def _adaptive_window_orphans(leader_session: str, session_name: str) -> list[str]:
+    from team_agent.runtime import run_cmd
+    prefix = f"team-agent:{session_name}:overview"
+    proc = run_cmd(["tmux", "list-windows", "-t", leader_session, "-F", "#{window_name}"], timeout=10)
+    if proc.returncode != 0:
+        return []
+    return [
+        f"{leader_session}:{window_name}"
+        for window_name in proc.stdout.splitlines()
+        if window_name == prefix or window_name.startswith(f"{prefix}-")
+    ]
+
+
 def kill_adaptive_window(target: str) -> bool:
     from team_agent.runtime import run_cmd
     proc = run_cmd(["tmux", "kill-window", "-t", target], timeout=10)

package/src/team_agent/display/close.py

@@ -8,9 +8,10 @@ from team_agent.display.ghostty import ghostty_pids_by_title
 from team_agent.display.workspace import kill_ghostty_workspace_linked_sessions
 
 
-def close_team_display_backends(state: dict[str, Any], event_log: EventLog) -> None:
-    close_adaptive_display(state, event_log)
+def close_team_display_backends(state: dict[str, Any], event_log: EventLog) -> dict[str, Any]:
+    result = close_adaptive_display(state, event_log)
     close_ghostty_workspace(state, event_log)
+    return result
 
 
 def close_ghostty_display(

package/src/team_agent/runtime.py

@@ -527,7 +527,7 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
             if proc.returncode == 0:
                 log_path.write_text(proc.stdout, encoding="utf-8")
                 captured.append(str(log_path))
-        _close_team_display_backends(state, event_log)
+        display_cleanup = _close_team_display_backends(state, event_log)
         for agent_id, agent_state in state.get("agents", {}).items():
             _close_ghostty_display(agent_id, agent_state, event_log)
             closed_displays.add(agent_id)
@@ -541,7 +541,7 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
             event_log.write("shutdown.kill_session", session=session_name, keep_logs=keep_logs, captured=captured)
     else:
         event_log.write("shutdown.idempotent", session=session_name, reason="session missing")
-        _close_team_display_backends(state, event_log)
+        display_cleanup = _close_team_display_backends(state, event_log)
     for agent_id, agent_state in state.get("agents", {}).items():
         if agent_id not in closed_displays:
             _close_ghostty_display(agent_id, agent_state, event_log)
@@ -573,7 +573,7 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
     archive_path, teams_remaining, new_active = _commit_shutdown_cleanup(
         workspace, str(resolved_team_id or ""), session_name, event_log
     )
-    return {
+    result = {
         "ok": True,
         "session_name": session_name,
         "team": resolved_team_id,
@@ -584,6 +584,24 @@ def shutdown(workspace: Path, keep_logs: bool = True, team: str | None = None) -
         "new_active_team_key": new_active,
         "cleanup_mode": "synchronous_committed",
     }
+    removed_orphans = (display_cleanup or {}).get("orphans_removed") or {}
+    remaining_orphans = (display_cleanup or {}).get("orphans_detected") or {}
+    if removed_orphans:
+        result["orphans_detected"] = removed_orphans
+        result["warnings"] = ["Adaptive display tmux objects were found and removed during shutdown cleanup."]
+    if remaining_orphans:
+        result["cleanup_mode"] = "synchronous_with_orphans"
+        result["orphans_detected"] = remaining_orphans
+        result["warning"] = "Adaptive display tmux objects remain after shutdown cleanup."
+        event_log.write(
+            "shutdown.orphans_detected",
+            warning=result["warning"],
+            message=result["warning"],
+            orphans_detected=remaining_orphans,
+            adaptive_display_sessions=remaining_orphans.get("adaptive_display_sessions", []),
+            adaptive_overview_windows=remaining_orphans.get("adaptive_overview_windows", []),
+        )
+    return result
 
 
 def _commit_shutdown_cleanup(