autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/cli/agent_team_tui/state.py

@@ -7,18 +7,18 @@ 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.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 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.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.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamStatusUpdateData
 from autobyteus.task_management.task import Task
-from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.events import TasksCreatedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.base_task_plan import TaskStatus
 
 logger = logging.getLogger(__name__)
 
@@ -39,14 +39,14 @@ class TUIStateStore:
         
         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_statuses: Dict[str, AgentStatus] = {}
+        self._team_statuses: Dict[str, AgentTeamStatus] = {self.team_name: AgentTeamStatus.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
+        # State for task plans
         self._task_plans: Dict[str, List[Task]] = {} # team_name -> List[Task]
         self._task_statuses: Dict[str, Dict[str, TaskStatus]] = {} # team_name -> {task_id: status}
         
@@ -75,8 +75,8 @@ class TUIStateStore:
     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
+        if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamStatusUpdateData):
+            self._team_statuses[self.team_name] = event.data.new_status
         
         self._process_event_recursively(event, self.team_name)
 
@@ -85,15 +85,15 @@ class TUIStateStore:
             self._team_event_history[parent_name] = []
         self._team_event_history[parent_name].append(event)
         
-        if event.event_source_type == "TASK_BOARD":
+        if event.event_source_type == "TASK_PLAN":
             team_name_key = parent_name
-            if isinstance(event.data, TasksAddedEvent):
+            if isinstance(event.data, TasksCreatedEvent):
                 if team_name_key not in self._task_plans: self._task_plans[team_name_key] = []
                 if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
                 self._task_plans[team_name_key].extend(event.data.tasks)
                 for task in event.data.tasks:
                     self._task_statuses[team_name_key][task.task_id] = TaskStatus.NOT_STARTED
-                logger.debug(f"TUI State: Added {len(event.data.tasks)} tasks to board for '{team_name_key}'.")
+                logger.debug(f"TUI State: Created {len(event.data.tasks)} tasks in plan for '{team_name_key}'.")
 
             elif isinstance(event.data, TaskStatusUpdatedEvent):
                 if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
@@ -121,11 +121,9 @@ class TUIStateStore:
                 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_event.event_type == AgentStreamEventType.AGENT_STATUS_UPDATED:
+                self._agent_statuses[agent_name] = agent_event.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
 
@@ -136,8 +134,8 @@ class TUIStateStore:
             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
+            if sub_team_event.event_source_type == "TEAM" and isinstance(sub_team_event.data, AgentTeamStatusUpdateData):
+                self._team_statuses[sub_team_name] = sub_team_event.data.new_status
             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):
@@ -164,10 +162,10 @@ class TUIStateStore:
     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]]:
+    def get_task_plan_tasks(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]]:
+    def get_task_plan_statuses(self, team_name: str) -> Optional[Dict[str, TaskStatus]]:
         return self._task_statuses.get(team_name)
 
     def clear_pending_approval(self, agent_name: str):

autobyteus/cli/agent_team_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.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from .shared import (
-    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, 
+    AGENT_STATUS_ICONS, TEAM_STATUS_ICONS, SUB_TEAM_ICON,
     TEAM_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, team_phases: Dict, speaking_agents: Dict) -> str:
+    def _build_label(self, name: str, node_data: Dict, agent_statuses: Dict, team_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 ["team", "subteam"]:
-            phase = team_phases.get(name, AgentTeamOperationalPhase.UNINITIALIZED)
+            status = team_statuses.get(name, AgentTeamStatus.UNINITIALIZED)
             default_icon = TEAM_ICON if node_type == "team" else SUB_TEAM_ICON
-            icon = TEAM_PHASE_ICONS.get(phase, default_icon)
+            icon = TEAM_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], team_phases: Dict[str, AgentTeamOperationalPhase], speaking_agents: Dict[str, bool]):
+    def update_tree(self, tree_data: Dict, agent_statuses: Dict[str, AgentStatus], team_statuses: Dict[str, AgentTeamStatus], 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, team_phases, speaking_agents)
+        self._update_node_recursively(tree.root, root_node_data, agent_statuses, team_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, team_phases: Dict, speaking_agents: Dict):
+    def _update_node_recursively(self, ui_node: TreeNode, node_data: Dict, agent_statuses: Dict, team_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, team_phases, speaking_agents)
+        label = self._build_label(name, node_data, agent_statuses, team_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, team_phases, speaking_agents)
+                self._update_node_recursively(child_ui_node, child_data, agent_statuses, team_statuses, 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)
+                new_child_label = self._build_label(child_name, child_data, agent_statuses, team_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, team_phases, speaking_agents)
+                    self._update_node_recursively(new_ui_node, child_data, agent_statuses, team_statuses, speaking_agents)
                 
                 self._node_map[child_name] = new_ui_node
 

autobyteus/cli/agent_team_tui/widgets/focus_pane.py

@@ -12,22 +12,23 @@ 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.agent.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from autobyteus.task_management.task 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,
+    AgentStatusUpdateData, AssistantChunkData, AssistantCompleteResponseData,
     ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData,
-    SystemTaskNotificationData
+    SystemTaskNotificationData, SegmentEventData
 )
+from autobyteus.agent.streaming.parser.events import SegmentEventType, SegmentType
 from .shared import (
-    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, DEFAULT_ICON,
+    AGENT_STATUS_ICONS, TEAM_STATUS_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
+from .task_plan_panel import TaskPlanPanel
 
 logger = logging.getLogger(__name__)
 
@@ -65,6 +66,8 @@ class FocusPane(Static):
         # Buffers for batched UI updates to improve performance
         self._reasoning_buffer: str = ""
         self._content_buffer: str = ""
+        self._segment_types_by_id: Dict[str, SegmentType] = {}
+        self._saw_segment_event: bool = False
 
     def compose(self):
         yield Static("Select a node from the sidebar", id="focus-pane-title")
@@ -89,7 +92,15 @@ class FocusPane(Static):
             return
 
         is_approved = event.button.id == "approve-btn"
-        reason = "User approved via TUI." if is_approved else "User denied via TUI."
+        
+        info_input = self.query_one(Input)
+        user_reason = info_input.value.strip()
+        info_input.value = "" # Clear the input
+        
+        if user_reason:
+            reason = user_reason
+        else:
+            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"
@@ -121,8 +132,8 @@ class FocusPane(Static):
     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
+        input_widget.placeholder = "Optional: Enter a reason for your decision..."
+        input_widget.disabled = False
         button_container = self.query_one("#approval-buttons")
         await button_container.remove_children()
         await button_container.mount(
@@ -130,7 +141,7 @@ class FocusPane(Static):
             Button("Deny", variant="error", id="deny-btn")
         )
 
-    def _update_title(self, agent_phases: Dict[str, AgentOperationalPhase], team_phases: Dict[str, AgentTeamOperationalPhase]):
+    def _update_title(self, agent_statuses: Dict[str, AgentStatus], team_statuses: Dict[str, AgentTeamStatus]):
         """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")
@@ -141,31 +152,31 @@ class FocusPane(Static):
         node_type_str = node_type.replace("_", " ").capitalize()
 
         title_icon = DEFAULT_ICON
-        phase_str = ""
+        status_str = ""
 
         if node_type == 'agent':
             title_icon = AGENT_ICON
-            phase = agent_phases.get(node_name, AgentOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = agent_statuses.get(node_name, AgentStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
         elif node_type == 'subteam':
             title_icon = SUB_TEAM_ICON
-            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = team_statuses.get(node_name, AgentTeamStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
         elif node_type == 'team':
             title_icon = TEAM_ICON
-            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = team_statuses.get(node_name, AgentTeamStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
 
-        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{phase_str}")
+        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{status_str}")
         
-    def update_current_node_status(self, all_agent_phases: Dict, all_team_phases: Dict):
+    def update_current_node_status(self, all_agent_statuses: Dict, all_team_statuses: Dict):
         """A lightweight method to only update the title with the latest status."""
-        self._update_title(all_agent_phases, all_team_phases)
+        self._update_title(all_agent_statuses, all_team_statuses)
 
     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],
+                             all_agent_statuses: Dict[str, AgentStatus],
+                             all_team_statuses: Dict[str, AgentTeamStatus],
                              task_plan: Optional[List[Task]],
                              task_statuses: Optional[Dict[str, TaskStatus]]):
         """The main method to update the entire pane based on new state."""
@@ -174,7 +185,7 @@ class FocusPane(Static):
         self._focused_node_data = node_data
         self._pending_approval_data = pending_approval
         
-        self._update_title(all_agent_phases, all_team_phases)
+        self._update_title(all_agent_statuses, all_team_statuses)
 
         log_container = self.query_one("#focus-pane-log-container")
         await log_container.remove_children()
@@ -192,39 +203,39 @@ class FocusPane(Static):
             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)
+            await self._render_team_dashboard(node_data, all_agent_statuses, all_team_statuses, 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],
+    async def _render_team_dashboard(self, node_data: Dict[str, Any],
+                                         all_agent_statuses: Dict[str, AgentStatus],
+                                         all_team_statuses: Dict[str, AgentTeamStatus],
                                          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)
+        status = all_team_statuses.get(node_data['name'], AgentTeamStatus.UNINITIALIZED)
+        status_icon = TEAM_STATUS_ICONS.get(status, 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}")
+        info_text.append(f"Status: {status_icon} {status.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']))
+        await log_container.mount(TaskPlanPanel(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")
+                    agent_status = all_agent_statuses.get(name, AgentStatus.UNINITIALIZED)
+                    agent_icon = AGENT_STATUS_ICONS.get(agent_status, DEFAULT_ICON)
+                    team_text.append(f" ▪ {agent_icon} {name} (Agent): {agent_status.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")
+                    wf_status = all_team_statuses.get(name, AgentTeamStatus.UNINITIALIZED)
+                    wf_icon = TEAM_STATUS_ICONS.get(wf_status, SUB_TEAM_ICON)
+                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Team): {wf_status.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):
@@ -252,10 +263,105 @@ class FocusPane(Static):
         if scrolled:
             self.query_one("#focus-pane-log-container").scroll_end(animate=False)
 
+    async def _ensure_thinking_widget(self, log_container: VerticalScroll) -> None:
+        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)
+
+    async def _ensure_assistant_content_widget(self, log_container: VerticalScroll) -> None:
+        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)
+
+    async def _handle_segment_event(self, data: SegmentEventData) -> None:
+        log_container = self.query_one("#focus-pane-log-container")
+        self._saw_segment_event = True
+        try:
+            event_type = SegmentEventType(data.event_type)
+        except ValueError:
+            logger.debug(f"TUI FocusPane: Unknown segment event type '{data.event_type}'.")
+            return
+
+        segment_type = None
+        if data.segment_type:
+            try:
+                segment_type = SegmentType(data.segment_type)
+            except ValueError:
+                logger.debug(f"TUI FocusPane: Unknown segment type '{data.segment_type}'.")
+
+        if segment_type is None and data.segment_id in self._segment_types_by_id:
+            segment_type = self._segment_types_by_id.get(data.segment_id)
+
+        metadata = {}
+        if isinstance(data.payload, dict):
+            metadata = data.payload.get("metadata", {}) or {}
+
+        if event_type == SegmentEventType.START:
+            if segment_type is not None:
+                self._segment_types_by_id[data.segment_id] = segment_type
+
+            if segment_type != SegmentType.REASONING:
+                await self._close_thinking_block(scroll=False)
+
+            if segment_type == SegmentType.REASONING:
+                await self._ensure_thinking_widget(log_container)
+                return
+
+            await self._ensure_assistant_content_widget(log_container)
+
+            if segment_type == SegmentType.WRITE_FILE:
+                path = metadata.get("path", "")
+                header = f"<write_file path=\"{path}\">" if path else "<write_file>"
+                self._content_buffer += f"{header}\n"
+            elif segment_type == SegmentType.RUN_BASH:
+                self._content_buffer += "<run_bash>\n"
+            elif segment_type == SegmentType.TOOL_CALL:
+                tool_name = metadata.get("tool_name", "")
+                header = f"<tool name=\"{tool_name}\">" if tool_name else "<tool>"
+                self._content_buffer += f"{header}\n"
+            return
+
+        if event_type == SegmentEventType.CONTENT:
+            delta = ""
+            if isinstance(data.payload, dict):
+                delta = data.payload.get("delta", "")
+
+            if segment_type == SegmentType.REASONING:
+                await self._ensure_thinking_widget(log_container)
+                self._reasoning_buffer += str(delta)
+            else:
+                await self._ensure_assistant_content_widget(log_container)
+                self._content_buffer += str(delta)
+            return
+
+        if event_type == SegmentEventType.END:
+            if segment_type == SegmentType.REASONING:
+                await self._close_thinking_block()
+                self._segment_types_by_id.pop(data.segment_id, None)
+                return
+
+            if segment_type in {SegmentType.WRITE_FILE, SegmentType.RUN_BASH, SegmentType.TOOL_CALL}:
+                tag = "write_file" if segment_type == SegmentType.WRITE_FILE else (
+                    "run_bash" if segment_type == SegmentType.RUN_BASH else "tool"
+                )
+                self._content_buffer += f"\n</{tag}>\n"
+
+            self._segment_types_by_id.pop(data.segment_id, None)
+            return
+
     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.SEGMENT_EVENT and isinstance(event.data, SegmentEventData):
+            await self._handle_segment_event(event.data)
+            return
+
         if event_type == AgentStreamEventType.ASSISTANT_CHUNK:
             data: AssistantChunkData = event.data
             if data.reasoning:
@@ -282,12 +388,13 @@ class FocusPane(Static):
             await self._close_thinking_block()
             self._assistant_content_widget = None
             self._assistant_content_text = None
-            if not was_streaming_content:
+            if not self._saw_segment_event and 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)
+            self._saw_segment_event = False
             return
 
         is_stream_breaking_event = event_type in [

autobyteus/cli/agent_team_tui/widgets/renderables.py

@@ -10,7 +10,7 @@ from rich.text import Text
 from rich.panel import Panel
 
 from autobyteus.agent.streaming.stream_event_payloads import (
-    AgentOperationalPhaseTransitionData, AssistantCompleteResponseData,
+    AgentStatusUpdateData, AssistantCompleteResponseData,
     ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData, SystemTaskNotificationData
 )

autobyteus/cli/agent_team_tui/widgets/shared.py

@@ -2,34 +2,34 @@
 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
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+from autobyteus.task_management.base_task_plan 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: "❗",
+AGENT_STATUS_ICONS: Dict[AgentStatus, str] = {
+    AgentStatus.UNINITIALIZED: "⚪",
+    AgentStatus.BOOTSTRAPPING: "⏳",
+    AgentStatus.IDLE: "🟢",
+    AgentStatus.PROCESSING_USER_INPUT: "💭",
+    AgentStatus.AWAITING_LLM_RESPONSE: "💭",
+    AgentStatus.ANALYZING_LLM_RESPONSE: "🤔",
+    AgentStatus.AWAITING_TOOL_APPROVAL: "❓",
+    AgentStatus.TOOL_DENIED: "❌",
+    AgentStatus.EXECUTING_TOOL: "🛠️",
+    AgentStatus.PROCESSING_TOOL_RESULT: "⚙️",
+    AgentStatus.SHUTTING_DOWN: "🌙",
+    AgentStatus.SHUTDOWN_COMPLETE: "⚫",
+    AgentStatus.ERROR: "❗",
 }
 
-TEAM_PHASE_ICONS: Dict[AgentTeamOperationalPhase, str] = {
-    AgentTeamOperationalPhase.UNINITIALIZED: "⚪",
-    AgentTeamOperationalPhase.BOOTSTRAPPING: "⏳",
-    AgentTeamOperationalPhase.IDLE: "🟢",
-    AgentTeamOperationalPhase.PROCESSING: "⚙️",
-    AgentTeamOperationalPhase.SHUTTING_DOWN: "🌙",
-    AgentTeamOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
-    AgentTeamOperationalPhase.ERROR: "❗",
+TEAM_STATUS_ICONS: Dict[AgentTeamStatus, str] = {
+    AgentTeamStatus.UNINITIALIZED: "⚪",
+    AgentTeamStatus.BOOTSTRAPPING: "⏳",
+    AgentTeamStatus.IDLE: "🟢",
+    AgentTeamStatus.PROCESSING: "⚙️",
+    AgentTeamStatus.SHUTTING_DOWN: "🌙",
+    AgentTeamStatus.SHUTDOWN_COMPLETE: "⚫",
+    AgentTeamStatus.ERROR: "❗",
 }
 
 TASK_STATUS_ICONS: Dict[TaskStatus, str] = {
@@ -55,6 +55,6 @@ ASSISTANT_ICON = "🤖"
 TOOL_ICON = "🛠️"
 PROMPT_ICON = "❓"
 ERROR_ICON = "💥"
-PHASE_ICON = "🔄"
+STATUS_ICON = "🔄"
 LOG_ICON = "📄"
 SYSTEM_TASK_ICON = "📥" # NEW

autobyteus/cli/agent_team_tui/widgets/{task_board_panel.py → task_plan_panel.py}

@@ -7,13 +7,13 @@ from rich.text import Text
 from textual.widgets import Static
 
 from autobyteus.task_management.task import Task
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan 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."""
+class TaskPlanPanel(Static):
+    """A widget to display the team's task plan."""
 
     def __init__(self, tasks: Optional[List[Task]], statuses: Dict[str, TaskStatus], team_name: str, **kwargs) -> None:
         super().__init__(**kwargs)
@@ -23,7 +23,7 @@ class TaskBoardPanel(Static):
 
     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"))
+            yield Static(Panel("No task plan has been published yet.", title="Task Plan", border_style="yellow", title_align="left"))
             return
 
         table = Table(
@@ -79,4 +79,4 @@ class TaskBoardPanel(Static):
                 ", ".join(dep_names)
             )
 
-        yield Static(Panel(table, title="Task Board", border_style="blue", title_align="left"))
+        yield Static(Panel(table, title="Task Plan", border_style="blue", title_align="left"))