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

autobyteus/agent_team/agent_team_builder.py

@@ -7,7 +7,6 @@ from autobyteus.agent_team.context.agent_team_config import AgentTeamConfig
 from autobyteus.agent_team.context.team_node_config import TeamNodeConfig
 from autobyteus.agent.context.agent_config import AgentConfig
 from autobyteus.agent_team.factory.agent_team_factory import AgentTeamFactory
-from autobyteus.agent_team.task_notification.task_notification_mode import TaskNotificationMode
 
 logger = logging.getLogger(__name__)
 
@@ -44,8 +43,6 @@ class AgentTeamBuilder:
         self._nodes: Dict[NodeDefinition, List[NodeDefinition]] = {}
         self._coordinator_config: Optional[AgentConfig] = None
         self._added_node_names: Set[str] = set()
-        self._task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
-        self._use_xml_tool_format: Optional[bool] = None
         logger.info(f"AgentTeamBuilder initialized for team: '{self._name}'.")
 
     def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
@@ -127,41 +124,6 @@ class AgentTeamBuilder:
         logger.debug(f"Set coordinator for team to '{agent_config.name}'.")
         return self
 
-    def set_task_notification_mode(self, mode: TaskNotificationMode) -> 'AgentTeamBuilder':
-        """
-        Sets the task notification mode for the team.
-
-        Args:
-            mode: The desired TaskNotificationMode (AGENT_MANUAL_NOTIFICATION or SYSTEM_EVENT_DRIVEN).
-
-        Returns:
-            The builder instance for fluent chaining.
-        """
-        if not isinstance(mode, TaskNotificationMode):
-            raise TypeError("mode must be an instance of TaskNotificationMode.")
-        self._task_notification_mode = mode
-        logger.debug(f"Task notification mode set to '{mode.value}'.")
-        return self
-
-    def set_use_xml_tool_format(self, use_xml: bool) -> 'AgentTeamBuilder':
-        """
-        Sets the team-level override for using XML tool format.
-
-        If set, this will override the setting on all individual agents within the team.
-
-        Args:
-            use_xml: If True, forces the team to use XML format for tool
-                     definitions and parsing.
-
-        Returns:
-            The builder instance for fluent chaining.
-        """
-        if not isinstance(use_xml, bool):
-            raise TypeError("use_xml must be a boolean.")
-        self._use_xml_tool_format = use_xml
-        logger.debug(f"Team-level XML tool format override set to '{use_xml}'.")
-        return self
-
     def build(self) -> AgentTeam:
         """
         Constructs and returns the final AgentTeam instance using the
@@ -194,9 +156,7 @@ class AgentTeamBuilder:
             description=self._description,
             role=self._role,
             nodes=tuple(final_nodes),
-            coordinator_node=coordinator_node_instance,
-            task_notification_mode=self._task_notification_mode,
-            use_xml_tool_format=self._use_xml_tool_format
+            coordinator_node=coordinator_node_instance
         )
         
         logger.info(f"AgentTeamConfig created successfully. Name: '{team_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")

autobyteus/agent_team/bootstrap_steps/__init__.py

@@ -4,20 +4,16 @@ Defines individual, self-contained steps for the agent team bootstrapping proces
 """
 
 from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
-from autobyteus.agent_team.bootstrap_steps.agent_team_runtime_queue_initialization_step import AgentTeamRuntimeQueueInitializationStep
 from autobyteus.agent_team.bootstrap_steps.team_context_initialization_step import TeamContextInitializationStep
 from autobyteus.agent_team.bootstrap_steps.task_notifier_initialization_step import TaskNotifierInitializationStep
-from autobyteus.agent_team.bootstrap_steps.coordinator_prompt_preparation_step import CoordinatorPromptPreparationStep
 from autobyteus.agent_team.bootstrap_steps.agent_configuration_preparation_step import AgentConfigurationPreparationStep
 from autobyteus.agent_team.bootstrap_steps.coordinator_initialization_step import CoordinatorInitializationStep
 from autobyteus.agent_team.bootstrap_steps.agent_team_bootstrapper import AgentTeamBootstrapper
 
 __all__ = [
     "BaseAgentTeamBootstrapStep",
-    "AgentTeamRuntimeQueueInitializationStep",
     "TeamContextInitializationStep",
     "TaskNotifierInitializationStep",
-    "CoordinatorPromptPreparationStep",
     "AgentConfigurationPreparationStep",
     "CoordinatorInitializationStep",
     "AgentTeamBootstrapper",

autobyteus/agent_team/bootstrap_steps/agent_configuration_preparation_step.py

@@ -4,11 +4,10 @@ from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
 from autobyteus.agent.context import AgentConfig
-from autobyteus.agent.message.send_message_to import SendMessageTo
+from autobyteus.agent_team.system_prompt_processor import TeamManifestInjectorProcessor
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +17,7 @@ class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
     agent in the team. It injects team-specific context, applies team-level
     settings like tool format overrides, and prepares the final coordinator prompt.
     """
-    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def execute(self, context: 'AgentTeamContext') -> bool:
         team_id = context.team_id
         logger.info(f"Team '{team_id}': Executing AgentConfigurationPreparationStep to prepare all agent configurations.")
         
@@ -28,8 +27,6 @@ class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
             return False
 
         try:
-            coordinator_node_config = context.config.coordinator_node
-            
             for node_config_wrapper in context.config.nodes:
                 # This step only configures direct agent members, not sub-teams.
                 if node_config_wrapper.is_sub_team:
@@ -44,13 +41,6 @@ class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
                 
                 final_config = node_definition.copy()
 
-                # --- Team-level Setting Propagation ---
-                # If the team config specifies a tool format, it overrides any agent-level setting.
-                if context.config.use_xml_tool_format is not None:
-                    final_config.use_xml_tool_format = context.config.use_xml_tool_format
-                    logger.debug(f"Team '{team_id}': Applied team-level use_xml_tool_format={final_config.use_xml_tool_format} to agent '{unique_name}'.")
-
-
                 # --- Shared Context Injection ---
                 # The shared context is injected into the initial_custom_data dictionary,
                 # which is then used by the AgentFactory to create the AgentRuntimeState.
@@ -63,12 +53,12 @@ class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
                 # The user is now fully responsible for defining all tools an agent needs
                 # in its AgentConfig. The framework no longer implicitly injects SendMessageTo.
                 
-                # If this is the coordinator, apply the prompt that was prepared in the previous step.
-                if node_config_wrapper == coordinator_node_config:
-                    coordinator_prompt = context.state.prepared_coordinator_prompt
-                    if coordinator_prompt:
-                        final_config.system_prompt = coordinator_prompt
-                        logger.info(f"Team '{team_id}': Applied dynamic prompt to coordinator '{unique_name}'.")
+                # Ensure the team manifest processor is attached for team agents.
+                if final_config.system_prompt_processors is None:
+                    final_config.system_prompt_processors = []
+                if not any(isinstance(p, TeamManifestInjectorProcessor) for p in final_config.system_prompt_processors):
+                    final_config.system_prompt_processors.append(TeamManifestInjectorProcessor())
+                    logger.debug(f"Team '{team_id}': Attached TeamManifestInjectorProcessor for agent '{unique_name}'.")
 
                 # Store the final, ready-to-use config in the team's state
                 context.state.final_agent_configs[unique_name] = final_config

autobyteus/agent_team/bootstrap_steps/agent_team_bootstrapper.py

@@ -3,17 +3,12 @@ import logging
 from typing import TYPE_CHECKING, List, Optional
 
 from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
-from autobyteus.agent_team.bootstrap_steps.agent_team_runtime_queue_initialization_step import AgentTeamRuntimeQueueInitializationStep
 from autobyteus.agent_team.bootstrap_steps.team_context_initialization_step import TeamContextInitializationStep
 from autobyteus.agent_team.bootstrap_steps.task_notifier_initialization_step import TaskNotifierInitializationStep
-from autobyteus.agent_team.bootstrap_steps.coordinator_prompt_preparation_step import CoordinatorPromptPreparationStep
 from autobyteus.agent_team.bootstrap_steps.agent_configuration_preparation_step import AgentConfigurationPreparationStep
 from autobyteus.agent_team.bootstrap_steps.coordinator_initialization_step import CoordinatorInitializationStep
-from autobyteus.agent_team.events.agent_team_events import AgentTeamReadyEvent
-
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -21,34 +16,27 @@ class AgentTeamBootstrapper:
     """Orchestrates the agent team's bootstrapping process."""
     def __init__(self, steps: Optional[List[BaseAgentTeamBootstrapStep]] = None):
         self.bootstrap_steps = steps or [
-            AgentTeamRuntimeQueueInitializationStep(),
             TeamContextInitializationStep(),
             TaskNotifierInitializationStep(),
-            CoordinatorPromptPreparationStep(),
             AgentConfigurationPreparationStep(),
             CoordinatorInitializationStep(),
         ]
 
-    async def run(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def run(self, context: 'AgentTeamContext') -> bool:
         team_id = context.team_id
-        await phase_manager.notify_bootstrapping_started()
         logger.info(f"Team '{team_id}': Bootstrapper starting.")
 
         for step in self.bootstrap_steps:
             step_name = step.__class__.__name__
             logger.debug(f"Team '{team_id}': Executing bootstrap step: {step_name}")
-            if not await step.execute(context, phase_manager):
+            if not await step.execute(context):
                 error_message = f"Bootstrap step {step_name} failed."
                 logger.error(f"Team '{team_id}': {error_message}")
-                await phase_manager.notify_error_occurred(error_message, f"Failed during bootstrap step '{step_name}'.")
                 return False
         
         logger.info(f"Team '{team_id}': All bootstrap steps completed successfully.")
-        if context.state.input_event_queues:
-            await context.state.input_event_queues.enqueue_internal_system_event(AgentTeamReadyEvent())
-        else:
+        if not context.state.input_event_queues:
             logger.critical(f"Team '{team_id}': Bootstrap succeeded but queues not available.")
-            await phase_manager.notify_error_occurred("Queues unavailable after bootstrap.", "")
             return False
-            
+
         return True

autobyteus/agent_team/bootstrap_steps/base_agent_team_bootstrap_step.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -13,7 +12,7 @@ class BaseAgentTeamBootstrapStep(ABC):
     """Abstract base class for individual steps in the agent team bootstrapping process."""
 
     @abstractmethod
-    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def execute(self, context: 'AgentTeamContext') -> bool:
         """
         Executes the bootstrap step.
 

autobyteus/agent_team/bootstrap_steps/coordinator_initialization_step.py

@@ -6,7 +6,6 @@ from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +15,7 @@ class CoordinatorInitializationStep(BaseAgentTeamBootstrapStep):
     using the TeamManager. This ensures the coordinator is ready before the
     agent team becomes idle.
     """
-    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def execute(self, context: 'AgentTeamContext') -> bool:
         team_id = context.team_id
         logger.info(f"Team '{team_id}': Executing CoordinatorInitializationStep.")
         

autobyteus/agent_team/bootstrap_steps/task_notifier_initialization_step.py

@@ -8,7 +8,6 @@ from autobyteus.agent_team.task_notification.system_event_driven_agent_task_noti
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -17,7 +16,7 @@ class TaskNotifierInitializationStep(BaseAgentTeamBootstrapStep):
     Bootstrap step to initialize the SystemEventDrivenAgentTaskNotifier if the
     team is configured for event-driven notifications.
     """
-    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def execute(self, context: 'AgentTeamContext') -> bool:
         team_id = context.team_id
         logger.info(f"Team '{team_id}': Executing TaskNotifierInitializationStep.")
         
@@ -27,9 +26,9 @@ class TaskNotifierInitializationStep(BaseAgentTeamBootstrapStep):
 
         logger.info(f"Team '{team_id}': Mode is SYSTEM_EVENT_DRIVEN. Initializing and activating task notifier.")
         try:
-            task_board = context.state.task_board
-            if not task_board:
-                logger.error(f"Team '{team_id}': TaskBoard not found. Cannot initialize task notifier. This step should run after TeamContextInitializationStep.")
+            task_plan = context.state.task_plan
+            if not task_plan:
+                logger.error(f"Team '{team_id}': TaskPlan not found. Cannot initialize task notifier. This step should run after TeamContextInitializationStep.")
                 return False
 
             team_manager = context.team_manager
@@ -38,7 +37,7 @@ class TaskNotifierInitializationStep(BaseAgentTeamBootstrapStep):
                 return False
 
             notifier = SystemEventDrivenAgentTaskNotifier(
-                task_board=task_board, 
+                task_plan=task_plan, 
                 team_manager=team_manager
             )
             notifier.start_monitoring()

autobyteus/agent_team/bootstrap_steps/team_context_initialization_step.py

@@ -3,41 +3,41 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
-from autobyteus.task_management import TaskBoard
+from autobyteus.task_management import TaskPlan
 from autobyteus.events.event_types import EventType
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
 class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
     """
     Bootstrap step to initialize shared team context components, such as the
-    TaskBoard, and bridges its events to the team's notifier.
+    TaskPlan, and bridges its events to the team's notifier.
     """
-    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+    async def execute(self, context: 'AgentTeamContext') -> bool:
         team_id = context.team_id
         logger.info(f"Team '{team_id}': Executing TeamContextInitializationStep.")
         try:
-            if context.state.task_board is None:
-                task_board = TaskBoard(team_id=team_id)
-                context.state.task_board = task_board
-                logger.info(f"Team '{team_id}': TaskBoard initialized and attached to team state.")
+            if context.state.task_plan is None:
+                task_plan = TaskPlan(team_id=team_id)
+                context.state.task_plan = task_plan
+                logger.info(f"Team '{team_id}': TaskPlan initialized and attached to team state.")
 
-                notifier = phase_manager.notifier
+                status_manager = context.status_manager
+                notifier = status_manager.notifier if status_manager else None
                 if notifier:
                     # The notifier, a long-lived component, subscribes to events
-                    # from the task_board, another long-lived component.
-                    notifier.subscribe_from(sender=task_board, event=EventType.TASK_BOARD_TASKS_ADDED, listener=notifier.handle_and_publish_task_board_event)
-                    notifier.subscribe_from(sender=task_board, event=EventType.TASK_BOARD_STATUS_UPDATED, listener=notifier.handle_and_publish_task_board_event)
-                    logger.info(f"Team '{team_id}': Successfully bridged TaskBoard events to the team notifier.")
+                    # from the task_plan, another long-lived component.
+                    notifier.subscribe_from(sender=task_plan, event=EventType.TASK_PLAN_TASKS_CREATED, listener=notifier.handle_and_publish_task_plan_event)
+                    notifier.subscribe_from(sender=task_plan, event=EventType.TASK_PLAN_STATUS_UPDATED, listener=notifier.handle_and_publish_task_plan_event)
+                    logger.info(f"Team '{team_id}': Successfully bridged TaskPlan events to the team notifier.")
                 else:
-                    logger.warning(f"Team '{team_id}': Notifier not found in PhaseManager. Cannot bridge TaskBoard events.")
+                    logger.warning(f"Team '{team_id}': Notifier not found in StatusManager. Cannot bridge TaskPlan events.")
 
             else:
-                logger.warning(f"Team '{team_id}': TaskBoard already exists. Skipping initialization.")
+                logger.warning(f"Team '{team_id}': TaskPlan already exists. Skipping initialization.")
 
             return True
         except Exception as e:

autobyteus/agent_team/context/agent_team_config.py

@@ -4,7 +4,10 @@ from dataclasses import dataclass, field
 from typing import List, Optional, Tuple
 
 from autobyteus.agent_team.context.team_node_config import TeamNodeConfig
-from autobyteus.agent_team.task_notification.task_notification_mode import TaskNotificationMode
+from autobyteus.agent_team.task_notification.task_notification_mode import (
+    TaskNotificationMode,
+    resolve_task_notification_mode,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -19,10 +22,10 @@ class AgentTeamConfig:
     nodes: Tuple[TeamNodeConfig, ...]
     coordinator_node: TeamNodeConfig
     role: Optional[str] = None
-    task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
-    use_xml_tool_format: Optional[bool] = None
+    task_notification_mode: TaskNotificationMode = field(init=False)
 
     def __post_init__(self):
+        object.__setattr__(self, "task_notification_mode", resolve_task_notification_mode())
         if not self.name or not isinstance(self.name, str):
             raise ValueError("The 'name' in AgentTeamConfig must be a non-empty string.")
         if not self.nodes:

autobyteus/agent_team/context/agent_team_context.py

@@ -2,11 +2,15 @@
 import logging
 from typing import TYPE_CHECKING, List, Optional, Dict
 
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_config import AgentTeamConfig
     from autobyteus.agent_team.context.agent_team_runtime_state import AgentTeamRuntimeState
     from autobyteus.agent.agent import Agent
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+    from autobyteus.agent_team.status.agent_team_status_manager import AgentTeamStatusManager
+    from autobyteus.agent_team.status.status_deriver import AgentTeamStatusDeriver
+    from autobyteus.agent_team.events.event_store import AgentTeamEventStore
     from autobyteus.agent_team.context.team_manager import TeamManager
     from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
     from autobyteus.agent.context import AgentConfig
@@ -49,8 +53,26 @@ class AgentTeamContext:
         return None
 
     @property
-    def phase_manager(self) -> Optional['AgentTeamPhaseManager']:
-        return self.state.phase_manager_ref
+    def status_manager(self) -> Optional['AgentTeamStatusManager']:
+        return self.state.status_manager_ref
+
+    @property
+    def current_status(self) -> 'AgentTeamStatus':
+        return self.state.current_status
+
+    @current_status.setter
+    def current_status(self, value: 'AgentTeamStatus'):
+        if not isinstance(value, AgentTeamStatus):  # pragma: no cover
+            raise TypeError(f"current_status must be an AgentTeamStatus instance. Got {type(value)}")
+        self.state.current_status = value
+
+    @property
+    def event_store(self) -> Optional['AgentTeamEventStore']:
+        return self.state.event_store
+
+    @property
+    def status_deriver(self) -> Optional['AgentTeamStatusDeriver']:
+        return self.state.status_deriver
 
     @property
     def team_manager(self) -> Optional['TeamManager']:

autobyteus/agent_team/context/agent_team_runtime_state.py

@@ -3,17 +3,19 @@ import logging
 from typing import List, Optional, TYPE_CHECKING, Dict
 from dataclasses import dataclass, 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.context import AgentConfig
 
 if TYPE_CHECKING:
     from autobyteus.agent.agent import Agent
     from autobyteus.agent_team.events.agent_team_input_event_queue_manager import AgentTeamInputEventQueueManager
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+    from autobyteus.agent_team.events.event_store import AgentTeamEventStore
+    from autobyteus.agent_team.status.agent_team_status_manager import AgentTeamStatusManager
+    from autobyteus.agent_team.status.status_deriver import AgentTeamStatusDeriver
     from autobyteus.agent_team.context.team_node_config import TeamNodeConfig
     from autobyteus.agent_team.context.team_manager import TeamManager
     from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
-    from autobyteus.task_management.base_task_board import BaseTaskBoard
+    from autobyteus.task_management.base_task_plan import BaseTaskPlan
     from autobyteus.agent_team.task_notification.system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 
 logger = logging.getLogger(__name__)
@@ -22,10 +24,9 @@ logger = logging.getLogger(__name__)
 class AgentTeamRuntimeState:
     """Encapsulates the dynamic, stateful data of a running agent team instance."""
     team_id: str
-    current_phase: AgentTeamOperationalPhase = AgentTeamOperationalPhase.UNINITIALIZED
+    current_status: AgentTeamStatus = AgentTeamStatus.UNINITIALIZED
     
     # State populated by bootstrap steps
-    prepared_coordinator_prompt: Optional[str] = None
     final_agent_configs: Dict[str, 'AgentConfig'] = field(default_factory=dict)
 
     # Core services
@@ -34,11 +35,13 @@ class AgentTeamRuntimeState:
 
     # Runtime components and references
     input_event_queues: Optional['AgentTeamInputEventQueueManager'] = None
-    phase_manager_ref: Optional['AgentTeamPhaseManager'] = None
+    status_manager_ref: Optional['AgentTeamStatusManager'] = None
     multiplexer_ref: Optional['AgentEventMultiplexer'] = None
+    event_store: Optional['AgentTeamEventStore'] = None
+    status_deriver: Optional['AgentTeamStatusDeriver'] = None
     
     # Dynamic planning and artifact state
-    task_board: Optional['BaseTaskBoard'] = None
+    task_plan: Optional['BaseTaskPlan'] = None
 
     def __post_init__(self):
         if not self.team_id or not isinstance(self.team_id, str):
@@ -48,7 +51,7 @@ class AgentTeamRuntimeState:
     def __repr__(self) -> str:
         agents_count = len(self.team_manager.get_all_agents()) if self.team_manager else 0
         coordinator_set = self.team_manager.coordinator_agent is not None if self.team_manager else False
-        return (f"<AgentTeamRuntimeState id='{self.team_id}', phase='{self.current_phase.value}', "
+        return (f"<AgentTeamRuntimeState id='{self.team_id}', status='{self.current_status.value}', "
                 f"agents_count={agents_count}, coordinator_set={coordinator_set}, "
                 f"final_configs_count={len(self.final_agent_configs)}, "
                 f"team_manager_set={self.team_manager is not None}>")

autobyteus/agent_team/events/__init__.py

@@ -6,7 +6,11 @@ from autobyteus.agent_team.events.agent_team_events import (
     BaseAgentTeamEvent,
     LifecycleAgentTeamEvent,
     OperationalAgentTeamEvent,
+    AgentTeamBootstrapStartedEvent,
     AgentTeamReadyEvent,
+    AgentTeamIdleEvent,
+    AgentTeamShutdownRequestedEvent,
+    AgentTeamStoppedEvent,
     AgentTeamErrorEvent,
     ProcessUserMessageEvent,
     InterAgentMessageRequestEvent,
@@ -14,16 +18,23 @@ from autobyteus.agent_team.events.agent_team_events import (
 )
 from autobyteus.agent_team.events.agent_team_event_dispatcher import AgentTeamEventDispatcher
 from autobyteus.agent_team.events.agent_team_input_event_queue_manager import AgentTeamInputEventQueueManager
+from autobyteus.agent_team.events.event_store import AgentTeamEventStore, EventEnvelope
 
 __all__ = [
     "BaseAgentTeamEvent",
     "LifecycleAgentTeamEvent",
     "OperationalAgentTeamEvent",
+    "AgentTeamBootstrapStartedEvent",
     "AgentTeamReadyEvent",
+    "AgentTeamIdleEvent",
+    "AgentTeamShutdownRequestedEvent",
+    "AgentTeamStoppedEvent",
     "AgentTeamErrorEvent",
     "ProcessUserMessageEvent",
     "InterAgentMessageRequestEvent",
     "ToolApprovalTeamEvent",
     "AgentTeamEventDispatcher",
     "AgentTeamInputEventQueueManager",
+    "AgentTeamEventStore",
+    "EventEnvelope",
 ]

autobyteus/agent_team/events/agent_team_event_dispatcher.py

@@ -3,12 +3,17 @@ import logging
 import traceback
 from typing import TYPE_CHECKING
 
-from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent, AgentTeamReadyEvent, ProcessUserMessageEvent
+from autobyteus.agent_team.events.agent_team_events import (
+    BaseAgentTeamEvent,
+    AgentTeamErrorEvent,
+    AgentTeamIdleEvent,
+    OperationalAgentTeamEvent,
+)
+from autobyteus.agent_team.status.status_update_utils import apply_event_and_derive_status
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
     from autobyteus.agent_team.handlers.agent_team_event_handler_registry import AgentTeamEventHandlerRegistry
-    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
 
 logger = logging.getLogger(__name__)
 
@@ -16,24 +21,32 @@ class AgentTeamEventDispatcher:
     """Dispatches agent team events to their appropriate handlers."""
 
     def __init__(self,
-                 event_handler_registry: 'AgentTeamEventHandlerRegistry',
-                 phase_manager: 'AgentTeamPhaseManager'):
+                 event_handler_registry: 'AgentTeamEventHandlerRegistry'):
         self.registry = event_handler_registry
-        self.phase_manager = phase_manager
 
     async def dispatch(self, event: BaseAgentTeamEvent, context: 'AgentTeamContext'):
-        handler = self.registry.get_handler(type(event))
         team_id = context.team_id
 
+        try:
+            await apply_event_and_derive_status(event, context)
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Team '{team_id}': Status derivation failed for '{type(event).__name__}': {e}", exc_info=True)
+
+        handler = self.registry.get_handler(type(event))
         if not handler:
             logger.warning(f"Team '{team_id}': No handler for event '{type(event).__name__}'.")
             return
 
         try:
             await handler.handle(event, context)
-            if isinstance(event, AgentTeamReadyEvent):
-                await self.phase_manager.notify_initialization_complete()
         except Exception as e:
             error_msg = f"Error handling '{type(event).__name__}' in team '{team_id}': {e}"
             logger.error(error_msg, exc_info=True)
-            await self.phase_manager.notify_error_occurred(error_msg, traceback.format_exc())
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=error_msg, exception_details=traceback.format_exc())
+                )
+        else:
+            if isinstance(event, OperationalAgentTeamEvent):
+                if context.state.input_event_queues:
+                    await context.state.input_event_queues.enqueue_internal_system_event(AgentTeamIdleEvent())

autobyteus/agent_team/events/agent_team_events.py

@@ -17,10 +17,26 @@ class OperationalAgentTeamEvent(BaseAgentTeamEvent):
     """Base class for events related to the agent team's operational logic."""
 
 # Specific Events
+@dataclass
+class AgentTeamBootstrapStartedEvent(LifecycleAgentTeamEvent):
+    """Indicates the agent team bootstrap sequence has begun."""
+
 @dataclass
 class AgentTeamReadyEvent(LifecycleAgentTeamEvent):
     """Indicates the agent team has completed bootstrapping and is ready for tasks."""
 
+@dataclass
+class AgentTeamIdleEvent(LifecycleAgentTeamEvent):
+    """Indicates the agent team has returned to an idle state after processing."""
+
+@dataclass
+class AgentTeamShutdownRequestedEvent(LifecycleAgentTeamEvent):
+    """Indicates a shutdown request has been issued for the agent team."""
+
+@dataclass
+class AgentTeamStoppedEvent(LifecycleAgentTeamEvent):
+    """Indicates the agent team has fully stopped."""
+
 @dataclass
 class AgentTeamErrorEvent(LifecycleAgentTeamEvent):
     """Indicates a significant error occurred within the agent team."""