Struct SubTask 

pub struct SubTask {

    pub id: String,
    pub name: String,
    pub instruction: String,
    pub specialty: Option<String>,
    pub dependencies: Vec<String>,
    pub priority: i32,
    pub max_steps: usize,
    pub context: SubTaskContext,
    pub status: SubTaskStatus,
    pub assigned_agent: Option<String>,
    pub created_at: DateTime<Utc>,
    pub completed_at: Option<DateTime<Utc>>,
    pub stage: usize,
    pub needs_worktree: Option<bool>,
}

A sub-task that can be executed by a sub-agent

Fields

id: String

Unique identifier

name: String

Human-readable name/description

instruction: String

The task instruction for the sub-agent

specialty: Option<String>

Specialty/domain for this subtask

dependencies: Vec<String>

Dependencies on other subtasks (by ID)

priority: i32

Priority (higher = more important)

max_steps: usize

Maximum steps allowed for this subtask

context: SubTaskContext

Input context from parent or dependencies

status: SubTaskStatus

Current status

assigned_agent: Option<String>

Assigned sub-agent ID

created_at: DateTime<Utc>

Creation timestamp

completed_at: Option<DateTime<Utc>>

Completion timestamp

stage: usize

Stage in the execution plan (0 = can run immediately)

needs_worktree: Option<bool>

Explicit override for whether this subtask needs an isolated git worktree. None (the default) runs SubTask::needs_worktree heuristics on specialty + instruction; Some(true) forces a worktree; Some(false) forces the shared working directory.

Skipping the worktree for read-only tasks (research, review, planning, fact-check) saves ~1s of setup, an inode, and .git/worktrees lock contention when running many agents in parallel. Tasks that edit files should keep the default or explicitly request a worktree so their edits don’t collide with sibling agents in the same swarm.

Implementations

impl SubTask

pub fn new(name: impl Into<String>, instruction: impl Into<String>) -> Self

Create a new subtask

pub fn with_specialty(self, specialty: impl Into<String>) -> Self

Add a specialty

pub fn with_dependencies(self, deps: Vec<String>) -> Self

Add dependencies

pub fn with_priority(self, priority: i32) -> Self

Set priority

pub fn with_max_steps(self, max_steps: usize) -> Self

Set max steps

pub fn with_context(self, context: SubTaskContext) -> Self

Add context

pub fn with_needs_worktree(self, needs: bool) -> Self

Explicitly set whether this subtask needs a worktree.

true forces isolation; false forces the shared directory; omit this call to fall back to SubTask::needs_worktree heuristics. See the field docs on SubTask::needs_worktree for why this matters in large swarms.

pub fn needs_worktree(&self) -> bool

Decide whether this subtask should run in an isolated worktree.

Honours the explicit override when set; otherwise applies a conservative heuristic:

• Specialty keywords like research, review, analy, audit, plan, fact, summari, search, explore, docs imply a read-only task → no worktree.
• Instruction keywords like write, edit, create, fix, implement, refactor, apply, commit imply file mutation → worktree.
• Unknown tasks default to true (worktree) to stay safe against accidental cross-agent edit collisions.

pub fn can_run(&self, completed: &[String]) -> bool

Check if this subtask can run (all dependencies complete)

pub fn start(&mut self, agent_id: &str)

Mark as running

pub fn complete(&mut self, success: bool)

Mark as completed

Trait Implementations

impl Clone for SubTask

fn clone(&self) -> SubTask

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubTask

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubTask

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SubTask

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

where __S: Serializer,

Serialize this value into the given Serde serializer.