autobyteus 1.2.1__py3-none-any.whl → 1.3.0__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.")
         

autobyteus/agent_team/bootstrap_steps/team_context_initialization_step.py

@@ -8,7 +8,6 @@ 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__)
 
@@ -17,7 +16,7 @@ class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
     Bootstrap step to initialize shared team context components, such as the
     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:
@@ -26,7 +25,8 @@ class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
                 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_plan, another long-lived component.
@@ -34,7 +34,7 @@ class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
                     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 TaskPlan events.")
+                    logger.warning(f"Team '{team_id}': Notifier not found in StatusManager. Cannot bridge TaskPlan events.")
 
             else:
                 logger.warning(f"Team '{team_id}': TaskPlan already exists. Skipping initialization.")

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,13 +3,15 @@ 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
@@ -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,8 +35,10 @@ 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_plan: Optional['BaseTaskPlan'] = None
@@ -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."""

autobyteus/agent_team/events/event_store.py

@@ -0,0 +1,57 @@
+# file: autobyteus/autobyteus/agent_team/events/event_store.py
+from __future__ import annotations
+
+import logging
+import time
+import uuid
+from dataclasses import dataclass
+from typing import List, Optional
+
+from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class EventEnvelope:
+    event_id: str
+    event_type: str
+    timestamp: float
+    team_id: str
+    event: BaseAgentTeamEvent
+    correlation_id: Optional[str] = None
+    caused_by_event_id: Optional[str] = None
+    sequence: int = 0
+
+
+class AgentTeamEventStore:
+    """
+    Simple in-memory event store for agent team events.
+    """
+    def __init__(self, team_id: str):
+        self._team_id = team_id
+        self._events: List[EventEnvelope] = []
+        self._sequence: int = 0
+        logger.debug(f"AgentTeamEventStore initialized for team_id '{team_id}'.")
+
+    def append(self,
+               event: BaseAgentTeamEvent,
+               correlation_id: Optional[str] = None,
+               caused_by_event_id: Optional[str] = None) -> EventEnvelope:
+        envelope = EventEnvelope(
+            event_id=str(uuid.uuid4()),
+            event_type=type(event).__name__,
+            timestamp=time.time(),
+            team_id=self._team_id,
+            event=event,
+            correlation_id=correlation_id,
+            caused_by_event_id=caused_by_event_id,
+            sequence=self._sequence,
+        )
+        self._sequence += 1
+        self._events.append(envelope)
+        logger.debug(f"Appended event '{envelope.event_type}' to store for team '{self._team_id}'.")
+        return envelope
+
+    def all_events(self) -> List[EventEnvelope]:
+        return list(self._events)

autobyteus/agent_team/factory/agent_team_factory.py

@@ -17,7 +17,11 @@ from autobyteus.agent_team.handlers.inter_agent_message_request_event_handler im
 from autobyteus.agent_team.handlers.tool_approval_team_event_handler import ToolApprovalTeamEventHandler
 from autobyteus.agent_team.events.agent_team_events import (
     ProcessUserMessageEvent,
+    AgentTeamBootstrapStartedEvent,
     AgentTeamReadyEvent,
+    AgentTeamIdleEvent,
+    AgentTeamShutdownRequestedEvent,
+    AgentTeamStoppedEvent,
     AgentTeamErrorEvent,
     InterAgentMessageRequestEvent,
     ToolApprovalTeamEvent
@@ -41,7 +45,11 @@ class AgentTeamFactory(metaclass=SingletonMeta):
         registry.register(InterAgentMessageRequestEvent, InterAgentMessageRequestEventHandler())
         registry.register(ToolApprovalTeamEvent, ToolApprovalTeamEventHandler())
         lifecycle_handler = LifecycleAgentTeamEventHandler()
+        registry.register(AgentTeamBootstrapStartedEvent, lifecycle_handler)
         registry.register(AgentTeamReadyEvent, lifecycle_handler)
+        registry.register(AgentTeamIdleEvent, lifecycle_handler)
+        registry.register(AgentTeamShutdownRequestedEvent, lifecycle_handler)
+        registry.register(AgentTeamStoppedEvent, lifecycle_handler)
         registry.register(AgentTeamErrorEvent, lifecycle_handler)
         return registry