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

autobyteus/task_management/events.py

@@ -5,23 +5,23 @@ Defines the Pydantic models for events emitted by a TaskBoard.
 from typing import List, Optional
 from pydantic import BaseModel
 
-from autobyteus.task_management.task_plan import TaskPlan
+from autobyteus.task_management.task import Task
 from autobyteus.task_management.base_task_board import TaskStatus
 from .deliverable import FileDeliverable
 
 class BaseTaskBoardEvent(BaseModel):
     """Base class for all task board events."""
     team_id: str
-    plan_id: Optional[str]
 
-class TaskPlanPublishedEvent(BaseTaskBoardEvent):
-    """Payload for when a new task plan is published to the board."""
-    plan: TaskPlan
+class TasksAddedEvent(BaseTaskBoardEvent):
+    """
+    Payload for when one or more tasks are added to the board.
+    """
+    tasks: List[Task]
 
 class TaskStatusUpdatedEvent(BaseTaskBoardEvent):
     """Payload for when a task's status is updated."""
     task_id: str
     new_status: TaskStatus
     agent_name: str
-    # This field is added to ensure listeners get the full state, including deliverables.
     deliverables: Optional[List[FileDeliverable]] = None

autobyteus/task_management/in_memory_task_board.py

@@ -8,9 +8,9 @@ from typing import Optional, List, Dict, Any
 from enum import Enum
 
 from autobyteus.events.event_types import EventType
-from .task_plan import TaskPlan, Task
+from .task import Task
 from .base_task_board import BaseTaskBoard, TaskStatus
-from .events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from .events import TasksAddedEvent, TaskStatusUpdatedEvent
 
 logger = logging.getLogger(__name__)
 
@@ -23,37 +23,63 @@ class InMemoryTaskBoard(BaseTaskBoard):
         """
         Initializes the InMemoryTaskBoard.
         """
-        # BaseTaskBoard now handles EventEmitter initialization
         super().__init__(team_id=team_id)
-        self.current_plan: Optional[TaskPlan] = None
         self.task_statuses: Dict[str, TaskStatus] = {}
         self._task_map: Dict[str, Task] = {}
         logger.info(f"InMemoryTaskBoard initialized for team '{self.team_id}'.")
 
-    def load_task_plan(self, plan: TaskPlan) -> bool:
+    def add_tasks(self, tasks: List[Task]) -> bool:
         """
-        Loads a new plan onto the board, resetting its state and emitting an event.
+        Adds new tasks to the board. This is an additive-only operation.
         """
-        if not isinstance(plan, TaskPlan):
-            logger.error(f"Team '{self.team_id}': Failed to load task plan. Provided object is not a TaskPlan.")
-            return False
+        for task in tasks:
+            self.tasks.append(task)
+            self.task_statuses[task.task_id] = TaskStatus.NOT_STARTED
+            self._task_map[task.task_id] = task
 
-        self.current_plan = plan
-        self.task_statuses = {task.task_id: TaskStatus.NOT_STARTED for task in plan.tasks}
-        self._task_map = {task.task_id: task for task in plan.tasks}
-        
-        logger.info(f"Team '{self.team_id}': New TaskPlan '{plan.plan_id}' loaded. Emitting event.")
+        self._hydrate_all_dependencies()
+        logger.info(f"Team '{self.team_id}': Added {len(tasks)} new task(s) to the board. Emitting TasksAddedEvent.")
         
-        # Emit event
-        event_payload = TaskPlanPublishedEvent(
+        event_payload = TasksAddedEvent(
             team_id=self.team_id,
-            plan_id=plan.plan_id,
-            plan=plan
+            tasks=tasks,
         )
-        self.emit(EventType.TASK_BOARD_PLAN_PUBLISHED, payload=event_payload)
-        
+        self.emit(EventType.TASK_BOARD_TASKS_ADDED, payload=event_payload)
         return True
 
+    def add_task(self, task: Task) -> bool:
+        """
+        Adds a single new task to the board by wrapping it in a list and calling add_tasks.
+        """
+        return self.add_tasks([task])
+        
+    def _hydrate_all_dependencies(self):
+        """
+        Re-calculates all dependencies to ensure they are all valid task_ids.
+        This robustly handles dependencies that are already IDs and those that are names.
+        """
+        name_to_id_map = {task.task_name: task.task_id for task in self.tasks}
+        all_task_ids = set(self._task_map.keys())
+
+        for task in self.tasks:
+            if not task.dependencies:
+                continue
+
+            resolved_deps = []
+            for dep in task.dependencies:
+                # Case 1: The dependency is already a valid task_id on the board.
+                if dep in all_task_ids:
+                    resolved_deps.append(dep)
+                # Case 2: The dependency is a task_name that can be resolved.
+                elif dep in name_to_id_map:
+                    resolved_deps.append(name_to_id_map[dep])
+                # Case 3: The dependency is invalid.
+                else:
+                    logger.warning(f"Team '{self.team_id}': Dependency '{dep}' for task '{task.task_name}' could not be resolved to a known task ID or name.")
+            
+            task.dependencies = resolved_deps
+
+
     def update_task_status(self, task_id: str, status: TaskStatus, agent_name: str) -> bool:
         """
         Updates the status of a specific task and emits an event.
@@ -67,40 +93,27 @@ class InMemoryTaskBoard(BaseTaskBoard):
         log_msg = f"Team '{self.team_id}': Status of task '{task_id}' updated from '{old_status.value if isinstance(old_status, Enum) else old_status}' to '{status.value}' by agent '{agent_name}'."
         logger.info(log_msg)
         
-        # Find the task to get its deliverables for the event payload
         task = self._task_map.get(task_id)
         task_deliverables = task.file_deliverables if task else None
 
-        # Emit event
         event_payload = TaskStatusUpdatedEvent(
             team_id=self.team_id,
-            plan_id=self.current_plan.plan_id if self.current_plan else None,
             task_id=task_id,
             new_status=status,
             agent_name=agent_name,
             deliverables=task_deliverables
         )
         self.emit(EventType.TASK_BOARD_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.
+        The overall_goal is now fetched from the context via the converter.
         """
-        if not self.current_plan:
-            return {
-                "plan_id": None,
-                "overall_goal": None,
-                "task_statuses": {},
-                "tasks": []
-            }
-        
         return {
-            "plan_id": self.current_plan.plan_id,
-            "overall_goal": self.current_plan.overall_goal,
             "task_statuses": {task_id: status.value for task_id, status in self.task_statuses.items()},
-            "tasks": [task.model_dump() for task in self.current_plan.tasks]
+            "tasks": [task.model_dump() for task in self.tasks]
         }
 
     def get_next_runnable_tasks(self) -> List[Task]:
@@ -108,9 +121,6 @@ class InMemoryTaskBoard(BaseTaskBoard):
         Calculates which tasks can be executed now based on dependencies and statuses.
         """
         runnable_tasks: List[Task] = []
-        if not self.current_plan:
-            return runnable_tasks
-
         for task_id, status in self.task_statuses.items():
             if status == TaskStatus.NOT_STARTED:
                 task = self._task_map.get(task_id)

autobyteus/task_management/schemas/__init__.py

@@ -2,12 +2,12 @@
 """
 Exposes the public schema models for the task management module.
 """
-from .plan_definition import TaskPlanDefinitionSchema, TaskDefinitionSchema
+from .task_definition import TasksDefinitionSchema, TaskDefinitionSchema
 from .task_status_report import TaskStatusReportSchema, TaskStatusReportItemSchema
 from .deliverable_schema import FileDeliverableSchema
 
 __all__ = [
-    "TaskPlanDefinitionSchema",
+    "TasksDefinitionSchema",
     "TaskDefinitionSchema",
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",

autobyteus/task_management/schemas/{plan_definition.py → task_definition.py}

@@ -1,5 +1,5 @@
 """
-Defines the Pydantic models for task plan "definitions".
+Defines the Pydantic models for task "definitions".
 
 These models represent the exact structure that an LLM is expected to generate.
 They serve as a blueprint or definition for a plan, which the system then uses
@@ -13,20 +13,19 @@ class TaskDefinitionSchema(BaseModel):
     """A Pydantic model representing a single task as defined by an LLM."""
     task_name: str = Field(..., description="A short, unique, descriptive name for this task within the plan (e.g., 'setup_project', 'implement_scraper'). Used for defining dependencies.")
     assignee_name: str = Field(..., description="The name of the agent or sub-team assigned to this task.")
-    description: str = Field(..., description="A detailed description of the task.")
+    description: str = Field(..., description="A clear, detailed, and unambiguous description of what this task entails. Provide all necessary context for the assignee to complete the work. For example, if the task involves a file, specify its full, absolute path. If it requires creating a file, specify where it should be saved. Mention any specific requirements or expected outputs.")
     dependencies: List[str] = Field(
         default_factory=list,
         description="A list of 'task_name' values for tasks that must be completed first."
     )
 
-class TaskPlanDefinitionSchema(BaseModel):
-    """A Pydantic model representing a full task plan as generated by an LLM."""
-    overall_goal: str = Field(..., description="The high-level objective of the entire plan.")
-    tasks: List[TaskDefinitionSchema] = Field(..., description="The list of tasks that make up this plan.")
+class TasksDefinitionSchema(BaseModel):
+    """A Pydantic model representing a list of tasks as generated by an LLM."""
+    tasks: List[TaskDefinitionSchema] = Field(..., description="The list of tasks to be published.")
 
     @field_validator('tasks')
     def task_names_must_be_unique(cls, tasks: List[TaskDefinitionSchema]) -> List[TaskDefinitionSchema]:
-        """Ensures that the LLM-provided task_names are unique within the plan."""
+        """Ensures that the LLM-provided task_names are unique within this list."""
         seen_names = set()
         for task in tasks:
             if task.task_name in seen_names:

autobyteus/task_management/schemas/task_status_report.py

@@ -16,12 +16,11 @@ class TaskStatusReportItemSchema(BaseModel):
     """Represents the status of a single task in an LLM-friendly format."""
     task_name: str = Field(..., description="The unique, descriptive name for this task.")
     assignee_name: str = Field(..., description="The name of the agent or sub-team assigned to this task.")
-    description: str = Field(..., description="A detailed description of the task.")
+    description: str = Field(..., description="A clear, detailed, and unambiguous description of what this task entails. Provide all necessary context for the assignee to complete the work. For example, if the task involves a file, specify its full, absolute path. If it requires creating a file, specify where it should be saved. Mention any specific requirements or expected outputs.")
     dependencies: List[str] = Field(..., description="A list of 'task_name' values for tasks that must be completed first.")
     status: TaskStatus = Field(..., description="The current status of this task.")
     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."""
-    overall_goal: str = Field(..., description="The high-level objective of the entire plan.")
     tasks: List[TaskStatusReportItemSchema] = Field(..., description="The list of tasks and their current statuses.")

autobyteus/task_management/task.py

@@ -0,0 +1,60 @@
+# file: autobyteus/autobyteus/task_management/task.py
+"""
+Defines the data structures for a task.
+"""
+import logging
+import uuid
+from typing import List, Any
+from pydantic import BaseModel, Field, model_validator
+
+# To avoid circular import, we use a string forward reference.
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from autobyteus.task_management.deliverable import FileDeliverable
+
+logger = logging.getLogger(__name__)
+
+def generate_task_id():
+    """Generates a unique task identifier."""
+    return f"task_{uuid.uuid4().hex}"
+
+class Task(BaseModel):
+    """
+    Represents a single, discrete unit of work.
+    """
+    task_name: str = Field(..., description="A short, unique, descriptive name for this task within the plan (e.g., 'setup_project', 'implement_scraper'). Used for defining dependencies.")
+    
+    task_id: str = Field(default_factory=generate_task_id, description="A unique system-generated identifier for this task within the plan.")
+    
+    assignee_name: str = Field(..., description="The unique name of the agent or sub-team responsible for executing this task (e.g., 'SoftwareEngineer', 'ResearchTeam').")
+    description: str = Field(..., description="A clear and concise description of what this task entails.")
+    
+    dependencies: List[str] = Field(
+        default_factory=list,
+        description="A list of 'task_name' values for tasks that must be completed before this one can be started."
+    )
+    
+    # This is the updated field as per user request.
+    file_deliverables: List["FileDeliverable"] = Field(
+        default_factory=list,
+        description="A list of file deliverables that were produced as a result of completing this task."
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def handle_local_id_compatibility(cls, data: Any) -> Any:
+        """Handles backward compatibility for the 'local_id' field."""
+        if isinstance(data, dict) and 'local_id' in data:
+            data['task_name'] = data.pop('local_id')
+        # Compatibility for old artifact field
+        if isinstance(data, dict) and 'produced_artifact_ids' in data:
+            del data['produced_artifact_ids']
+        return data
+
+    def model_post_init(self, __context: Any) -> None:
+        """Called after the model is initialized and validated."""
+        logger.debug(f"Task created: Name='{self.task_name}', SystemID='{self.task_id}', Assignee='{self.assignee_name}'")
+
+# This is necessary for Pydantic v2 to correctly handle the recursive model
+from autobyteus.task_management.deliverable import FileDeliverable
+Task.model_rebuild()

autobyteus/task_management/tools/__init__.py

@@ -4,11 +4,15 @@ 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_task_plan import PublishTaskPlan
+from .publish_tasks import PublishTasks
+from .publish_task import PublishTask
 from .update_task_status import UpdateTaskStatus
+from .assign_task_to import AssignTaskTo
 
 __all__ = [
     "GetTaskBoardStatus",
-    "PublishTaskPlan",
+    "PublishTasks",
+    "PublishTask",
     "UpdateTaskStatus",
+    "AssignTaskTo",
 ]

autobyteus/task_management/tools/assign_task_to.py

@@ -0,0 +1,125 @@
+# file: autobyteus/autobyteus/task_management/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
+from autobyteus.task_management.task import Task
+
+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 "AssignTaskTo"
+
+    @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 TaskBoard 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}'.")
+
+        # --- Get Team Context and Task Board ---
+        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."
+            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."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+        
+        # --- Action 1: Add the task to the Task Board ---
+        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}")
+            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."
+            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.")
+
+        # --- 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_board.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."
+
+            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/get_my_tasks.py

@@ -0,0 +1,80 @@
+# file: autobyteus/autobyteus/task_management/tools/get_my_tasks.py
+import json
+import logging
+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
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class GetMyTasks(BaseTool):
+    """A tool for an agent to inspect its own assigned tasks from the central TaskBoard."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "GetMyTasks"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Retrieves the list of tasks currently assigned to you from the team's shared task board. "
+            "This is your personal to-do list. Use this to understand your current workload and decide what to do next."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[None]:
+        # This tool takes no arguments.
+        return None
+
+    async def _execute(self, context: 'AgentContext') -> str:
+        """
+        Executes the tool by fetching tasks from the team's TaskBoard and
+        filtering them for the current agent.
+        """
+        agent_name = context.config.name
+        logger.info(f"Agent '{agent_name}' is executing GetMyTasks.")
+
+        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."
+            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."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+        
+        # Filter the tasks from the central board 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
+        ]
+
+        if not my_tasks:
+            return "Your personal task queue is empty. You have no new tasks assigned and ready to be started."
+
+        try:
+            # Convert the internal Task objects back to the LLM-friendly schema.
+            tasks_for_llm = [
+                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.")
+            return json.dumps(tasks_for_llm, indent=2)
+            
+        except Exception as e:
+            error_msg = f"An unexpected error occurred while formatting your tasks: {e}"
+            logger.error(f"Agent '{agent_name}': {error_msg}", exc_info=True)
+            return f"Error: {error_msg}"

autobyteus/task_management/tools/get_task_board_status.py

@@ -25,8 +25,8 @@ class GetTaskBoardStatus(BaseTool):
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Retrieves the current status of the team's task board, including the overall goal "
-            "and the status of all individual tasks. Returns the status as a structured, LLM-friendly JSON string."
+            "Retrieves the current status of the team's task board, including the status of all individual tasks. "
+            "Returns the status as a structured, LLM-friendly JSON string."
         )
 
     @classmethod
@@ -57,7 +57,7 @@ class GetTaskBoardStatus(BaseTool):
             status_report_schema = TaskBoardConverter.to_schema(task_board)
             
             if not status_report_schema:
-                return "The task board is currently empty. No plan has been published."
+                return "The task board is currently empty. No tasks have been published."
             
             logger.info(f"Agent '{context.agent_id}' successfully retrieved and formatted task board status.")
             return status_report_schema.model_dump_json(indent=2)

autobyteus/task_management/tools/publish_task.py

@@ -0,0 +1,77 @@
+# file: autobyteus/autobyteus/task_management/tools/publish_task.py
+import logging
+from typing import TYPE_CHECKING, Optional, Dict, 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
+from autobyteus.task_management.task import Task
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class PublishTask(BaseTool):
+    """A tool for any agent to add a single new task to the team's task board."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "PublishTask"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Adds a single new task to the team's shared task board. This is an additive action "
+            "and does not affect existing tasks. Use this to create follow-up tasks or delegate new work."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        # The schema for this tool is effectively the schema of a single task definition.
+        return pydantic_to_parameter_schema(TaskDefinitionSchema)
+
+    async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
+        """
+        Executes the tool by validating the task object and adding it to the board.
+        """
+        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}'.")
+
+        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."
+            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."
+            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}")
+            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."
+            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."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"