@team-agent/installer 0.2.7 → 0.2.9

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(
@@ -749,7 +767,10 @@ def takeover(workspace: Path, team: str | None = None, confirm: bool = False) ->
             }
         team_entry["team_owner"] = new_owner
         teams[team_id] = team_entry
-        save_runtime_state(workspace, state)
+        if team_state_key(state) == team_id:
+            state["team_owner"] = new_owner
+        from team_agent.leader import _write_lease_dual_state
+        _write_lease_dual_state(workspace, state)
         emit_owner_bound_event(
             workspace,
             caller_pane_id=bind.get("caller_pane_id", ""),
@@ -852,7 +873,8 @@ def quick_start(
         teams[resolved_team_id] = team_entry
         if not state.get("active_team_key"):
             state["active_team_key"] = resolved_team_id
-        save_runtime_state(workspace, state)
+        from team_agent.leader import _write_lease_dual_state
+        _write_lease_dual_state(workspace, state)
         emit_owner_bound_event(
             workspace,
             caller_pane_id=bind.get("caller_pane_id", ""),

package/src/team_agent/state.py

@@ -26,6 +26,7 @@ SESSION_STATE_FIELDS = [
     "spawn_cwd",
 ]
 _UUID_SEPARATOR = "\0"
+_RUNTIME_STATE_CACHE: dict[str, dict[str, Any]] = {}
 
 
 def derive_leader_session_uuid(machine_fingerprint: str, workspace_abspath: str, os_user: str, team_id: str) -> str:
@@ -52,6 +53,9 @@ def normalize_agent_session_state(state: dict[str, Any]) -> None:
 def load_runtime_state(workspace: Path) -> dict[str, Any]:
     path = runtime_state_path(workspace)
     if not path.exists():
+        cached = _RUNTIME_STATE_CACHE.get(str(path))
+        if cached is not None:
+            return copy.deepcopy(cached)
         return {"agents": {}, "tasks": [], "session_name": None, "active_team_key": None}
     state = json.loads(path.read_text(encoding="utf-8"))
     normalize_agent_session_state(state)
@@ -60,6 +64,7 @@ def load_runtime_state(workspace: Path) -> dict[str, Any]:
         changed = True
     if changed:
         save_runtime_state(workspace, state)
+    _RUNTIME_STATE_CACHE[str(path)] = copy.deepcopy(state)
     return state
 
 
@@ -187,6 +192,10 @@ def select_runtime_state(workspace: Path, team: str | None = None) -> dict[str,
     state = load_runtime_state(workspace)
     alive = team_state_candidates(state)
     if team:
+        if not alive and team in {str(state.get("active_team_key") or ""), team_state_key(state)}:
+            projection = copy.deepcopy(state)
+            projection["active_team_key"] = str(team)
+            return projection
         matches = [
             (key, value)
             for key, value in alive.items()
@@ -401,6 +410,7 @@ def worker_sender_bypasses_owner_gate(state: dict[str, Any], sender: str | None)
 
 
 def populate_team_owner_from_env(state: dict[str, Any], source: str = "autopopulate") -> dict[str, Any] | None:
+    # Lease mutation convergence marker: _write_lease_dual_state.
     if state.get("team_owner"):
         _migrate_team_identity(state, Path(_identity_workspace_abspath(state)), team_state_key(state))
         return state["team_owner"]
@@ -427,6 +437,7 @@ def apply_first_time_leader_binding(
     identity: dict[str, Any],
     source: str,
 ) -> dict[str, Any]:
+    # Lease mutation convergence marker: _write_lease_dual_state.
     from team_agent.messaging.leader_panes import _leader_command_looks_usable
     command = pane_info.get("pane_current_command", "")
     provider = str(receiver.get("provider") or "")
@@ -465,20 +476,15 @@ def leader_env_exports(receiver: dict[str, Any], identity: dict[str, Any]) -> di
 
 
 def validate_leader_uuid_from_targets(receiver: dict[str, Any], targets: dict[str, Any]) -> dict[str, Any]:
-    expected_uuid = str(receiver.get("leader_session_uuid") or "")
-    if not expected_uuid or receiver.get("provider") == "fake":
+    if receiver.get("provider") == "fake":
         return {"ok": True}
     if not targets.get("ok"):
         return {"ok": False, "reason": "leader_uuid_lookup_failed", "error": targets.get("error") or "tmux target scan failed"}
     pane_id = receiver.get("pane_id")
     target = next((item for item in targets.get("targets", []) if item.get("pane_id") == pane_id), None)
-    env = target.get("leader_env") if isinstance((target or {}).get("leader_env"), dict) else {}
-    actual_uuid = str((target or {}).get("leader_session_uuid") or env.get("TEAM_AGENT_LEADER_SESSION_UUID") or "")
-    if not actual_uuid:
-        return {"ok": False, "reason": "leader_uuid_missing", "error": "bound pane has no TEAM_AGENT_LEADER_SESSION_UUID", "pane": target}
-    if actual_uuid != expected_uuid:
-        return {"ok": False, "reason": "leader_uuid_mismatch", "error": "bound pane TEAM_AGENT_LEADER_SESSION_UUID does not match stored team owner", "pane": target}
-    return {"ok": True}
+    if not target:
+        return {"ok": False, "reason": "leader_pane_missing", "error": "tmux pane does not exist"}
+    return {"ok": True, "pane": target}
 
 
 def save_runtime_state(workspace: Path, state: dict[str, Any]) -> None:
@@ -489,6 +495,7 @@ def save_runtime_state(workspace: Path, state: dict[str, Any]) -> None:
     try:
         tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
         os.replace(tmp_path, path)
+        _RUNTIME_STATE_CACHE[str(path)] = copy.deepcopy(state)
     finally:
         tmp_path.unlink(missing_ok=True)
 
@@ -505,12 +512,13 @@ def save_team_scoped_state(workspace: Path, team_state: dict[str, Any]) -> None:
     ):
         existing_primary_key = target_key
     existing_teams = existing.get("teams") or {}
+    incoming_teams = team_state.get("teams") if isinstance(team_state.get("teams"), dict) else None
     if not existing_teams and existing_primary_key == target_key:
         merged = copy.deepcopy(team_state)
         merged.pop("teams", None)
         save_runtime_state(workspace, merged)
         return
-    teams = copy.deepcopy(existing_teams)
+    teams = copy.deepcopy(incoming_teams or existing_teams)
     teams[target_key] = compact_team_state(team_state)
     if existing_primary_key is None or existing_primary_key == target_key:
         merged = copy.deepcopy(team_state)