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

autobyteus/cli/agent_team_tui/widgets/logo.py

@@ -0,0 +1,20 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/widgets/logo.py
+"""
+Defines a widget to display the AutoByteus ASCII art logo and tagline.
+"""
+from rich.text import Text
+from textual.widgets import Static
+from textual.containers import Vertical
+
+class Logo(Vertical):
+    """A widget to display the AutoByteus logo and tagline."""
+
+    def compose(self) -> None:
+        # A simple, clean, single-line text logo that is more readable
+        # and respects that "AutoByteus" is one word.
+        logo_text = Text(justify="center")
+        logo_text.append("Auto", style="bold cyan")
+        logo_text.append("Byteus", style="bold magenta")
+        
+        yield Static(logo_text, classes="logo-art")
+        yield Static("Orchestrating AI Agent Teams.", classes="logo-tagline")

autobyteus/cli/agent_team_tui/widgets/renderables.py

@@ -0,0 +1,77 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/widgets/renderables.py
+"""
+Contains pure functions that convert agent event data into Rich renderables for the FocusPane.
+This separates presentation logic from the view logic of the widget itself.
+"""
+import json
+from typing import Optional
+
+from rich.text import Text
+from rich.panel import Panel
+
+from autobyteus.agent.streaming.stream_event_payloads import (
+    AgentOperationalPhaseTransitionData, AssistantCompleteResponseData,
+    ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData,
+    ToolInvocationAutoExecutingData, SystemTaskNotificationData
+)
+from .shared import ASSISTANT_ICON, TOOL_ICON, PROMPT_ICON, ERROR_ICON, LOG_ICON, SYSTEM_TASK_ICON
+
+def render_assistant_complete_response(data: AssistantCompleteResponseData) -> list[Text | Panel]:
+    """Renders a complete, pre-aggregated assistant response."""
+    renderables = []
+    if data.reasoning:
+        reasoning_text = Text("<Thinking>\n", style="dim italic cyan")
+        reasoning_text.append(data.reasoning)
+        reasoning_text.append("\n</Thinking>", style="dim italic cyan")
+        renderables.append(reasoning_text)
+    
+    if data.content:
+        content_text = Text()
+        content_text.append(f"{ASSISTANT_ICON} assistant: ", style="bold green")
+        content_text.append(data.content)
+        renderables.append(content_text)
+    
+    return renderables
+
+def render_tool_interaction_log(data: ToolInteractionLogEntryData) -> Text:
+    """Renders a tool interaction log entry."""
+    return Text(f"{LOG_ICON} [tool-log] {data.log_entry}", style="dim")
+
+def render_tool_auto_executing(data: ToolInvocationAutoExecutingData) -> Text:
+    """Renders a notification that a tool is being executed automatically."""
+    try:
+        args_str = json.dumps(data.arguments, indent=2)
+    except (TypeError, OverflowError):
+        args_str = str(data.arguments)
+        
+    text_content = Text(f"{TOOL_ICON} Executing tool '", style="default")
+    text_content.append(f"{data.tool_name}", style="bold yellow")
+    text_content.append("' with arguments:\n", style="default")
+    text_content.append(args_str, style="yellow")
+    return text_content
+    
+def render_tool_approval_request(data: ToolInvocationApprovalRequestedData) -> Text:
+    """Renders a prompt for the user to approve a tool call."""
+    try:
+        args_str = json.dumps(data.arguments, indent=2)
+    except (TypeError, OverflowError):
+        args_str = str(data.arguments)
+
+    text_content = Text(f"{PROMPT_ICON} Requesting approval for tool '", style="default")
+    text_content.append(f"{data.tool_name}", style="bold yellow")
+    text_content.append("' with arguments:\n", style="default")
+    text_content.append(args_str, style="yellow")
+    return text_content
+
+def render_error(data: ErrorEventData) -> Text:
+    """Renders an error event."""
+    error_text = f"Error from {data.source}: {data.message}"
+    if data.details: 
+        error_text += f"\nDetails: {data.details}"
+    return Text(f"{ERROR_ICON} {error_text}", style="bold red")
+
+def render_system_task_notification(data: SystemTaskNotificationData) -> Text:
+    """Renders a system-generated task notification."""
+    text_content = Text(f"{SYSTEM_TASK_ICON} System Task Notification: ", style="bold magenta")
+    text_content.append(data.content, style="magenta")
+    return text_content

autobyteus/cli/agent_team_tui/widgets/shared.py

@@ -0,0 +1,60 @@
+"""
+Shared constants and data for TUI widgets.
+"""
+from typing import Dict
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.task_management.base_task_board import TaskStatus
+
+AGENT_PHASE_ICONS: Dict[AgentOperationalPhase, str] = {
+    AgentOperationalPhase.UNINITIALIZED: "⚪",
+    AgentOperationalPhase.BOOTSTRAPPING: "⏳",
+    AgentOperationalPhase.IDLE: "🟢",
+    AgentOperationalPhase.PROCESSING_USER_INPUT: "💭",
+    AgentOperationalPhase.AWAITING_LLM_RESPONSE: "💭",
+    AgentOperationalPhase.ANALYZING_LLM_RESPONSE: "🤔",
+    AgentOperationalPhase.AWAITING_TOOL_APPROVAL: "❓",
+    AgentOperationalPhase.TOOL_DENIED: "❌",
+    AgentOperationalPhase.EXECUTING_TOOL: "🛠️",
+    AgentOperationalPhase.PROCESSING_TOOL_RESULT: "⚙️",
+    AgentOperationalPhase.SHUTTING_DOWN: "🌙",
+    AgentOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
+    AgentOperationalPhase.ERROR: "❗",
+}
+
+TEAM_PHASE_ICONS: Dict[AgentTeamOperationalPhase, str] = {
+    AgentTeamOperationalPhase.UNINITIALIZED: "⚪",
+    AgentTeamOperationalPhase.BOOTSTRAPPING: "⏳",
+    AgentTeamOperationalPhase.IDLE: "🟢",
+    AgentTeamOperationalPhase.PROCESSING: "⚙️",
+    AgentTeamOperationalPhase.SHUTTING_DOWN: "🌙",
+    AgentTeamOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
+    AgentTeamOperationalPhase.ERROR: "❗",
+}
+
+TASK_STATUS_ICONS: Dict[TaskStatus, str] = {
+    TaskStatus.NOT_STARTED: "⚪",
+    TaskStatus.IN_PROGRESS: "⏳",
+    TaskStatus.COMPLETED: "✅",
+    TaskStatus.FAILED: "❌",
+    TaskStatus.BLOCKED: "🔒",
+}
+
+# Main component icons
+SUB_TEAM_ICON = "📂"
+TEAM_ICON = "🏁"
+AGENT_ICON = "🤖"
+
+# General UI icons
+SPEAKING_ICON = "🔊"
+DEFAULT_ICON = "❓"
+
+# Semantic icons for log entries
+USER_ICON = "👤"
+ASSISTANT_ICON = "🤖"
+TOOL_ICON = "🛠️"
+PROMPT_ICON = "❓"
+ERROR_ICON = "💥"
+PHASE_ICON = "🔄"
+LOG_ICON = "📄"
+SYSTEM_TASK_ICON = "📥" # NEW

autobyteus/cli/agent_team_tui/widgets/status_bar.py

@@ -0,0 +1,14 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/widgets/status_bar.py
+"""
+Defines the status bar widget for the TUI.
+"""
+
+from textual.widgets import Footer
+
+class StatusBar(Footer):
+    """A simple footer widget that displays key bindings."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        # This will be automatically populated by Textual's binding system.
+        # You can add more status information here if needed in the future.

autobyteus/cli/agent_team_tui/widgets/task_board_panel.py

@@ -0,0 +1,82 @@
+import logging
+from typing import List, Optional, Dict, Union
+
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from textual.widgets import Static
+
+from autobyteus.task_management.task_plan import Task
+from autobyteus.task_management.base_task_board import TaskStatus
+from .shared import TASK_STATUS_ICONS, LOG_ICON
+
+logger = logging.getLogger(__name__)
+
+class TaskBoardPanel(Static):
+    """A widget to display the team's task board."""
+
+    def __init__(self, tasks: Optional[List[Task]], statuses: Dict[str, TaskStatus], team_name: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.tasks = tasks or []
+        self.statuses = statuses or {}
+        self.team_name = team_name
+
+    def compose(self) -> None:
+        if not self.tasks:
+            yield Static(Panel("No task plan has been published yet.", title="Task Board", border_style="yellow", title_align="left"))
+            return
+
+        table = Table(
+            expand=True,
+            show_header=True,
+            header_style="bold magenta",
+            show_lines=True
+        )
+        table.add_column("ID", justify="left", style="cyan", no_wrap=True, min_width=10)
+        table.add_column("Name", style="white", min_width=15)
+        table.add_column("Status", justify="left", style="white")
+        table.add_column("Assigned To", justify="center", style="green")
+        table.add_column("Deliverables", justify="left", style="cyan", min_width=30)
+        table.add_column("Depends On", justify="center", style="dim")
+
+        # Create a name-to-ID map to resolve dependency names
+        id_to_name_map = {task.task_id: task.task_name for task in self.tasks}
+        
+        # Sort tasks by name for consistent ordering
+        sorted_tasks = sorted(self.tasks, key=lambda t: t.task_name)
+
+        for task in sorted_tasks:
+            task_status = self.statuses.get(task.task_id, TaskStatus.NOT_STARTED)
+            status_icon = TASK_STATUS_ICONS.get(task_status, "❓")
+            status_text = f"{status_icon} {task_status.value.upper().replace('_', ' ')}"
+            
+            status_style = "default"
+            if task_status == TaskStatus.COMPLETED:
+                status_style = "strike dim green"
+            elif task_status == TaskStatus.FAILED:
+                status_style = "bold red"
+            
+            # Create a renderable for the deliverables column
+            deliverables_renderable: Union[str, Text] = "N/A"
+            if task.file_deliverables:
+                text = Text()
+                for i, d in enumerate(task.file_deliverables):
+                    if i > 0:
+                        text.append("\n") # Add a newline for spacing between deliverables
+                    text.append(f"{LOG_ICON} {d.file_path}\n", style="bold")
+                    text.append(f"   └─ {d.summary}", style="dim")
+                deliverables_renderable = text
+
+            # Resolve dependency IDs to names for display
+            dep_names = [id_to_name_map.get(dep_id, dep_id) for dep_id in task.dependencies]
+
+            table.add_row(
+                task.task_id,
+                task.task_name,
+                Text(status_text, style=status_style),
+                task.assignee_name or "N/A",
+                deliverables_renderable,
+                ", ".join(dep_names)
+            )
+
+        yield Static(Panel(table, title="Task Board", border_style="blue", title_align="left"))

autobyteus/cli/cli_display.py

@@ -4,7 +4,7 @@ import sys
 from typing import Optional, List, Dict, Any
 import json 
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases.phase_enum import AgentOperationalPhase
 from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
     AssistantChunkData,

autobyteus/cli/workflow_tui/__init__.py

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

autobyteus/cli/workflow_tui/app.py

@@ -0,0 +1,210 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/app.py
+"""
+The main Textual application class for the workflow 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.workflow.agentic_workflow import AgenticWorkflow
+from autobyteus.workflow.streaming.workflow_event_stream import WorkflowEventStream
+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.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, WorkflowPhaseTransitionData
+
+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 WorkflowApp(App):
+    """A Textual TUI for interacting with an agentic workflow, 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, workflow: AgenticWorkflow, **kwargs):
+        super().__init__(**kwargs)
+        self.workflow = workflow
+        self.store = TUIStateStore(workflow=self.workflow)
+        self.workflow_stream: Optional[WorkflowEventStream] = 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.workflow.start()
+        self.workflow_stream = WorkflowEventStream(self.workflow)
+        
+        # Initialize the UI with the starting state
+        initial_tree = self.store.get_tree_data()
+        initial_focus_node = initial_tree.get(self.workflow.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_workflow_events(), name="workflow_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("Workflow TUI mounted, workflow listener and throttled UI updater started.")
+
+    async def on_unmount(self) -> None:
+        if self.workflow and self.workflow.is_running:
+            await self.workflow.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_workflow_events(self) -> None:
+        """A background worker that forwards workflow events to the state store and updates the UI."""
+        if not self.workflow_stream: return
+        try:
+            async for event in self.workflow_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.
+                # This is for components like the FocusPane's text stream, which needs
+                # to be as low-latency as possible. The actual UI update is buffered.
+                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 the event is for the currently focused agent, send the event
+                    # to be buffered and eventually rendered.
+                    if is_currently_focused:
+                        await focus_pane.add_agent_event(agent_event)
+
+        except asyncio.CancelledError:
+            logger.info("Workflow event listener task was cancelled.")
+        except Exception:
+            logger.error("Critical error in workflow TUI event listener", exc_info=True)
+        finally:
+            if self.workflow_stream: await self.workflow_stream.close()
+
+    # --- Reactive Watchers ---
+
+    async def watch_store_version(self, new_version: int):
+        """
+        Reacts to changes in the store version. This is now called by the throttled
+        updater, not on every event. Its main job is to update less-frequently
+        changing components like the sidebar tree and workflow dashboards.
+        """
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+
+        # Fetch fresh data from the store for the update
+        tree_data = self.store.get_tree_data()
+        agent_phases = self.store._agent_phases
+        workflow_phases = self.store._workflow_phases
+        speaking_agents = self.store._speaking_agents
+        
+        # Update sidebar
+        sidebar.update_tree(tree_data, agent_phases, workflow_phases, speaking_agents)
+        
+        # Intelligently update the focus pane
+        focused_data = self.focused_node_data
+        if focused_data and focused_data.get("type") in ['workflow', 'subworkflow']:
+            # If a workflow/subworkflow is focused, its dashboard might be out of date.
+            # A full re-render is cheap and ensures consistency for its title and panels.
+            history = self.store.get_history_for_node(focused_data['name'], focused_data['type'])
+            await focus_pane.update_content(
+                node_data=focused_data,
+                history=history,
+                pending_approval=None,
+                all_agent_phases=agent_phases,
+                all_workflow_phases=workflow_phases
+            )
+        elif focused_data and focused_data.get("type") == 'agent':
+            # For agents, we only need to update the title status, not the whole log.
+            focus_pane.update_current_node_status(agent_phases, workflow_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
+        
+        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_workflow_phases=self.store._workflow_phases
+        )
+        
+        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.workflow.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.workflow.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/workflow_tui/state.py

@@ -0,0 +1,189 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/state.py
+"""
+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.workflow.agentic_workflow import AgenticWorkflow
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.workflow.phases import WorkflowOperationalPhase
+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.workflow.streaming.workflow_stream_events import WorkflowStreamEvent
+from autobyteus.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload, WorkflowPhaseTransitionData
+
+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. This is a plain
+    Python class and does not use Textual reactive properties.
+    """
+
+    def __init__(self, workflow: AgenticWorkflow):
+        self.workflow_name = workflow.name
+        self.workflow_role = workflow.role
+        
+        self.focused_node_data: Optional[Dict[str, Any]] = None
+        
+        self._node_roles: Dict[str, str] = self._extract_node_roles(workflow)
+        self._nodes: Dict[str, Any] = self._initialize_root_node()
+        self._agent_phases: Dict[str, AgentOperationalPhase] = {}
+        self._workflow_phases: Dict[str, WorkflowOperationalPhase] = {self.workflow_name: WorkflowOperationalPhase.UNINITIALIZED}
+        self._agent_event_history: Dict[str, List[AgentStreamEvent]] = {}
+        self._workflow_event_history: Dict[str, List[WorkflowStreamEvent]] = {self.workflow_name: []}
+        self._pending_approvals: Dict[str, ToolInvocationApprovalRequestedData] = {}
+        self._speaking_agents: Dict[str, bool] = {}
+        
+        # REMOVED: The complex stream aggregator is the source of the bug.
+        # self._agent_stream_aggregators: Dict[str, Dict[str, str]] = {}
+
+        # Version counter to signal state changes to the UI
+        self.version = 0
+
+    def _extract_node_roles(self, workflow: AgenticWorkflow) -> Dict[str, str]:
+        """Builds a map of node names to their defined roles from the config."""
+        roles = {}
+        if workflow._runtime and workflow._runtime.context and workflow._runtime.context.config:
+            for node_config in workflow._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]:
+        """Creates the initial root node for the state tree."""
+        return {
+            self.workflow_name: {
+                "type": "workflow",
+                "name": self.workflow_name,
+                "role": self.workflow_role,
+                "children": {}
+            }
+        }
+
+    def process_event(self, event: WorkflowStreamEvent):
+        """
+        The main entry point for processing events from the backend.
+        This method acts as a reducer, updating the state based on the event.
+        """
+        if event.event_source_type == "WORKFLOW" and isinstance(event.data, WorkflowPhaseTransitionData):
+            self._workflow_phases[self.workflow_name] = event.data.new_phase
+        
+        self._process_event_recursively(event, self.workflow_name)
+        
+        # Increment version to signal that the state has changed.
+        self.version += 1
+
+    # REMOVED: The flush aggregator logic is no longer needed.
+    # def _flush_aggregator_for_agent(self, agent_name: str): ...
+
+    def _process_event_recursively(self, event: WorkflowStreamEvent, parent_name: str):
+        """Recursively processes events to build up the state tree."""
+        if parent_name not in self._workflow_event_history:
+            self._workflow_event_history[parent_name] = []
+        self._workflow_event_history[parent_name].append(event)
+
+        # AGENT EVENT (LEAF NODE)
+        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 in state tree.")
+
+            # SIMPLIFIED LOGIC: Always append the event to the history, regardless of focus.
+            # This ensures the history is always a complete and accurate log of what happened.
+            self._agent_event_history[agent_name].append(agent_event)
+
+            # --- State update logic for specific events (applies to both focused and non-focused) ---
+            if agent_event.event_type == AgentStreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION:
+                phase_data: AgentOperationalPhaseTransitionData = agent_event.data
+                self._agent_phases[agent_name] = phase_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
+
+        # SUB-WORKFLOW EVENT (BRANCH NODE)
+        elif isinstance(event.data, SubWorkflowEventRebroadcastPayload):
+            payload = event.data
+            sub_workflow_name = payload.sub_workflow_node_name
+            sub_workflow_event = payload.sub_workflow_event
+            
+            sub_workflow_node = self._find_node(sub_workflow_name)
+            if not sub_workflow_node:
+                role = self._node_roles.get(sub_workflow_name, "Sub-Workflow")
+                self._add_node(sub_workflow_name, {"type": "subworkflow", "name": sub_workflow_name, "role": role, "children": {}}, parent_name)
+
+            if sub_workflow_event.event_source_type == "WORKFLOW" and isinstance(sub_workflow_event.data, WorkflowPhaseTransitionData):
+                self._workflow_phases[sub_workflow_name] = sub_workflow_event.data.new_phase
+
+            self._process_event_recursively(sub_workflow_event, parent_name=sub_workflow_name)
+
+    def _add_node(self, node_name: str, node_data: Dict, parent_name: str):
+        """Adds a node to the state tree under a specific parent."""
+        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]:
+        """Recursively finds a node by name in the state tree."""
+        if tree is None:
+            tree = 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:
+        """Constructs a serializable representation of the tree for the sidebar."""
+        return copy.deepcopy(self._nodes)
+    
+    def get_history_for_node(self, node_name: str, node_type: str) -> List:
+        """Retrieves the event history for a given node."""
+        if node_type == 'agent':
+            # REMOVED: Flushing is no longer necessary as the history is always complete.
+            return self._agent_event_history.get(node_name, [])
+        elif node_type in ['workflow', 'subworkflow']:
+            return []
+        return []
+        
+    def get_pending_approval_for_agent(self, agent_name: str) -> Optional[ToolInvocationApprovalRequestedData]:
+        """Gets pending approval data for a specific agent."""
+        return self._pending_approvals.get(agent_name)
+
+    def clear_pending_approval(self, agent_name: str):
+        """Clears a pending approval after it's been handled."""
+        if agent_name in self._pending_approvals:
+            del self._pending_approvals[agent_name]
+    
+    def set_focused_node(self, node_data: Optional[Dict[str, Any]]):
+        """Sets the currently focused node in the state."""
+        # REMOVED: Flushing logic is no longer needed here.
+        self.focused_node_data = node_data