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

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

@@ -0,0 +1,164 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py
+import asyncio
+import logging
+from typing import Set, Any, TYPE_CHECKING, List, Union
+
+from autobyteus.events.event_types import EventType
+from autobyteus.agent_team.events import ProcessUserMessageEvent
+from autobyteus.agent.message import AgentInputUserMessage
+from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.task_plan import Task
+
+if TYPE_CHECKING:
+    from autobyteus.task_management.base_task_board import BaseTaskBoard
+    from autobyteus.agent_team.context.team_manager import TeamManager
+
+logger = logging.getLogger(__name__)
+
+class SystemEventDrivenAgentTaskNotifier:
+    """
+    An internal component that monitors a TaskBoard and automatically sends
+    notifications to agents when their assigned tasks become runnable.
+    """
+    def __init__(self, task_board: 'BaseTaskBoard', team_manager: 'TeamManager'):
+        """
+        Initializes the SystemEventDrivenAgentTaskNotifier.
+
+        Args:
+            task_board: The team's shared task board instance.
+            team_manager: The team's manager for submitting notification events.
+        """
+        if not task_board or not team_manager:
+            raise ValueError("TaskBoard and TeamManager are required for the notifier.")
+            
+        self._task_board = task_board
+        self._team_manager = team_manager
+        self._dispatched_task_ids: Set[str] = set()
+        logger.info(f"SystemEventDrivenAgentTaskNotifier initialized for team '{self._team_manager.team_id}'.")
+
+    def start_monitoring(self):
+        """
+        Subscribes to task board events to begin monitoring for runnable tasks.
+        This should be called once during the agent team's bootstrap process.
+        """
+        self._task_board.subscribe(
+            EventType.TASK_BOARD_PLAN_PUBLISHED,
+            self._handle_task_board_update
+        )
+        self._task_board.subscribe(
+            EventType.TASK_BOARD_STATUS_UPDATED,
+            self._handle_task_board_update
+        )
+        logger.info(f"Team '{self._team_manager.team_id}': Task notifier is now monitoring TaskBoard events.")
+
+    async def _handle_task_board_update(self, payload: Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent], **kwargs):
+        """
+        Asynchronous event handler triggered by the task board. It uses the event
+        payload to decide when to check for and notify agents of newly runnable tasks.
+        """
+        if isinstance(payload, TaskPlanPublishedEvent):
+            logger.info(f"Team '{self._team_manager.team_id}': New task plan detected. Resetting dispatched tasks and checking for initial runnable tasks.")
+            self._dispatched_task_ids.clear()
+            await self._scan_and_notify_all_runnable_tasks()
+        
+        elif isinstance(payload, TaskStatusUpdatedEvent):
+            # Only trigger a check for dependent tasks if a task has been completed,
+            # as this is the only status change that can unblock dependent tasks.
+            if payload.new_status == TaskStatus.COMPLETED:
+                logger.info(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' completed. Checking for newly unblocked dependent tasks.")
+                await self._check_and_notify_dependent_tasks(payload.task_id)
+            else:
+                logger.debug(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' status updated to '{payload.new_status.value}'. No dependent task check needed.")
+        else:
+            # This case should ideally not be hit with the new strong typing, but is kept as a safeguard.
+            logger.warning(f"Team '{self._team_manager.team_id}': Task notifier received an unhandled payload type: {type(payload)}")
+
+
+    async def _check_and_notify_dependent_tasks(self, completed_task_id: str):
+        """
+        Finds tasks that depend on the completed task and notifies their assignees
+        if all of their other dependencies are also met.
+        """
+        if not getattr(self._task_board, 'current_plan', None):
+            return
+
+        all_tasks = self._task_board.current_plan.tasks
+        task_statuses = getattr(self._task_board, 'task_statuses', {})
+
+        for child_task in all_tasks:
+            # Find tasks that are direct children of the completed task
+            if completed_task_id in child_task.dependencies:
+                # Now, check if this child task is fully runnable (all its parents are done)
+                all_deps_met = all(
+                    task_statuses.get(dep_id) == TaskStatus.COMPLETED for dep_id in child_task.dependencies
+                )
+                
+                if all_deps_met and child_task.task_id not in self._dispatched_task_ids:
+                    await self._dispatch_notification_for_task(child_task)
+
+    async def _scan_and_notify_all_runnable_tasks(self):
+        """
+        Scans the entire board for any runnable tasks. Used for initial plan loading.
+        """
+        try:
+            runnable_tasks = self._task_board.get_next_runnable_tasks()
+            for task in runnable_tasks:
+                if task.task_id not in self._dispatched_task_ids:
+                    await self._dispatch_notification_for_task(task)
+        except Exception as e:
+            logger.error(f"Team '{self._team_manager.team_id}': Error during full scan for runnable tasks: {e}", exc_info=True)
+    
+    async def _dispatch_notification_for_task(self, task: Task):
+        """
+        Constructs and sends a context-rich notification for a single runnable task
+        by treating it as a user message to trigger the full processing pipeline.
+        It tags the message with metadata to indicate its system origin.
+        """
+        try:
+            team_id = self._team_manager.team_id
+            logger.info(f"Team '{team_id}': Dispatching notification for runnable task '{task.task_name}' to assignee '{task.assignee_name}'.")
+            
+            context_from_parents = []
+            if task.dependencies:
+                parent_task_deliverables_info = []
+                for dep_id in task.dependencies:
+                    parent_task = getattr(self._task_board, '_task_map', {}).get(dep_id)
+                    if parent_task and parent_task.file_deliverables:
+                        deliverables_str = "\n".join(
+                            [f"  - File: {d.file_path}, Summary: {d.summary}" for d in parent_task.file_deliverables]
+                        )
+                        parent_task_deliverables_info.append(
+                            f"The parent task '{parent_task.task_name}' produced the following deliverables:\n{deliverables_str}"
+                        )
+                
+                if parent_task_deliverables_info:
+                    context_from_parents.append(
+                        "Your task is now unblocked. Here is the context from the completed parent task(s):\n" +
+                        "\n\n".join(parent_task_deliverables_info)
+                    )
+
+            message_parts: List[str] = [f"Your task '{task.task_name}' is now ready to start."]
+            if context_from_parents:
+                message_parts.extend(context_from_parents)
+            
+            message_parts.append(f"\nYour task description:\n{task.description}")
+            
+            content = "\n\n".join(message_parts)
+            
+            # Create the user message with metadata indicating its origin.
+            user_message = AgentInputUserMessage(
+                content=content,
+                metadata={'source': 'system_task_notifier'}
+            )
+            event = ProcessUserMessageEvent(
+                user_message=user_message,
+                target_agent_name=task.assignee_name
+            )
+
+            # Use the existing method for dispatching user messages.
+            await self._team_manager.dispatch_user_message_to_agent(event)
+            self._dispatched_task_ids.add(task.task_id)
+
+        except Exception as e:
+            logger.error(f"Team '{self._team_manager.team_id}': Failed to dispatch notification for task '{task.task_id}': {e}", exc_info=True)

autobyteus/agent_team/task_notification/task_notification_mode.py

@@ -0,0 +1,24 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/task_notification_mode.py
+"""
+Defines the enum for controlling how task notifications are handled in an agent team.
+"""
+from enum import Enum
+
+class TaskNotificationMode(str, Enum):
+    """
+    Enumerates the modes for handling task notifications within an agent team.
+    """
+    AGENT_MANUAL_NOTIFICATION = "agent_manual_notification"
+    """
+    In this mode, an agent (typically the coordinator) is responsible for
+    manually sending notifications to other agents to start their tasks.
+    """
+    
+    SYSTEM_EVENT_DRIVEN = "system_event_driven"
+    """
+    In this mode, the agent team framework automatically monitors the TaskBoard
+    and sends notifications to agents when their assigned tasks become runnable.
+    """
+
+    def __str__(self) -> str:
+        return self.value

autobyteus/agent_team/utils/__init__.py

@@ -0,0 +1,9 @@
+# file: autobyteus/autobyteus/agent_team/utils/__init__.py
+"""
+Utility functions for interacting with agent teams.
+"""
+from .wait_for_idle import wait_for_team_to_be_idle
+
+__all__ = [
+    "wait_for_team_to_be_idle",
+]

autobyteus/agent_team/utils/wait_for_idle.py

@@ -0,0 +1,46 @@
+# file: autobyteus/autobyteus/agent_team/utils/wait_for_idle.py
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
+from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.agent_team import AgentTeam
+
+logger = logging.getLogger(__name__)
+
+async def _wait_loop(streamer: AgentTeamEventStream, team_id: str):
+    """Internal helper to listen for the IDLE or ERROR event."""
+    async for event in streamer.all_events():
+        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.IDLE:
+            logger.info(f"Team '{team_id}' has become idle.")
+            return
+        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.ERROR:
+             error_message = f"Team '{team_id}' entered an error state while waiting for idle: {event.data.error_message}"
+             logger.error(error_message)
+             raise RuntimeError(error_message)
+
+async def wait_for_team_to_be_idle(team: 'AgentTeam', timeout: float = 60.0):
+    """
+    Waits for an agent team to complete its bootstrapping and enter the IDLE state.
+
+    Args:
+        team: The agent team instance to monitor.
+        timeout: The maximum time in seconds to wait.
+
+    Raises:
+        asyncio.TimeoutError: If the team does not become idle within the timeout period.
+        RuntimeError: If the team enters an error state.
+    """
+    if team.get_current_phase() == AgentTeamOperationalPhase.IDLE:
+        return
+    
+    logger.info(f"Waiting for team '{team.team_id}' to become idle (timeout: {timeout}s)...")
+    
+    streamer = AgentTeamEventStream(team)
+    try:
+        await asyncio.wait_for(_wait_loop(streamer, team.team_id), timeout=timeout)
+    finally:
+        await streamer.close()

autobyteus/cli/agent_team_tui/__init__.py

@@ -0,0 +1,4 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/__init__.py
+"""
+A Textual-based TUI for interacting with Agent Teams.
+"""

autobyteus/cli/agent_team_tui/app.py

@@ -0,0 +1,210 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/app.py
+"""
+The main Textual application class for the agent team TUI. This class orchestrates
+the UI by reacting to changes in a central state store.
+"""
+import asyncio
+import logging
+from typing import Dict, Optional, Any
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Header, Static
+from textual.reactive import reactive
+
+from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent.streaming.stream_events import StreamEventType as AgentStreamEventType
+from autobyteus.agent.streaming.stream_event_payloads import AssistantChunkData
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, AgentTeamPhaseTransitionData
+
+from .state import TUIStateStore
+from .widgets.agent_list_sidebar import AgentListSidebar
+from .widgets.focus_pane import FocusPane
+from .widgets.status_bar import StatusBar
+
+logger = logging.getLogger(__name__)
+
+class AgentTeamApp(App):
+    """A Textual TUI for interacting with an agent team, built around a central state store."""
+
+    TITLE = "AutoByteus"
+    CSS_PATH = "app.css"
+    BINDINGS = [
+        ("d", "toggle_dark", "Toggle Dark Mode"),
+        ("q", "quit", "Quit"),
+    ]
+
+    focused_node_data: reactive[Optional[Dict[str, Any]]] = reactive(None)
+    # The store_version property will trigger UI updates for the sidebar.
+    store_version: reactive[int] = reactive(0)
+
+    def __init__(self, team: AgentTeam, **kwargs):
+        super().__init__(**kwargs)
+        self.team = team
+        self.store = TUIStateStore(team=self.team)
+        self.team_stream: Optional[AgentTeamEventStream] = None
+        # Flag to indicate that the UI needs an update, used for throttling.
+        self._ui_update_pending = False
+
+    def compose(self) -> ComposeResult:
+        yield Header(id="app-header", name="AutoByteus Mission Control")
+        with Horizontal(id="main-container"):
+            yield AgentListSidebar(id="sidebar")
+            yield FocusPane(id="focus-pane")
+        yield StatusBar()
+
+    async def on_mount(self) -> None:
+        """Start background tasks when the app is mounted."""
+        self.team.start()
+        self.team_stream = AgentTeamEventStream(self.team)
+        
+        # Initialize the UI with the starting state
+        initial_tree = self.store.get_tree_data()
+        initial_focus_node = initial_tree.get(self.team.name)
+        
+        self.store.set_focused_node(initial_focus_node)
+        self.focused_node_data = initial_focus_node
+        self.store_version = self.store.version # Trigger initial render
+        
+        self.run_worker(self._listen_for_team_events(), name="team_listener")
+        
+        # Set up a timer to run the throttled UI updater at ~15 FPS.
+        self.set_interval(1 / 15, self._throttled_ui_updater, name="ui_updater")
+        logger.info("Agent Team TUI mounted, team listener and throttled UI updater started.")
+
+    async def on_unmount(self) -> None:
+        if self.team and self.team.is_running:
+            await self.team.stop()
+
+    def _throttled_ui_updater(self) -> None:
+        """
+        Periodically checks if the UI state is dirty and, if so, triggers
+        reactive updates. It also flushes streaming buffers from the focus pane.
+        """
+        focus_pane = self.query_one(FocusPane)
+        if self._ui_update_pending:
+            self._ui_update_pending = False
+            # This is the throttled trigger for the async watcher.
+            self.store_version = self.store.version
+        
+        # Always flush the focus pane's streaming buffer for smooth text rendering.
+        focus_pane.flush_stream_buffers()
+
+    async def _listen_for_team_events(self) -> None:
+        """A background worker that forwards team events to the state store and updates the UI."""
+        if not self.team_stream: return
+        try:
+            async for event in self.team_stream.all_events():
+                # 1. Always update the central state store immediately.
+                self.store.process_event(event)
+                
+                # 2. Mark the UI as needing an update for the throttled components.
+                self._ui_update_pending = True
+                
+                # 3. Handle real-time, incremental updates directly.
+                if isinstance(event.data, AgentEventRebroadcastPayload):
+                    payload = event.data
+                    agent_name = payload.agent_name
+                    agent_event = payload.agent_event
+                    focus_pane = self.query_one(FocusPane)
+                    
+                    is_currently_focused = (focus_pane._focused_node_data and focus_pane._focused_node_data.get('name') == agent_name)
+
+                    if is_currently_focused:
+                        await focus_pane.add_agent_event(agent_event)
+
+        except asyncio.CancelledError:
+            logger.info("Agent team event listener task was cancelled.")
+        except Exception:
+            logger.error("Critical error in agent team TUI event listener", exc_info=True)
+        finally:
+            if self.team_stream: await self.team_stream.close()
+
+    # --- Reactive Watchers ---
+
+    async def watch_store_version(self, new_version: int):
+        """
+        Reacts to changes in the store version.
+        """
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+
+        tree_data = self.store.get_tree_data()
+        agent_phases = self.store._agent_phases
+        team_phases = self.store._team_phases
+        speaking_agents = self.store._speaking_agents
+        
+        sidebar.update_tree(tree_data, agent_phases, team_phases, speaking_agents)
+        
+        focused_data = self.focused_node_data
+        if focused_data and focused_data.get("type") in ['team', 'subteam']:
+            node_name = focused_data['name']
+            task_plan = self.store.get_task_board_plan(node_name)
+            task_statuses = self.store.get_task_board_statuses(node_name)
+            await focus_pane.update_content(
+                node_data=focused_data,
+                history=[], # No history for teams
+                pending_approval=None,
+                all_agent_phases=agent_phases,
+                all_team_phases=team_phases,
+                task_plan=task_plan,
+                task_statuses=task_statuses
+            )
+        elif focused_data and focused_data.get("type") == 'agent':
+            focus_pane.update_current_node_status(agent_phases, team_phases)
+
+
+    async def watch_focused_node_data(self, new_node_data: Optional[Dict[str, Any]]):
+        """Reacts to changes in which node is focused. Primarily used for full pane reloads on user click."""
+        if not new_node_data: return
+        
+        node_name = new_node_data['name']
+        node_type = new_node_data['type']
+
+        history = self.store.get_history_for_node(node_name, node_type)
+        pending_approval = self.store.get_pending_approval_for_agent(node_name) if node_type == 'agent' else None
+        
+        task_plan = None
+        task_statuses = None
+        if node_type in ['team', 'subteam']:
+            task_plan = self.store.get_task_board_plan(node_name)
+            task_statuses = self.store.get_task_board_statuses(node_name)
+        
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+        
+        await focus_pane.update_content(
+            node_data=new_node_data,
+            history=history,
+            pending_approval=pending_approval,
+            all_agent_phases=self.store._agent_phases,
+            all_team_phases=self.store._team_phases,
+            task_plan=task_plan,
+            task_statuses=task_statuses
+        )
+        
+        sidebar.update_selection(node_name)
+
+    # --- Event Handlers (Actions) ---
+
+    def on_agent_list_sidebar_node_selected(self, message: AgentListSidebar.NodeSelected):
+        """Handles a node being selected by updating the store and the app's reactive state."""
+        self.store.set_focused_node(message.node_data)
+        self.focused_node_data = message.node_data
+
+    async def on_focus_pane_message_submitted(self, message: FocusPane.MessageSubmitted):
+        """Dispatches a user message to the backend model."""
+        user_message = AgentInputUserMessage(content=message.text)
+        await self.team.post_message(message=user_message, target_agent_name=message.agent_name)
+
+    async def on_focus_pane_approval_submitted(self, message: FocusPane.ApprovalSubmitted):
+        """Dispatches a tool approval to the backend model."""
+        self.store.clear_pending_approval(message.agent_name)
+        await self.team.post_tool_execution_approval(
+            agent_name=message.agent_name,
+            tool_invocation_id=message.invocation_id,
+            is_approved=message.is_approved,
+            reason=message.reason,
+        )

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