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

autobyteus/agent_team/streaming/__init__.py

@@ -7,7 +7,7 @@ from .agent_team_event_stream import AgentTeamEventStream
 from .agent_team_stream_events import AgentTeamStreamEvent, AgentTeamStreamDataPayload
 from .agent_team_stream_event_payloads import (
     BaseTeamSpecificPayload,
-    AgentTeamPhaseTransitionData,
+    AgentTeamStatusUpdateData,
     AgentEventRebroadcastPayload,
 )
 from .agent_event_bridge import AgentEventBridge
@@ -19,7 +19,7 @@ __all__ = [
     "AgentTeamStreamEvent",
     "AgentTeamStreamDataPayload",
     "BaseTeamSpecificPayload",
-    "AgentTeamPhaseTransitionData",
+    "AgentTeamStatusUpdateData",
     "AgentEventRebroadcastPayload",
     "AgentEventBridge",
     "AgentEventMultiplexer",

autobyteus/agent_team/streaming/agent_team_event_notifier.py

@@ -4,10 +4,10 @@ from typing import Optional, Dict, Any, TYPE_CHECKING
 
 from autobyteus.events.event_emitter import EventEmitter
 from autobyteus.events.event_types import EventType
-from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
-from .agent_team_stream_events import AgentTeamStreamEvent, AgentEventRebroadcastPayload, AgentTeamPhaseTransitionData, SubTeamEventRebroadcastPayload
-from autobyteus.task_management.events import BaseTaskBoardEvent
+from .agent_team_stream_events import AgentTeamStreamEvent, AgentEventRebroadcastPayload, AgentTeamStatusUpdateData, SubTeamEventRebroadcastPayload
+from autobyteus.task_management.events import BaseTaskPlanEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.runtime.agent_team_runtime import AgentTeamRuntime
@@ -32,14 +32,14 @@ class AgentTeamExternalEventNotifier(EventEmitter):
         """
         self.emit(EventType.TEAM_STREAM_EVENT, payload=event)
 
-    def notify_phase_change(self, new_phase: AgentTeamOperationalPhase, old_phase: Optional[AgentTeamOperationalPhase], extra_data: Optional[Dict[str, Any]] = None):
+    def notify_status_updated(self, new_status: AgentTeamStatus, old_status: Optional[AgentTeamStatus], extra_data: Optional[Dict[str, Any]] = None):
         """
-        Notifies of an agent team phase transition by creating and emitting a
+        Notifies of an agent team status update by creating and emitting a
         'TEAM' sourced event.
         """
-        payload_dict = { "new_phase": new_phase, "old_phase": old_phase, "error_message": extra_data.get("error_message") if extra_data else None }
+        payload_dict = { "new_status": new_status, "old_status": old_status, "error_message": extra_data.get("error_message") if extra_data else None }
         filtered_payload_dict = {k: v for k, v in payload_dict.items() if v is not None}
-        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TEAM", data=AgentTeamPhaseTransitionData(**filtered_payload_dict))
+        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TEAM", data=AgentTeamStatusUpdateData(**filtered_payload_dict))
         self._emit_event(event)
     
     def publish_agent_event(self, agent_name: str, agent_event: AgentStreamEvent):
@@ -56,9 +56,9 @@ class AgentTeamExternalEventNotifier(EventEmitter):
         event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="SUB_TEAM", data=SubTeamEventRebroadcastPayload(sub_team_node_name=sub_team_node_name, sub_team_event=sub_team_event))
         self._emit_event(event)
 
-    def handle_and_publish_task_board_event(self, payload: BaseTaskBoardEvent, **kwargs):
+    def handle_and_publish_task_plan_event(self, payload: BaseTaskPlanEvent, **kwargs):
         """
-        Listener for TaskBoard events. It wraps the event and publishes it on the main team stream.
+        Listener for TaskPlan events. It wraps the event and publishes it on the main team stream.
         """
-        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TASK_BOARD", data=payload)
+        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TASK_PLAN", data=payload)
         self._emit_event(event)

autobyteus/agent_team/streaming/agent_team_stream_event_payloads.py

@@ -1,9 +1,9 @@
 # file: autobyteus/autobyteus/agent_team/streaming/agent_team_stream_event_payloads.py
 from typing import Optional, Any
 from pydantic import BaseModel, Field
-from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
-from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksCreatedEvent, TaskStatusUpdatedEvent
 # Need to use a forward reference string to avoid circular import at runtime
 from typing import TYPE_CHECKING, Union
 if TYPE_CHECKING:
@@ -13,9 +13,9 @@ if TYPE_CHECKING:
 class BaseTeamSpecificPayload(BaseModel):
     pass
 
-class AgentTeamPhaseTransitionData(BaseTeamSpecificPayload):
-    new_phase: AgentTeamOperationalPhase
-    old_phase: Optional[AgentTeamOperationalPhase] = None
+class AgentTeamStatusUpdateData(BaseTeamSpecificPayload):
+    new_status: AgentTeamStatus
+    old_status: Optional[AgentTeamStatus] = None
     error_message: Optional[str] = None
 
 # --- Payload for events originating from the "AGENT" source ---
@@ -28,5 +28,5 @@ class SubTeamEventRebroadcastPayload(BaseModel):
     sub_team_node_name: str # The friendly name of the sub-team node
     sub_team_event: "AgentTeamStreamEvent" = Field(..., description="The original, unmodified event from the sub-team's stream")
 
-# --- Payload for events originating from the "TASK_BOARD" source ---
-TaskBoardEventPayload = Union[TasksAddedEvent, TaskStatusUpdatedEvent]
+# --- Payload for events originating from the "TASK_PLAN" source ---
+TaskPlanEventPayload = Union[TasksCreatedEvent, TaskStatusUpdatedEvent]

autobyteus/agent_team/streaming/agent_team_stream_events.py

@@ -5,22 +5,22 @@ from typing import Literal, Union
 from pydantic import BaseModel, Field, model_validator
 
 from .agent_team_stream_event_payloads import (
-    AgentTeamPhaseTransitionData, AgentEventRebroadcastPayload, 
-    SubTeamEventRebroadcastPayload, TaskBoardEventPayload
+    AgentTeamStatusUpdateData, AgentEventRebroadcastPayload,
+    SubTeamEventRebroadcastPayload, TaskPlanEventPayload
 )
-from autobyteus.task_management.events import BaseTaskBoardEvent
+from autobyteus.task_management.events import BaseTaskPlanEvent
 
 # A union of all possible payloads for a "TEAM" sourced event.
-TeamSpecificPayload = Union[AgentTeamPhaseTransitionData]
+TeamSpecificPayload = Union[AgentTeamStatusUpdateData]
 
 # The top-level discriminated union for the main event stream's payload.
-AgentTeamStreamDataPayload = Union[TeamSpecificPayload, AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, TaskBoardEventPayload]
+AgentTeamStreamDataPayload = Union[TeamSpecificPayload, AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, TaskPlanEventPayload]
 
 class AgentTeamStreamEvent(BaseModel):
     event_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     timestamp: datetime.datetime = Field(default_factory=datetime.datetime.utcnow)
     team_id: str
-    event_source_type: Literal["TEAM", "AGENT", "SUB_TEAM", "TASK_BOARD"]
+    event_source_type: Literal["TEAM", "AGENT", "SUB_TEAM", "TASK_PLAN"]
     data: AgentTeamStreamDataPayload
 
     @model_validator(mode='after')
@@ -32,10 +32,10 @@ class AgentTeamStreamEvent(BaseModel):
         is_sub_team_payload = isinstance(self.data, SubTeamEventRebroadcastPayload)
 
         is_team_event = self.event_source_type == "TEAM"
-        is_team_payload = isinstance(self.data, AgentTeamPhaseTransitionData)
+        is_team_payload = isinstance(self.data, AgentTeamStatusUpdateData)
         
-        is_task_board_event = self.event_source_type == "TASK_BOARD"
-        is_task_board_payload = isinstance(self.data, BaseTaskBoardEvent)
+        is_task_plan_event = self.event_source_type == "TASK_PLAN"
+        is_task_plan_payload = isinstance(self.data, BaseTaskPlanEvent)
 
         if is_agent_event and not is_agent_payload:
             raise ValueError("event_source_type is 'AGENT' but data is not an AgentEventRebroadcastPayload")
@@ -46,8 +46,8 @@ class AgentTeamStreamEvent(BaseModel):
         if is_team_event and not is_team_payload:
             raise ValueError("event_source_type is 'TEAM' but data is not a valid team-specific payload")
 
-        if is_task_board_event and not is_task_board_payload:
-            raise ValueError("event_source_type is 'TASK_BOARD' but data is not a TaskBoardEventPayload")
+        if is_task_plan_event and not is_task_plan_payload:
+            raise ValueError("event_source_type is 'TASK_PLAN' but data is not a BaseTaskPlanEvent instance")
 
         return self
 

autobyteus/agent_team/system_prompt_processor/__init__.py

@@ -0,0 +1,6 @@
+# file: autobyteus/autobyteus/agent_team/system_prompt_processor/__init__.py
+from .team_manifest_injector_processor import TeamManifestInjectorProcessor
+
+__all__ = [
+    "TeamManifestInjectorProcessor",
+]

autobyteus/agent_team/system_prompt_processor/team_manifest_injector_processor.py

@@ -0,0 +1,76 @@
+# file: autobyteus/autobyteus/agent_team/system_prompt_processor/team_manifest_injector_processor.py
+import logging
+from typing import Dict, List, TYPE_CHECKING
+
+from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPromptProcessor
+from autobyteus.agent_team.context import AgentTeamConfig
+
+if TYPE_CHECKING:
+    from autobyteus.tools.base_tool import BaseTool
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+
+class TeamManifestInjectorProcessor(BaseSystemPromptProcessor):
+    """
+    Injects a team manifest into the system prompt for agents that belong to a team.
+    If the prompt contains {{team}}, the placeholder is replaced. Otherwise, the
+    manifest is appended as a dedicated section.
+    """
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "TeamManifestInjector"
+
+    @classmethod
+    def get_order(cls) -> int:
+        return 450
+
+    def process(
+        self,
+        system_prompt: str,
+        tool_instances: Dict[str, 'BaseTool'],
+        agent_id: str,
+        context: 'AgentContext',
+    ) -> str:
+        team_context = context.custom_data.get("team_context")
+        if team_context is None:
+            logger.debug(f"Agent '{agent_id}': No team_context found; skipping team manifest injection.")
+            return system_prompt
+
+        manifest = self._generate_team_manifest(team_context, exclude_name=context.config.name)
+
+        if "{{team}}" in system_prompt:
+            logger.info(f"Agent '{agent_id}': Replacing {{team}} placeholder with team manifest.")
+            return system_prompt.replace("{{team}}", manifest)
+
+        logger.info(f"Agent '{agent_id}': Appending team manifest to system prompt.")
+        return system_prompt + "\n\n## Team Manifest\n\n" + manifest
+
+    def _generate_team_manifest(self, context: 'AgentTeamContext', exclude_name: str) -> str:
+        """
+        Builds a manifest string of all team members except the given agent.
+        Includes sub-teams so agents see the full collaboration surface.
+        """
+        prompt_parts: List[str] = []
+
+        for node in sorted(list(context.config.nodes), key=lambda n: n.name):
+            if node.name == exclude_name:
+                continue
+
+            node_def = node.node_definition
+            description = "No description available."
+
+            if hasattr(node_def, "description") and isinstance(node_def.description, str):
+                description = node_def.description
+            elif isinstance(node_def, AgentTeamConfig):
+                description = node_def.role or node_def.description
+
+            prompt_parts.append(f"- name: {node.name}\n  description: {description}")
+
+        if not prompt_parts:
+            return "You are working alone. You have no team members to delegate to."
+
+        return "\n".join(prompt_parts)

autobyteus/agent_team/task_notification/activation_policy.py

@@ -31,7 +31,7 @@ class ActivationPolicy:
     def reset(self):
         """
         Resets the activation state. This should be called when a new batch of
-        tasks is published to the task board, signifying a new plan or a
+        tasks is published to the task plan, signifying a new plan or a
         significant change in scope.
         """
         logger.info(f"Team '{self._team_id}': ActivationPolicy state has been reset. All agents are now considered inactive.")

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

@@ -3,39 +3,39 @@ import logging
 from typing import Union, TYPE_CHECKING
 
 from autobyteus.events.event_types import EventType
-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
 
 # Import the new, separated components
 from .activation_policy import ActivationPolicy
 from .task_activator import TaskActivator
 
 if TYPE_CHECKING:
-    from autobyteus.task_management.base_task_board import BaseTaskBoard
+    from autobyteus.task_management.base_task_plan import BaseTaskPlan
     from autobyteus.agent_team.context.team_manager import TeamManager
 
 logger = logging.getLogger(__name__)
 
 class SystemEventDrivenAgentTaskNotifier:
     """
-    An internal component that monitors a TaskBoard and orchestrates agent
+    An internal component that monitors a TaskPlan and orchestrates agent
     activation based on task runnability.
 
     This class acts as a conductor, delegating the logic for *when* to activate
     to an ActivationPolicy and the action of *how* to activate to a TaskActivator.
     """
-    def __init__(self, task_board: 'BaseTaskBoard', team_manager: 'TeamManager'):
+    def __init__(self, task_plan: 'BaseTaskPlan', team_manager: 'TeamManager'):
         """
         Initializes the SystemEventDrivenAgentTaskNotifier.
 
         Args:
-            task_board: The team's shared task board instance.
+            task_plan: The team's shared task plan instance.
             team_manager: The team's manager for activating agents.
         """
-        if not task_board or not team_manager:
-            raise ValueError("TaskBoard and TeamManager are required for the notifier.")
+        if not task_plan or not team_manager:
+            raise ValueError("TaskPlan and TeamManager are required for the notifier.")
             
-        self._task_board = task_board
+        self._task_plan = task_plan
         self._team_manager = team_manager
         
         # Instantiate the components that hold the actual logic and action
@@ -46,27 +46,27 @@ class SystemEventDrivenAgentTaskNotifier:
 
     def start_monitoring(self):
         """
-        Subscribes to task board events to begin monitoring for runnable tasks.
+        Subscribes to task plan events to begin monitoring for runnable tasks.
         """
-        self._task_board.subscribe(EventType.TASK_BOARD_TASKS_ADDED, self._handle_tasks_changed)
-        self._task_board.subscribe(EventType.TASK_BOARD_STATUS_UPDATED, self._handle_tasks_changed)
-        logger.info(f"Team '{self._team_manager.team_id}': Task notifier orchestrator is now monitoring TaskBoard events.")
+        self._task_plan.subscribe(EventType.TASK_PLAN_TASKS_CREATED, self._handle_tasks_changed)
+        self._task_plan.subscribe(EventType.TASK_PLAN_STATUS_UPDATED, self._handle_tasks_changed)
+        logger.info(f"Team '{self._team_manager.team_id}': Task notifier orchestrator is now monitoring TaskPlan events.")
     
-    async def _handle_tasks_changed(self, payload: Union[TasksAddedEvent, TaskStatusUpdatedEvent], **kwargs):
+    async def _handle_tasks_changed(self, payload: Union[TasksCreatedEvent, TaskStatusUpdatedEvent], **kwargs):
         """
-        Orchestrates the agent activation workflow upon any change to the task board.
+        Orchestrates the agent activation workflow upon any change to the task plan.
         """
         team_id = self._team_manager.team_id
-        logger.info(f"Team '{team_id}': Task board changed ({type(payload).__name__}). Orchestrating activation check.")
+        logger.info(f"Team '{team_id}': Task plan changed ({type(payload).__name__}). Orchestrating activation check.")
 
         # If a new batch of tasks was added, it's a new "wave" of work.
         # We must reset the policy's memory of who has been activated.
-        if isinstance(payload, TasksAddedEvent):
-            logger.info(f"Team '{team_id}': New tasks added. Resetting activation policy.")
+        if isinstance(payload, TasksCreatedEvent):
+            logger.info(f"Team '{team_id}': New tasks created. Resetting activation policy.")
             self._policy.reset()
 
-        # 1. DATA FETCHING: Get the current state of runnable tasks from the board.
-        runnable_tasks = self._task_board.get_next_runnable_tasks()
+        # 1. DATA FETCHING: Get the current state of runnable tasks from the plan.
+        runnable_tasks = self._task_plan.get_next_runnable_tasks()
         
         if not runnable_tasks:
             logger.debug(f"Team '{team_id}': No runnable tasks found after change. No action needed.")
@@ -87,8 +87,8 @@ class SystemEventDrivenAgentTaskNotifier:
             agent_runnable_tasks = [t for t in runnable_tasks if t.assignee_name == agent_name]
             for task in agent_runnable_tasks:
                 # We only need to queue tasks that are NOT_STARTED.
-                if self._task_board.task_statuses.get(task.task_id) == TaskStatus.NOT_STARTED:
-                    self._task_board.update_task_status(
+                if self._task_plan.task_statuses.get(task.task_id) == TaskStatus.NOT_STARTED:
+                    self._task_plan.update_task_status(
                         task_id=task.task_id,
                         status=TaskStatus.QUEUED,
                         agent_name="SystemTaskNotifier"

autobyteus/agent_team/task_notification/task_notification_mode.py

@@ -2,6 +2,7 @@
 """
 Defines the enum for controlling how task notifications are handled in an agent team.
 """
+import os
 from enum import Enum
 
 class TaskNotificationMode(str, Enum):
@@ -16,9 +17,27 @@ class TaskNotificationMode(str, Enum):
     
     SYSTEM_EVENT_DRIVEN = "system_event_driven"
     """
-    In this mode, the agent team framework automatically monitors the TaskBoard
+    In this mode, the agent team framework automatically monitors the TaskPlan
     and sends notifications to agents when their assigned tasks become runnable.
     """
 
     def __str__(self) -> str:
         return self.value
+
+
+ENV_TASK_NOTIFICATION_MODE = "AUTOBYTEUS_TASK_NOTIFICATION_MODE"
+DEFAULT_TASK_NOTIFICATION_MODE = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+_VALID_TASK_NOTIFICATION_MODES = {mode.value: mode for mode in TaskNotificationMode}
+
+
+def resolve_task_notification_mode() -> TaskNotificationMode:
+    """
+    Resolve task notification mode from environment.
+
+    Env var: AUTOBYTEUS_TASK_NOTIFICATION_MODE
+    """
+    raw_value = os.getenv(ENV_TASK_NOTIFICATION_MODE)
+    if not raw_value:
+        return DEFAULT_TASK_NOTIFICATION_MODE
+    normalized = raw_value.strip().lower()
+    return _VALID_TASK_NOTIFICATION_MODES.get(normalized, DEFAULT_TASK_NOTIFICATION_MODE)

autobyteus/agent_team/utils/wait_for_idle.py

@@ -4,7 +4,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
-from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.agent_team import AgentTeam
@@ -14,10 +14,10 @@ logger = logging.getLogger(__name__)
 async def _wait_loop(streamer: AgentTeamEventStream, team_id: str):
     """Internal helper to listen for the IDLE or ERROR event."""
     async for event in streamer.all_events():
-        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.IDLE:
+        if event.event_source_type == "TEAM" and event.data.new_status == AgentTeamStatus.IDLE:
             logger.info(f"Team '{team_id}' has become idle.")
             return
-        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.ERROR:
+        if event.event_source_type == "TEAM" and event.data.new_status == AgentTeamStatus.ERROR:
              error_message = f"Team '{team_id}' entered an error state while waiting for idle: {event.data.error_message}"
              logger.error(error_message)
              raise RuntimeError(error_message)
@@ -34,7 +34,7 @@ async def wait_for_team_to_be_idle(team: 'AgentTeam', timeout: float = 60.0):
         asyncio.TimeoutError: If the team does not become idle within the timeout period.
         RuntimeError: If the team enters an error state.
     """
-    if team.get_current_phase() == AgentTeamOperationalPhase.IDLE:
+    if team.get_current_status() == AgentTeamStatus.IDLE:
         return
     
     logger.info(f"Waiting for team '{team.team_id}' to become idle (timeout: {timeout}s)...")

autobyteus/cli/agent_cli.py

@@ -70,16 +70,24 @@ async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool
             agent_turn_complete_event.clear()
 
             if cli_display.pending_approval_data:
-                approval_input = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
-                approval_input = approval_input.strip().lower()
-                
-                approval_data = cli_display.pending_approval_data
-                cli_display.pending_approval_data = None
-                
-                is_approved = approval_input in ["y", "yes"]
-                reason = "User approved via CLI" if is_approved else "User denied via CLI"
-                
-                await agent.post_tool_execution_approval(approval_data.invocation_id, is_approved, reason)
+                approval_prompt = cli_display.get_approval_prompt()
+                if approval_prompt:
+                    approval_input = await asyncio.get_event_loop().run_in_executor(None, lambda: input(approval_prompt))
+                    approval_input = approval_input.strip().lower()
+                    
+                    approval_data = cli_display.pending_approval_data
+                    cli_display.clear_pending_approval()
+                    
+                    is_approved = approval_input in ["y", "yes"]
+                    reason = "User approved via CLI"
+                    
+                    if not is_approved:
+                        reason_input = await asyncio.get_event_loop().run_in_executor(None, lambda: input("Reason (optional): "))
+                        reason = reason_input.strip()
+                        if not reason:
+                            reason = "User denied via CLI"
+                    
+                    await agent.post_tool_execution_approval(approval_data.invocation_id, is_approved, reason)
 
             else:
                 sys.stdout.write("You: ")

autobyteus/cli/agent_team_tui/app.py

@@ -13,11 +13,12 @@ from textual.widgets import Header, Static
 from textual.reactive import reactive
 
 from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent.streaming.stream_events import StreamEventType as AgentStreamEventType
-from autobyteus.agent.streaming.stream_event_payloads import AssistantChunkData
-from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, AgentTeamPhaseTransitionData
+from autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamStatusUpdateData
 
 from .state import TUIStateStore
 from .widgets.agent_list_sidebar import AgentListSidebar
@@ -104,7 +105,9 @@ class AgentTeamApp(App):
                 self._ui_update_pending = True
                 
                 # 3. Handle real-time, incremental updates directly.
-                if isinstance(event.data, AgentEventRebroadcastPayload):
+                if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamStatusUpdateData):
+                    self.store._team_statuses[self.team.name] = event.data.new_status
+                elif isinstance(event.data, AgentEventRebroadcastPayload):
                     payload = event.data
                     agent_name = payload.agent_name
                     agent_event = payload.agent_event
@@ -132,28 +135,28 @@ class AgentTeamApp(App):
         focus_pane = self.query_one(FocusPane)
 
         tree_data = self.store.get_tree_data()
-        agent_phases = self.store._agent_phases
-        team_phases = self.store._team_phases
+        agent_statuses = self.store._agent_statuses
+        team_statuses = self.store._team_statuses
         speaking_agents = self.store._speaking_agents
         
-        sidebar.update_tree(tree_data, agent_phases, team_phases, speaking_agents)
+        sidebar.update_tree(tree_data, agent_statuses, team_statuses, speaking_agents)
         
         focused_data = self.focused_node_data
         if focused_data and focused_data.get("type") in ['team', 'subteam']:
             node_name = focused_data['name']
-            task_plan = self.store.get_task_board_plan(node_name)
-            task_statuses = self.store.get_task_board_statuses(node_name)
+            task_plan = self.store.get_task_plan_tasks(node_name)
+            task_statuses = self.store.get_task_plan_statuses(node_name)
             await focus_pane.update_content(
                 node_data=focused_data,
                 history=[], # No history for teams
                 pending_approval=None,
-                all_agent_phases=agent_phases,
-                all_team_phases=team_phases,
+                all_agent_statuses=agent_statuses,
+                all_team_statuses=team_statuses,
                 task_plan=task_plan,
                 task_statuses=task_statuses
             )
         elif focused_data and focused_data.get("type") == 'agent':
-            focus_pane.update_current_node_status(agent_phases, team_phases)
+            focus_pane.update_current_node_status(agent_statuses, team_statuses)
 
 
     async def watch_focused_node_data(self, new_node_data: Optional[Dict[str, Any]]):
@@ -169,8 +172,8 @@ class AgentTeamApp(App):
         task_plan = None
         task_statuses = None
         if node_type in ['team', 'subteam']:
-            task_plan = self.store.get_task_board_plan(node_name)
-            task_statuses = self.store.get_task_board_statuses(node_name)
+            task_plan = self.store.get_task_plan_tasks(node_name)
+            task_statuses = self.store.get_task_plan_statuses(node_name)
         
         sidebar = self.query_one(AgentListSidebar)
         focus_pane = self.query_one(FocusPane)
@@ -179,8 +182,8 @@ class AgentTeamApp(App):
             node_data=new_node_data,
             history=history,
             pending_approval=pending_approval,
-            all_agent_phases=self.store._agent_phases,
-            all_team_phases=self.store._team_phases,
+            all_agent_statuses=self.store._agent_statuses,
+            all_team_statuses=self.store._team_statuses,
             task_plan=task_plan,
             task_statuses=task_statuses
         )