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

autobyteus/task_management/todo.py

@@ -0,0 +1,29 @@
+# file: autobyteus/autobyteus/task_management/todo.py
+"""
+Defines the data structures for a ToDo item.
+A ToDo represents a small, personal step an agent creates for itself to break down a larger Task.
+"""
+import logging
+from enum import Enum
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+class ToDoStatus(str, Enum):
+    """Enumerates the possible lifecycle states of a ToDo item."""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    DONE = "done"
+
+class ToDo(BaseModel):
+    """
+    Represents a single, discrete item on a personal ToDoList.
+    It is intentionally simpler than a `Task`, as it's for an agent's internal planning.
+    """
+    description: str = Field(..., description="A clear and concise description of what this to-do item or step entails.")
+    todo_id: str = Field(..., description="A unique, sequential, system-generated identifier for this to-do item (e.g., 'todo_1').")
+    status: ToDoStatus = Field(default=ToDoStatus.PENDING, description="The current status of this to-do item.")
+
+    def model_post_init(self, __context: any) -> None:
+        """Called after the model is initialized and validated."""
+        logger.debug(f"ToDo created: ID='{self.todo_id}', Description='{self.description}'")

autobyteus/task_management/todo_list.py

@@ -0,0 +1,75 @@
+# file: autobyteus/autobyteus/task_management/todo_list.py
+"""
+An in-memory implementation of a personal ToDoList for a single agent.
+"""
+import logging
+from typing import List, Dict, Optional
+
+from autobyteus.task_management.schemas import ToDoDefinitionSchema
+from .todo import ToDo, ToDoStatus
+
+logger = logging.getLogger(__name__)
+
+class ToDoList:
+    """
+    An in-memory, list-based implementation of a personal ToDo list for an agent.
+    It manages a collection of ToDo items.
+    """
+    def __init__(self, agent_id: str):
+        self.agent_id = agent_id
+        self.todos: List[ToDo] = []
+        self._todo_map: Dict[str, ToDo] = {}
+        self._id_counter: int = 0
+        logger.info(f"ToDoList initialized for agent '{self.agent_id}'.")
+
+    def _generate_next_id(self) -> str:
+        self._id_counter += 1
+        return f"todo_{self._id_counter:04d}"
+
+    def add_todos(self, todo_definitions: List[ToDoDefinitionSchema]) -> List[ToDo]:
+        """Creates and adds new to-do items from definitions, and returns the created items."""
+        new_todos: List[ToDo] = []
+        for definition in todo_definitions:
+            new_id = self._generate_next_id()
+            todo = ToDo(todo_id=new_id, **definition.model_dump())
+            # This check is defensive, with a sequential counter it should not happen
+            if todo.todo_id in self._todo_map:
+                logger.warning(f"ToDo with ID '{todo.todo_id}' already exists in the list for agent '{self.agent_id}'. Skipping.")
+                continue
+            self.todos.append(todo)
+            self._todo_map[todo.todo_id] = todo
+            new_todos.append(todo)
+        logger.info(f"Agent '{self.agent_id}': Added {len(new_todos)} new item(s) to the ToDoList.")
+        return new_todos
+
+    def add_todo(self, todo_definition: ToDoDefinitionSchema) -> ToDo:
+        """Adds a single new to-do item from a definition."""
+        created_todos = self.add_todos([todo_definition])
+        return created_todos[0]
+
+    def get_todo_by_id(self, todo_id: str) -> Optional[ToDo]:
+        """Retrieves a to-do item by its ID."""
+        return self._todo_map.get(todo_id)
+
+    def update_todo_status(self, todo_id: str, status: ToDoStatus) -> bool:
+        """Updates the status of a specific to-do item."""
+        todo = self.get_todo_by_id(todo_id)
+        if not todo:
+            logger.warning(f"Agent '{self.agent_id}': Attempted to update status for non-existent todo_id '{todo_id}'.")
+            return False
+        
+        old_status = todo.status
+        todo.status = status
+        logger.info(f"Agent '{self.agent_id}': Status of todo '{todo_id}' updated from '{old_status.value}' to '{status.value}'.")
+        return True
+
+    def get_all_todos(self) -> List[ToDo]:
+        """Returns all to-do items."""
+        return self.todos
+
+    def clear(self) -> None:
+        """Clears all to-do items from the list."""
+        self.todos.clear()
+        self._todo_map.clear()
+        self._id_counter = 0
+        logger.info(f"ToDoList for agent '{self.agent_id}' has been cleared.")

autobyteus/task_management/tools/__init__.py

@@ -3,14 +3,32 @@
 This package contains the class-based tools related to task and project
 management within an agent team.
 """
-from .get_task_board_status import GetTaskBoardStatus
-from .publish_tasks import PublishTasks
-from .publish_task import PublishTask
-from .update_task_status import UpdateTaskStatus
+from .task_tools import (
+    GetTaskPlanStatus,
+    CreateTasks,
+    CreateTask,
+    UpdateTaskStatus,
+    AssignTaskTo,
+    GetMyTasks,
+)
+from .todo_tools import (
+    CreateToDoList,
+    AddToDo,
+    GetToDoList,
+    UpdateToDoStatus,
+    UpdateToDoStatusTool,
+)
 
 __all__ = [
-    "GetTaskBoardStatus",
-    "PublishTasks",
-    "PublishTask",
+    "GetTaskPlanStatus",
+    "CreateTasks",
+    "CreateTask",
     "UpdateTaskStatus",
+    "AssignTaskTo",
+    "GetMyTasks",
+    "CreateToDoList",
+    "AddToDo",
+    "GetToDoList",
+    "UpdateToDoStatus",
+    "UpdateToDoStatusTool",
 ]

autobyteus/task_management/tools/task_tools/__init__.py

@@ -0,0 +1,19 @@
+# file: autobyteus/task_management/tools/task_tools/__init__.py
+"""
+Task management tool package exposing task plan utilities.
+"""
+from .get_task_plan_status import GetTaskPlanStatus
+from .create_tasks import CreateTasks
+from .create_task import CreateTask
+from .update_task_status import UpdateTaskStatus
+from .assign_task_to import AssignTaskTo
+from .get_my_tasks import GetMyTasks
+
+__all__ = [
+    "GetTaskPlanStatus",
+    "CreateTasks",
+    "CreateTask",
+    "UpdateTaskStatus",
+    "AssignTaskTo",
+    "GetMyTasks",
+]

autobyteus/task_management/tools/task_tools/assign_task_to.py

@@ -0,0 +1,125 @@
+# file: autobyteus/autobyteus/task_management/tools/task_tools/assign_task_to.py
+import logging
+from typing import TYPE_CHECKING, Optional, Any
+
+from pydantic import ValidationError
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
+from autobyteus.task_management.schemas import TaskDefinitionSchema
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+    from autobyteus.agent_team.context.team_manager import TeamManager
+
+logger = logging.getLogger(__name__)
+
+class AssignTaskTo(BaseTool):
+    """A tool for one agent to directly create and assign a single task to another agent."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "assign_task_to"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Creates and assigns a single new task to a specific team member, and sends them a direct notification "
+            "with the task details. Use this to delegate a well-defined piece of work you have identified."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        # The schema is the same as for defining a single task.
+        return pydantic_to_parameter_schema(TaskDefinitionSchema)
+
+    async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
+        """
+        Executes the tool by adding the task to the central TaskPlan and then
+        sending a direct message to the assignee with the task's details.
+        """
+        agent_name = context.config.name
+        task_name = kwargs.get("task_name", "unnamed task")
+        assignee_name = kwargs.get("assignee_name")
+        logger.info(f"Agent '{agent_name}' is executing assign_task_to for task '{task_name}' assigned to '{assignee_name}'.")
+
+        # --- Get Team Context and Task Plan ---
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Error: Team context is not available. Cannot access the task plan or send messages."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+
+        task_plan = getattr(team_context.state, 'task_plan', None)
+        if not task_plan:
+            error_msg = "Error: Task plan has not been initialized for this team."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+        
+        # --- Action 1: Add the task to the Task Plan ---
+        try:
+            task_def_schema = TaskDefinitionSchema(**kwargs)
+        except (ValidationError, ValueError) as e:
+            error_msg = f"Invalid task definition provided: {e}"
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for assign_task_to: {error_msg}")
+            return f"Error: {error_msg}"
+
+        # The task plan now handles ID generation and returns the created Task object.
+        new_task = task_plan.add_task(task_def_schema)
+        if not new_task:
+            error_msg = f"Failed to publish task '{task_name}' to the plan for an unknown reason."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"
+        
+        logger.info(f"Agent '{agent_name}' successfully published task '{new_task.task_name}' (ID: {new_task.task_id}) to the task plan.")
+
+        # --- Action 2: Send a direct notification message to the assignee ---
+        team_manager: Optional['TeamManager'] = team_context.team_manager
+        if not team_manager:
+            # This is a degraded state, but the primary action (publishing) succeeded.
+            warning_msg = (f"Successfully published task '{new_task.task_name}', but could not send a direct notification "
+                           "because the TeamManager is not available.")
+            logger.warning(f"Agent '{agent_name}': {warning_msg}")
+            return warning_msg
+
+        try:
+            # Local import to break potential circular dependency at module load time.
+            from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent
+
+            notification_content = (
+                f"You have been assigned a new task directly from agent '{agent_name}'.\n\n"
+                f"**Task Name**: '{new_task.task_name}'\n"
+                f"**Description**: {new_task.description}\n"
+            )
+            if new_task.dependencies:
+                # Resolve dependency names for the message
+                id_to_name_map = {task.task_id: task.task_name for task in task_plan.tasks}
+                dep_names = [id_to_name_map.get(dep_id, str(dep_id)) for dep_id in new_task.dependencies]
+                notification_content += f"**Dependencies**: {', '.join(dep_names)}\n"
+            
+            notification_content += "\nThis task has been logged on the team's task plan. You can begin work when its dependencies are met."
+
+            event = InterAgentMessageRequestEvent(
+                sender_agent_id=context.agent_id,
+                recipient_name=new_task.assignee_name,
+                content=notification_content,
+                message_type="task_assignment"
+            )
+            
+            await team_manager.dispatch_inter_agent_message_request(event)
+            logger.info(f"Agent '{agent_name}' successfully dispatched a notification message for task '{new_task.task_name}' to '{new_task.assignee_name}'.")
+        
+        except Exception as e:
+            # Again, this is a degraded state. The main goal was achieved.
+            warning_msg = (f"Successfully published task '{new_task.task_name}', but failed to send the direct notification message. "
+                           f"Error: {e}")
+            logger.error(f"Agent '{agent_name}': {warning_msg}", exc_info=True)
+            return warning_msg
+            
+        success_msg = f"Successfully assigned task '{new_task.task_name}' to agent '{new_task.assignee_name}' and sent a notification."
+        return success_msg

autobyteus/task_management/tools/{publish_task.py → task_tools/create_task.py}

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/task_management/tools/publish_task.py
+# file: autobyteus/autobyteus/task_management/tools/task_tools/create_task.py
 import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
@@ -9,7 +9,6 @@ from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.schemas import TaskDefinitionSchema
-from autobyteus.task_management.task import Task
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
@@ -17,19 +16,19 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class PublishTask(BaseTool):
-    """A tool for any agent to add a single new task to the team's task board."""
+class CreateTask(BaseTool):
+    """A tool for any agent to add a single new task to the team's task plan."""
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
     @classmethod
     def get_name(cls) -> str:
-        return "PublishTask"
+        return "create_task"
 
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Adds a single new task to the team's shared task board. This is an additive action "
+            "Adds a single new task to the team's shared task plan. This is an additive action "
             "and does not affect existing tasks. Use this to create follow-up tasks or delegate new work."
         )
 
@@ -40,38 +39,37 @@ class PublishTask(BaseTool):
 
     async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
         """
-        Executes the tool by validating the task object and adding it to the board.
+        Executes the tool by validating the task definition and adding it to the plan.
         """
         agent_name = context.config.name
         task_name = kwargs.get("task_name", "unnamed task")
-        logger.info(f"Agent '{agent_name}' is executing PublishTask for task '{task_name}'.")
+        logger.info(f"Agent '{agent_name}' is executing create_task for task '{task_name}'.")
 
         team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
         if not team_context:
-            error_msg = "Error: Team context is not available. Cannot access the task board."
+            error_msg = "Error: Team context is not available. Cannot access the task plan."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
 
-        task_board = getattr(team_context.state, 'task_board', None)
-        if not task_board:
-            error_msg = "Error: Task board has not been initialized for this team."
+        task_plan = getattr(team_context.state, 'task_plan', None)
+        if not task_plan:
+            error_msg = "Error: Task plan has not been initialized for this team."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
             
         try:
             task_def_schema = TaskDefinitionSchema(**kwargs)
-            new_task = Task(**task_def_schema.model_dump())
         except (ValidationError, ValueError) as e:
             error_msg = f"Invalid task definition provided: {e}"
-            logger.warning(f"Agent '{agent_name}' provided an invalid definition for PublishTask: {error_msg}")
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for create_task: {error_msg}")
             return f"Error: {error_msg}"
 
-        if task_board.add_task(new_task):
-            success_msg = f"Successfully published new task '{new_task.task_name}' to the task board."
+        new_task = task_plan.add_task(task_def_schema)
+        if new_task:
+            success_msg = f"Successfully created new task '{new_task.task_name}' (ID: {new_task.task_id}) in the task plan."
             logger.info(f"Agent '{agent_name}': {success_msg}")
             return success_msg
         else:
-            # This path is less likely now but kept for robustness.
-            error_msg = "Failed to publish task to the board for an unknown reason."
+            error_msg = f"Failed to create task '{task_name}' in the plan for an unknown reason."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return f"Error: {error_msg}"

autobyteus/task_management/tools/{publish_tasks.py → task_tools/create_tasks.py}

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/task_management/tools/publish_tasks.py
+# file: autobyteus/autobyteus/task_management/tools/task_tools/create_tasks.py
 import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
@@ -9,7 +9,6 @@ from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.schemas import TasksDefinitionSchema
-from autobyteus.task_management.task import Task
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
@@ -17,21 +16,22 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class PublishTasks(BaseTool):
+
+class CreateTasks(BaseTool):
     """
-    A tool to publish multiple tasks to the task board. This is an additive-only operation.
+    A tool to create multiple tasks in the task plan. This is an additive-only operation.
     """
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
     @classmethod
     def get_name(cls) -> str:
-        return "PublishTasks"
+        return "create_tasks"
 
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Adds a list of new tasks to the team's shared task board. This action is additive and "
+            "Adds a list of new tasks to the team's shared task plan. This action is additive and "
             "does not affect existing tasks or the team's overall goal."
         )
 
@@ -41,34 +41,34 @@ class PublishTasks(BaseTool):
 
     async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
         agent_name = context.config.name
-        logger.info(f"Agent '{agent_name}' is executing PublishTasks.")
+        logger.info(f"Agent '{agent_name}' is executing create_tasks.")
         
         team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
         if not team_context:
-            error_msg = "Error: Team context is not available. Cannot access the task board."
+            error_msg = "Error: Team context is not available. Cannot access the task plan."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
             
-        task_board = getattr(team_context.state, 'task_board', None)
-        if not task_board:
-            error_msg = "Error: Task board has not been initialized for this team."
+        task_plan = getattr(team_context.state, 'task_plan', None)
+        if not task_plan:
+            error_msg = "Error: Task plan has not been initialized for this team."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
             
         try:
             tasks_def_schema = TasksDefinitionSchema(**kwargs)
-            final_tasks = [Task(**task_def.model_dump()) for task_def in tasks_def_schema.tasks]
         except (ValidationError, ValueError) as e:
             error_msg = f"Invalid task definitions provided: {e}"
-            logger.warning(f"Agent '{agent_name}' provided an invalid definition for PublishTasks: {error_msg}")
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for create_tasks: {error_msg}")
             return f"Error: {error_msg}"
 
-        if task_board.add_tasks(tasks=final_tasks):
-            success_msg = f"Successfully published {len(final_tasks)} new task(s) to the task board."
+        newly_created_tasks = task_plan.add_tasks(tasks_def_schema.tasks)
+        if newly_created_tasks:
+            success_msg = f"Successfully created {len(newly_created_tasks)} new task(s) in the task plan."
             logger.info(f"Agent '{agent_name}': {success_msg}")
             return success_msg
         else:
-            # This path is less likely now but kept for robustness.
-            error_msg = "Failed to publish tasks to the board for an unknown reason."
-            logger.error(f"Agent '{agent_name}': {error_msg}")
-            return f"Error: {error_msg}"
+            # This case might happen if the input list was empty, or an error occurred.
+            warning_msg = "No tasks were created. The provided list may have been empty."
+            logger.warning(f"Agent '{agent_name}': {warning_msg}")
+            return warning_msg

autobyteus/task_management/tools/{get_my_tasks.py → task_tools/get_my_tasks.py}

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/task_management/tools/get_my_tasks.py
+# file: autobyteus/autobyteus/task_management/tools/task_tools/get_my_tasks.py
 import json
 import logging
 from typing import TYPE_CHECKING, Optional, List
@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Optional, List
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.task_management.schemas import TaskDefinitionSchema
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
@@ -15,18 +15,18 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 class GetMyTasks(BaseTool):
-    """A tool for an agent to inspect its own assigned tasks from the central TaskBoard."""
+    """A tool for an agent to inspect its own assigned tasks from the central TaskPlan."""
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
     @classmethod
     def get_name(cls) -> str:
-        return "GetMyTasks"
+        return "get_my_tasks"
 
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Retrieves the list of tasks currently assigned to you from the team's shared task board. "
+            "Retrieves the list of tasks currently assigned to you from the team's shared task plan. "
             "This is your personal to-do list. Use this to understand your current workload and decide what to do next."
         )
 
@@ -37,29 +37,29 @@ class GetMyTasks(BaseTool):
 
     async def _execute(self, context: 'AgentContext') -> str:
         """
-        Executes the tool by fetching tasks from the team's TaskBoard and
+        Executes the tool by fetching tasks from the team's TaskPlan and
         filtering them for the current agent.
         """
         agent_name = context.config.name
-        logger.info(f"Agent '{agent_name}' is executing GetMyTasks.")
+        logger.info(f"Agent '{agent_name}' is executing get_my_tasks.")
 
         team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
         if not team_context:
-            error_msg = "Error: Team context is not available. Cannot access the task board."
+            error_msg = "Error: Team context is not available. Cannot access the task plan."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
 
-        task_board = getattr(team_context.state, 'task_board', None)
-        if not task_board:
-            error_msg = "Error: Task board has not been initialized for this team."
+        task_plan = getattr(team_context.state, 'task_plan', None)
+        if not task_plan:
+            error_msg = "Error: Task plan has not been initialized for this team."
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
         
-        # Filter the tasks from the central board for this agent.
+        # Filter the tasks from the central plan for this agent.
         # An agent should only see tasks that are specifically for them and are ready to be worked on.
         my_tasks = [
-            task for task in task_board.tasks 
-            if task.assignee_name == agent_name and task_board.task_statuses.get(task.task_id) == TaskStatus.QUEUED
+            task for task in task_plan.tasks 
+            if task.assignee_name == agent_name and task_plan.task_statuses.get(task.task_id) == TaskStatus.QUEUED
         ]
 
         if not my_tasks:
@@ -71,7 +71,7 @@ class GetMyTasks(BaseTool):
                 TaskDefinitionSchema.model_validate(task).model_dump() for task in my_tasks
             ]
             
-            logger.info(f"Agent '{agent_name}' retrieved {len(tasks_for_llm)} tasks from the central task board.")
+            logger.info(f"Agent '{agent_name}' retrieved {len(tasks_for_llm)} tasks from the central task plan.")
             return json.dumps(tasks_for_llm, indent=2)
             
         except Exception as e:

autobyteus/task_management/tools/{get_task_board_status.py → task_tools/get_task_plan_status.py}

@@ -1,11 +1,11 @@
-# file: autobyteus/autobyteus/task_management/tools/get_task_board_status.py
+# file: autobyteus/autobyteus/task_management/tools/task_tools/get_task_plan_status.py
 import json
 import logging
 from typing import TYPE_CHECKING, Optional
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.task_management.converters import TaskBoardConverter
+from autobyteus.task_management.converters import TaskPlanConverter
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
@@ -13,19 +13,19 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-class GetTaskBoardStatus(BaseTool):
-    """A tool for agents to get a current snapshot of the team's TaskBoard."""
+class GetTaskPlanStatus(BaseTool):
+    """A tool for agents to get a current snapshot of the team's TaskPlan."""
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
     @classmethod
     def get_name(cls) -> str:
-        return "GetTaskBoardStatus"
+        return "get_task_plan_status"
 
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Retrieves the current status of the team's task board, including the status of all individual tasks. "
+            "Retrieves the current status of the team's task plan, including the status of all individual tasks. "
             "Returns the status as a structured, LLM-friendly JSON string."
         )
 
@@ -36,33 +36,33 @@ class GetTaskBoardStatus(BaseTool):
 
     async def _execute(self, context: 'AgentContext') -> str:
         """
-        Executes the tool by fetching the task board and using a converter to
+        Executes the tool by fetching the task plan and using a converter to
         generate an LLM-friendly report.
         """
-        logger.info(f"Agent '{context.agent_id}' is executing GetTaskBoardStatus.")
+        logger.info(f"Agent '{context.agent_id}' is executing get_task_plan_status.")
         
         team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
         if not team_context:
-            error_msg = "Error: Team context is not available to the agent. Cannot access the task board."
+            error_msg = "Error: Team context is not available to the agent. Cannot access the task plan."
             logger.error(f"Agent '{context.agent_id}': {error_msg}")
             return error_msg
 
-        task_board = getattr(team_context.state, 'task_board', None)
-        if not task_board:
-            error_msg = "Error: Task board has not been initialized for this team."
+        task_plan = getattr(team_context.state, 'task_plan', None)
+        if not task_plan:
+            error_msg = "Error: Task plan has not been initialized for this team."
             logger.error(f"Agent '{context.agent_id}': {error_msg}")
             return error_msg
         
         try:
-            status_report_schema = TaskBoardConverter.to_schema(task_board)
+            status_report_schema = TaskPlanConverter.to_schema(task_plan)
             
             if not status_report_schema:
-                return "The task board is currently empty. No tasks have been published."
+                return "The task plan is currently empty. No tasks have been published."
             
-            logger.info(f"Agent '{context.agent_id}' successfully retrieved and formatted task board status.")
+            logger.info(f"Agent '{context.agent_id}' successfully retrieved and formatted task plan status.")
             return status_report_schema.model_dump_json(indent=2)
             
         except Exception as e:
-            error_msg = f"An unexpected error occurred while retrieving or formatting task board status: {e}"
+            error_msg = f"An unexpected error occurred while retrieving or formatting task plan status: {e}"
             logger.error(f"Agent '{context.agent_id}': {error_msg}", exc_info=True)
             return error_msg