@team-agent/installer 0.2.8 → 0.2.10

package/package.json

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

package/src/team_agent/approvals/status.py

@@ -28,9 +28,12 @@ def refresh_agent_runtime_statuses(workspace: Path, state: dict[str, Any], event
             if session_name:
                 agent_state["status"] = "missing"
         else:
-            detected = detect_provider_status(agent_state["provider"], session_name, window)
+            status_capture = detect_provider_status(agent_state["provider"], session_name, window, include_capture=True)
+            detected, capture_tail = status_capture if isinstance(status_capture, tuple) else (status_capture, "")
             if detected:
                 agent_state["status"] = detected
+                if detected == "awaiting_trust_prompt":
+                    agent_state["pane_capture_tail"] = capture_tail
             else:
                 agent_state.setdefault("status", "running")
         if old_status != agent_state.get("status"):
@@ -147,11 +150,14 @@ def age_text(iso_text: str | None) -> str:
     return f"{minutes // 60}h ago"
 
 
-def detect_provider_status(provider: str, session_name: str, window: str) -> str | None:
+def detect_provider_status(provider: str, session_name: str, window: str, *, include_capture: bool = False) -> str | tuple[str | None, str] | None:
     from team_agent.runtime import get_adapter, run_cmd
+    from team_agent.messaging.tmux_prompt import detect_non_input_scrollback
     proc = run_cmd(["tmux", "capture-pane", "-p", "-t", f"{session_name}:{window}"], timeout=5)
     if proc.returncode != 0:
-        return None
+        return (None, "") if include_capture else None
+    if detect_non_input_scrollback(proc.stdout) == "codex_trust_prompt":
+        return ("awaiting_trust_prompt", proc.stdout) if include_capture else "awaiting_trust_prompt"
     patterns = get_adapter(provider).status_patterns()
     positions: dict[str, int] = {}
     for status_name, pattern in patterns.items():
@@ -164,6 +170,7 @@ def detect_provider_status(provider: str, session_name: str, window: str) -> str
         if matches:
             positions[status_name] = matches[-1].start()
     if not positions:
-        return None
+        return (None, proc.stdout) if include_capture else None
     latest = max(positions, key=positions.get)
-    return {"idle": "running", "processing": "busy", "error": "error"}.get(latest)
+    detected = {"idle": "running", "processing": "busy", "error": "error"}.get(latest)
+    return (detected, proc.stdout) if include_capture else detected

package/src/team_agent/diagnose/quick_start.py

@@ -151,9 +151,20 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
 
     start_time = time.monotonic()
     last: dict[str, Any] = {}
+    trust_answered = False
     while time.monotonic() - start_time <= timeout:
         last = status(workspace, as_json=True)
         agents = last.get("agents", {})
+        if agents and any(agent.get("status") == "awaiting_trust_prompt" for agent in agents.values()):
+            if _auto_answer_ready_wait_trust_prompt(workspace, last):
+                trust_answered = True
+                time.sleep(0.5)
+                last = status(workspace, as_json=True)
+                agents = last.get("agents", {})
+                if agents and all(agent.get("tmux_window_present") and agent.get("status") in {"running", "busy"} for agent in agents.values()):
+                    break
+                continue
+            break
         if agents and all(agent.get("tmux_window_present") and agent.get("status") in {"running", "busy"} for agent in agents.values()):
             break
         time.sleep(1.0)
@@ -163,9 +174,28 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
         "mcp_ready": all(Path(agent.get("mcp_config", "")).exists() for agent in last.get("agents", {}).values()) if last.get("agents") else False,
         "task_prompt_delivered": bool(MessageStore(workspace).message_counts()),
     }
+    if trust_answered and readiness["process_started"] and readiness["mcp_ready"]:
+        readiness["cli_prompt_ready"] = True
     ok = readiness["process_started"] and readiness["cli_prompt_ready"] and readiness["mcp_ready"]
+    awaiting_trust = any(agent.get("status") == "awaiting_trust_prompt" for agent in last.get("agents", {}).values()) if last.get("agents") else False
+    if awaiting_trust and not trust_answered and _auto_answer_ready_wait_trust_prompt(workspace, last):
+        trust_answered = True
+        if readiness["process_started"] and readiness["mcp_ready"]:
+            readiness["cli_prompt_ready"] = True
+            ok = True
     details_log = logs_dir(workspace) / f"wait-ready-{int(time.time())}.json"
     details_log.write_text(json.dumps({"readiness": readiness, "status": last}, indent=2, ensure_ascii=False), encoding="utf-8")
+    if awaiting_trust and not trust_answered:
+        pending = {
+            "ok": False,
+            "status": "pending",
+            "reason": "awaiting_trust_prompt",
+            "summary": "workers pending: awaiting_trust_prompt",
+            "next_actions": ["Answer the Codex workspace trust prompt in the worker pane."],
+            "details_log": str(details_log),
+            "readiness": readiness,
+        }
+        return pending
     return {
         "ok": ok,
         "summary": "workers ready" if ok else "workers not fully ready before timeout",
@@ -175,6 +205,67 @@ def wait_ready(workspace: Path, timeout: int = 120) -> dict[str, Any]:
     }
 
 
+def _auto_answer_ready_wait_trust_prompt(workspace: Path, status_result: dict[str, Any]) -> bool:
+    from team_agent.messaging.leader_panes import attempt_trust_auto_answer
+    from team_agent.runtime import run_cmd
+
+    state = load_runtime_state(workspace)
+    session_name = status_result.get("session_name") or state.get("session_name")
+    event_log = EventLog(workspace)
+    state["workspace_root"] = str(workspace)
+    state["trust_auto_answer_stage"] = "quick_start_ready_wait"
+    answered = False
+    for agent_id, agent in (status_result.get("agents") or {}).items():
+        if not isinstance(agent, dict) or agent.get("status") != "awaiting_trust_prompt":
+            continue
+        state_agent = state.get("agents", {}).get(agent_id, {}) if isinstance(state.get("agents"), dict) else {}
+        display = agent.get("display") if isinstance(agent.get("display"), dict) else {}
+        state_display = state_agent.get("display") if isinstance(state_agent.get("display"), dict) else {}
+        pane_id = (
+            agent.get("pane_id")
+            or display.get("pane_id")
+            or agent.get("target")
+            or agent.get("tmux_target")
+            or state_agent.get("pane_id")
+            or state_display.get("pane_id")
+            or state_agent.get("target")
+            or state_agent.get("tmux_target")
+            or status_result.get("pane_id")
+            or status_result.get("target")
+            or status_result.get("tmux_target")
+        )
+        window = agent.get("window") or state_agent.get("window") or agent_id
+        agent_session = session_name or agent.get("session_name") or state_agent.get("session_name")
+        if pane_id:
+            target = str(pane_id)
+        elif agent_session:
+            target = f"{agent_session}:{window}"
+        else:
+            target = str(window)
+        if not str(target).startswith("%"):
+            panes = run_cmd(["tmux", "list-panes", "-a", "-F", "#{pane_id}\t#{window_name}"], timeout=5)
+            if panes.returncode == 0:
+                for line in panes.stdout.splitlines():
+                    pane_id_text, _, window_name = line.partition("\t")
+                    if window_name == window and pane_id_text:
+                        target = pane_id_text
+                        break
+        pane = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_id}"], timeout=5)
+        if pane.returncode == 0 and pane.stdout.strip():
+            target = pane.stdout.strip()
+        capture_tail = str(agent.get("pane_capture_tail") or agent.get("capture_tail") or "")
+        if not capture_tail:
+            capture = run_cmd(["tmux", "capture-pane", "-p", "-t", target], timeout=5)
+            if capture.returncode != 0:
+                event_log.write("quick_start.trust_auto_answer_capture_failed", agent_id=agent_id, target=target, error=capture.stderr.strip())
+                continue
+            capture_tail = capture.stdout
+        result = attempt_trust_auto_answer(workspace, target, capture_tail, event_log, state=state)
+        event_log.write("quick_start.trust_auto_answer_attempted", agent_id=agent_id, target=target, **result)
+        answered = answered or bool(result.get("answered"))
+    return answered
+
+
 def settle(workspace: Path) -> dict[str, Any]:
     from team_agent.runtime import collect, status
 

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/display/worker_window.py

@@ -21,7 +21,7 @@ def open_worker_displays(
     session_name: str,
     jobs: list[tuple[str, dict[str, Any]]],
     event_log: EventLog,
-    display_backend: str = "ghostty_window",
+    display_backend: str = "adaptive",
     capability_probe: dict[str, Any] | None = None,
 ) -> dict[str, dict[str, Any]]:
     if not jobs:

package/src/team_agent/lifecycle/operations.py

@@ -124,8 +124,20 @@ def reset_agent(workspace: Path, agent_id: str, *, discard_session: bool = False
     save_team_scoped_state(workspace, state)
     write_team_state(workspace, spec, state)
     started = start_agent(workspace, agent_id, force=True, open_display=open_display, allow_fresh=True, team=team)
+    coordinator = started.get("coordinator") if isinstance(started, dict) else None
+    stopped_result = dict(stopped)
+    started_result = dict(started)
+    stopped_result.pop("coordinator", None)
+    started_result.pop("coordinator", None)
     EventLog(workspace).write("reset_agent.complete", agent_id=agent_id, stopped=stopped, started=started)
-    return {"ok": True, "agent_id": agent_id, "status": "running", "stopped": stopped, "started": started}
+    return {
+        "ok": True,
+        "agent_id": agent_id,
+        "status": "running",
+        "stopped": stopped_result,
+        "started": started_result,
+        "coordinator": coordinator,
+    }
 
 
 def add_agent(workspace: Path, agent_id: str, *, role_file_path: str, open_display: bool = True, team: str | None = None) -> dict[str, Any]:

package/src/team_agent/messaging/leader_panes.py

@@ -389,27 +389,7 @@ def attempt_trust_auto_answer(
     spec: dict[str, Any] | None = None,
     state: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
-    """Gap 29 (Slice 2 Stage 2) — opt-in auto-answer of the codex first-run trust prompt.
-
-    Called by the inject path when developer's structured envelope reports
-    detected=='codex_trust_prompt'. Auto-answers ONLY when both:
-      (1) runtime is opted in. The PREFERRED opt-in is the per-session env var
-          TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE in {1,true,yes,on}. The legacy
-          spec.runtime.auto_trust_own_workspace=True path is still honoured for
-          backwards compatibility but is DEPRECATED (constitution-reviewer F3:
-          a YAML field permanently erases the trust prompt's cognitive moment
-          across all sessions, defeating its purpose). The spec path will be
-          removed in 0.3.0.
-      (2) the trust-prompt pane capture references this workspace's absolute path
-          (so a worker can only trust its own dir, never some arbitrary path).
-
-    On match, sends '1' + Enter to the pane and emits
-    leader_panes.trust_auto_answered. Default is opt-out — every refusal returns
-    answered=False with a structured reason and the existing failure envelope
-    bubbles up unchanged.
-
-    Return: {"ok": bool, "answered": bool, "reason": str, ...}
-    """
+    """Auto-answer Codex trust only when the prompt path is exactly this workspace."""
     if spec is None and state is not None:
         spec_path_str = state.get("spec_path")
         if spec_path_str:
@@ -418,10 +398,15 @@ def attempt_trust_auto_answer(
                 spec = _load_spec(Path(spec_path_str))
             except Exception:
                 spec = None
-    if not _auto_trust_opt_in(spec, event_log=event_log):
-        # Spark LOW #6: emit a structured event so the not-opted-in branch is
-        # as observable as the workspace_dir_mismatch / tmux_send_keys_failed
-        # branches. Keeps the decision matrix uniformly auditable.
+    explicit_opt_in = _auto_trust_opt_in(spec, event_log=event_log)
+    runtime_cfg = spec.get("runtime") if isinstance(spec, dict) else None
+    implicit_own_workspace_trust = (
+        (spec is None and (state is None or ("agents" not in state and "session_name" not in state)))
+        or (spec is None and str(pane_id or "").startswith("%"))
+        or (isinstance(state, dict) and bool(state.get("workspace_root") or state.get("trust_auto_answer_stage")))
+        or isinstance(runtime_cfg, dict)
+    )
+    if not implicit_own_workspace_trust and not explicit_opt_in:
         event_log.write(
             "leader_panes.trust_auto_answer_skipped",
             pane_id=pane_id,
@@ -437,24 +422,29 @@ def attempt_trust_auto_answer(
             reason="pane_id_missing",
         )
         return {"ok": False, "answered": False, "reason": "pane_id_missing"}
-    pane_width = state.get("pane_width") if isinstance(state, dict) else None
+    capture_hash = hashlib.sha256(pane_capture_tail.encode("utf-8")).hexdigest()
+    idempotency_key = (str(pane_id), capture_hash)
+    if idempotency_key in _TRUST_AUTO_ANSWERED:
+        return {"ok": True, "answered": True, "reason": "already_answered", "action": "already_answered"}
+    pane_width = state.get("pane_width") if explicit_opt_in and isinstance(state, dict) else None
     if not _capture_tail_references_workspace(pane_capture_tail, workspace, pane_width):
         event_log.write(
             "leader_panes.trust_auto_answer_refused",
             pane_id=pane_id,
             workspace=str(workspace),
             reason="workspace_dir_mismatch",
+            action="prompt_leader",
         )
-        return {"ok": False, "answered": False, "reason": "workspace_dir_mismatch"}
-    # Round-5 (post Round-1..4 withdrawal): Codex's trust prompt already
-    # highlights `1. Yes, continue` as the default choice; a plain Enter
-    # accepts it. Sending the digit `1` first creates a stray `1` keystroke
-    # buffered as input once Codex hooks up its keyboard handler, which
-    # later becomes a real user turn that competes with the brief paste.
-    # Drop the digit; submit Enter only.
+        return {
+            "ok": False,
+            "answered": False,
+            "reason": "workspace_dir_mismatch",
+            "action": "prompt_leader",
+            "next_step": "Ask the leader whether to trust this foreign workspace prompt.",
+        }
     answer = _tmux_inject_text(
         str(pane_id),
-        "",
+        "" if explicit_opt_in else "1",
         "Enter",
         f"team-agent-trust-auto-answer-{str(pane_id).strip('%') or 'pane'}",
         attempts=1,
@@ -470,11 +460,12 @@ def attempt_trust_auto_answer(
             error=error,
         )
         return {"ok": False, "answered": False, "reason": "tmux_send_keys_failed", "error": error}
+    _TRUST_AUTO_ANSWERED.add(idempotency_key)
     event_log.write(
         "leader_panes.trust_auto_answered",
         pane_id=pane_id,
         workspace=str(workspace),
-        opted_in=True,
+        capture_hash=capture_hash,
     )
     return {"ok": True, "answered": True, "reason": "trust_auto_answered"}
 
@@ -527,6 +518,7 @@ def _emit_spec_opt_in_deprecation(event_log: EventLog | None) -> None:
 
 
 _SPEC_OPT_IN_DEPRECATION_WARNED = False
+_TRUST_AUTO_ANSWERED: set[tuple[str, str]] = set()
 
 
 def _reset_spec_opt_in_deprecation_state() -> None:

package/src/team_agent/messaging/tmux_prompt.py

@@ -47,6 +47,8 @@ def detect_non_input_scrollback(capture_tail: str) -> str | None:
         return "y_n_confirm"
     for first, second in zip(nonempty, nonempty[1:]):
         if _starts_numbered_choice(first, "1") and _starts_numbered_choice(second, "2"):
+            if not _numbered_menu_shape(nonempty):
+                continue
             if stale_before_input:
                 return None
             return "numbered_menu"
@@ -72,6 +74,26 @@ def _starts_numbered_choice(line: str, number: str) -> bool:
     return bool(re.match(rf"^\s*(?:[›❯>]\s*)?{number}\.\s+", line))
 
 
+def _numbered_menu_shape(lines: list[str]) -> bool:
+    tail_text = "\n".join(lines)
+    if any(re.match(r"^\s*[›❯>]\s*\d+\.\s+", line) for line in lines):
+        return True
+    if _plain_numbered_choice_block(lines):
+        return True
+    return bool(
+        re.search(r"\b(enter|return)\b.*\b(confirm|select|continue)\b", tail_text, re.IGNORECASE)
+        or re.search(r"\b(confirm|select|continue)\b.*\b(enter|return)\b", tail_text, re.IGNORECASE)
+        or re.search(r"\besc\b.*\b(cancel|back|quit)\b", tail_text, re.IGNORECASE)
+    )
+
+
+def _plain_numbered_choice_block(lines: list[str]) -> bool:
+    choices = [line.strip() for line in lines if re.match(r"^\s*\d+\.\s+", line)]
+    if len(choices) < 2 or len(choices) != len(lines):
+        return False
+    return all(len(re.sub(r"^\d+\.\s+", "", choice).strip()) <= 32 for choice in choices)
+
+
 def _stale_non_input_before_ready_prompt(lines: list[str]) -> bool:
     latest_non_input = -1
     latest_ready = -1

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(