autobyteus 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/agent_team/agent_team_builder.py

@@ -0,0 +1,184 @@
+# file: autobyteus/autobyteus/agent_team/agent_team_builder.py
+import logging
+from typing import List, Optional, Dict, Union, Set
+
+from autobyteus.agent_team.agent_team import AgentTeam
+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__)
+
+# Define a type hint for the possible definition types for clarity
+NodeDefinition = Union[AgentConfig, AgentTeamConfig]
+
+class AgentTeamBuilder:
+    """
+    A fluent API for constructing and configuring an AgentTeam.
+    
+    This builder simplifies creating an agent team by abstracting away the manual
+    creation of config objects and providing an intuitive way to define the
+    agent and sub-team graph. It enforces that all nodes within the team have
+    a unique name.
+    """
+    def __init__(self, name: str, description: str, role: Optional[str] = None):
+        """
+        Initializes the AgentTeamBuilder.
+
+        Args:
+            name: A unique name for the agent team.
+            description: A high-level description of the team's goal.
+            role: An optional role description for when this team is used
+                  as a sub-team within a parent.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Agent team name must be a non-empty string.")
+        if not description or not isinstance(description, str):
+            raise ValueError("Agent team description must be a non-empty string.")
+
+        self._name = name
+        self._description = description
+        self._role = role
+        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
+        logger.info(f"AgentTeamBuilder initialized for team: '{self._name}'.")
+
+    def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
+        """
+        Adds a regular agent node to the agent team.
+
+        Args:
+            agent_config: The configuration for the agent at this node.
+            dependencies: A list of AgentConfig or AgentTeamConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(agent_config, dependencies)
+        return self
+
+    def add_sub_team_node(self, team_config: AgentTeamConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
+        """
+        Adds a sub-team node to the agent team.
+
+        Args:
+            team_config: The configuration for the sub-team.
+            dependencies: A list of AgentConfig or AgentTeamConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(team_config, dependencies)
+        return self
+
+    def _add_node_internal(self, node_definition: NodeDefinition, dependencies: Optional[List[NodeDefinition]]):
+        """Internal helper to add a node of any type."""
+        if not isinstance(node_definition, (AgentConfig, AgentTeamConfig)):
+            raise TypeError("node_definition must be an instance of AgentConfig or AgentTeamConfig.")
+        
+        node_name = node_definition.name
+        if node_name in self._added_node_names:
+            # Enforce unique names. This is the new, simpler validation.
+            raise ValueError(f"Duplicate node name '{node_name}' detected. All nodes in a team must have a unique name.")
+
+        if node_definition in self._nodes or node_definition == self._coordinator_config:
+            raise ValueError(f"The exact same node definition object for '{node_name}' has already been added to the team.")
+
+        if dependencies:
+            for dep_config in dependencies:
+                if dep_config not in self._nodes and dep_config != self._coordinator_config:
+                    raise ValueError(f"Dependency node '{dep_config.name}' must be added to the builder before being used as a dependency.")
+
+        self._nodes[node_definition] = dependencies or []
+        self._added_node_names.add(node_name)
+        
+        node_type = "Sub-Team" if isinstance(node_definition, AgentTeamConfig) else "Agent"
+        logger.debug(f"Added {node_type} node '{node_name}' to builder with {len(dependencies or [])} dependencies.")
+
+    def set_coordinator(self, agent_config: AgentConfig) -> 'AgentTeamBuilder':
+        """
+        Sets the coordinator agent for the team. A coordinator must be an agent.
+
+        Args:
+            agent_config: The configuration for the coordinator agent.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if self._coordinator_config is not None:
+            raise ValueError("A coordinator has already been set for this team.")
+            
+        if not isinstance(agent_config, AgentConfig):
+            raise TypeError("Coordinator must be an instance of AgentConfig.")
+            
+        node_name = agent_config.name
+        if node_name in self._added_node_names:
+            raise ValueError(f"Duplicate node name '{node_name}' detected. The coordinator's name must also be unique within the team.")
+
+        self._coordinator_config = agent_config
+        self._added_node_names.add(node_name)
+        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 build(self) -> AgentTeam:
+        """
+        Constructs and returns the final AgentTeam instance using the
+        singleton AgentTeamFactory.
+        """
+        logger.info("Building AgentTeam from builder...")
+        if self._coordinator_config is None:
+            raise ValueError("Cannot build team: A coordinator must be set.")
+
+        node_map: Dict[NodeDefinition, TeamNodeConfig] = {}
+        # Ensure the coordinator config is also in the set of definitions to process
+        all_definitions = list(self._nodes.keys())
+        if self._coordinator_config not in all_definitions:
+             all_definitions.append(self._coordinator_config)
+        
+        for definition in all_definitions:
+            node_map[definition] = TeamNodeConfig(node_definition=definition)
+        
+        for node_def, dep_defs in self._nodes.items():
+            if node_def in node_map and dep_defs:
+                current_node = node_map[node_def]
+                dependency_nodes = [node_map[dep_def] for dep_def in dep_defs]
+                current_node.dependencies = tuple(dependency_nodes)
+
+        final_nodes = list(node_map.values())
+        coordinator_node_instance = node_map[self._coordinator_config]
+
+        team_config = AgentTeamConfig(
+            name=self._name,
+            description=self._description,
+            role=self._role,
+            nodes=tuple(final_nodes),
+            coordinator_node=coordinator_node_instance,
+            task_notification_mode=self._task_notification_mode
+        )
+        
+        logger.info(f"AgentTeamConfig created successfully. Name: '{team_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")
+
+        factory = AgentTeamFactory()
+        return factory.create_team(config=team_config)

autobyteus/agent_team/base_agent_team.py

@@ -0,0 +1,86 @@
+# file: autobyteus/autobyteus/agent_team/base_agent_team.py
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, Any, TYPE_CHECKING
+
+# These are forward declarations that might be used by subclasses.
+if TYPE_CHECKING:
+    from autobyteus.agent_team.agent_team import AgentTeam
+
+logger = logging.getLogger(__name__)
+
+class BaseAgentTeam(ABC):
+    """
+    Optional abstract base class for creating domain-specific, type-safe
+    APIs for agent teams.
+
+    Users can subclass BaseAgentTeam to create a more structured and
+    specific interface for their multi-agent tasks, rather than using the
+    generic `AgentTeam.process(**kwargs)` method directly.
+
+    Subclasses would typically encapsulate an `AgentTeam` instance and define
+    methods that map domain-specific inputs to the underlying team's execution.
+    """
+
+    def __init__(self,
+                 name: str,
+                 wrapped_team_instance: Optional['AgentTeam'] = None):
+        """
+        Initializes the BaseAgentTeam.
+
+        Args:
+            name: A descriptive name for this specific team implementation.
+            wrapped_team_instance: Optional. An instance of AgentTeam that this class
+                                   will wrap and delegate to. If not provided, the subclass
+                                   is responsible for initializing its own team instance.
+        """
+        self.name: str = name
+        self._wrapped_team: Optional[Any] = wrapped_team_instance
+        
+        if self._wrapped_team:
+            logger.info(f"BaseAgentTeam '{self.name}' initialized, wrapping an instance of "
+                        f"'{self._wrapped_team.__class__.__name__}'.")
+        else:
+            logger.info(f"BaseAgentTeam '{self.name}' initialized without a pre-wrapped instance. "
+                        "Subclass should handle team setup.")
+
+    @property
+    def wrapped_team(self) -> Optional[Any]:
+        """Provides access to the wrapped AgentTeam instance."""
+        return self._wrapped_team
+
+    @abstractmethod
+    async def start(self) -> None:
+        """
+        Starts the team. Subclasses should implement this to delegate
+        to the start method of their wrapped AgentTeam.
+        """
+        pass
+
+    @abstractmethod
+    async def stop(self, timeout: float = 10.0) -> None:
+        """
+        Stops the team. Subclasses should implement this to delegate
+        to the stop method of their wrapped AgentTeam.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def is_running(self) -> bool:
+        """
+        Checks if the team is currently running. Subclasses should implement
+        this to delegate to the is_running property of their wrapped instance.
+        """
+        pass
+    
+    def __repr__(self) -> str:
+        running_status = "N/A (not implemented by subclass)"
+        try:
+            running_status = str(self.is_running)
+        except NotImplementedError:
+            pass
+            
+        return (f"<{self.__class__.__name__} name='{self.name}', "
+                f"wraps='{self._wrapped_team.__class__.__name__ if self._wrapped_team else 'NoneInternal'}', "
+                f"is_running={running_status}>")

autobyteus/agent_team/bootstrap_steps/__init__.py

@@ -0,0 +1,24 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/__init__.py
+"""
+Defines individual, self-contained steps for the agent team bootstrapping process.
+"""
+
+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

@@ -0,0 +1,73 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_configuration_preparation_step.py
+import logging
+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
+
+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 AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
+    """
+    Bootstrap step to prepare the final, immutable configuration for every
+    agent in the team. It injects team-specific context and applies the final
+    coordinator prompt. It no longer injects tools.
+    """
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing AgentConfigurationPreparationStep to prepare all agent configurations.")
+        
+        team_manager = context.team_manager
+        if not team_manager:
+            logger.error(f"Team '{team_id}': TeamManager not found in context during agent config preparation.")
+            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:
+                    continue
+
+                unique_name = node_config_wrapper.name
+                node_definition = node_config_wrapper.node_definition
+
+                if not isinstance(node_definition, AgentConfig):
+                    logger.warning(f"Team '{team_id}': Node '{unique_name}' has an unexpected definition type and will be skipped: {type(node_definition)}")
+                    continue
+                
+                final_config = node_definition.copy()
+
+                # --- 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.
+                if final_config.initial_custom_data is None:
+                    final_config.initial_custom_data = {}
+                final_config.initial_custom_data["team_context"] = context
+                logger.debug(f"Team '{team_id}': Injected shared team_context into initial_custom_data for agent '{unique_name}'.")
+
+                # --- Tool Injection Logic Removed ---
+                # 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}'.")
+
+                # Store the final, ready-to-use config in the team's state
+                context.state.final_agent_configs[unique_name] = final_config
+                logger.info(f"Team '{team_id}': Prepared final config for agent '{unique_name}' with user-defined tools: {[t.get_name() for t in final_config.tools]}")
+            
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Failed during agent configuration preparation: {e}", exc_info=True)
+            return False

autobyteus/agent_team/bootstrap_steps/agent_team_bootstrapper.py

@@ -0,0 +1,54 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_team_bootstrapper.py
+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__)
+
+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:
+        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):
+                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:
+            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/agent_team_runtime_queue_initialization_step.py

@@ -0,0 +1,25 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_team_runtime_queue_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent_team.events.agent_team_input_event_queue_manager import AgentTeamInputEventQueueManager
+
+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 AgentTeamRuntimeQueueInitializationStep(BaseAgentTeamBootstrapStep):
+    """Bootstrap step for initializing the agent team's runtime event queues."""
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing AgentTeamRuntimeQueueInitializationStep.")
+        try:
+            context.state.input_event_queues = AgentTeamInputEventQueueManager()
+            logger.info(f"Team '{team_id}': AgentTeamInputEventQueueManager initialized.")
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Critical failure during queue initialization: {e}", exc_info=True)
+            return False

autobyteus/agent_team/bootstrap_steps/base_agent_team_bootstrap_step.py

@@ -0,0 +1,23 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/base_agent_team_bootstrap_step.py
+import logging
+from abc import ABC, abstractmethod
+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__)
+
+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:
+        """
+        Executes the bootstrap step.
+
+        Returns:
+            True if the step completed successfully, False otherwise.
+        """
+        raise NotImplementedError("Subclasses must implement the 'execute' method.")

autobyteus/agent_team/bootstrap_steps/coordinator_initialization_step.py

@@ -0,0 +1,41 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/coordinator_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+
+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 CoordinatorInitializationStep(BaseAgentTeamBootstrapStep):
+    """
+    Bootstrap step that eagerly instantiates and starts the coordinator agent
+    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:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing CoordinatorInitializationStep.")
+        
+        try:
+            team_manager = context.team_manager
+            if not team_manager:
+                raise RuntimeError("TeamManager not found in team context. It should be created by the factory.")
+
+            coordinator_name = context.config.coordinator_node.name
+
+            # This call now ensures the coordinator agent is fully created and ready.
+            coordinator = await team_manager.ensure_coordinator_is_ready(coordinator_name)
+            
+            if not coordinator:
+                raise RuntimeError(f"TeamManager failed to return a ready coordinator agent for '{coordinator_name}'.")
+
+            logger.info(f"Team '{team_id}': Coordinator '{coordinator_name}' initialized and started via TeamManager.")
+            return True
+        
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Failed to initialize coordinator agent: {e}", exc_info=True)
+            return False

autobyteus/agent_team/bootstrap_steps/coordinator_prompt_preparation_step.py

@@ -0,0 +1,85 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/coordinator_prompt_preparation_step.py
+import logging
+from typing import TYPE_CHECKING, List
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent.context import AgentConfig
+from autobyteus.agent_team.context import AgentTeamConfig
+
+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 CoordinatorPromptPreparationStep(BaseAgentTeamBootstrapStep):
+    """
+    Bootstrap step to finalize the coordinator's system prompt by injecting a
+    dynamically generated team manifest into a user-defined prompt template.
+    The user is expected to provide a `system_prompt` in the coordinator's
+    AgentConfig with a `{{team}}` placeholder.
+    """
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing CoordinatorPromptPreparationStep.")
+        try:
+            coordinator_node_config_wrapper = context.config.coordinator_node
+            
+            # The coordinator must be an agent with a defined config.
+            if not isinstance(coordinator_node_config_wrapper.node_definition, AgentConfig):
+                logger.error(f"Team '{team_id}': Coordinator node '{coordinator_node_config_wrapper.name}' is not defined by an AgentConfig. Cannot prepare prompt.")
+                return False
+            
+            coordinator_agent_config: AgentConfig = coordinator_node_config_wrapper.node_definition
+            
+            # Start with the user's provided prompt template.
+            prompt_template = coordinator_agent_config.system_prompt
+            if not prompt_template:
+                logger.warning(f"Team '{team_id}': Coordinator '{coordinator_agent_config.name}' has no system_prompt defined. No prompt will be applied.")
+                context.state.prepared_coordinator_prompt = ""
+                return True
+
+            team_manifest = self._generate_team_manifest(context)
+            
+            # Inject the manifest into the template.
+            if "{{team}}" in prompt_template:
+                final_prompt = prompt_template.replace("{{team}}", team_manifest)
+                logger.debug(f"Team '{team_id}': Injected team manifest into coordinator's system prompt.")
+            else:
+                final_prompt = prompt_template
+                logger.warning(f"Team '{team_id}': The coordinator's system prompt does not contain a '{{team}}' placeholder. The team manifest will not be injected.")
+            
+            # Store the finalized prompt in the state for the AgentToolInjectionStep to use.
+            context.state.prepared_coordinator_prompt = final_prompt
+
+            logger.info(f"Team '{team_id}': Coordinator prompt prepared successfully and stored in state.")
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Failed to prepare coordinator prompt: {e}", exc_info=True)
+            return False
+
+    def _generate_team_manifest(self, context: 'AgentTeamContext') -> str:
+        """Generates a string manifest of all non-coordinator team members."""
+        prompt_parts: List[str] = []
+        coordinator_node = context.config.coordinator_node
+        member_nodes = {node for node in context.config.nodes if node != coordinator_node}
+
+        if not member_nodes:
+            return "You are working alone. You have no team members to delegate to."
+
+        # Sort for deterministic prompt generation
+        for node in sorted(list(member_nodes), key=lambda n: n.name):
+            node_def = node.node_definition
+            description = "No description available."
+            
+            # --- THE FIX ---
+            # Use the 'description' for an AgentConfig and the 'role' for an AgentTeamConfig (sub-team).
+            if isinstance(node_def, AgentConfig):
+                description = node_def.description
+            elif isinstance(node_def, AgentTeamConfig):
+                # A sub-team's role is its most concise and relevant description for a parent coordinator.
+                description = node_def.role or node_def.description
+            
+            prompt_parts.append(f"- name: {node.name}\n  description: {description}")
+        
+        return "\n".join(prompt_parts)

autobyteus/agent_team/bootstrap_steps/task_notifier_initialization_step.py

@@ -0,0 +1,51 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/task_notifier_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent_team.task_notification.task_notification_mode import TaskNotificationMode
+from autobyteus.agent_team.task_notification.system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
+
+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 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:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing TaskNotifierInitializationStep.")
+        
+        if context.config.task_notification_mode != TaskNotificationMode.SYSTEM_EVENT_DRIVEN:
+            logger.info(f"Team '{team_id}': Task notification mode is '{context.config.task_notification_mode.value}'. Skipping event-driven notifier setup.")
+            return True
+
+        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.")
+                return False
+
+            team_manager = context.team_manager
+            if not team_manager:
+                logger.error(f"Team '{team_id}': TeamManager not found. Cannot initialize task notifier.")
+                return False
+
+            notifier = SystemEventDrivenAgentTaskNotifier(
+                task_board=task_board, 
+                team_manager=team_manager
+            )
+            notifier.start_monitoring()
+            
+            context.state.task_notifier = notifier
+            logger.info(f"Team '{team_id}': SystemEventDrivenAgentTaskNotifier initialized and monitoring started.")
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Critical failure during task notifier initialization: {e}", exc_info=True)
+            return False