autobyteus 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

autobyteus/cli/cli_display.py

@@ -1,20 +1,22 @@
 import asyncio
 import logging
 import sys
-from typing import Optional, List, Dict, Any
+from typing import Optional
 import json 
 
-from autobyteus.agent.phases.phase_enum import AgentOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
 from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
     AssistantChunkData,
     AssistantCompleteResponseData,
     ToolInvocationApprovalRequestedData,
     ToolInteractionLogEntryData,
-    AgentOperationalPhaseTransitionData,
+    AgentStatusUpdateData,
     ErrorEventData,
     ToolInvocationAutoExecutingData,
+    SegmentEventData,
 )
+from autobyteus.agent.streaming.parser.events import SegmentEventType, SegmentType
 
 logger = logging.getLogger(__name__) 
 
@@ -30,14 +32,21 @@ class InteractiveCLIDisplay:
         self.current_line_empty = True
         self.agent_has_spoken_this_turn = False
         self.pending_approval_data: Optional[ToolInvocationApprovalRequestedData] = None
+        self.approval_prompt_shown: bool = False
+        self.current_status: Optional[AgentStatus] = None
+        self.awaiting_approval: bool = False
         self.is_thinking = False
         self.is_in_content_block = False
+        self._segment_types_by_id = {}
+        self._saw_segment_event = False
 
     def reset_turn_state(self):
         """Resets flags that are tracked on a per-turn basis."""
         self._end_thinking_block()
         self.agent_has_spoken_this_turn = False
         self.is_in_content_block = False
+        self._segment_types_by_id.clear()
+        self._saw_segment_event = False
 
     def _ensure_new_line(self):
         """Ensures the cursor is on a new line if the current one isn't empty."""
@@ -54,10 +63,148 @@ class InteractiveCLIDisplay:
             self.is_thinking = False
             self.current_line_empty = False
 
-    def _display_tool_approval_prompt(self):
-        """Displays the tool approval prompt using stored pending data."""
-        if not self.pending_approval_data:
+    def _ensure_agent_prefix(self):
+        """Prints the Agent prefix once per turn."""
+        if not self.agent_has_spoken_this_turn:
+            self._ensure_new_line()
+            sys.stdout.write("Agent:\n")
+            sys.stdout.flush()
+            self.agent_has_spoken_this_turn = True
+            self.current_line_empty = True
+
+    def _handle_segment_event(self, segment_event: SegmentEventData):
+        """Render segment events emitted by the streaming parser."""
+        try:
+            event_type = SegmentEventType(segment_event.event_type)
+        except ValueError:
+            logger.debug(f"CLI Display: Unknown segment event type '{segment_event.event_type}'.")
+            return
+
+        self._saw_segment_event = True
+
+        segment_type = None
+        if segment_event.segment_type:
+            try:
+                segment_type = SegmentType(segment_event.segment_type)
+            except ValueError:
+                logger.debug(f"CLI Display: Unknown segment type '{segment_event.segment_type}'.")
+
+        if segment_type is None and segment_event.segment_id in self._segment_types_by_id:
+            segment_type = self._segment_types_by_id.get(segment_event.segment_id)
+
+        metadata = {}
+        if isinstance(segment_event.payload, dict):
+            metadata = segment_event.payload.get("metadata", {}) or {}
+
+        if event_type == SegmentEventType.START:
+            if segment_type is not None:
+                self._segment_types_by_id[segment_event.segment_id] = segment_type
+
+            if segment_type != SegmentType.REASONING:
+                self._end_thinking_block()
+
+            self._ensure_agent_prefix()
+
+            if segment_type == SegmentType.REASONING:
+                if not self.is_thinking:
+                    sys.stdout.write("<Thinking>\n")
+                    sys.stdout.flush()
+                    self.is_thinking = True
+                    self.current_line_empty = True
+                return
+
+            if segment_type == SegmentType.WRITE_FILE:
+                path = metadata.get("path", "")
+                header = f"<write_file path=\"{path}\">" if path else "<write_file>"
+                sys.stdout.write(f"{header}\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = True
+                return
+
+            if segment_type == SegmentType.RUN_BASH:
+                sys.stdout.write("<run_bash>\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = True
+                return
+
+            if segment_type == SegmentType.TOOL_CALL:
+                tool_name = metadata.get("tool_name", "")
+                header = f"<tool name=\"{tool_name}\">" if tool_name else "<tool>"
+                sys.stdout.write(f"{header}\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = True
+                return
+
+            # Text segment start does not need a visible marker.
+            self.is_in_content_block = True
+            return
+
+        if event_type == SegmentEventType.CONTENT:
+            if segment_type == SegmentType.REASONING:
+                if not self.is_thinking:
+                    self._ensure_agent_prefix()
+                    sys.stdout.write("<Thinking>\n")
+                    sys.stdout.flush()
+                    self.is_thinking = True
+                delta = segment_event.payload.get("delta", "")
+                sys.stdout.write(str(delta))
+                sys.stdout.flush()
+                self.current_line_empty = str(delta).endswith("\n")
+                return
+
+            delta = segment_event.payload.get("delta", "")
+            if delta:
+                self._ensure_agent_prefix()
+                sys.stdout.write(str(delta))
+                sys.stdout.flush()
+                self.current_line_empty = str(delta).endswith("\n")
+                self.is_in_content_block = True
             return
+
+        if event_type == SegmentEventType.END:
+            if segment_type == SegmentType.REASONING:
+                self._end_thinking_block()
+                self._segment_types_by_id.pop(segment_event.segment_id, None)
+                return
+
+            if segment_type == SegmentType.WRITE_FILE:
+                sys.stdout.write("\n</write_file>\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = False
+                self._segment_types_by_id.pop(segment_event.segment_id, None)
+                return
+
+            if segment_type == SegmentType.RUN_BASH:
+                sys.stdout.write("\n</run_bash>\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = False
+                self._segment_types_by_id.pop(segment_event.segment_id, None)
+                return
+
+            if segment_type == SegmentType.TOOL_CALL:
+                sys.stdout.write("\n</tool>\n")
+                sys.stdout.flush()
+                self.current_line_empty = True
+                self.is_in_content_block = False
+                self._segment_types_by_id.pop(segment_event.segment_id, None)
+                return
+
+            if segment_type == SegmentType.TEXT:
+                self.is_in_content_block = False
+                self._segment_types_by_id.pop(segment_event.segment_id, None)
+                return
+
+            self._segment_types_by_id.pop(segment_event.segment_id, None)
+
+    def get_approval_prompt(self) -> Optional[str]:
+        """Returns the tool approval prompt string using stored pending data."""
+        if not self.pending_approval_data:
+            return None
             
         try:
             args_str = json.dumps(self.pending_approval_data.arguments, indent=2)
@@ -69,31 +216,17 @@ class InteractiveCLIDisplay:
             f"Tool Call: '{self.pending_approval_data.tool_name}' requests permission to run with arguments:\n"
             f"{args_str}\nApprove? (y/n): "
         )
-        sys.stdout.write(prompt_message)
-        sys.stdout.flush()
-        self.current_line_empty = False
+        return prompt_message
+
+    def clear_pending_approval(self):
+        self.pending_approval_data = None
+        self.approval_prompt_shown = False
 
     async def handle_stream_event(self, event: StreamEvent):
         """Processes a single StreamEvent and updates the CLI display."""
-        # A block of thinking ends if any event other than a reasoning chunk arrives.
-        is_reasoning_only_chunk = (
-            event.event_type == StreamEventType.ASSISTANT_CHUNK and
-            isinstance(event.data, AssistantChunkData) and
-            bool(event.data.reasoning) and not bool(event.data.content)
-        )
-        if not is_reasoning_only_chunk:
-            self._end_thinking_block()
-
-        # Most events should start on a new line.
-        if event.event_type != StreamEventType.ASSISTANT_CHUNK:
-            self._ensure_new_line()
-
-        if event.event_type in [
-            StreamEventType.AGENT_IDLE,
-            StreamEventType.ERROR_EVENT,
-            StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED,
-        ]:
-            self.agent_turn_complete_event.set()
+        if event.event_type == StreamEventType.SEGMENT_EVENT and isinstance(event.data, SegmentEventData):
+            self._handle_segment_event(event.data)
+            return
 
         if event.event_type == StreamEventType.ASSISTANT_CHUNK and isinstance(event.data, AssistantChunkData):
             # If this is the first output from the agent this turn, print the "Agent: " prefix.
@@ -110,7 +243,7 @@ class InteractiveCLIDisplay:
                     sys.stdout.write("<Thinking>\n")
                     sys.stdout.flush()
                     self.is_thinking = True
-                    self.current_line_empty = True # We just printed a newline
+                    self.current_line_empty = True
                 
                 sys.stdout.write(event.data.reasoning)
                 sys.stdout.flush()
@@ -119,7 +252,7 @@ class InteractiveCLIDisplay:
             # Stream content to stdout.
             if event.data.content:
                 if not self.is_in_content_block:
-                    self._ensure_new_line() # Ensures content starts on a new line after </Thinking>
+                    self._ensure_new_line()
                     self.is_in_content_block = True
                 sys.stdout.write(event.data.content)
                 sys.stdout.flush()
@@ -132,11 +265,15 @@ class InteractiveCLIDisplay:
                     f"[Token Usage: Prompt={usage.prompt_tokens}, "
                     f"Completion={usage.completion_tokens}, Total={usage.total_tokens}]"
                 )
+            return
 
-        elif event.event_type == StreamEventType.ASSISTANT_COMPLETE_RESPONSE and isinstance(event.data, AssistantCompleteResponseData):
+        self._end_thinking_block()
+        self._ensure_new_line()
+
+        if event.event_type == StreamEventType.ASSISTANT_COMPLETE_RESPONSE and isinstance(event.data, AssistantCompleteResponseData):
             # The reasoning has already been streamed. Do not log it again.
             
-            if not self.agent_has_spoken_this_turn:
+            if not self._saw_segment_event and not self.agent_has_spoken_this_turn:
                 # This case handles responses that might not have streamed any content chunks (e.g., only a tool call).
                 # We still need to ensure the agent's turn is visibly terminated with a newline.
                 self._ensure_new_line()
@@ -159,7 +296,8 @@ class InteractiveCLIDisplay:
 
         elif event.event_type == StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED and isinstance(event.data, ToolInvocationApprovalRequestedData):
             self.pending_approval_data = event.data
-            self._display_tool_approval_prompt()
+            if self.awaiting_approval or self.current_status == AgentStatus.AWAITING_TOOL_APPROVAL:
+                self.agent_turn_complete_event.set()
 
         elif event.event_type == StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING and isinstance(event.data, ToolInvocationAutoExecutingData):
             tool_name = event.data.tool_name
@@ -175,30 +313,41 @@ class InteractiveCLIDisplay:
                     f"[Tool Log ({event.data.tool_name} | {event.data.tool_invocation_id})]: {event.data.log_entry}"
                 )
 
-        elif event.event_type == StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION and isinstance(event.data, AgentOperationalPhaseTransitionData):
-            if event.data.new_phase == AgentOperationalPhase.EXECUTING_TOOL:
+        elif event.event_type == StreamEventType.AGENT_STATUS_UPDATED and isinstance(event.data, AgentStatusUpdateData):
+            self.current_status = event.data.new_status
+            if event.data.new_status == AgentStatus.AWAITING_TOOL_APPROVAL:
+                self.awaiting_approval = True
+                if self.pending_approval_data:
+                    self.agent_turn_complete_event.set()
+            else:
+                self.awaiting_approval = False
+
+            if event.data.new_status in {AgentStatus.IDLE, AgentStatus.ERROR}:
+                self.agent_turn_complete_event.set()
+
+            if event.data.new_status == AgentStatus.EXECUTING_TOOL:
                 tool_name = event.data.tool_name or "a tool"
                 sys.stdout.write(f"Agent: Waiting for tool '{tool_name}' to complete...\n")
                 sys.stdout.flush()
                 self.current_line_empty = True
                 self.agent_has_spoken_this_turn = True
-            elif event.data.new_phase == AgentOperationalPhase.BOOTSTRAPPING:
+            elif event.data.new_status == AgentStatus.IDLE:
+                logger.info("[Agent is now idle.]")
+            elif event.data.new_status == AgentStatus.BOOTSTRAPPING:
                 logger.info("[Agent is initializing...]")
-            elif event.data.new_phase == AgentOperationalPhase.TOOL_DENIED:
+            elif event.data.new_status == AgentStatus.TOOL_DENIED:
                 tool_name = event.data.tool_name or "a tool"
                 logger.info(f"[Tool '{tool_name}' was denied by user. Agent is reconsidering.]")
             else:
-                phase_msg = f"[Agent Status: {event.data.new_phase.value}"
+                status_msg = f"[Agent Status: {event.data.new_status.value}"
                 if event.data.tool_name:
-                    phase_msg += f" ({event.data.tool_name})"
-                phase_msg += "]"
-                logger.info(phase_msg)
+                    status_msg += f" ({event.data.tool_name})"
+                status_msg += "]"
+                logger.info(status_msg)
 
         elif event.event_type == StreamEventType.ERROR_EVENT and isinstance(event.data, ErrorEventData):
             logger.error(f"[Error: {event.data.message} (Source: {event.data.source})]")
-
-        elif event.event_type == StreamEventType.AGENT_IDLE:
-            logger.info("[Agent is now idle.]")
+            self.agent_turn_complete_event.set()
         
         else:
             # Add logging for unhandled events for better debugging

autobyteus/cli/workflow_tui/app.py

@@ -16,8 +16,7 @@ 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 autobyteus.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload
 
 from .state import TUIStateStore
 from .widgets.agent_list_sidebar import AgentListSidebar
@@ -139,12 +138,12 @@ class WorkflowApp(App):
 
         # 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
+        agent_statuses = self.store._agent_statuses
+        workflow_statuses = self.store._workflow_statuses
         speaking_agents = self.store._speaking_agents
         
         # Update sidebar
-        sidebar.update_tree(tree_data, agent_phases, workflow_phases, speaking_agents)
+        sidebar.update_tree(tree_data, agent_statuses, workflow_statuses, speaking_agents)
         
         # Intelligently update the focus pane
         focused_data = self.focused_node_data
@@ -156,12 +155,12 @@ class WorkflowApp(App):
                 node_data=focused_data,
                 history=history,
                 pending_approval=None,
-                all_agent_phases=agent_phases,
-                all_workflow_phases=workflow_phases
+                all_agent_statuses=agent_statuses,
+                all_workflow_statuses=workflow_statuses
             )
         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)
+            focus_pane.update_current_node_status(agent_statuses, workflow_statuses)
 
 
     async def watch_focused_node_data(self, new_node_data: Optional[Dict[str, Any]]):
@@ -181,8 +180,8 @@ class WorkflowApp(App):
             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
+            all_agent_statuses=self.store._agent_statuses,
+            all_workflow_statuses=self.store._workflow_statuses
         )
         
         sidebar.update_selection(node_name)

autobyteus/cli/workflow_tui/state.py

@@ -8,15 +8,15 @@ 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.status.status_enum import AgentStatus
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 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
+    AgentStatusUpdateData, ToolInvocationApprovalRequestedData, 
+    AssistantCompleteResponseData
 )
 from autobyteus.workflow.streaming.workflow_stream_events import WorkflowStreamEvent
-from autobyteus.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload, WorkflowPhaseTransitionData
+from autobyteus.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload, WorkflowStatusUpdateData
 
 logger = logging.getLogger(__name__)
 
@@ -38,8 +38,8 @@ class TUIStateStore:
         
         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_statuses: Dict[str, AgentStatus] = {}
+        self._workflow_statuses: Dict[str, WorkflowStatus] = {self.workflow_name: WorkflowStatus.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] = {}
@@ -77,8 +77,8 @@ class TUIStateStore:
         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
+        if event.event_source_type == "WORKFLOW" and isinstance(event.data, WorkflowStatusUpdateData):
+            self._workflow_statuses[self.workflow_name] = event.data.new_status
         
         self._process_event_recursively(event, self.workflow_name)
         
@@ -113,13 +113,11 @@ class TUIStateStore:
             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_event.event_type == AgentStreamEventType.AGENT_STATUS_UPDATED:
+                status_data: AgentStatusUpdateData = agent_event.data
+                self._agent_statuses[agent_name] = status_data.new_status
                 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
 
@@ -134,8 +132,8 @@ class TUIStateStore:
                 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
+            if sub_workflow_event.event_source_type == "WORKFLOW" and isinstance(sub_workflow_event.data, WorkflowStatusUpdateData):
+                self._workflow_statuses[sub_workflow_name] = sub_workflow_event.data.new_status
 
             self._process_event_recursively(sub_workflow_event, parent_name=sub_workflow_name)
 

autobyteus/cli/workflow_tui/widgets/agent_list_sidebar.py

@@ -10,10 +10,10 @@ 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.workflow.phases import WorkflowOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 from .shared import (
-    AGENT_PHASE_ICONS, WORKFLOW_PHASE_ICONS, SUB_WORKFLOW_ICON, 
+    AGENT_STATUS_ICONS, WORKFLOW_STATUS_ICONS, SUB_WORKFLOW_ICON, 
     WORKFLOW_ICON, SPEAKING_ICON, DEFAULT_ICON
 )
 from .logo import Logo
@@ -45,19 +45,19 @@ class AgentListSidebar(Static):
             self.post_message(self.NodeSelected(event.node.data))
         event.stop()
 
-    def _build_label(self, name: str, node_data: Dict, agent_phases: Dict, workflow_phases: Dict, speaking_agents: Dict) -> str:
+    def _build_label(self, name: str, node_data: Dict, agent_statuses: Dict, workflow_statuses: 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)
+            status = agent_statuses.get(name, AgentStatus.UNINITIALIZED)
+            icon = SPEAKING_ICON if speaking_agents.get(name) else AGENT_STATUS_ICONS.get(status, DEFAULT_ICON)
             label = f"{icon} {name}"
         elif node_type in ["workflow", "subworkflow"]:
-            phase = workflow_phases.get(name, WorkflowOperationalPhase.UNINITIALIZED)
+            status = workflow_statuses.get(name, WorkflowStatus.UNINITIALIZED)
             default_icon = WORKFLOW_ICON if node_type == "workflow" else SUB_WORKFLOW_ICON
-            icon = WORKFLOW_PHASE_ICONS.get(phase, default_icon)
+            icon = WORKFLOW_STATUS_ICONS.get(status, default_icon)
             role = node_data.get("role")
             label = f"{icon} {role or name}"
             if role and role != name:
@@ -67,7 +67,7 @@ class AgentListSidebar(Static):
             
         return label
 
-    def update_tree(self, tree_data: Dict, agent_phases: Dict[str, AgentOperationalPhase], workflow_phases: Dict[str, WorkflowOperationalPhase], speaking_agents: Dict[str, bool]):
+    def update_tree(self, tree_data: Dict, agent_statuses: Dict[str, AgentStatus], workflow_statuses: Dict[str, WorkflowStatus], 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.
@@ -82,17 +82,17 @@ class AgentListSidebar(Static):
         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, workflow_phases, speaking_agents)
+        self._update_node_recursively(tree.root, root_node_data, agent_statuses, workflow_statuses, 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, workflow_phases: Dict, speaking_agents: Dict):
+    def _update_node_recursively(self, ui_node: TreeNode, node_data: Dict, agent_statuses: Dict, workflow_statuses: 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, workflow_phases, speaking_agents)
+        label = self._build_label(name, node_data, agent_statuses, workflow_statuses, 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
@@ -106,10 +106,10 @@ class AgentListSidebar(Static):
             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, workflow_phases, speaking_agents)
+                self._update_node_recursively(child_ui_node, child_data, agent_statuses, workflow_statuses, speaking_agents)
             else:
                 # Node is new, so we add it
-                new_child_label = self._build_label(child_name, child_data, agent_phases, workflow_phases, speaking_agents)
+                new_child_label = self._build_label(child_name, child_data, agent_statuses, workflow_statuses, speaking_agents)
                 is_leaf = child_data.get("children", {}) == {} and child_data['type'] == 'agent'
                 
                 if is_leaf:
@@ -117,7 +117,7 @@ class AgentListSidebar(Static):
                 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, workflow_phases, speaking_agents)
+                    self._update_node_recursively(new_ui_node, child_data, agent_statuses, workflow_statuses, speaking_agents)
                 
                 self._node_map[child_name] = new_ui_node