autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/task_management/{in_memory_task_board.py → in_memory_task_plan.py}

@@ -1,6 +1,6 @@
-# file: autobyteus/autobyteus/task_management/in_memory_task_board.py
+# file: autobyteus/autobyteus/task_management/in_memory_task_plan.py
 """
-An in-memory implementation of the BaseTaskBoard.
+An in-memory implementation of the BaseTaskPlan.
 It tracks task statuses in a simple dictionary and emits events on state changes.
 """
 import logging
@@ -8,50 +8,62 @@ from typing import Optional, List, Dict, Any
 from enum import Enum
 
 from autobyteus.events.event_types import EventType
+from .schemas import TaskDefinitionSchema
 from .task import Task
-from .base_task_board import BaseTaskBoard, TaskStatus
-from .events import TasksAddedEvent, TaskStatusUpdatedEvent
+from .base_task_plan import BaseTaskPlan, TaskStatus
+from .events import TasksCreatedEvent, TaskStatusUpdatedEvent
 
 logger = logging.getLogger(__name__)
 
-class InMemoryTaskBoard(BaseTaskBoard):
+class InMemoryTaskPlan(BaseTaskPlan):
     """
-    An in-memory, dictionary-based implementation of the TaskBoard that emits
+    An in-memory, dictionary-based implementation of the TaskPlan that emits
     events on state changes.
     """
     def __init__(self, team_id: str):
         """
-        Initializes the InMemoryTaskBoard.
+        Initializes the InMemoryTaskPlan.
         """
         super().__init__(team_id=team_id)
         self.task_statuses: Dict[str, TaskStatus] = {}
         self._task_map: Dict[str, Task] = {}
-        logger.info(f"InMemoryTaskBoard initialized for team '{self.team_id}'.")
+        self._id_counter: int = 0
+        logger.info(f"InMemoryTaskPlan initialized for team '{self.team_id}'.")
+    
+    def _generate_next_id(self) -> str:
+        self._id_counter += 1
+        return f"task_{self._id_counter:04d}"
 
-    def add_tasks(self, tasks: List[Task]) -> bool:
+    def add_tasks(self, task_definitions: List[TaskDefinitionSchema]) -> List[Task]:
         """
-        Adds new tasks to the board. This is an additive-only operation.
+        Creates new tasks from definitions, adds them to the plan, and returns the created tasks.
         """
-        for task in tasks:
+        new_tasks: List[Task] = []
+        for task_def in task_definitions:
+            new_id = self._generate_next_id()
+            task = Task(task_id=new_id, **task_def.model_dump())
+            
             self.tasks.append(task)
             self.task_statuses[task.task_id] = TaskStatus.NOT_STARTED
             self._task_map[task.task_id] = task
+            new_tasks.append(task)
 
         self._hydrate_all_dependencies()
-        logger.info(f"Team '{self.team_id}': Added {len(tasks)} new task(s) to the board. Emitting TasksAddedEvent.")
+        logger.info(f"Team '{self.team_id}': Added {len(new_tasks)} new task(s) to the plan. Emitting TasksCreatedEvent.")
         
-        event_payload = TasksAddedEvent(
+        event_payload = TasksCreatedEvent(
             team_id=self.team_id,
-            tasks=tasks,
+            tasks=new_tasks,
         )
-        self.emit(EventType.TASK_BOARD_TASKS_ADDED, payload=event_payload)
-        return True
+        self.emit(EventType.TASK_PLAN_TASKS_CREATED, payload=event_payload)
+        return new_tasks
 
-    def add_task(self, task: Task) -> bool:
+    def add_task(self, task_definition: TaskDefinitionSchema) -> Optional[Task]:
         """
-        Adds a single new task to the board by wrapping it in a list and calling add_tasks.
+        Creates a single new task from a definition, adds it to the plan, and returns it.
         """
-        return self.add_tasks([task])
+        created_tasks = self.add_tasks([task_definition])
+        return created_tasks[0] if created_tasks else None
         
     def _hydrate_all_dependencies(self):
         """
@@ -67,7 +79,7 @@ class InMemoryTaskBoard(BaseTaskBoard):
 
             resolved_deps = []
             for dep in task.dependencies:
-                # Case 1: The dependency is already a valid task_id on the board.
+                # Case 1: The dependency is already a valid task_id on the plan.
                 if dep in all_task_ids:
                     resolved_deps.append(dep)
                 # Case 2: The dependency is a task_name that can be resolved.
@@ -103,12 +115,12 @@ class InMemoryTaskBoard(BaseTaskBoard):
             agent_name=agent_name,
             deliverables=task_deliverables
         )
-        self.emit(EventType.TASK_BOARD_STATUS_UPDATED, payload=event_payload)
+        self.emit(EventType.TASK_PLAN_STATUS_UPDATED, payload=event_payload)
         return True
 
     def get_status_overview(self) -> Dict[str, Any]:
         """
-        Returns a serializable dictionary of the board's current state.
+        Returns a serializable dictionary of the plan's current state.
         The overall_goal is now fetched from the context via the converter.
         """
         return {

autobyteus/task_management/schemas/__init__.py

@@ -5,6 +5,7 @@ Exposes the public schema models for the task management module.
 from .task_definition import TasksDefinitionSchema, TaskDefinitionSchema
 from .task_status_report import TaskStatusReportSchema, TaskStatusReportItemSchema
 from .deliverable_schema import FileDeliverableSchema
+from .todo_definition import ToDoDefinitionSchema, ToDosDefinitionSchema
 
 __all__ = [
     "TasksDefinitionSchema",
@@ -12,4 +13,6 @@ __all__ = [
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",
     "FileDeliverableSchema",
+    "ToDoDefinitionSchema",
+    "ToDosDefinitionSchema",
 ]

autobyteus/task_management/schemas/task_status_report.py

@@ -9,7 +9,7 @@ but includes dynamic state information (like task status).
 from typing import List, Optional
 from pydantic import BaseModel, Field
 
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from autobyteus.task_management.deliverable import FileDeliverable
 
 class TaskStatusReportItemSchema(BaseModel):
@@ -22,5 +22,5 @@ class TaskStatusReportItemSchema(BaseModel):
     file_deliverables: List[FileDeliverable] = Field(default_factory=list, description="A list of files submitted as deliverables for this task.")
 
 class TaskStatusReportSchema(BaseModel):
-    """Represents a full task board status report in an LLM-friendly format."""
+    """Represents a full task plan status report in an LLM-friendly format."""
     tasks: List[TaskStatusReportItemSchema] = Field(..., description="The list of tasks and their current statuses.")

autobyteus/task_management/schemas/todo_definition.py

@@ -0,0 +1,15 @@
+# file: autobyteus/autobyteus/task_management/schemas/todo_definition.py
+"""
+Defines the Pydantic models for ToDo "definitions".
+These models represent the structure an LLM is expected to generate for personal planning.
+"""
+from typing import List
+from pydantic import BaseModel, Field
+
+class ToDoDefinitionSchema(BaseModel):
+    """A Pydantic model representing a single to-do item as defined by an LLM."""
+    description: str = Field(..., description="A clear, detailed description of what this to-do item or step entails.")
+
+class ToDosDefinitionSchema(BaseModel):
+    """A Pydantic model representing a list of to-do items as generated by an LLM."""
+    todos: List[ToDoDefinitionSchema] = Field(..., description="The list of to-do items to create.")

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,16 +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 .assign_task_to import AssignTaskTo
+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/{assign_task_to.py → task_tools/assign_task_to.py}

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/task_management/tools/assign_task_to.py
+# file: autobyteus/autobyteus/task_management/tools/task_tools/assign_task_to.py
 import logging
 from typing import TYPE_CHECKING, Optional, 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
@@ -25,7 +24,7 @@ class AssignTaskTo(BaseTool):
 
     @classmethod
     def get_name(cls) -> str:
-        return "AssignTaskTo"
+        return "assign_task_to"
 
     @classmethod
     def get_description(cls) -> str:
@@ -41,42 +40,43 @@ class AssignTaskTo(BaseTool):
 
     async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
         """
-        Executes the tool by adding the task to the central TaskBoard and then
+        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 AssignTaskTo for task '{task_name}' assigned to '{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 Board ---
+        # --- 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 board or send messages."
+            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_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
         
-        # --- Action 1: Add the task to the Task Board ---
+        # --- Action 1: Add the task to the Task Plan ---
         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 AssignTaskTo: {error_msg}")
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for assign_task_to: {error_msg}")
             return f"Error: {error_msg}"
 
-        if not task_board.add_task(new_task):
-            error_msg = f"Failed to publish task '{new_task.task_name}' to the board for an unknown reason."
+        # 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}' to the task board.")
+        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
@@ -98,11 +98,11 @@ class AssignTaskTo(BaseTool):
             )
             if new_task.dependencies:
                 # Resolve dependency names for the message
-                id_to_name_map = {task.task_id: task.task_name for task in task_board.tasks}
+                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 board. You can begin work when its dependencies are met."
+            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,

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