Struct Subtask 

pub struct Subtask {

    pub id: String,
    pub instruction: String,
    pub deps: Vec<String>,
    pub parallel_ok: bool,
    pub context: Vec<String>,
    pub verify: Option<String>,
    pub status: SubtaskStatus,
    pub result: Option<String>,
    pub parent: Option<String>,
    pub kind: NodeKind,
    pub conversation_id: Option<String>,
    pub artifact_ref: Option<ArtifactRef>,
    pub caveat_policy: CaveatPolicy,
}

One unit of work in a Plan — the serialized form of a single scheduler dispatch. A fragment-valid [[subtask]] table is exactly this.

Fields

id: String

Stable identifier, referenced by other subtasks’ Subtask::deps.

instruction: String

What the child agent is asked to do.

deps: Vec<String>

Ids of subtasks that must complete before this one may start.

parallel_ok: bool

May this subtask run concurrently with its ready siblings?

context: Vec<String>

The leaf’s FILE SCOPE — its write lane (#812), not reading material. At dispatch this is forwarded as args["scope"] and intersected into the effective writable set (worktree ∩ fs_write ∩ scope): a meet-only convenience fence that can only narrow, never widen. Empty = unfenced (pre-#812 behavior). Matching is exact-file or directory-prefix, with ./ and trailing-/ normalized; degenerate entries ("", ".") fail open. Populated by the harness’s own def-site grounding, with model-declared files appended as untrusted augmentation.

verify: Option<String>

Optional verify command whose enforced result gates the subtask (#332 S1). Absent = no per-subtask gate.

status: SubtaskStatus

Execution status — makes the plan file a resumable run-log.

result: Option<String>

Where the child’s output lands on completion (aggregation destination). None until the subtask has run.

parent: Option<String>

The id of the subtask this one decomposes — None for a root. This is how a flat [[subtask]] list expresses a task→sub-task tree (exactly as Subtask::deps expresses a DAG via id-pointers, not nesting). A subtask that no other subtask names as its parent is a leaf — the unit that dispatches/executes (a leaf is a CrewTask); a subtask that is named is a branch (a grouping / aggregation node). Kept flat on purpose: a nested Vec<Subtask> would break the fragment handoff (one leaf slice = one dispatch). None is also fine in a fragment whose parent lives outside the slice (the pointer is soft, like a cross-fragment dep).

kind: NodeKind

#1030 tree node kind — this subtask’s role in a Roadmap→Phase→Plan→Task tree. Defaults to NodeKind::Task so a legacy flat plan (every subtask a work unit) is unchanged: the existing leaf/crew semantics read status/parent/deps, never kind. A scalar — precedes the tables.

conversation_id: Option<String>

#1030: for a NodeKind::Plan node, the id of the conversations row that IS this plan’s context window (“each plan is a conversational context”). None for Roadmap/Phase grouping nodes, Task leaves, and every legacy subtask — a soft pointer, like Subtask::parent.

artifact_ref: Option<ArtifactRef>

#1030: the objective work artifact an evaluator reads to close this node (a branch/commit for a Task or Plan, a PR for a Phase). None until the node is bound to real work. Serialized as a sub-table, so — like caveat_policy — every scalar field precedes it; it is placed before caveat_policy and both tables trail the scalars.

caveat_policy: CaveatPolicy

The authority this subtask declares it needs. Default-deny: an omitted policy denies every capability axis (see CaveatPolicy).

Serialized last so every scalar field precedes this sub-table — TOML requires values before tables within a [[subtask]] entry.

Implementations

impl Subtask

pub fn node( id: impl Into<String>, instruction: impl Into<String>, kind: NodeKind, parent: Option<String>, ) -> Self

#1030: a tree node with the given id, instruction, NodeKind, and optional parent, everything else defaulted — Pending, no deps/verify/ result/artifact/conversation, and the default-deny CaveatPolicy. The convenience constructor for authoring a roadmap tree node by node.

pub fn to_crew_task(&self, parent: &Caveats) -> CrewTask

Project this subtask into the CrewTask the active topology’s CrewRunner dispatches — the same projection for /mode single|crew|mesh|remote, so a plan authored once lifts across runners unchanged. caveats = parent.meet(self.caveat_policy.to_caveats()): the plan requests, the parent grants, meet enforces ⊑ (attenuation only). Intended for a leaf (see Plan::leaves); a branch is a grouping node, not a dispatch unit.

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 Eq for Subtask

impl PartialEq for Subtask

fn eq(&self, other: &Subtask) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

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.

impl StructuralPartialEq for Subtask