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

autobyteus/agent/context/agent_runtime_state.py

@@ -12,6 +12,7 @@ from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.tool_invocation import ToolInvocation
 # LLMConfig is no longer needed here
 # from autobyteus.llm.utils.llm_config import LLMConfig 
+from autobyteus.task_management.todo_list import ToDoList
 
 if TYPE_CHECKING:
     from autobyteus.agent.phases import AgentPhaseManager 
@@ -52,6 +53,9 @@ class AgentRuntimeState:
         # NEW: State for multi-tool call invocation turns, with a very explicit name.
         self.active_multi_tool_call_turn: Optional['ToolInvocationTurn'] = None
         
+        # NEW: State for the agent's personal ToDoList
+        self.todo_list: Optional[ToDoList] = None
+        
         self.processed_system_prompt: Optional[str] = None
         # self.final_llm_config_for_creation removed
         

autobyteus/agent/events/notifiers.py

@@ -1,6 +1,6 @@
 # file: autobyteus/autobyteus/agent/events/notifiers.py
 import logging
-from typing import Optional, Dict, Any, TYPE_CHECKING
+from typing import Optional, Dict, Any, TYPE_CHECKING, List
 
 from autobyteus.events.event_emitter import EventEmitter
 from autobyteus.events.event_types import EventType 
@@ -117,6 +117,10 @@ class AgentExternalEventNotifier(EventEmitter):
         """Notifies that the agent has received a system-generated task notification."""
         self._emit_event(EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED, payload_content=notification_data)
 
+    def notify_agent_data_todo_list_updated(self, todo_list: List[Dict[str, Any]]):
+        """Notifies that the agent's ToDo list has been updated."""
+        self._emit_event(EventType.AGENT_DATA_TODO_LIST_UPDATED, payload_content={"todos": todo_list})
+
     def notify_agent_error_output_generation(self, error_source: str, error_message: str, error_details: Optional[str] = None): 
         payload_dict = { 
             "source": error_source,

autobyteus/agent/message/send_message_to.py

@@ -21,7 +21,7 @@ class SendMessageTo(BaseTool):
     This tool dynamically retrieves the team communication channel from the
     agent's context at runtime.
     """
-    TOOL_NAME = "SendMessageTo"
+    TOOL_NAME = "send_message_to"
     CATEGORY = ToolCategory.AGENT_COMMUNICATION
 
     def __init__(self, config: Optional[ToolConfig] = None):
@@ -30,7 +30,7 @@ class SendMessageTo(BaseTool):
         """
         super().__init__(config=config)
         # The TeamManager is no longer stored as an instance variable.
-        logger.debug("SendMessageTo tool initialized (stateless).")
+        logger.debug("%s tool initialized (stateless).", self.get_name())
 
     # The set_team_manager method has been removed.
 
@@ -81,7 +81,8 @@ class SendMessageTo(BaseTool):
         # --- NEW: Retrieve TeamManager dynamically from context ---
         team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
         if not team_context:
-            error_msg = "Critical error: SendMessageTo tool is not configured for team communication. It can only be used within a managed AgentTeam."
+            error_msg = (f"Critical error: {self.get_name()} tool is not configured for team communication. "
+                         "It can only be used within a managed AgentTeam.")
             logger.error(f"Agent '{context.agent_id}': {error_msg}")
             return f"Error: {error_msg}"
         
@@ -122,4 +123,4 @@ class SendMessageTo(BaseTool):
 
         success_msg = f"Message dispatch for recipient '{recipient_name}' has been successfully requested."
         logger.info(f"Tool '{self.get_name()}': {success_msg}")
-        return success_msg
+        return success_msg

autobyteus/agent/streaming/agent_event_stream.py

@@ -17,6 +17,7 @@ from autobyteus.agent.streaming.stream_event_payloads import (
     create_tool_invocation_approval_requested_data,
     create_tool_invocation_auto_executing_data,
     create_system_task_notification_data, # NEW
+    create_todo_list_update_data,
     AssistantChunkData,
     AssistantCompleteResponseData,
     ToolInteractionLogEntryData,
@@ -25,6 +26,7 @@ from autobyteus.agent.streaming.stream_event_payloads import (
     ToolInvocationAutoExecutingData,
     ErrorEventData,
     SystemTaskNotificationData, # NEW
+    ToDoListUpdateData,
     EmptyData,
     StreamDataPayload,
 )
@@ -107,6 +109,9 @@ class AgentEventStream(EventEmitter):
             elif event_type == EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED:
                 typed_payload_for_stream_event = create_system_task_notification_data(payload)
                 stream_event_type_for_generic_stream = StreamEventType.SYSTEM_TASK_NOTIFICATION
+            elif event_type == EventType.AGENT_DATA_TODO_LIST_UPDATED:
+                typed_payload_for_stream_event = create_todo_list_update_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.AGENT_TODO_LIST_UPDATE
             
             elif event_type in [EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END, EventType.AGENT_DATA_TOOL_LOG_STREAM_END]:
                  pass 

autobyteus/agent/streaming/stream_event_payloads.py

@@ -66,6 +66,14 @@ class SystemTaskNotificationData(BaseStreamPayload):
     sender_id: str
     content: str
 
+class ToDoItemData(BaseStreamPayload):
+    description: str
+    todo_id: str
+    status: str
+
+class ToDoListUpdateData(BaseStreamPayload):
+    todos: List[ToDoItemData]
+
 class EmptyData(BaseStreamPayload):
     pass
 
@@ -79,6 +87,7 @@ StreamDataPayload = Union[
     ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData,
     SystemTaskNotificationData, # NEW
+    ToDoListUpdateData,
     EmptyData
 ]
 
@@ -196,3 +205,19 @@ def create_system_task_notification_data(notification_data_dict: Any) -> SystemT
         return SystemTaskNotificationData(**notification_data_dict)
     raise ValueError(f"Cannot create SystemTaskNotificationData from {type(notification_data_dict)}")
 
+def create_todo_list_update_data(todo_data_dict: Any) -> ToDoListUpdateData:
+    if isinstance(todo_data_dict, dict):
+        todos_payload = todo_data_dict.get('todos', [])
+        if not isinstance(todos_payload, list):
+            raise ValueError("Expected 'todos' to be a list when creating ToDoListUpdateData.")
+        todo_items = []
+        for todo_entry in todos_payload:
+            if not isinstance(todo_entry, dict):
+                logger.warning(f"Skipping non-dict todo entry when creating ToDoListUpdateData: {todo_entry!r}")
+                continue
+            try:
+                todo_items.append(ToDoItemData(**todo_entry))
+            except Exception as exc:
+                logger.warning(f"Failed to parse todo entry into ToDoItemData: {todo_entry!r}; error: {exc}")
+        return ToDoListUpdateData(todos=todo_items)
+    raise ValueError(f"Cannot create ToDoListUpdateData from {type(todo_data_dict)}")

autobyteus/agent/streaming/stream_events.py

@@ -17,7 +17,17 @@ from .stream_event_payloads import (
     ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData,
     SystemTaskNotificationData, # NEW
-    EmptyData
+    ToDoListUpdateData,
+    EmptyData,
+    create_assistant_chunk_data,
+    create_assistant_complete_response_data,
+    create_tool_interaction_log_entry_data,
+    create_agent_operational_phase_transition_data, 
+    create_error_event_data,
+    create_tool_invocation_approval_requested_data,
+    create_tool_invocation_auto_executing_data,
+    create_system_task_notification_data, # NEW
+    create_todo_list_update_data,
 )
 
 logger = logging.getLogger(__name__)
@@ -35,6 +45,7 @@ class StreamEventType(str, Enum):
     TOOL_INVOCATION_APPROVAL_REQUESTED = "tool_invocation_approval_requested" 
     TOOL_INVOCATION_AUTO_EXECUTING = "tool_invocation_auto_executing"
     SYSTEM_TASK_NOTIFICATION = "system_task_notification" # NEW
+    AGENT_TODO_LIST_UPDATE = "agent_todo_list_updated"
     AGENT_IDLE = "agent_idle"
 
 
@@ -47,6 +58,7 @@ _STREAM_EVENT_TYPE_TO_PAYLOAD_CLASS: Dict[StreamEventType, Type[BaseModel]] = {
     StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED: ToolInvocationApprovalRequestedData,
     StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING: ToolInvocationAutoExecutingData,
     StreamEventType.SYSTEM_TASK_NOTIFICATION: SystemTaskNotificationData, # NEW
+    StreamEventType.AGENT_TODO_LIST_UPDATE: ToDoListUpdateData,
     StreamEventType.AGENT_IDLE: AgentOperationalPhaseTransitionData,
 }
 

autobyteus/agent_team/bootstrap_steps/task_notifier_initialization_step.py

@@ -27,9 +27,9 @@ class TaskNotifierInitializationStep(BaseAgentTeamBootstrapStep):
 
         logger.info(f"Team '{team_id}': Mode is SYSTEM_EVENT_DRIVEN. Initializing and activating task notifier.")
         try:
-            task_board = context.state.task_board
-            if not task_board:
-                logger.error(f"Team '{team_id}': TaskBoard not found. Cannot initialize task notifier. This step should run after TeamContextInitializationStep.")
+            task_plan = context.state.task_plan
+            if not task_plan:
+                logger.error(f"Team '{team_id}': TaskPlan not found. Cannot initialize task notifier. This step should run after TeamContextInitializationStep.")
                 return False
 
             team_manager = context.team_manager
@@ -38,7 +38,7 @@ class TaskNotifierInitializationStep(BaseAgentTeamBootstrapStep):
                 return False
 
             notifier = SystemEventDrivenAgentTaskNotifier(
-                task_board=task_board, 
+                task_plan=task_plan, 
                 team_manager=team_manager
             )
             notifier.start_monitoring()

autobyteus/agent_team/bootstrap_steps/team_context_initialization_step.py

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

autobyteus/agent_team/context/agent_team_runtime_state.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from autobyteus.agent_team.context.team_node_config import TeamNodeConfig
     from autobyteus.agent_team.context.team_manager import TeamManager
     from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
-    from autobyteus.task_management.base_task_board import BaseTaskBoard
+    from autobyteus.task_management.base_task_plan import BaseTaskPlan
     from autobyteus.agent_team.task_notification.system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 
 logger = logging.getLogger(__name__)
@@ -38,7 +38,7 @@ class AgentTeamRuntimeState:
     multiplexer_ref: Optional['AgentEventMultiplexer'] = None
     
     # Dynamic planning and artifact state
-    task_board: Optional['BaseTaskBoard'] = None
+    task_plan: Optional['BaseTaskPlan'] = None
 
     def __post_init__(self):
         if not self.team_id or not isinstance(self.team_id, str):

autobyteus/agent_team/streaming/agent_team_event_notifier.py

@@ -7,7 +7,7 @@ from autobyteus.events.event_types import EventType
 from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
 from .agent_team_stream_events import AgentTeamStreamEvent, AgentEventRebroadcastPayload, AgentTeamPhaseTransitionData, SubTeamEventRebroadcastPayload
-from autobyteus.task_management.events import BaseTaskBoardEvent
+from autobyteus.task_management.events import BaseTaskPlanEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.runtime.agent_team_runtime import AgentTeamRuntime
@@ -56,9 +56,9 @@ class AgentTeamExternalEventNotifier(EventEmitter):
         event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="SUB_TEAM", data=SubTeamEventRebroadcastPayload(sub_team_node_name=sub_team_node_name, sub_team_event=sub_team_event))
         self._emit_event(event)
 
-    def handle_and_publish_task_board_event(self, payload: BaseTaskBoardEvent, **kwargs):
+    def handle_and_publish_task_plan_event(self, payload: BaseTaskPlanEvent, **kwargs):
         """
-        Listener for TaskBoard events. It wraps the event and publishes it on the main team stream.
+        Listener for TaskPlan events. It wraps the event and publishes it on the main team stream.
         """
-        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TASK_BOARD", data=payload)
+        event = AgentTeamStreamEvent(team_id=self.team_id, event_source_type="TASK_PLAN", data=payload)
         self._emit_event(event)

autobyteus/agent_team/streaming/agent_team_stream_event_payloads.py

@@ -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 TasksAddedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksCreatedEvent, TaskStatusUpdatedEvent
 # Need to use a forward reference string to avoid circular import at runtime
 from typing import TYPE_CHECKING, Union
 if TYPE_CHECKING:
@@ -28,5 +28,5 @@ class SubTeamEventRebroadcastPayload(BaseModel):
     sub_team_node_name: str # The friendly name of the sub-team node
     sub_team_event: "AgentTeamStreamEvent" = Field(..., description="The original, unmodified event from the sub-team's stream")
 
-# --- Payload for events originating from the "TASK_BOARD" source ---
-TaskBoardEventPayload = Union[TasksAddedEvent, TaskStatusUpdatedEvent]
+# --- Payload for events originating from the "TASK_PLAN" source ---
+TaskPlanEventPayload = Union[TasksCreatedEvent, TaskStatusUpdatedEvent]

autobyteus/agent_team/streaming/agent_team_stream_events.py

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

autobyteus/agent_team/task_notification/activation_policy.py

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

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

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

autobyteus/agent_team/task_notification/task_notification_mode.py

@@ -16,7 +16,7 @@ class TaskNotificationMode(str, Enum):
     
     SYSTEM_EVENT_DRIVEN = "system_event_driven"
     """
-    In this mode, the agent team framework automatically monitors the TaskBoard
+    In this mode, the agent team framework automatically monitors the TaskPlan
     and sends notifications to agents when their assigned tasks become runnable.
     """
 

autobyteus/cli/agent_team_tui/app.py

@@ -141,8 +141,8 @@ class AgentTeamApp(App):
         focused_data = self.focused_node_data
         if focused_data and focused_data.get("type") in ['team', 'subteam']:
             node_name = focused_data['name']
-            task_plan = self.store.get_task_board_plan(node_name)
-            task_statuses = self.store.get_task_board_statuses(node_name)
+            task_plan = self.store.get_task_plan_tasks(node_name)
+            task_statuses = self.store.get_task_plan_statuses(node_name)
             await focus_pane.update_content(
                 node_data=focused_data,
                 history=[], # No history for teams
@@ -169,8 +169,8 @@ class AgentTeamApp(App):
         task_plan = None
         task_statuses = None
         if node_type in ['team', 'subteam']:
-            task_plan = self.store.get_task_board_plan(node_name)
-            task_statuses = self.store.get_task_board_statuses(node_name)
+            task_plan = self.store.get_task_plan_tasks(node_name)
+            task_statuses = self.store.get_task_plan_statuses(node_name)
         
         sidebar = self.query_one(AgentListSidebar)
         focus_pane = self.query_one(FocusPane)

autobyteus/cli/agent_team_tui/state.py

@@ -17,8 +17,8 @@ from autobyteus.agent.streaming.stream_event_payloads import (
 from autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
 from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamPhaseTransitionData
 from autobyteus.task_management.task import Task
-from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.events import TasksCreatedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.base_task_plan import TaskStatus
 
 logger = logging.getLogger(__name__)
 
@@ -46,7 +46,7 @@ class TUIStateStore:
         self._pending_approvals: Dict[str, ToolInvocationApprovalRequestedData] = {}
         self._speaking_agents: Dict[str, bool] = {}
         
-        # State for task boards
+        # State for task plans
         self._task_plans: Dict[str, List[Task]] = {} # team_name -> List[Task]
         self._task_statuses: Dict[str, Dict[str, TaskStatus]] = {} # team_name -> {task_id: status}
         
@@ -85,15 +85,15 @@ class TUIStateStore:
             self._team_event_history[parent_name] = []
         self._team_event_history[parent_name].append(event)
         
-        if event.event_source_type == "TASK_BOARD":
+        if event.event_source_type == "TASK_PLAN":
             team_name_key = parent_name
-            if isinstance(event.data, TasksAddedEvent):
+            if isinstance(event.data, TasksCreatedEvent):
                 if team_name_key not in self._task_plans: self._task_plans[team_name_key] = []
                 if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
                 self._task_plans[team_name_key].extend(event.data.tasks)
                 for task in event.data.tasks:
                     self._task_statuses[team_name_key][task.task_id] = TaskStatus.NOT_STARTED
-                logger.debug(f"TUI State: Added {len(event.data.tasks)} tasks to board for '{team_name_key}'.")
+                logger.debug(f"TUI State: Created {len(event.data.tasks)} tasks in plan for '{team_name_key}'.")
 
             elif isinstance(event.data, TaskStatusUpdatedEvent):
                 if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
@@ -164,10 +164,10 @@ class TUIStateStore:
     def get_pending_approval_for_agent(self, agent_name: str) -> Optional[ToolInvocationApprovalRequestedData]:
         return self._pending_approvals.get(agent_name)
         
-    def get_task_board_plan(self, team_name: str) -> Optional[List[Task]]:
+    def get_task_plan_tasks(self, team_name: str) -> Optional[List[Task]]:
         return self._task_plans.get(team_name)
 
-    def get_task_board_statuses(self, team_name: str) -> Optional[Dict[str, TaskStatus]]:
+    def get_task_plan_statuses(self, team_name: str) -> Optional[Dict[str, TaskStatus]]:
         return self._task_statuses.get(team_name)
 
     def clear_pending_approval(self, agent_name: str):

autobyteus/cli/agent_team_tui/widgets/focus_pane.py

@@ -14,7 +14,7 @@ from textual.containers import VerticalScroll, Horizontal
 
 from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent_team.phases import AgentTeamOperationalPhase
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from autobyteus.task_management.task import Task
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
@@ -27,7 +27,7 @@ from .shared import (
     USER_ICON, ASSISTANT_ICON, TEAM_ICON, AGENT_ICON, SYSTEM_TASK_ICON
 )
 from . import renderables
-from .task_board_panel import TaskBoardPanel
+from .task_plan_panel import TaskPlanPanel
 
 logger = logging.getLogger(__name__)
 
@@ -211,7 +211,7 @@ class FocusPane(Static):
         info_text.append(f"Status: {phase_icon} {phase.value}")
         await log_container.mount(Static(Panel(info_text, title="Team Info", border_style="green", title_align="left")))
 
-        await log_container.mount(TaskBoardPanel(tasks=task_plan, statuses=task_statuses, team_name=node_data['name']))
+        await log_container.mount(TaskPlanPanel(tasks=task_plan, statuses=task_statuses, team_name=node_data['name']))
 
         children_data = node_data.get("children", {})
         if children_data:

autobyteus/cli/agent_team_tui/widgets/shared.py

@@ -4,7 +4,7 @@ Shared constants and data for TUI widgets.
 from typing import Dict
 from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent_team.phases import AgentTeamOperationalPhase
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 
 AGENT_PHASE_ICONS: Dict[AgentOperationalPhase, str] = {
     AgentOperationalPhase.UNINITIALIZED: "⚪",

autobyteus/cli/agent_team_tui/widgets/{task_board_panel.py → task_plan_panel.py}

@@ -7,13 +7,13 @@ from rich.text import Text
 from textual.widgets import Static
 
 from autobyteus.task_management.task import Task
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from .shared import TASK_STATUS_ICONS, LOG_ICON
 
 logger = logging.getLogger(__name__)
 
-class TaskBoardPanel(Static):
-    """A widget to display the team's task board."""
+class TaskPlanPanel(Static):
+    """A widget to display the team's task plan."""
 
     def __init__(self, tasks: Optional[List[Task]], statuses: Dict[str, TaskStatus], team_name: str, **kwargs) -> None:
         super().__init__(**kwargs)
@@ -23,7 +23,7 @@ class TaskBoardPanel(Static):
 
     def compose(self) -> None:
         if not self.tasks:
-            yield Static(Panel("No task plan has been published yet.", title="Task Board", border_style="yellow", title_align="left"))
+            yield Static(Panel("No task plan has been published yet.", title="Task Plan", border_style="yellow", title_align="left"))
             return
 
         table = Table(
@@ -79,4 +79,4 @@ class TaskBoardPanel(Static):
                 ", ".join(dep_names)
             )
 
-        yield Static(Panel(table, title="Task Board", border_style="blue", title_align="left"))
+        yield Static(Panel(table, title="Task Plan", border_style="blue", title_align="left"))

autobyteus/clients/__init__.py

@@ -0,0 +1,10 @@
+"""
+Client utilities for communicating with the Autobyteus LLM server.
+
+Consolidates the previously standalone autobyteus-llm-client package so the
+HTTP client can evolve alongside the rest of the framework.
+"""
+
+from .autobyteus_client import AutobyteusClient, CertificateError
+
+__all__ = ["AutobyteusClient", "CertificateError"]