autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/cli/agent_team_tui/state.py

@@ -0,0 +1,180 @@
+"""
+Defines a centralized state store for the TUI application, following state management best practices.
+"""
+import logging
+from typing import Dict, List, Optional, Any
+import copy
+
+from autobyteus.agent.context import AgentConfig
+from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
+from autobyteus.agent.streaming.stream_event_payloads import (
+    AgentOperationalPhaseTransitionData, ToolInvocationApprovalRequestedData, 
+    AssistantChunkData, AssistantCompleteResponseData
+)
+from autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamPhaseTransitionData
+from autobyteus.task_management.task_plan import Task
+from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.base_task_board import TaskStatus
+
+logger = logging.getLogger(__name__)
+
+class TUIStateStore:
+    """
+    A centralized store for all TUI-related state.
+
+    This class acts as the single source of truth for the UI. It processes events
+    from the backend and updates its state. The main App class can then react to
+    these state changes to update the UI components declaratively.
+    """
+
+    def __init__(self, team: AgentTeam):
+        self.team_name = team.name
+        self.team_role = team.role
+        
+        self.focused_node_data: Optional[Dict[str, Any]] = None
+        
+        self._node_roles: Dict[str, str] = self._extract_node_roles(team)
+        self._nodes: Dict[str, Any] = self._initialize_root_node()
+        self._agent_phases: Dict[str, AgentOperationalPhase] = {}
+        self._team_phases: Dict[str, AgentTeamOperationalPhase] = {self.team_name: AgentTeamOperationalPhase.UNINITIALIZED}
+        self._agent_event_history: Dict[str, List[AgentStreamEvent]] = {}
+        self._team_event_history: Dict[str, List[AgentTeamStreamEvent]] = {self.team_name: []}
+        self._pending_approvals: Dict[str, ToolInvocationApprovalRequestedData] = {}
+        self._speaking_agents: Dict[str, bool] = {}
+        
+        # State for task boards
+        self._task_plans: Dict[str, List[Task]] = {} # team_name -> List[Task]
+        self._task_statuses: Dict[str, Dict[str, TaskStatus]] = {} # team_name -> {task_id: status}
+        
+        # Version counter to signal state changes to the UI
+        self.version = 0
+
+    def _extract_node_roles(self, team: AgentTeam) -> Dict[str, str]:
+        roles = {}
+        if team._runtime and team._runtime.context and team._runtime.context.config:
+            for node_config in team._runtime.context.config.nodes:
+                role = getattr(node_config.node_definition, 'role', None)
+                if role:
+                    roles[node_config.name] = role
+        return roles
+
+    def _initialize_root_node(self) -> Dict[str, Any]:
+        return {
+            self.team_name: {
+                "type": "team",
+                "name": self.team_name,
+                "role": self.team_role,
+                "children": {}
+            }
+        }
+
+    def process_event(self, event: AgentTeamStreamEvent):
+        self.version += 1 # Increment on any event to signal a change
+        
+        if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamPhaseTransitionData):
+            self._team_phases[self.team_name] = event.data.new_phase
+        
+        self._process_event_recursively(event, self.team_name)
+
+    def _process_event_recursively(self, event: AgentTeamStreamEvent, parent_name: str):
+        if parent_name not in self._team_event_history:
+            self._team_event_history[parent_name] = []
+        self._team_event_history[parent_name].append(event)
+        
+        if event.event_source_type == "TASK_BOARD":
+            # The 'parent_name' argument holds the friendly name of the team (or sub-team)
+            # that is the context for this event. This is the key we use for UI state.
+            team_name_key = parent_name
+            if isinstance(event.data, TaskPlanPublishedEvent):
+                self._task_plans[team_name_key] = event.data.plan.tasks
+                # Reset statuses when a new plan is published
+                self._task_statuses[team_name_key] = {task.task_id: TaskStatus.NOT_STARTED for task in event.data.plan.tasks}
+                logger.debug(f"TUI State: Updated task plan for '{team_name_key}' with {len(event.data.plan.tasks)} tasks.")
+            elif isinstance(event.data, TaskStatusUpdatedEvent):
+                # Update status
+                if team_name_key not in self._task_statuses:
+                    self._task_statuses[team_name_key] = {}
+                self._task_statuses[team_name_key][event.data.task_id] = event.data.new_status
+                logger.debug(f"TUI State: Updated status for task '{event.data.task_id}' in team '{team_name_key}' to {event.data.new_status}.")
+                
+                # Update deliverables if they are provided in the event.
+                if event.data.deliverables is not None:
+                    if team_name_key in self._task_plans:
+                        for task in self._task_plans[team_name_key]:
+                            if task.task_id == event.data.task_id:
+                                task.file_deliverables = event.data.deliverables
+                                logger.debug(f"TUI State: Synced deliverables for task '{event.data.task_id}' in team '{team_name_key}'.")
+                                break
+            return
+
+        if isinstance(event.data, AgentEventRebroadcastPayload):
+            payload = event.data
+            agent_name = payload.agent_name
+            agent_event = payload.agent_event
+
+            if agent_name not in self._agent_event_history:
+                self._agent_event_history[agent_name] = []
+                if self._find_node(parent_name):
+                    agent_role = self._node_roles.get(agent_name, "Agent")
+                    self._add_node(agent_name, {"type": "agent", "name": agent_name, "role": agent_role, "children": {}}, parent_name)
+                else: logger.error(f"Cannot add agent node '{agent_name}': parent '{parent_name}' not found.")
+            self._agent_event_history[agent_name].append(agent_event)
+
+            if agent_event.event_type == AgentStreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION:
+                self._agent_phases[agent_name] = agent_event.data.new_phase
+                if agent_name in self._pending_approvals: del self._pending_approvals[agent_name]
+            elif agent_event.event_type == AgentStreamEventType.AGENT_IDLE:
+                self._agent_phases[agent_name] = AgentOperationalPhase.IDLE
+            elif agent_event.event_type == AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED:
+                self._pending_approvals[agent_name] = agent_event.data
+
+        elif isinstance(event.data, SubTeamEventRebroadcastPayload):
+            payload = event.data
+            sub_team_name = payload.sub_team_node_name
+            sub_team_event = payload.sub_team_event
+            if not self._find_node(sub_team_name):
+                role = self._node_roles.get(sub_team_name, "Sub-Team")
+                self._add_node(sub_team_name, {"type": "subteam", "name": sub_team_name, "role": role, "children": {}}, parent_name)
+            if sub_team_event.event_source_type == "TEAM" and isinstance(sub_team_event.data, AgentTeamPhaseTransitionData):
+                self._team_phases[sub_team_name] = sub_team_event.data.new_phase
+            self._process_event_recursively(sub_team_event, parent_name=sub_team_name)
+
+    def _add_node(self, node_name: str, node_data: Dict, parent_name: str):
+        parent = self._find_node(parent_name)
+        if parent: parent["children"][node_name] = node_data
+        else: logger.error(f"Could not find parent node '{parent_name}' to add child '{node_name}'.")
+
+    def _find_node(self, node_name: str, tree: Optional[Dict] = None) -> Optional[Dict]:
+        tree = tree or self._nodes
+        for name, node_data in tree.items():
+            if name == node_name: return node_data
+            if node_data.get("children"):
+                found = self._find_node(node_name, node_data.get("children"))
+                if found: return found
+        return None
+
+    def get_tree_data(self) -> Dict:
+        return copy.deepcopy(self._nodes)
+    
+    def get_history_for_node(self, node_name: str, node_type: str) -> List:
+        if node_type == 'agent': return self._agent_event_history.get(node_name, [])
+        return []
+        
+    def get_pending_approval_for_agent(self, agent_name: str) -> Optional[ToolInvocationApprovalRequestedData]:
+        return self._pending_approvals.get(agent_name)
+        
+    def get_task_board_plan(self, team_name: str) -> Optional[List[Task]]:
+        return self._task_plans.get(team_name)
+
+    def get_task_board_statuses(self, team_name: str) -> Optional[Dict[str, TaskStatus]]:
+        return self._task_statuses.get(team_name)
+
+    def clear_pending_approval(self, agent_name: str):
+        if agent_name in self._pending_approvals: del self._pending_approvals[agent_name]
+    
+    def set_focused_node(self, node_data: Optional[Dict[str, Any]]):
+        self.focused_node_data = node_data

autobyteus/cli/agent_team_tui/widgets/__init__.py

@@ -0,0 +1,6 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/widgets/__init__.py
+"""
+Custom Textual widgets for the agent team TUI.
+"""
+from . import renderables
+from .logo import Logo

autobyteus/cli/agent_team_tui/widgets/agent_list_sidebar.py

@@ -0,0 +1,149 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/widgets/agent_list_sidebar.py
+"""
+Defines the sidebar widget that lists all nodes in the team hierarchy.
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from textual.message import Message
+from textual.widgets import Static, Tree
+from textual.widgets.tree import TreeNode
+from textual.containers import Vertical
+
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from .shared import (
+    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, 
+    TEAM_ICON, SPEAKING_ICON, DEFAULT_ICON
+)
+from .logo import Logo
+
+logger = logging.getLogger(__name__)
+
+class AgentListSidebar(Static):
+    """A widget to display the hierarchical list of team nodes. This is a dumb
+    rendering component driven by the TUIStateStore."""
+
+    class NodeSelected(Message):
+        """Posted when any node is selected in the tree."""
+        def __init__(self, node_data: Dict[str, Any]) -> None:
+            self.node_data = node_data
+            super().__init__()
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._node_map: Dict[str, TreeNode] = {} # Maps node names to TreeNode objects
+
+    def compose(self):
+        with Vertical():
+            yield Tree("Agent Team", id="agent-tree")
+            yield Logo()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        """Handle node selection from the tree."""
+        if event.node.data:
+            self.post_message(self.NodeSelected(event.node.data))
+        event.stop()
+
+    def _build_label(self, name: str, node_data: Dict, agent_phases: Dict, team_phases: Dict, speaking_agents: Dict) -> str:
+        """Constructs the display label for a tree node."""
+        node_type = node_data["type"]
+        icon = DEFAULT_ICON
+        
+        if node_type == "agent":
+            phase = agent_phases.get(name, AgentOperationalPhase.UNINITIALIZED)
+            icon = SPEAKING_ICON if speaking_agents.get(name) else AGENT_PHASE_ICONS.get(phase, DEFAULT_ICON)
+            label = f"{icon} {name}"
+        elif node_type in ["team", "subteam"]:
+            phase = team_phases.get(name, AgentTeamOperationalPhase.UNINITIALIZED)
+            default_icon = TEAM_ICON if node_type == "team" else SUB_TEAM_ICON
+            icon = TEAM_PHASE_ICONS.get(phase, default_icon)
+            role = node_data.get("role")
+            label = f"{icon} {role or name}"
+            if role and role != name:
+                label += f" ({name})"
+        else:
+            label = f"{icon} {name}"
+            
+        return label
+
+    def update_tree(self, tree_data: Dict, agent_phases: Dict[str, AgentOperationalPhase], team_phases: Dict[str, AgentTeamOperationalPhase], speaking_agents: Dict[str, bool]):
+        """
+        Performs an in-place update of the tree to reflect the new state,
+        avoiding a full rebuild for better performance and preserving UI state like expansion.
+        """
+        tree = self.query_one(Tree)
+
+        if not tree_data:
+            tree.root.set_label("Initializing agent team...")
+            return
+
+        root_name = list(tree_data.keys())[0]
+        root_node_data = tree_data[root_name]
+
+        # Kick off the recursive update from the root.
+        self._update_node_recursively(tree.root, root_node_data, agent_phases, team_phases, speaking_agents)
+        
+        # Ensure the root is expanded on the first run.
+        if not tree.root.is_expanded:
+            tree.root.expand()
+
+    def _update_node_recursively(self, ui_node: TreeNode, node_data: Dict, agent_phases: Dict, team_phases: Dict, speaking_agents: Dict):
+        """Recursively updates a node and reconciles its children."""
+        # 1. Update the current node's label and data
+        name = node_data['name']
+        label = self._build_label(name, node_data, agent_phases, team_phases, speaking_agents)
+        ui_node.set_label(label)
+        ui_node.data = node_data
+        self._node_map[name] = ui_node  # Ensure map is always up-to-date
+
+        # 2. Reconcile children
+        new_children_data = node_data.get("children", {})
+        existing_ui_children_by_name = {child.data['name']: child for child in ui_node.children if child.data}
+
+        # Add new nodes and update existing ones
+        for child_name, child_data in new_children_data.items():
+            if child_name in existing_ui_children_by_name:
+                # Node exists, so we recursively update it
+                child_ui_node = existing_ui_children_by_name[child_name]
+                self._update_node_recursively(child_ui_node, child_data, agent_phases, team_phases, speaking_agents)
+            else:
+                # Node is new, so we add it
+                new_child_label = self._build_label(child_name, child_data, agent_phases, team_phases, speaking_agents)
+                is_leaf = child_data.get("children", {}) == {} and child_data['type'] == 'agent'
+                
+                if is_leaf:
+                    new_ui_node = ui_node.add_leaf(new_child_label, data=child_data)
+                else:
+                    new_ui_node = ui_node.add(new_child_label, data=child_data)
+                    # Since this is a new branch, we must build its children too
+                    self._update_node_recursively(new_ui_node, child_data, agent_phases, team_phases, speaking_agents)
+                
+                self._node_map[child_name] = new_ui_node
+
+        # Remove old nodes that no longer exist in the new data
+        nodes_to_remove = []
+        for existing_child_name, existing_child_node in existing_ui_children_by_name.items():
+            if existing_child_name not in new_children_data:
+                nodes_to_remove.append(existing_child_node)
+                if existing_child_name in self._node_map:
+                    del self._node_map[existing_child_name]
+        
+        for node in nodes_to_remove:
+            node.remove()
+
+    def update_selection(self, node_name: Optional[str]):
+        """Updates the tree's selection and expands parents to make it visible."""
+        if not node_name or node_name not in self._node_map:
+            return
+            
+        tree = self.query_one(Tree)
+        node_to_select = self._node_map[node_name]
+        
+        parent = node_to_select.parent
+        while parent:
+            parent.expand()
+            parent = parent.parent
+        
+        tree.select_node(node_to_select)
+        tree.scroll_to_node(node_to_select)

autobyteus/cli/agent_team_tui/widgets/focus_pane.py

@@ -0,0 +1,320 @@
+"""
+Defines the main focus pane widget for displaying detailed logs or summaries.
+"""
+import logging
+import json
+from typing import Optional, List, Any, Dict
+
+from rich.text import Text
+from rich.panel import Panel
+from rich.syntax import Syntax
+from textual.message import Message
+from textual.widgets import Input, Static, Button
+from textual.containers import VerticalScroll, Horizontal
+
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.task_plan import Task
+from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
+from autobyteus.agent.streaming.stream_event_payloads import (
+    AgentOperationalPhaseTransitionData, AssistantChunkData, AssistantCompleteResponseData,
+    ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData,
+    SystemTaskNotificationData
+)
+from .shared import (
+    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, DEFAULT_ICON,
+    USER_ICON, ASSISTANT_ICON, TEAM_ICON, AGENT_ICON, SYSTEM_TASK_ICON
+)
+from . import renderables
+from .task_board_panel import TaskBoardPanel
+
+logger = logging.getLogger(__name__)
+
+class FocusPane(Static):
+    """
+    A widget to display detailed logs for agents or high-level dashboards for teams.
+    This is a dumb rendering component driven by the TUIStateStore.
+    """
+
+    class MessageSubmitted(Message):
+        def __init__(self, text: str, agent_name: str) -> None:
+            self.text = text
+            self.agent_name = agent_name
+            super().__init__()
+
+    class ApprovalSubmitted(Message):
+        def __init__(self, agent_name: str, invocation_id: str, is_approved: bool, reason: Optional[str]) -> None:
+            self.agent_name = agent_name
+            self.invocation_id = invocation_id
+            self.is_approved = is_approved
+            self.reason = reason
+            super().__init__()
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._focused_node_data: Optional[Dict[str, Any]] = None
+        self._pending_approval_data: Optional[ToolInvocationApprovalRequestedData] = None
+        
+        # State variables for streaming
+        self._thinking_widget: Optional[Static] = None
+        self._thinking_text: Optional[Text] = None
+        self._assistant_content_widget: Optional[Static] = None
+        self._assistant_content_text: Optional[Text] = None
+        
+        # Buffers for batched UI updates to improve performance
+        self._reasoning_buffer: str = ""
+        self._content_buffer: str = ""
+
+    def compose(self):
+        yield Static("Select a node from the sidebar", id="focus-pane-title")
+        yield VerticalScroll(id="focus-pane-log-container")
+        yield Horizontal(id="approval-buttons")
+        yield Input(placeholder="Select an agent to send messages...", id="focus-pane-input", disabled=True)
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.value and self._focused_node_data and self._focused_node_data.get("type") == 'agent':
+            log_container = self.query_one("#focus-pane-log-container")
+            user_message_text = Text(f"{USER_ICON} You: {event.value}", style="bright_blue")
+            await log_container.mount(Static(""))
+            await log_container.mount(Static(user_message_text))
+            log_container.scroll_end(animate=False)
+            
+            self.post_message(self.MessageSubmitted(event.value, self._focused_node_data['name']))
+            self.query_one(Input).clear()
+        event.stop()
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if not self._pending_approval_data or not self._focused_node_data:
+            return
+
+        is_approved = event.button.id == "approve-btn"
+        reason = "User approved via TUI." if is_approved else "User denied via TUI."
+        
+        log_container = self.query_one("#focus-pane-log-container")
+        approval_text = "APPROVED" if is_approved else "DENIED"
+        display_text = Text(f"{USER_ICON} You: {approval_text} (Reason: {reason})", style="bright_cyan")
+        await log_container.mount(Static(""))
+        await log_container.mount(Static(display_text))
+        log_container.scroll_end(animate=False)
+
+        self.post_message(self.ApprovalSubmitted(
+            agent_name=self._focused_node_data['name'],
+            invocation_id=self._pending_approval_data.invocation_id,
+            is_approved=is_approved, reason=reason
+        ))
+        await self._clear_approval_ui()
+        event.stop()
+
+    async def _clear_approval_ui(self):
+        self._pending_approval_data = None
+        await self.query_one("#approval-buttons").remove_children()
+        input_widget = self.query_one(Input)
+        if self._focused_node_data and self._focused_node_data.get("type") == "agent":
+            input_widget.disabled = False
+            input_widget.placeholder = f"Send a message to {self._focused_node_data['name']}..."
+            input_widget.focus()
+        else:
+            input_widget.disabled = True
+            input_widget.placeholder = "Select an agent to send messages..."
+
+    async def _show_approval_prompt(self):
+        if not self._pending_approval_data: return
+        input_widget = self.query_one(Input)
+        input_widget.placeholder = "Please approve or deny the tool call..."
+        input_widget.disabled = True
+        button_container = self.query_one("#approval-buttons")
+        await button_container.remove_children()
+        await button_container.mount(
+            Button("Approve", variant="success", id="approve-btn"),
+            Button("Deny", variant="error", id="deny-btn")
+        )
+
+    def _update_title(self, agent_phases: Dict[str, AgentOperationalPhase], team_phases: Dict[str, AgentTeamOperationalPhase]):
+        """Renders the title of the focus pane with the node's current status."""
+        if not self._focused_node_data:
+            self.query_one("#focus-pane-title").update("Select a node from the sidebar")
+            return
+
+        node_name = self._focused_node_data.get("name", "Unknown")
+        node_type = self._focused_node_data.get("type", "node")
+        node_type_str = node_type.replace("_", " ").capitalize()
+
+        title_icon = DEFAULT_ICON
+        phase_str = ""
+
+        if node_type == 'agent':
+            title_icon = AGENT_ICON
+            phase = agent_phases.get(node_name, AgentOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+        elif node_type == 'subteam':
+            title_icon = SUB_TEAM_ICON
+            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+        elif node_type == 'team':
+            title_icon = TEAM_ICON
+            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+
+        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{phase_str}")
+        
+    def update_current_node_status(self, all_agent_phases: Dict, all_team_phases: Dict):
+        """A lightweight method to only update the title with the latest status."""
+        self._update_title(all_agent_phases, all_team_phases)
+
+    async def update_content(self, node_data: Dict[str, Any], history: List[Any], 
+                             pending_approval: Optional[ToolInvocationApprovalRequestedData], 
+                             all_agent_phases: Dict[str, AgentOperationalPhase], 
+                             all_team_phases: Dict[str, AgentTeamOperationalPhase],
+                             task_plan: Optional[List[Task]],
+                             task_statuses: Optional[Dict[str, TaskStatus]]):
+        """The main method to update the entire pane based on new state."""
+        self.flush_stream_buffers()
+
+        self._focused_node_data = node_data
+        self._pending_approval_data = pending_approval
+        
+        self._update_title(all_agent_phases, all_team_phases)
+
+        log_container = self.query_one("#focus-pane-log-container")
+        await log_container.remove_children()
+
+        self._thinking_widget = None
+        self._thinking_text = None
+        self._assistant_content_widget = None
+        self._assistant_content_text = None
+
+        await self._clear_approval_ui()
+
+        if self._focused_node_data.get("type") == 'agent':
+            for event in history:
+                await self.add_agent_event(event)
+            if self._pending_approval_data:
+                await self._show_approval_prompt()
+        elif self._focused_node_data.get("type") in ['team', 'subteam']:
+            await self._render_team_dashboard(node_data, all_agent_phases, all_team_phases, task_plan, task_statuses)
+
+    async def _render_team_dashboard(self, node_data: Dict[str, Any], 
+                                         all_agent_phases: Dict[str, AgentOperationalPhase],
+                                         all_team_phases: Dict[str, AgentTeamOperationalPhase],
+                                         task_plan: Optional[List[Task]],
+                                         task_statuses: Optional[Dict[str, TaskStatus]]):
+        """Renders a static summary dashboard for a team or sub-team."""
+        log_container = self.query_one("#focus-pane-log-container")
+        
+        phase = all_team_phases.get(node_data['name'], AgentTeamOperationalPhase.UNINITIALIZED)
+        phase_icon = TEAM_PHASE_ICONS.get(phase, DEFAULT_ICON)
+        info_text = Text()
+        info_text.append(f"Name: {node_data['name']}\n", style="bold")
+        if node_data.get('role'):
+            info_text.append(f"Role: {node_data['role']}\n")
+        info_text.append(f"Status: {phase_icon} {phase.value}")
+        await log_container.mount(Static(Panel(info_text, title="Team Info", border_style="green", title_align="left")))
+
+        await log_container.mount(TaskBoardPanel(tasks=task_plan, statuses=task_statuses, team_name=node_data['name']))
+
+        children_data = node_data.get("children", {})
+        if children_data:
+            team_text = Text()
+            for name, child_node in children_data.items():
+                if child_node['type'] == 'agent':
+                    agent_phase = all_agent_phases.get(name, AgentOperationalPhase.UNINITIALIZED)
+                    agent_icon = AGENT_PHASE_ICONS.get(agent_phase, DEFAULT_ICON)
+                    team_text.append(f" ▪ {agent_icon} {name} (Agent): {agent_phase.value}\n")
+                elif child_node['type'] == 'subteam':
+                    wf_phase = all_team_phases.get(name, AgentTeamOperationalPhase.UNINITIALIZED)
+                    wf_icon = TEAM_PHASE_ICONS.get(wf_phase, SUB_TEAM_ICON)
+                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Team): {wf_phase.value}\n")
+            await log_container.mount(Static(Panel(team_text, title="Team Status", border_style="blue", title_align="left")))
+
+    async def _close_thinking_block(self, scroll: bool = True):
+        if self._thinking_widget and self._thinking_text:
+            self.flush_stream_buffers()
+            self._thinking_text.append("\n</Thinking>", style="dim italic cyan")
+            self._thinking_widget.update(self._thinking_text)
+            if scroll:
+                self.query_one("#focus-pane-log-container").scroll_end(animate=False)
+            self._thinking_widget = None
+            self._thinking_text = None
+
+    def flush_stream_buffers(self):
+        scrolled = False
+        if self._reasoning_buffer and self._thinking_widget and self._thinking_text:
+            self._thinking_text.append(self._reasoning_buffer)
+            self._thinking_widget.update(self._thinking_text)
+            self._reasoning_buffer = ""
+            scrolled = True
+        if self._content_buffer and self._assistant_content_widget and self._assistant_content_text:
+            self._assistant_content_text.append(self._content_buffer)
+            self._assistant_content_widget.update(self._assistant_content_text)
+            self._content_buffer = ""
+            scrolled = True
+        if scrolled:
+            self.query_one("#focus-pane-log-container").scroll_end(animate=False)
+
+    async def add_agent_event(self, event: AgentStreamEvent):
+        log_container = self.query_one("#focus-pane-log-container")
+        event_type = event.event_type
+
+        if event_type == AgentStreamEventType.ASSISTANT_CHUNK:
+            data: AssistantChunkData = event.data
+            if data.reasoning:
+                if self._thinking_widget is None:
+                    self.flush_stream_buffers()
+                    await log_container.mount(Static(""))
+                    self._thinking_text = Text("<Thinking>\n", style="dim italic cyan")
+                    self._thinking_widget = Static(self._thinking_text)
+                    await log_container.mount(self._thinking_widget)
+                self._reasoning_buffer += data.reasoning
+            if data.content:
+                if self._thinking_widget: await self._close_thinking_block()
+                if self._assistant_content_widget is None:
+                    await log_container.mount(Static(""))
+                    self._assistant_content_text = Text(f"{ASSISTANT_ICON} assistant: ", style="bold green")
+                    self._assistant_content_widget = Static(self._assistant_content_text)
+                    await log_container.mount(self._assistant_content_widget)
+                self._content_buffer += data.content
+            return
+
+        if event_type == AgentStreamEventType.ASSISTANT_COMPLETE_RESPONSE:
+            was_streaming_content = self._assistant_content_widget is not None
+            self.flush_stream_buffers()
+            await self._close_thinking_block()
+            self._assistant_content_widget = None
+            self._assistant_content_text = None
+            if not was_streaming_content:
+                renderables_list = renderables.render_assistant_complete_response(event.data)
+                if renderables_list:
+                    await log_container.mount(Static(""))
+                    for item in renderables_list: await log_container.mount(Static(item))
+                    log_container.scroll_end(animate=False)
+            return
+
+        is_stream_breaking_event = event_type in [
+            AgentStreamEventType.TOOL_INTERACTION_LOG_ENTRY,
+            AgentStreamEventType.TOOL_INVOCATION_AUTO_EXECUTING,
+            AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED,
+            AgentStreamEventType.ERROR_EVENT,
+            AgentStreamEventType.SYSTEM_TASK_NOTIFICATION, # NEW
+        ]
+        if is_stream_breaking_event:
+            self.flush_stream_buffers()
+            await self._close_thinking_block()
+            self._assistant_content_widget = None
+            self._assistant_content_text = None
+        
+        renderable = None
+        if event_type == AgentStreamEventType.TOOL_INTERACTION_LOG_ENTRY: renderable = renderables.render_tool_interaction_log(event.data)
+        elif event_type == AgentStreamEventType.TOOL_INVOCATION_AUTO_EXECUTING: renderable = renderables.render_tool_auto_executing(event.data)
+        elif event_type == AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED:
+            renderable = renderables.render_tool_approval_request(event.data)
+            self._pending_approval_data = event.data
+            await self._show_approval_prompt()
+        elif event_type == AgentStreamEventType.ERROR_EVENT: renderable = renderables.render_error(event.data)
+        elif event_type == AgentStreamEventType.SYSTEM_TASK_NOTIFICATION: renderable = renderables.render_system_task_notification(event.data) # NEW
+        
+        if renderable:
+            await log_container.mount(Static(""))
+            await log_container.mount(Static(renderable))
+
+        log_container.scroll_end(animate=False)