Struct Task 

pub struct Task {

    pub id: String,
    pub description: String,
    pub status: TaskStatus,
    pub plan_id: Option<String>,
    pub parent_id: Option<String>,
    pub children: Vec<String>,
    pub depends_on: Vec<String>,
    pub priority: TaskPriority,
    pub assigned_to: Option<String>,
    pub iterations: u32,
    pub summary: Option<String>,
    pub created_at: i64,
    pub updated_at: i64,
    pub started_at: Option<i64>,
    pub completed_at: Option<i64>,
}

A task being executed by an agent (supports tree structure)

Fields

id: String

Unique task ID

description: String

Task description

status: TaskStatus

Current status

plan_id: Option<String>

Associated plan ID (links task to a plan)

parent_id: Option<String>

Parent task ID (for tree structure)

children: Vec<String>

Child task IDs

depends_on: Vec<String>

Task IDs this task depends on (must complete before this can start)

priority: TaskPriority

Task priority

assigned_to: Option<String>

Assigned agent (if any)

iterations: u32

Number of iterations executed

summary: Option<String>

Result summary (when completed or failed)

created_at: i64

Creation timestamp

updated_at: i64

Last update timestamp

started_at: Option<i64>

When the task was started (for time tracking)

completed_at: Option<i64>

When the task was completed (for time tracking)

Implementations

impl Task

pub fn new<S: Into<String>>(id: S, description: S) -> Self

Create a new pending task

pub fn new_for_plan<S: Into<String>>(id: S, description: S, plan_id: S) -> Self

Create a new task associated with a plan

pub fn new_subtask<S: Into<String>>(id: S, description: S, parent_id: S) -> Self

Create a new task with a parent (subtask)

pub fn start(&mut self)

Mark task as in progress

pub fn complete<S: Into<String>>(&mut self, summary: S)

Mark task as completed

pub fn duration_secs(&self) -> Option<i64>

Get task duration in seconds (if started and completed)

pub fn elapsed_secs(&self) -> Option<i64>

Get elapsed time since task started (in seconds)

pub fn fail<S: Into<String>>(&mut self, error: S)

Mark task as failed

pub fn block(&mut self)

Mark task as blocked (waiting on dependencies)

pub fn skip<S: Into<String>>(&mut self, reason: Option<S>)

Mark task as skipped

pub fn increment_iteration(&mut self)

Increment iterations

pub fn add_child(&mut self, child_id: String)

Add a child task ID

pub fn add_dependency(&mut self, task_id: String)

Add a dependency

pub fn has_dependencies(&self) -> bool

Check if task has any incomplete dependencies

pub fn has_children(&self) -> bool

Check if task has children

pub fn is_root(&self) -> bool

Check if task is a root task (no parent)

pub fn set_priority(&mut self, priority: TaskPriority)

Set priority

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Task

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Task

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.