aline-ai 0.7.3__py3-none-any.whl → 0.7.5__py3-none-any.whl

realign/dashboard/widgets/agents_panel.py

@@ -7,13 +7,14 @@ import json as _json
 import re
 import shlex
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
 from textual import events
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical
-from textual.widgets import Button, Static
+from textual.widgets import Button, Rule, Static
 from textual.message import Message
 from textual.worker import Worker, WorkerState
 from rich.text import Text
@@ -25,6 +26,54 @@ from ..clipboard import copy_text
 logger = setup_logger("realign.dashboard.widgets.agents_panel", "dashboard.log")
 
 
+@dataclass(frozen=True)
+class _ProcessSnapshot:
+    created_at_monotonic: float
+    tty_key: str
+    children: dict[int, list[int]]
+    comms: dict[int, str]
+
+
+class TruncButton(Button):
+    """Button that truncates its label with '...' based on actual widget width."""
+
+    def __init__(self, full_text: str, **kwargs) -> None:
+        super().__init__(full_text, **kwargs)
+        self._full_text = full_text
+
+    def render(self) -> Text:
+        width = self.size.width
+        gutter = self.styles.gutter
+        avail = width - gutter.width
+        text = self._full_text
+        if avail > 3 and len(text) > avail:
+            return Text(text[: avail - 3] + "...")
+        return Text(text)
+
+class SpinnerPrefixButton(Button):
+    """Button label with an animated spinner prefix, truncated to widget width."""
+
+    _FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
+
+    def __init__(self, *, prefix: str, label: str, **kwargs) -> None:
+        self._prefix = prefix
+        self._label = label
+        super().__init__(f"{prefix}{label}", **kwargs)
+
+    def render(self) -> Text:
+        width = self.size.width
+        gutter = self.styles.gutter
+        avail = width - gutter.width
+
+        idx = int(time.monotonic() * 8) % len(self._FRAMES)
+        spinner = self._FRAMES[idx]
+        text = f"{self._prefix}{spinner} {self._label}"
+
+        if avail > 3 and len(text) > avail:
+            return Text(text[: avail - 3] + "...")
+        return Text(text)
+
+
 class AgentNameButton(Button):
     """Button that emits a message on double-click."""
 
@@ -40,9 +89,178 @@ class AgentNameButton(Button):
             self.post_message(self.DoubleClicked(self, self.name or ""))
 
 
+class _TerminalRowWidget(Horizontal):
+    def __init__(
+        self,
+        *,
+        terminal_id: str,
+        term_safe_id: str,
+        prefix: str,
+        title: str,
+        running_agent: str | None,
+        pane_current_command: str | None,
+        is_active: bool,
+    ) -> None:
+        super().__init__(classes="terminal-row")
+
+        switch_classes = "terminal-switch active-terminal" if is_active else "terminal-switch"
+
+        pane_cmd = (pane_current_command or "").strip().lower()
+        title_is_relevant = bool(title) and (
+            bool(running_agent) or pane_cmd in {"claude", "codex", "opencode"}
+        )
+
+        if title_is_relevant:
+            label = f"{prefix}{title}"
+            switch_btn: Button = TruncButton(
+                label,
+                id=f"switch-{term_safe_id}",
+                name=terminal_id,
+                classes=switch_classes,
+            )
+            switch_btn.tooltip = title
+        elif running_agent:
+            provider = (running_agent or "").strip().lower()
+            provider_label = (running_agent or "").strip().capitalize()
+            if provider in {"codex", "claude"}:
+                switch_btn = SpinnerPrefixButton(
+                    prefix=prefix,
+                    label=provider_label,
+                    id=f"switch-{term_safe_id}",
+                    name=terminal_id,
+                    classes=f"{switch_classes} spinner",
+                )
+            else:
+                switch_btn = TruncButton(
+                    f"{prefix}{provider_label}",
+                    id=f"switch-{term_safe_id}",
+                    name=terminal_id,
+                    classes=switch_classes,
+                )
+        else:
+            display = (pane_current_command or "").strip() or "Terminal"
+            switch_btn = TruncButton(
+                f"{prefix}{display}",
+                id=f"switch-{term_safe_id}",
+                name=terminal_id,
+                classes=switch_classes,
+            )
+
+        self._switch_btn = switch_btn
+        self._close_btn = Button(
+            "✕",
+            id=f"close-{term_safe_id}",
+            name=terminal_id,
+            variant="error",
+            classes="terminal-close",
+        )
+
+    def compose(self) -> ComposeResult:
+        yield self._switch_btn
+        yield self._close_btn
+
+
+class _TerminalConnectorWidget(Horizontal):
+    def __init__(self) -> None:
+        super().__init__(classes="terminal-row")
+
+    def compose(self) -> ComposeResult:
+        yield Button("│", classes="terminal-switch")
+
+
+class _AgentBlockWidget(Container):
+    def __init__(self, *, agent: dict, active_terminal_id: str | None) -> None:
+        super().__init__(classes="agent-block")
+        self._agent = agent
+        self._active_terminal_id = active_terminal_id
+
+    def compose(self) -> ComposeResult:
+        agent = self._agent
+        safe_id = AgentsPanel._safe_id(agent["id"])
+
+        rule = Rule(line_style="solid")
+        rule.styles.color = "black"
+        yield rule
+
+        with Horizontal(classes="agent-row"):
+            name_label = Text(f"▸ {agent['name']}", style="bold")
+            agent_btn = AgentNameButton(
+                name_label,
+                id=f"agent-{safe_id}",
+                name=agent["id"],
+                classes="agent-name",
+            )
+            if agent.get("description"):
+                agent_btn.tooltip = agent["description"]
+            yield agent_btn
+
+            if agent.get("share_url"):
+                yield Button(
+                    "Sync",
+                    id=f"sync-{safe_id}",
+                    name=agent["id"],
+                    classes="agent-share",
+                )
+                yield Button(
+                    "Link",
+                    id=f"link-{safe_id}",
+                    name=agent["id"],
+                    classes="agent-share",
+                )
+            else:
+                yield Button(
+                    "Share",
+                    id=f"share-{safe_id}",
+                    name=agent["id"],
+                    classes="agent-share",
+                )
+
+            yield Button(
+                "+",
+                id=f"create-term-{safe_id}",
+                name=agent["id"],
+                classes="agent-create",
+            )
+            yield Button(
+                "✕",
+                id=f"delete-{safe_id}",
+                name=agent["id"],
+                variant="error",
+                classes="agent-delete",
+            )
+
+        terminals = agent.get("terminals") or []
+        if not terminals:
+            return
+
+        with Vertical(classes="terminal-list"):
+            for term_idx, term in enumerate(terminals):
+                is_last_term = term_idx == len(terminals) - 1
+                prefix = "└ " if is_last_term else "├ "
+
+                terminal_id = term["terminal_id"]
+                term_safe_id = AgentsPanel._safe_id(terminal_id)
+                is_active = terminal_id == self._active_terminal_id
+
+                yield _TerminalRowWidget(
+                    terminal_id=terminal_id,
+                    term_safe_id=term_safe_id,
+                    prefix=prefix,
+                    title=term.get("title", "") or "",
+                    running_agent=term.get("running_agent"),
+                    pane_current_command=term.get("pane_current_command"),
+                    is_active=is_active,
+                )
+                if not is_last_term:
+                    yield _TerminalConnectorWidget()
+
+
 class AgentsPanel(Container, can_focus=True):
     """Panel displaying agent profiles with their associated terminals."""
 
+    REFRESH_INTERVAL_SECONDS = 2.0
+    SPINNER_INTERVAL_SECONDS = 0.15
+
     DEFAULT_CSS = """
     AgentsPanel {
         height: 100%;
@@ -56,10 +274,11 @@ class AgentsPanel(Container, can_focus=True):
 
     AgentsPanel .summary {
         height: auto;
-        margin: 0 0 1 0;
+        margin: 0;
         padding: 0;
         background: transparent;
         border: none;
+        align: right middle;
     }
 
     AgentsPanel Button {
@@ -86,15 +305,22 @@ class AgentsPanel(Container, can_focus=True):
         background: transparent;
     }
 
+    AgentsPanel Rule {
+        margin: 0;
+    }
+
     AgentsPanel .agent-row {
+        height: 2;
+        margin: 0;
+    }
+
+    AgentsPanel .agent-block {
         height: auto;
-        min-height: 2;
-        margin: 0 0 0 0;
     }
 
     AgentsPanel .agent-row Button.agent-name {
         width: 1fr;
-        height: 2;
+        height: 1;
         margin: 0;
         padding: 0 1;
         text-align: left;
@@ -102,28 +328,28 @@ class AgentsPanel(Container, can_focus=True):
     }
 
     AgentsPanel .agent-row Button.agent-create {
-        width: auto;
-        min-width: 8;
-        height: 2;
-        margin-left: 1;
-        padding: 0 1;
+        width: 3;
+        min-width: 3;
+        height: 1;
+        margin-left: 0;
+        padding: 0;
         content-align: center middle;
     }
 
     AgentsPanel .agent-row Button.agent-delete {
         width: 3;
         min-width: 3;
-        height: 2;
-        margin-left: 1;
+        height: 1;
+        margin-left: 0;
         padding: 0;
         content-align: center middle;
     }
 
     AgentsPanel .agent-row Button.agent-share {
         width: auto;
-        min-width: 8;
-        height: 2;
-        margin-left: 1;
+        min-width: 6;
+        height: 1;
+        margin-left: 0;
         padding: 0 1;
         content-align: center middle;
     }
@@ -137,25 +363,34 @@ class AgentsPanel(Container, can_focus=True):
     }
 
     AgentsPanel .terminal-row {
-        height: auto;
-        min-height: 2;
+        height: 1;
         margin: 0;
     }
 
     AgentsPanel .terminal-row Button.terminal-switch {
         width: 1fr;
-        height: 2;
+        height: 1;
         margin: 0;
         padding: 0 1;
         text-align: left;
-        content-align: left top;
+        content-align: left middle;
+        text-opacity: 60%;
+    }
+
+    AgentsPanel .terminal-row Button.terminal-switch:hover {
+        text-opacity: 100%;
+    }
+
+    AgentsPanel .terminal-row Button.active-terminal {
+        text-opacity: 100%;
+        text-style: bold;
     }
 
     AgentsPanel .terminal-row Button.terminal-close {
         width: 3;
         min-width: 3;
-        height: 2;
-        margin-left: 1;
+        height: 1;
+        margin: 0;
         padding: 0;
         content-align: center middle;
     }
@@ -165,30 +400,58 @@ class AgentsPanel(Container, can_focus=True):
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._agents: list[dict] = []
+        self._active_terminal_id: str | None = None
         self._rendered_fingerprint: str = ""
+        self._switch_worker: Optional[Worker] = None
+        self._switch_seq: int = 0
         self._refresh_worker: Optional[Worker] = None
+        self._render_worker: Optional[Worker] = None
+        self._pending_render: bool = False
+        self._pending_render_reason: str | None = None
         self._share_worker: Optional[Worker] = None
         self._sync_worker: Optional[Worker] = None
         self._share_agent_id: Optional[str] = None
         self._sync_agent_id: Optional[str] = None
         self._refresh_timer = None
+        self._spinner_timer = None
         self._last_refresh_error_at: float | None = None
+        self._last_render_started_at: float | None = None
+        self._last_render_completed_at: float | None = None
+        self._process_snapshot: _ProcessSnapshot | None = None
 
     def compose(self) -> ComposeResult:
         with Horizontal(classes="summary"):
-            yield Button("+ Create Agent", id="create-agent", variant="primary")
+            yield Button("Add Agent", id="create-agent", variant="primary")
         with Vertical(id="agents-list", classes="list"):
-            yield Static("No agents yet. Click 'Create Agent' to add one.")
+            yield Static("No agents yet. Click 'Add Agent' to add one.")
+
+    def on_mount(self) -> None:
+        btn = self.query_one("#create-agent", Button)
+        btn.styles.border = ("round", "black")
+        btn.styles.text_align = "center"
+        btn.styles.content_align = ("center", "middle")
 
     def on_show(self) -> None:
         if self._refresh_timer is None:
             # Refresh frequently, but avoid hammering SQLite/tmux (can cause transient empty UI).
-            self._refresh_timer = self.set_interval(2.0, self._on_refresh_timer)
+            self._refresh_timer = self.set_interval(
+                self.REFRESH_INTERVAL_SECONDS, self._on_refresh_timer
+            )
         else:
             try:
                 self._refresh_timer.resume()
             except Exception:
                 pass
+
+        if self._spinner_timer is None:
+            self._spinner_timer = self.set_interval(
+                self.SPINNER_INTERVAL_SECONDS, self._on_spinner_timer
+            )
+        else:
+            try:
+                self._spinner_timer.resume()
+            except Exception:
+                pass
         self.refresh_data()
 
     def on_hide(self) -> None:
@@ -197,10 +460,24 @@ class AgentsPanel(Container, can_focus=True):
                 self._refresh_timer.pause()
             except Exception:
                 pass
+        if self._spinner_timer is not None:
+            try:
+                self._spinner_timer.pause()
+            except Exception:
+                pass
 
     def _on_refresh_timer(self) -> None:
         self.refresh_data()
 
+    def _on_spinner_timer(self) -> None:
+        if not self.display:
+            return
+        try:
+            for btn in self.query("Button.spinner"):
+                btn.refresh()
+        except Exception:
+            pass
+
     def refresh_data(self) -> None:
         if not self.display:
             return
@@ -213,7 +490,177 @@ class AgentsPanel(Container, can_focus=True):
             self._collect_agents, thread=True, exit_on_error=False
         )
 
-    def _collect_agents(self) -> list[dict]:
+    def diagnostics_state(self) -> dict[str, object]:
+        """Small, safe snapshot for watchdog logging (never raises)."""
+        state: dict[str, object] = {}
+        try:
+            state["agents_count"] = int(len(self._agents))
+            state["rendered_fingerprint_len"] = int(len(self._rendered_fingerprint))
+            state["refresh_worker_state"] = str(
+                getattr(getattr(self, "_refresh_worker", None), "state", None)
+            )
+            state["render_worker_state"] = str(
+                getattr(getattr(self, "_render_worker", None), "state", None)
+            )
+            state["pending_render"] = bool(self._pending_render)
+            state["last_refresh_error_at"] = self._last_refresh_error_at
+            state["last_render_started_at"] = self._last_render_started_at
+            state["last_render_completed_at"] = self._last_render_completed_at
+        except Exception:
+            pass
+        try:
+            container = self.query_one("#agents-list", Vertical)
+            state["agents_list_children"] = int(len(getattr(container, "children", []) or []))
+        except Exception:
+            pass
+        return state
+
+    def _ui_blank(self) -> bool:
+        try:
+            container = self.query_one("#agents-list", Vertical)
+            return len(container.children) == 0
+        except Exception:
+            return False
+
+    def _schedule_render(self, *, reason: str) -> None:
+        if not self.display:
+            return
+
+        if self._render_worker is not None and self._render_worker.state in (
+            WorkerState.PENDING,
+            WorkerState.RUNNING,
+        ):
+            self._pending_render = True
+            self._pending_render_reason = reason
+            return
+
+        self._pending_render = False
+        self._pending_render_reason = None
+        self._last_render_started_at = time.monotonic()
+        self._render_worker = self.run_worker(
+            self._render_agents(), group="agents-render", exit_on_error=False
+        )
+
+    def force_render(self, *, reason: str) -> None:
+        """Force a re-render even if the collected data didn't change."""
+        # Reset fingerprint so the next refresh doesn't treat the UI as "up to date".
+        self._rendered_fingerprint = ""
+        if self._agents:
+            self._schedule_render(reason=reason)
+
+    @staticmethod
+    def _detect_running_agent(
+        pane_pid: int | None, snapshot: _ProcessSnapshot | None
+    ) -> str | None:
+        """Detect whether a known agent process exists under a tmux pane PID.
+
+        Uses a cached process snapshot built once per refresh to avoid spawning `ps`
+        repeatedly for every terminal row.
+        """
+        if not pane_pid or snapshot is None:
+            return None
+
+        children = snapshot.children
+        comms = snapshot.comms
+        stack = [pane_pid]
+        seen: set[int] = set()
+        while stack:
+            p = stack.pop()
+            if p in seen:
+                continue
+            seen.add(p)
+            comm = (comms.get(p) or "").lower()
+            for kw in ("claude", "codex", "opencode"):
+                if kw in comm:
+                    return kw
+            stack.extend(children.get(p, []))
+        return None
+
+    @staticmethod
+    def _normalize_tty(tty: str) -> str:
+        s = (tty or "").strip()
+        if not s:
+            return ""
+        if s.startswith("/dev/"):
+            s = s[len("/dev/") :]
+        return s.strip()
+
+    def _get_process_snapshot(self, *, pane_ttys: set[str]) -> _ProcessSnapshot | None:
+        """Return a cached process snapshot scoped to the given TTY set.
+
+        TTL is aligned with the panel refresh interval so the snapshot is at most one refresh stale.
+        """
+        ttys = sorted(
+            {self._normalize_tty(t) for t in (pane_ttys or set()) if self._normalize_tty(t)}
+        )
+        if not ttys:
+            return None
+        tty_key = ",".join(ttys)
+
+        now = time.monotonic()
+        cached = self._process_snapshot
+        if (
+            cached
+            and cached.tty_key == tty_key
+            and (now - cached.created_at_monotonic) < float(self.REFRESH_INTERVAL_SECONDS)
+        ):
+            return cached
+
+        try:
+            import subprocess
+
+            # Prefer TTY-limited `ps` to keep output small. BSD ps supports comma-separated TTY list.
+            result = subprocess.run(
+                ["ps", "-o", "pid=,ppid=,comm=", "-t", tty_key],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            stdout = result.stdout or ""
+            if result.returncode != 0 or not stdout.strip():
+                # Fallback: some environments may not accept `-t` list; fall back to a single
+                # snapshot of all processes and filter by TTY.
+                result = subprocess.run(
+                    ["ps", "-axo", "pid=,ppid=,tty=,comm="],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                stdout = result.stdout or ""
+
+                allowed = set(ttys)
+                filtered_lines: list[str] = []
+                for line in stdout.splitlines():
+                    parts = line.split(None, 3)
+                    if len(parts) < 4:
+                        continue
+                    tty = self._normalize_tty(parts[2])
+                    if tty and tty in allowed:
+                        filtered_lines.append(f"{parts[0]} {parts[1]} {parts[3]}")
+                stdout = "\n".join(filtered_lines)
+
+            children: dict[int, list[int]] = {}
+            comms: dict[int, str] = {}
+            for line in stdout.splitlines():
+                parts = line.split(None, 2)
+                if len(parts) < 3:
+                    continue
+                try:
+                    pid, ppid = int(parts[0]), int(parts[1])
+                except ValueError:
+                    continue
+                children.setdefault(ppid, []).append(pid)
+                comms[pid] = parts[2]
+
+            snap = _ProcessSnapshot(
+                created_at_monotonic=now, tty_key=tty_key, children=children, comms=comms
+            )
+            self._process_snapshot = snap
+            return snap
+        except Exception:
+            return None
+
+    def _collect_agents(self) -> dict:
         """Collect agent info with their terminals."""
         agents: list[dict] = []
 
@@ -241,15 +688,41 @@ class AgentsPanel(Container, can_focus=True):
             l.terminal_id: l for l in latest_links if getattr(l, "terminal_id", None)
         }
 
+        tmux_windows_ok = True
         try:
             tmux_windows = tmux_manager.list_inner_windows()
         except Exception as e:
             logger.debug(f"Failed to list tmux windows: {e}")
+            tmux_windows_ok = False
             tmux_windows = []
         terminal_to_window = {
             w.terminal_id: w for w in tmux_windows if getattr(w, "terminal_id", None)
         }
 
+        # If we are running inside the managed tmux dashboard environment, only show terminals
+        # that still exist in the inner tmux server. This prevents stale buttons when a user
+        # exits a shell directly (tmux window disappears but DB record may still be "active").
+        try:
+            if tmux_manager.managed_env_enabled() and tmux_windows_ok:
+                present = {tid for tid in terminal_to_window.keys() if tid}
+                if present:
+                    active_terminals = [t for t in active_terminals if getattr(t, "id", None) in present]
+                else:
+                    # Inner session exists but no tracked terminals are present.
+                    active_terminals = []
+        except Exception:
+            pass
+
+        pane_ttys: set[str] = set()
+        for w in tmux_windows:
+            if getattr(w, "pane_pid", None) and getattr(w, "pane_tty", None):
+                pane_ttys.add(str(w.pane_tty))
+        ps_snapshot = self._get_process_snapshot(pane_ttys=pane_ttys) if pane_ttys else None
+
+        # Detect currently active terminal
+        active_window = next((w for w in tmux_windows if w.active), None)
+        active_terminal_id = active_window.terminal_id if active_window else None
+
         # Collect all session_ids for title lookup
         session_ids: list[str] = []
         for t in active_terminals:
@@ -260,8 +733,31 @@ class AgentsPanel(Container, can_focus=True):
             window = terminal_to_window.get(t.id)
             if window and getattr(window, "session_id", None):
                 session_ids.append(window.session_id)
+                continue
+            # Fallback: agent record (works even when WindowLink isn't available yet / at all).
+            agent_session_id = getattr(t, "session_id", None)
+            if agent_session_id:
+                session_ids.append(agent_session_id)
 
-        titles = self._fetch_session_titles(session_ids)
+        titles: dict[str, str] = {}
+        session_agent_id: dict[str, str] = {}
+        try:
+            uniq_session_ids = sorted({sid for sid in session_ids if sid})
+            if uniq_session_ids:
+                sessions = db.get_sessions_by_ids(uniq_session_ids)
+                for s in sessions:
+                    sid = getattr(s, "id", None)
+                    if not sid:
+                        continue
+                    title = (getattr(s, "session_title", "") or "").strip()
+                    if title:
+                        titles[sid] = title
+                    agent_id = getattr(s, "agent_id", None)
+                    if agent_id:
+                        session_agent_id[sid] = agent_id
+        except Exception:
+            titles = {}
+            session_agent_id = {}
 
         # Map agent_info.id -> list of terminals
         agent_to_terminals: dict[str, list[dict]] = {}
@@ -284,12 +780,7 @@ class AgentsPanel(Container, can_focus=True):
             if not agent_info_id:
                 window = terminal_to_window.get(t.id)
                 if window and getattr(window, "session_id", None):
-                    try:
-                        session = db.get_session_by_id(window.session_id)
-                    except Exception:
-                        session = None
-                    if session:
-                        agent_info_id = session.agent_id
+                    agent_info_id = session_agent_id.get(window.session_id) or None
 
             if agent_info_id:
                 agent_to_terminals.setdefault(agent_info_id, [])
@@ -302,25 +793,32 @@ class AgentsPanel(Container, can_focus=True):
                     else (
                         window.session_id
                         if window and getattr(window, "session_id", None)
-                        else None
+                        else getattr(t, "session_id", None)
                     )
                 )
                 title = titles.get(session_id, "") if session_id else ""
 
-                agent_to_terminals[agent_info_id].append(
-                    {
-                        "terminal_id": t.id,
-                        "session_id": session_id,
-                        "provider": (
-                            link.provider
-                            if link and getattr(link, "provider", None)
-                            else (t.provider or "")
-                        ),
-                        "session_type": t.session_type or "",
-                        "title": title,
-                        "cwd": t.cwd or "",
-                    }
+                pane_cmd = window.pane_current_command if window else None
+                provider = (
+                    link.provider
+                    if link and getattr(link, "provider", None)
+                    else (t.provider or "")
                 )
+                pane_pid = window.pane_pid if window else None
+                running_agent = self._detect_running_agent(pane_pid, ps_snapshot)
+
+                entry = {
+                    "terminal_id": t.id,
+                    "window_id": window.window_id if window else None,
+                    "session_id": session_id,
+                    "provider": provider,
+                    "session_type": t.session_type or "",
+                    "title": title,
+                    "cwd": t.cwd or "",
+                    "running_agent": running_agent,
+                    "pane_current_command": pane_cmd,
+                }
+                agent_to_terminals[agent_info_id].append(entry)
 
         for info in agent_infos:
             terminals = agent_to_terminals.get(info.id, [])
@@ -335,7 +833,7 @@ class AgentsPanel(Container, can_focus=True):
                 }
             )
 
-        return agents
+        return {"agents": agents, "active_terminal_id": active_terminal_id}
 
     @staticmethod
     def _fingerprint(agents: list[dict]) -> str:
@@ -346,6 +844,42 @@ class AgentsPanel(Container, can_focus=True):
             return ""
 
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        # Handle switch worker
+        if self._switch_worker is not None and event.worker is self._switch_worker:
+            if event.state == WorkerState.SUCCESS:
+                result = self._switch_worker.result or {}
+                if isinstance(result, dict):
+                    seq = int(result.get("seq", 0) or 0)
+                    if seq != self._switch_seq:
+                        return
+                    terminal_id = str(result.get("terminal_id", "") or "").strip() or None
+                    ok = bool(result.get("ok", False))
+                    if ok and terminal_id:
+                        self._active_terminal_id = terminal_id
+                        self._update_active_terminal_ui(terminal_id)
+                        # Prevent the next refresh from forcing a full re-render just due to
+                        # active-terminal changes.
+                        self._rendered_fingerprint = (
+                            self._fingerprint(self._agents) + f"|active:{self._active_terminal_id}"
+                        )
+                    else:
+                        msg = str(result.get("error", "") or "Failed to switch").strip()
+                        self.app.notify(msg, title="Agent", severity="error")
+                        self.refresh_data()
+            elif event.state == WorkerState.ERROR:
+                err = self._switch_worker.error
+                msg = "Failed to switch"
+                if isinstance(err, BaseException):
+                    msg = f"Failed to switch: {err}"
+                elif err:
+                    msg = f"Failed to switch: {err}"
+                self.app.notify(msg, title="Agent", severity="error")
+                self.refresh_data()
+
+            if event.state in {WorkerState.SUCCESS, WorkerState.ERROR, WorkerState.CANCELLED}:
+                self._switch_worker = None
+            return
+
         # Handle refresh worker
         if self._refresh_worker is not None and event.worker is self._refresh_worker:
             if event.state == WorkerState.ERROR:
@@ -362,20 +896,70 @@ class AgentsPanel(Container, can_focus=True):
                     logger.warning(f"Agents refresh failed: {err}")
                 return
             elif event.state == WorkerState.SUCCESS:
-                self._agents = self._refresh_worker.result or []
+                prev_agents = self._agents
+                prev_active = self._active_terminal_id
+                payload = self._refresh_worker.result or {}
+                if isinstance(payload, dict) and "agents" in payload:
+                    self._agents = payload.get("agents") or []
+                    self._active_terminal_id = payload.get("active_terminal_id") or None
+                else:
+                    self._agents = payload or []
                 self._last_refresh_error_at = None
             else:
                 return
-            fp = self._fingerprint(self._agents)
-            if fp == self._rendered_fingerprint:
+
+            # Fast path: only the active terminal changed; update button classes in-place
+            # to avoid full re-render flicker / input lag.
+            try:
+                prev_agents_fp = self._fingerprint(prev_agents)
+                new_agents_fp = self._fingerprint(self._agents)
+                if (
+                    prev_agents_fp == new_agents_fp
+                    and prev_active != self._active_terminal_id
+                    and not self._ui_blank()
+                ):
+                    self._update_active_terminal_ui(self._active_terminal_id)
+                    self._rendered_fingerprint = new_agents_fp + f"|active:{self._active_terminal_id}"
+                    return
+            except Exception:
+                new_agents_fp = self._fingerprint(self._agents)
+
+            fp = new_agents_fp + f"|active:{self._active_terminal_id}"
+            # Important: the UI can become blank due to cancellation or transient Textual issues.
+            # If data didn't change but the widget tree is empty, force a re-render.
+            should_render = (fp != self._rendered_fingerprint) or (
+                self._agents and self._ui_blank()
+            )
+            if not should_render:
                 return  # nothing changed – skip re-render to avoid flicker
             self._rendered_fingerprint = fp
-            self.run_worker(
-                self._render_agents(),
-                group="agents-render",
-                exclusive=True,
-                exit_on_error=False,
-            )
+            self._schedule_render(reason="refresh")
+            return
+
+        # Handle render worker
+        if self._render_worker is not None and event.worker is self._render_worker:
+            if event.state == WorkerState.ERROR:
+                err = self._render_worker.error
+                if isinstance(err, BaseException):
+                    logger.warning(
+                        "Agents render failed",
+                        exc_info=(type(err), err, err.__traceback__),
+                    )
+                else:
+                    logger.warning(f"Agents render failed: {err}")
+                # Force next refresh to re-render even if data is unchanged.
+                self._rendered_fingerprint = ""
+            elif event.state == WorkerState.SUCCESS:
+                self._last_render_completed_at = time.monotonic()
+            elif event.state == WorkerState.CANCELLED:
+                self._rendered_fingerprint = ""
+
+            if event.state in {WorkerState.SUCCESS, WorkerState.ERROR, WorkerState.CANCELLED}:
+                self._last_render_completed_at = time.monotonic()
+                self._render_worker = None
+                if self._pending_render:
+                    reason = self._pending_render_reason or "pending"
+                    self._schedule_render(reason=reason)
             return
 
         # Handle share worker
@@ -390,112 +974,20 @@ class AgentsPanel(Container, can_focus=True):
         async with self._refresh_lock:
             try:
                 container = self.query_one("#agents-list", Vertical)
-                await container.remove_children()
-
-                if not self._agents:
-                    await container.mount(Static("No agents yet. Click 'Create Agent' to add one."))
-                    return
-
-                for agent in self._agents:
-                    safe_id = self._safe_id(agent["id"])
-
-                    # Agent row with name, create button, and delete button
-                    row = Horizontal(classes="agent-row")
-                    await container.mount(row)
-
-                    # Agent name button
-                    name_label = Text(agent["name"], style="bold")
-                    terminal_count = len(agent["terminals"])
-                    if terminal_count > 0:
-                        name_label.append(f" ({terminal_count})", style="dim")
-
-                    agent_btn = AgentNameButton(
-                        name_label,
-                        id=f"agent-{safe_id}",
-                        name=agent["id"],
-                        classes="agent-name",
-                    )
-                    if agent.get("description"):
-                        agent_btn.tooltip = agent["description"]
-                    await row.mount(agent_btn)
-
-                    # Share or Sync button (Sync if agent already has a share_url)
-                    if agent.get("share_url"):
-                        await row.mount(
-                            Button(
-                                "Sync",
-                                id=f"sync-{safe_id}",
-                                name=agent["id"],
-                                classes="agent-share",
-                            )
-                        )
-                        await row.mount(
-                            Button(
-                                "Link",
-                                id=f"link-{safe_id}",
-                                name=agent["id"],
-                                classes="agent-share",
-                            )
-                        )
-                    else:
-                        await row.mount(
-                            Button(
-                                "Share",
-                                id=f"share-{safe_id}",
-                                name=agent["id"],
-                                classes="agent-share",
-                            )
-                        )
-
-                    # Create terminal button
-                    await row.mount(
-                        Button(
-                            "+ Term",
-                            id=f"create-term-{safe_id}",
-                            name=agent["id"],
-                            classes="agent-create",
-                        )
-                    )
+                with self.app.batch_update():
+                    await container.remove_children()
 
-                    # Delete agent button
-                    await row.mount(
-                        Button(
-                            "✕",
-                            id=f"delete-{safe_id}",
-                            name=agent["id"],
-                            variant="error",
-                            classes="agent-delete",
+                    if not self._agents:
+                        await container.mount(
+                            Static("No agents yet. Click 'Add Agent' to add one.")
                         )
-                    )
+                        return
 
-                    # Terminal list (indented under agent)
-                    if agent["terminals"]:
-                        term_list = Vertical(classes="terminal-list")
-                        await container.mount(term_list)
-
-                        for term in agent["terminals"]:
-                            term_safe_id = self._safe_id(term["terminal_id"])
-                            term_row = Horizontal(classes="terminal-row")
-                            await term_list.mount(term_row)
-
-                            label = self._make_terminal_label(term)
-                            await term_row.mount(
-                                Button(
-                                    label,
-                                    id=f"switch-{term_safe_id}",
-                                    name=term["terminal_id"],
-                                    classes="terminal-switch",
-                                )
-                            )
-                            await term_row.mount(
-                                Button(
-                                    "✕",
-                                    id=f"close-{term_safe_id}",
-                                    name=term["terminal_id"],
-                                    variant="error",
-                                    classes="terminal-close",
-                                )
-                            )
+                    blocks = [
+                        _AgentBlockWidget(agent=agent, active_terminal_id=self._active_terminal_id)
+                        for agent in self._agents
+                    ]
+                    await container.mount_all(blocks)
             except Exception:
                 logger.exception("Failed to render agents list")
                 try:
@@ -507,35 +999,11 @@ class AgentsPanel(Container, can_focus=True):
                 except Exception:
                     pass
                 return
-
-    def _make_terminal_label(self, term: dict) -> Text:
-        """Generate label for a terminal."""
-        provider = term.get("provider", "")
-        session_id = term.get("session_id", "")
-        title = term.get("title", "")
-
-        label = Text(no_wrap=True, overflow="ellipsis")
-
-        # First line: title or provider
-        if title:
-            label.append(title)
-        elif provider:
-            label.append(provider.capitalize())
-        else:
-            label.append("Terminal")
-
-        label.append("\n")
-
-        # Second line: [provider] session_id
-        if provider:
-            detail = f"[{provider.capitalize()}]"
-        else:
-            detail = ""
-        if session_id:
-            detail = f"{detail} #{self._short_id(session_id)}"
-
-        label.append(detail, style="dim")
-        return label
+            except asyncio.CancelledError:
+                # Best-effort: avoid leaving the UI in a permanently blank state.
+                logger.warning("Agents render cancelled")
+                self._rendered_fingerprint = ""
+                return
 
     @staticmethod
     def _short_id(val: str | None) -> str:
@@ -583,6 +1051,21 @@ class AgentsPanel(Container, can_focus=True):
             pass
         return None
 
+    def _update_active_terminal_ui(self, terminal_id: str | None) -> None:
+        """Update just the active-terminal button classes (no full re-render)."""
+        try:
+            for btn in self.query("Button.terminal-switch"):
+                btn_id = btn.id or ""
+                if not btn_id.startswith("switch-"):
+                    continue
+                is_active = bool(terminal_id and (btn.name == terminal_id))
+                if is_active:
+                    btn.add_class("active-terminal")
+                else:
+                    btn.remove_class("active-terminal")
+        except Exception:
+            return
+
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         btn_id = event.button.id or ""
 
@@ -621,7 +1104,7 @@ class AgentsPanel(Container, can_focus=True):
 
         if btn_id.startswith("switch-"):
             terminal_id = event.button.name or ""
-            await self._switch_to_terminal(terminal_id)
+            self._request_switch_to_terminal(terminal_id)
             return
 
         if btn_id.startswith("close-"):
@@ -734,6 +1217,16 @@ class AgentsPanel(Container, can_focus=True):
         """Create a Claude terminal associated with an agent."""
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("cc")
+        logger.info(
+            "Create terminal requested: provider=claude terminal_id=%s agent_id=%s workspace=%s "
+            "no_track=%s skip_permissions=%s context_id=%s",
+            terminal_id,
+            agent_id,
+            workspace,
+            no_track,
+            skip_permissions,
+            context_id,
+        )
 
         # Prepare CODEX_HOME so user can run codex in this terminal
         try:
@@ -777,6 +1270,13 @@ class AgentsPanel(Container, can_focus=True):
         )
 
         if created:
+            logger.info(
+                "Create terminal success: provider=claude terminal_id=%s window_id=%s",
+                terminal_id,
+                created.window_id,
+            )
+            if not tmux_manager.focus_right_pane():
+                logger.warning("Create terminal: focus_right_pane failed (provider=claude)")
             # Store agent association in database with agent_info_id in source
             try:
                 from ...db import get_database
@@ -794,6 +1294,7 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
+            logger.warning("Create terminal failed: provider=claude terminal_id=%s", terminal_id)
             self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     async def _create_codex_terminal(self, workspace: str, no_track: bool, agent_id: str) -> None:
@@ -821,6 +1322,15 @@ class AgentsPanel(Container, can_focus=True):
 
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("cx")
+        logger.info(
+            "Create terminal requested: provider=codex terminal_id=%s agent_id=%s workspace=%s "
+            "no_track=%s context_id=%s",
+            terminal_id,
+            agent_id,
+            workspace,
+            no_track,
+            context_id,
+        )
 
         try:
             from ...codex_home import prepare_codex_home
@@ -870,13 +1380,30 @@ class AgentsPanel(Container, can_focus=True):
             no_track=no_track,
         )
 
-        if not created:
+        if created:
+            logger.info(
+                "Create terminal success: provider=codex terminal_id=%s window_id=%s",
+                terminal_id,
+                created.window_id,
+            )
+            if not tmux_manager.focus_right_pane():
+                logger.warning("Create terminal: focus_right_pane failed (provider=codex)")
+        else:
+            logger.warning("Create terminal failed: provider=codex terminal_id=%s", terminal_id)
             self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     async def _create_opencode_terminal(self, workspace: str, agent_id: str) -> None:
         """Create an Opencode terminal associated with an agent."""
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("oc")
+        logger.info(
+            "Create terminal requested: provider=opencode terminal_id=%s agent_id=%s workspace=%s "
+            "context_id=%s",
+            terminal_id,
+            agent_id,
+            workspace,
+            context_id,
+        )
 
         # Prepare CODEX_HOME so user can run codex in this terminal
         try:
@@ -913,6 +1440,13 @@ class AgentsPanel(Container, can_focus=True):
         )
 
         if created:
+            logger.info(
+                "Create terminal success: provider=opencode terminal_id=%s window_id=%s",
+                terminal_id,
+                created.window_id,
+            )
+            if not tmux_manager.focus_right_pane():
+                logger.warning("Create terminal: focus_right_pane failed (provider=opencode)")
             # Store agent association in database
             try:
                 from ...db import get_database
@@ -930,12 +1464,20 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
+            logger.warning("Create terminal failed: provider=opencode terminal_id=%s", terminal_id)
             self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     async def _create_zsh_terminal(self, workspace: str, agent_id: str) -> None:
         """Create a zsh terminal associated with an agent."""
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("zsh")
+        logger.info(
+            "Create terminal requested: provider=zsh terminal_id=%s agent_id=%s workspace=%s context_id=%s",
+            terminal_id,
+            agent_id,
+            workspace,
+            context_id,
+        )
 
         # Prepare CODEX_HOME so user can run codex in this terminal
         try:
@@ -970,6 +1512,13 @@ class AgentsPanel(Container, can_focus=True):
         )
 
         if created:
+            logger.info(
+                "Create terminal success: provider=zsh terminal_id=%s window_id=%s",
+                terminal_id,
+                created.window_id,
+            )
+            if not tmux_manager.focus_right_pane():
+                logger.warning("Create terminal: focus_right_pane failed (provider=zsh)")
             # Store agent association in database
             try:
                 from ...db import get_database
@@ -987,6 +1536,7 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
+            logger.warning("Create terminal failed: provider=zsh terminal_id=%s", terminal_id)
             self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     def _install_claude_hooks(self, workspace: str) -> None:
@@ -1040,20 +1590,87 @@ class AgentsPanel(Container, can_focus=True):
         except Exception as e:
             self.app.notify(f"Failed: {e}", title="Agent", severity="error")
 
-    async def _switch_to_terminal(self, terminal_id: str) -> None:
+    def _request_switch_to_terminal(self, terminal_id: str) -> None:
+        """Switch terminals without blocking the UI thread."""
+        terminal_id = (terminal_id or "").strip()
         if not terminal_id:
             return
 
-        window_id = self._find_window(terminal_id)
-        if not window_id:
-            self.app.notify("Window not found", title="Agent", severity="warning")
-            return
+        self._active_terminal_id = terminal_id
+        self._update_active_terminal_ui(terminal_id)
+        self._rendered_fingerprint = (
+            self._fingerprint(self._agents) + f"|active:{self._active_terminal_id}"
+        )
+
+        self._switch_seq += 1
+        seq = self._switch_seq
+
+        if self._switch_worker is not None and self._switch_worker.state in (
+            WorkerState.PENDING,
+            WorkerState.RUNNING,
+        ):
+            try:
+                self._switch_worker.cancel()
+            except Exception:
+                pass
+
+        agents_snapshot = self._agents
+
+        def work() -> dict:
+            # Prefer cached window_id to avoid a blocking tmux scan on every click.
+            window_id = None
+            try:
+                for agent in agents_snapshot:
+                    for term in agent.get("terminals") or []:
+                        if term.get("terminal_id") == terminal_id:
+                            window_id = (term.get("window_id") or "").strip() or None
+                            break
+                    if window_id:
+                        break
+            except Exception:
+                window_id = None
+
+            if not window_id:
+                # Fall back to querying tmux (best-effort).
+                window_id = self._find_window(terminal_id)
+
+            if not window_id:
+                # If the terminal was closed from within the shell (e.g. `exit`), the DB record can
+                # remain "active" briefly. Trigger a refresh so the stale button disappears.
+                try:
+                    from ...db import get_database
+
+                    db = get_database(read_only=False)
+                    db.update_agent(terminal_id, status="inactive")
+                except Exception:
+                    pass
+                return {
+                    "seq": seq,
+                    "terminal_id": terminal_id,
+                    "ok": False,
+                    "error": "Window not found",
+                }
 
-        if tmux_manager.select_inner_window(window_id):
-            tmux_manager.focus_right_pane()
+            if not tmux_manager.select_inner_window(window_id):
+                return {
+                    "seq": seq,
+                    "terminal_id": terminal_id,
+                    "window_id": window_id,
+                    "ok": False,
+                    "error": "Failed to switch",
+                }
+
+            # Prefer showing the terminal after switching (best-effort).
+            if not tmux_manager.focus_right_pane():
+                logger.warning(
+                    "Switch terminal: focus_right_pane failed (terminal_id=%s window_id=%s)",
+                    terminal_id,
+                    window_id,
+                )
             tmux_manager.clear_attention(window_id)
-        else:
-            self.app.notify("Failed to switch", title="Agent", severity="error")
+            return {"seq": seq, "terminal_id": terminal_id, "window_id": window_id, "ok": True}
+
+        self._switch_worker = self.run_worker(work, thread=True, exit_on_error=False)
 
     async def _close_terminal(self, terminal_id: str) -> None:
         if not terminal_id:
@@ -1312,6 +1929,4 @@ class AgentsPanel(Container, can_focus=True):
         if copied:
             self.app.notify("Share link copied to clipboard", title="Link", timeout=3)
         else:
-            self.app.notify(
-                f"Failed to copy. Link: {share_url}", title="Link", severity="warning"
-            )
+            self.app.notify(f"Failed to copy. Link: {share_url}", title="Link", severity="warning")