autobyteus 1.1.8__py3-none-any.whl → 1.1.9__py3-none-any.whl

autobyteus/agent/message/agent_input_user_message.py

@@ -4,6 +4,7 @@ from typing import Optional, List, Dict, Any
 from dataclasses import dataclass, field
 
 from .context_file import ContextFile # Import the new ContextFile dataclass
+from autobyteus.agent.sender_type import SenderType
 
 logger = logging.getLogger(__name__)
 
@@ -15,11 +16,14 @@ class AgentInputUserMessage:
     allowing users to provide various documents and media as context via a single list.
     """
     content: str
+    sender_type: SenderType = SenderType.USER
     context_files: Optional[List[ContextFile]] = field(default=None)
     metadata: Dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self):
         # Basic type validation that dataclasses don't do automatically for mutable defaults or complex types
+        if not isinstance(self.sender_type, SenderType):
+            raise TypeError(f"AgentInputUserMessage 'sender_type' must be a SenderType enum. Got {type(self.sender_type)}")
         if self.context_files is not None and not (isinstance(self.context_files, list) and all(isinstance(cf, ContextFile) for cf in self.context_files)):
             raise TypeError("AgentInputUserMessage 'context_files' must be a list of ContextFile objects if provided.")
         if not isinstance(self.metadata, dict): # Should be caught by default_factory, but good practice
@@ -30,7 +34,7 @@ class AgentInputUserMessage:
         if logger.isEnabledFor(logging.DEBUG):
             num_context_files = len(self.context_files) if self.context_files else 0
             logger.debug(
-                f"AgentInputUserMessage initialized. Content: '{self.content[:50]}...', "
+                f"AgentInputUserMessage initialized. SenderType: {self.sender_type.value}, Content: '{self.content[:50]}...', "
                 f"Num ContextFiles: {num_context_files}, "
                 f"Metadata keys: {list(self.metadata.keys())}"
             )
@@ -44,6 +48,7 @@ class AgentInputUserMessage:
 
         return {
             "content": self.content,
+            "sender_type": self.sender_type.value,
             "context_files": context_files_dict_list,
             "metadata": self.metadata,
         }
@@ -55,6 +60,13 @@ class AgentInputUserMessage:
         if not isinstance(content, str): # Ensure content is string
             raise ValueError("AgentInputUserMessage 'content' in dictionary must be a string.")
 
+        sender_type_val = data.get("sender_type", "user")
+        try:
+            sender_type = SenderType(sender_type_val)
+        except ValueError:
+            logger.warning(f"Invalid sender_type '{sender_type_val}' in AgentInputUserMessage data. Defaulting to USER.")
+            sender_type = SenderType.USER
+
         context_files_data = data.get("context_files")
         context_files_list: Optional[List[ContextFile]] = None
         if context_files_data is not None:
@@ -68,6 +80,7 @@ class AgentInputUserMessage:
 
         return cls(
             content=content,
+            sender_type=sender_type,
             context_files=context_files_list,
             metadata=metadata
         )
@@ -82,5 +95,5 @@ class AgentInputUserMessage:
             
         meta_repr = f", metadata_keys={list(self.metadata.keys())}" if self.metadata else ""
         
-        return (f"AgentInputUserMessage(content='{content_preview}'"
+        return (f"AgentInputUserMessage(sender_type='{self.sender_type.value}', content='{content_preview}'"
                 f"{context_repr}{meta_repr})")

autobyteus/agent/message/send_message_to.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
 # This import is for type hinting only and avoids circular dependencies at runtime
 if TYPE_CHECKING:

autobyteus/agent/processor_option.py

@@ -0,0 +1,17 @@
+# file: autobyteus/autobyteus/agent/processor_option.py
+"""
+Defines common data transfer objects for agent component options.
+"""
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class ProcessorOption:
+    """A data class representing a processor option for configuration."""
+    name: str
+    is_mandatory: bool
+
+@dataclass(frozen=True)
+class HookOption:
+    """A data class representing a hook option for configuration."""
+    name: str
+    is_mandatory: bool

autobyteus/agent/sender_type.py

@@ -9,6 +9,7 @@ class SenderType(str, Enum):
     USER = "user"        # A message originating from an external human user.
     AGENT = "agent"      # A message from another agent within the same team or a different team.
     SYSTEM = "system"    # An automated message from an internal system component.
+    TOOL = "tool"        # A message generated as the result of a tool execution.
 
 
 # --- System Sender Identification ---

autobyteus/agent/system_prompt_processor/base_processor.py

@@ -24,6 +24,22 @@ class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
         """
         return cls.__name__
 
+    @classmethod
+    def get_order(cls) -> int:
+        """
+        Returns the execution order for this processor. Lower numbers execute earlier.
+        Defaults to 500 (normal priority).
+        """
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """
+        Returns True if this processor is mandatory for the agent to function correctly.
+        Defaults to False (optional).
+        """
+        return False
+
     @abstractmethod
     def process(self,
                 system_prompt: str,
@@ -45,4 +61,4 @@ class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
         raise NotImplementedError("Subclasses must implement the 'process' method.")
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"
+        return f"&lt;{self.__class__.__name__}&gt;"

autobyteus/agent/system_prompt_processor/processor_registry.py

@@ -3,6 +3,7 @@ import logging
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.processor_option import ProcessorOption
 from .processor_definition import SystemPromptProcessorDefinition # Relative import
 
 if TYPE_CHECKING:
@@ -24,14 +25,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def register_processor(self, definition: SystemPromptProcessorDefinition) -> None:
         """
         Registers a system prompt processor definition.
-        If a definition with the same name already exists, it will be overwritten,
-        and a warning will be logged.
-
-        Args:
-            definition: The SystemPromptProcessorDefinition object to register.
-
-        Raises:
-            TypeError: If the definition is not an instance of SystemPromptProcessorDefinition.
         """
         if not isinstance(definition, SystemPromptProcessorDefinition):
             raise TypeError(f"Expected SystemPromptProcessorDefinition instance, got {type(definition).__name__}.")
@@ -46,12 +39,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def get_processor_definition(self, name: str) -> Optional[SystemPromptProcessorDefinition]:
         """
         Retrieves a system prompt processor definition by its name.
-
-        Args:
-            name: The name of the system prompt processor definition to retrieve.
-
-        Returns:
-            The SystemPromptProcessorDefinition object if found, otherwise None.
         """
         if not isinstance(name, str):
             logger.warning(f"Attempted to retrieve system prompt processor definition with non-string name: {type(name).__name__}.")
@@ -64,12 +51,6 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
     def get_processor(self, name: str) -> Optional['BaseSystemPromptProcessor']:
         """
         Retrieves an instance of a system prompt processor by its name.
-
-        Args:
-            name: The name of the system prompt processor to retrieve.
-
-        Returns:
-            An instance of the BaseSystemPromptProcessor if found and instantiable, otherwise None.
         """
         definition = self.get_processor_definition(name)
         if definition:
@@ -83,19 +64,26 @@ class SystemPromptProcessorRegistry(metaclass=SingletonMeta):
 
     def list_processor_names(self) -> List[str]:
         """
-        Returns a list of names of all registered system prompt processor definitions.
-
-        Returns:
-            A list of strings, where each string is a registered processor name.
+        Returns an unordered list of names of all registered system prompt processor definitions.
         """
         return list(self._definitions.keys())
 
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        """
+        Returns a list of ProcessorOption objects, sorted by their execution order.
+        """
+        definitions = list(self._definitions.values())
+        sorted_definitions = sorted(definitions, key=lambda d: d.processor_class.get_order())
+        return [
+            ProcessorOption(
+                name=d.name,
+                is_mandatory=d.processor_class.is_mandatory()
+            ) for d in sorted_definitions
+        ]
+
     def get_all_definitions(self) -> Dict[str, SystemPromptProcessorDefinition]:
         """
         Returns a shallow copy of the dictionary containing all registered system prompt processor definitions.
-
-        Returns:
-            A dictionary where keys are processor names and values are SystemPromptProcessorDefinition objects.
         """
         return dict(self._definitions)
 

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -32,6 +32,16 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
     def get_name(cls) -> str:
         return "ToolManifestInjector"
 
+    @classmethod
+    def get_order(cls) -> int:
+        """Explicitly set to default, as it's often the only system prompt processor."""
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """This processor is essential for the LLM to know which tools are available."""
+        return True
+
     def process(self, system_prompt: str, tool_instances: Dict[str, 'BaseTool'], agent_id: str, context: 'AgentContext') -> str:
         try:
             prompt_template = PromptTemplate(template=system_prompt)

autobyteus/agent/tool_execution_result_processor/base_processor.py

@@ -26,6 +26,22 @@ class BaseToolExecutionResultProcessor(ABC, metaclass=ToolExecutionResultProcess
         """
         return cls.__name__
 
+    @classmethod
+    def get_order(cls) -> int:
+        """
+        Returns the execution order for this processor. Lower numbers execute earlier.
+        Defaults to 500 (normal priority).
+        """
+        return 500
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        """
+        Returns True if this processor is mandatory for the agent to function correctly.
+        Defaults to False (optional).
+        """
+        return False
+
     @abstractmethod
     async def process(self,
                       event: 'ToolResultEvent',
@@ -43,4 +59,4 @@ class BaseToolExecutionResultProcessor(ABC, metaclass=ToolExecutionResultProcess
         raise NotImplementedError("Subclasses must implement the 'process' method.")
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"
+        return f"&lt;{self.__class__.__name__}&gt;"

autobyteus/agent/tool_execution_result_processor/processor_registry.py

@@ -3,6 +3,7 @@ import logging
 from typing import TYPE_CHECKING, Dict, List, Optional
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.processor_option import ProcessorOption
 from .processor_definition import ToolExecutionResultProcessorDefinition
 
 if TYPE_CHECKING:
@@ -56,10 +57,23 @@ class ToolExecutionResultProcessorRegistry(metaclass=SingletonMeta):
 
     def list_processor_names(self) -> List[str]:
         """
-        Returns a list of names of all registered processor definitions.
+        Returns an unordered list of names of all registered processor definitions.
         """
         return list(self._definitions.keys())
 
+    def get_ordered_processor_options(self) -> List[ProcessorOption]:
+        """
+        Returns a list of ProcessorOption objects, sorted by their execution order.
+        """
+        definitions = list(self._definitions.values())
+        sorted_definitions = sorted(definitions, key=lambda d: d.processor_class.get_order())
+        return [
+            ProcessorOption(
+                name=d.name,
+                is_mandatory=d.processor_class.is_mandatory()
+            ) for d in sorted_definitions
+        ]
+
     def get_all_definitions(self) -> Dict[str, ToolExecutionResultProcessorDefinition]:
         """
         Returns a dictionary of all registered processor definitions.

autobyteus/agent/workspace/base_workspace.py

@@ -3,7 +3,7 @@ import logging
 import uuid
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Dict, TYPE_CHECKING
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.agent.workspace.workspace_meta import WorkspaceMeta
 from autobyteus.agent.workspace.workspace_config import WorkspaceConfig
 

autobyteus/agent/workspace/workspace_definition.py

@@ -4,7 +4,7 @@ for a specific type of agent workspace.
 """
 import logging
 from typing import Type, Optional, TYPE_CHECKING
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 
 if TYPE_CHECKING:
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace

autobyteus/agent_team/bootstrap_steps/team_context_initialization_step.py

@@ -30,7 +30,7 @@ class TeamContextInitializationStep(BaseAgentTeamBootstrapStep):
                 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_PLAN_PUBLISHED, listener=notifier.handle_and_publish_task_board_event)
+                    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.")
                 else:

autobyteus/agent_team/streaming/agent_team_stream_event_payloads.py

@@ -3,7 +3,7 @@ from typing import Optional, Any
 from pydantic import BaseModel, Field
 from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
-from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
 # Need to use a forward reference string to avoid circular import at runtime
 from typing import TYPE_CHECKING, Union
 if TYPE_CHECKING:
@@ -29,4 +29,4 @@ class SubTeamEventRebroadcastPayload(BaseModel):
     sub_team_event: "AgentTeamStreamEvent" = Field(..., description="The original, unmodified event from the sub-team's stream")
 
 # --- Payload for events originating from the "TASK_BOARD" source ---
-TaskBoardEventPayload = Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent]
+TaskBoardEventPayload = Union[TasksAddedEvent, TaskStatusUpdatedEvent]

autobyteus/agent_team/task_notification/__init__.py

@@ -4,8 +4,12 @@ This package contains components for automatically notifying agents of runnable
 """
 from .system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 from .task_notification_mode import TaskNotificationMode
+from .activation_policy import ActivationPolicy
+from .task_activator import TaskActivator
 
 __all__ = [
     "SystemEventDrivenAgentTaskNotifier",
     "TaskNotificationMode",
+    "ActivationPolicy",
+    "TaskActivator",
 ]

autobyteus/agent_team/task_notification/activation_policy.py

@@ -0,0 +1,70 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/activation_policy.py
+"""
+Defines the policy for deciding which agents should be activated based on task runnability.
+"""
+import logging
+from typing import List, Set
+
+from autobyteus.task_management.task import Task
+
+logger = logging.getLogger(__name__)
+
+class ActivationPolicy:
+    """
+    Encapsulates the "Single Wave" notification logic for an agent team.
+
+    This class maintains a stateful set of agents that have already been
+    activated. It decides which new agents should receive a "start work"
+    notification based on a list of currently runnable tasks.
+    """
+    def __init__(self, team_id: str):
+        """
+        Initializes the ActivationPolicy.
+
+        Args:
+            team_id: The ID of the team this policy belongs to, for logging.
+        """
+        self._team_id = team_id
+        self._activated_agents: Set[str] = set()
+        logger.debug(f"ActivationPolicy initialized for team '{self._team_id}'.")
+
+    def reset(self):
+        """
+        Resets the activation state. This should be called when a new batch of
+        tasks is published to the task board, signifying a new plan or a
+        significant change in scope.
+        """
+        logger.info(f"Team '{self._team_id}': ActivationPolicy state has been reset. All agents are now considered inactive.")
+        self._activated_agents.clear()
+
+    def determine_activations(self, runnable_tasks: List[Task]) -> List[str]:
+        """
+        Determines which agents should be activated based on a list of runnable tasks.
+
+        An agent is selected for activation if they have one or more runnable tasks
+        and have not already been activated in the current work cycle.
+
+        This method is stateful: it updates its internal set of activated agents
+        with the new agents it returns.
+
+        Args:
+            runnable_tasks: A list of tasks that are currently runnable.
+
+        Returns:
+            A list of unique agent names that should be activated.
+        """
+        if not runnable_tasks:
+            return []
+
+        agents_with_runnable_tasks = {task.assignee_name for task in runnable_tasks}
+        
+        # Determine which of these agents have not yet been activated.
+        new_agents_to_activate = list(agents_with_runnable_tasks - self._activated_agents)
+
+        if new_agents_to_activate:
+            # Update the state to remember that these agents have now been activated.
+            self._activated_agents.update(new_agents_to_activate)
+            logger.info(f"Team '{self._team_id}': Policy determined {len(new_agents_to_activate)} new agent(s) to activate: {new_agents_to_activate}. "
+                        f"Total activated agents is now {len(self._activated_agents)}.")
+        
+        return new_agents_to_activate

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

@@ -1,14 +1,14 @@
 # file: autobyteus/autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py
-import asyncio
 import logging
-from typing import Set, Any, TYPE_CHECKING, List, Union
+from typing import Union, TYPE_CHECKING
 
 from autobyteus.events.event_types import EventType
-from autobyteus.agent_team.events import ProcessUserMessageEvent
-from autobyteus.agent.message import AgentInputUserMessage
-from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
 from autobyteus.task_management.base_task_board import TaskStatus
-from autobyteus.task_management.task_plan import Task
+
+# Import the new, separated components
+from .activation_policy import ActivationPolicy
+from .task_activator import TaskActivator
 
 if TYPE_CHECKING:
     from autobyteus.task_management.base_task_board import BaseTaskBoard
@@ -18,8 +18,11 @@ logger = logging.getLogger(__name__)
 
 class SystemEventDrivenAgentTaskNotifier:
     """
-    An internal component that monitors a TaskBoard and automatically sends
-    notifications to agents when their assigned tasks become runnable.
+    An internal component that monitors a TaskBoard and orchestrates agent
+    activation based on task runnability.
+
+    This class acts as a conductor, delegating the logic for *when* to activate
+    to an ActivationPolicy and the action of *how* to activate to a TaskActivator.
     """
     def __init__(self, task_board: 'BaseTaskBoard', team_manager: 'TeamManager'):
         """
@@ -27,138 +30,69 @@ class SystemEventDrivenAgentTaskNotifier:
 
         Args:
             task_board: The team's shared task board instance.
-            team_manager: The team's manager for submitting notification events.
+            team_manager: The team's manager for activating agents.
         """
         if not task_board or not team_manager:
             raise ValueError("TaskBoard and TeamManager are required for the notifier.")
             
         self._task_board = task_board
         self._team_manager = team_manager
-        self._dispatched_task_ids: Set[str] = set()
-        logger.info(f"SystemEventDrivenAgentTaskNotifier initialized for team '{self._team_manager.team_id}'.")
+        
+        # Instantiate the components that hold the actual logic and action
+        self._policy = ActivationPolicy(team_id=self._team_manager.team_id)
+        self._activator = TaskActivator(team_manager=self._team_manager)
+
+        logger.info(f"SystemEventDrivenAgentTaskNotifier orchestrator initialized for team '{self._team_manager.team_id}'.")
 
     def start_monitoring(self):
         """
         Subscribes to task board events to begin monitoring for runnable tasks.
-        This should be called once during the agent team's bootstrap process.
         """
-        self._task_board.subscribe(
-            EventType.TASK_BOARD_PLAN_PUBLISHED,
-            self._handle_task_board_update
-        )
-        self._task_board.subscribe(
-            EventType.TASK_BOARD_STATUS_UPDATED,
-            self._handle_task_board_update
-        )
-        logger.info(f"Team '{self._team_manager.team_id}': Task notifier is now monitoring TaskBoard events.")
-
-    async def _handle_task_board_update(self, payload: Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent], **kwargs):
+        self._task_board.subscribe(EventType.TASK_BOARD_TASKS_ADDED, self._handle_tasks_changed)
+        self._task_board.subscribe(EventType.TASK_BOARD_STATUS_UPDATED, self._handle_tasks_changed)
+        logger.info(f"Team '{self._team_manager.team_id}': Task notifier orchestrator is now monitoring TaskBoard events.")
+    
+    async def _handle_tasks_changed(self, payload: Union[TasksAddedEvent, TaskStatusUpdatedEvent], **kwargs):
         """
-        Asynchronous event handler triggered by the task board. It uses the event
-        payload to decide when to check for and notify agents of newly runnable tasks.
+        Orchestrates the agent activation workflow upon any change to the task board.
         """
-        if isinstance(payload, TaskPlanPublishedEvent):
-            logger.info(f"Team '{self._team_manager.team_id}': New task plan detected. Resetting dispatched tasks and checking for initial runnable tasks.")
-            self._dispatched_task_ids.clear()
-            await self._scan_and_notify_all_runnable_tasks()
-        
-        elif isinstance(payload, TaskStatusUpdatedEvent):
-            # Only trigger a check for dependent tasks if a task has been completed,
-            # as this is the only status change that can unblock dependent tasks.
-            if payload.new_status == TaskStatus.COMPLETED:
-                logger.info(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' completed. Checking for newly unblocked dependent tasks.")
-                await self._check_and_notify_dependent_tasks(payload.task_id)
-            else:
-                logger.debug(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' status updated to '{payload.new_status.value}'. No dependent task check needed.")
-        else:
-            # This case should ideally not be hit with the new strong typing, but is kept as a safeguard.
-            logger.warning(f"Team '{self._team_manager.team_id}': Task notifier received an unhandled payload type: {type(payload)}")
+        team_id = self._team_manager.team_id
+        logger.info(f"Team '{team_id}': Task board changed ({type(payload).__name__}). Orchestrating activation check.")
 
+        # If a new batch of tasks was added, it's a new "wave" of work.
+        # We must reset the policy's memory of who has been activated.
+        if isinstance(payload, TasksAddedEvent):
+            logger.info(f"Team '{team_id}': New tasks added. Resetting activation policy.")
+            self._policy.reset()
 
-    async def _check_and_notify_dependent_tasks(self, completed_task_id: str):
-        """
-        Finds tasks that depend on the completed task and notifies their assignees
-        if all of their other dependencies are also met.
-        """
-        if not getattr(self._task_board, 'current_plan', None):
+        # 1. DATA FETCHING: Get the current state of runnable tasks from the board.
+        runnable_tasks = self._task_board.get_next_runnable_tasks()
+        
+        if not runnable_tasks:
+            logger.debug(f"Team '{team_id}': No runnable tasks found after change. No action needed.")
             return
 
-        all_tasks = self._task_board.current_plan.tasks
-        task_statuses = getattr(self._task_board, 'task_statuses', {})
+        # 2. POLICY DECISION: Ask the policy to decide which agents to activate.
+        # The policy contains all the complex state and logic.
+        agents_to_activate = self._policy.determine_activations(runnable_tasks)
 
-        for child_task in all_tasks:
-            # Find tasks that are direct children of the completed task
-            if completed_task_id in child_task.dependencies:
-                # Now, check if this child task is fully runnable (all its parents are done)
-                all_deps_met = all(
-                    task_statuses.get(dep_id) == TaskStatus.COMPLETED for dep_id in child_task.dependencies
-                )
-                
-                if all_deps_met and child_task.task_id not in self._dispatched_task_ids:
-                    await self._dispatch_notification_for_task(child_task)
+        if not agents_to_activate:
+            logger.info(f"Team '{team_id}': Runnable tasks exist, but policy determined no new agents need activation.")
+            return
 
-    async def _scan_and_notify_all_runnable_tasks(self):
-        """
-        Scans the entire board for any runnable tasks. Used for initial plan loading.
-        """
-        try:
-            runnable_tasks = self._task_board.get_next_runnable_tasks()
-            for task in runnable_tasks:
-                if task.task_id not in self._dispatched_task_ids:
-                    await self._dispatch_notification_for_task(task)
-        except Exception as e:
-            logger.error(f"Team '{self._team_manager.team_id}': Error during full scan for runnable tasks: {e}", exc_info=True)
-    
-    async def _dispatch_notification_for_task(self, task: Task):
-        """
-        Constructs and sends a context-rich notification for a single runnable task
-        by treating it as a user message to trigger the full processing pipeline.
-        It tags the message with metadata to indicate its system origin.
-        """
-        try:
-            team_id = self._team_manager.team_id
-            logger.info(f"Team '{team_id}': Dispatching notification for runnable task '{task.task_name}' to assignee '{task.assignee_name}'.")
-            
-            context_from_parents = []
-            if task.dependencies:
-                parent_task_deliverables_info = []
-                for dep_id in task.dependencies:
-                    parent_task = getattr(self._task_board, '_task_map', {}).get(dep_id)
-                    if parent_task and parent_task.file_deliverables:
-                        deliverables_str = "\n".join(
-                            [f"  - File: {d.file_path}, Summary: {d.summary}" for d in parent_task.file_deliverables]
-                        )
-                        parent_task_deliverables_info.append(
-                            f"The parent task '{parent_task.task_name}' produced the following deliverables:\n{deliverables_str}"
-                        )
-                
-                if parent_task_deliverables_info:
-                    context_from_parents.append(
-                        "Your task is now unblocked. Here is the context from the completed parent task(s):\n" +
-                        "\n\n".join(parent_task_deliverables_info)
+        # 3. ACTION EXECUTION: Tell the activator to perform the activations.
+        for agent_name in agents_to_activate:
+            # First, update the status for all of that agent's runnable tasks to QUEUED.
+            # This is a state change action, which the orchestrator is responsible for.
+            agent_runnable_tasks = [t for t in runnable_tasks if t.assignee_name == agent_name]
+            for task in agent_runnable_tasks:
+                # We only need to queue tasks that are NOT_STARTED.
+                if self._task_board.task_statuses.get(task.task_id) == TaskStatus.NOT_STARTED:
+                    self._task_board.update_task_status(
+                        task_id=task.task_id,
+                        status=TaskStatus.QUEUED,
+                        agent_name="SystemTaskNotifier"
                     )
-
-            message_parts: List[str] = [f"Your task '{task.task_name}' is now ready to start."]
-            if context_from_parents:
-                message_parts.extend(context_from_parents)
-            
-            message_parts.append(f"\nYour task description:\n{task.description}")
-            
-            content = "\n\n".join(message_parts)
             
-            # Create the user message with metadata indicating its origin.
-            user_message = AgentInputUserMessage(
-                content=content,
-                metadata={'source': 'system_task_notifier'}
-            )
-            event = ProcessUserMessageEvent(
-                user_message=user_message,
-                target_agent_name=task.assignee_name
-            )
-
-            # Use the existing method for dispatching user messages.
-            await self._team_manager.dispatch_user_message_to_agent(event)
-            self._dispatched_task_ids.add(task.task_id)
-
-        except Exception as e:
-            logger.error(f"Team '{self._team_manager.team_id}': Failed to dispatch notification for task '{task.task_id}': {e}", exc_info=True)
+            # Now, trigger the single activation notification.
+            await self._activator.activate_agent(agent_name)