Struct TaskNode 

pub struct TaskNode {

    pub id: TaskId,
    pub title: String,
    pub description: String,
    pub agent_hint: Option<String>,
    pub status: TaskStatus,
    pub depends_on: Vec<TaskId>,
    pub result: Option<TaskResult>,
    pub assigned_agent: Option<String>,
    pub retry_count: u32,
    pub predicate_rerun_count: u32,
    pub failure_strategy: Option<FailureStrategy>,
    pub max_retries: Option<u32>,
    pub execution_mode: ExecutionMode,
    pub verify_predicate: Option<VerifyPredicate>,
    pub predicate_outcome: Option<PredicateOutcome>,
    pub execution_environment: Option<String>,
    pub token_budget_cents: Option<f64>,
    pub network_scope: Option<NetworkScope>,
    pub asset_sensitivity: Option<AssetSensitivity>,
}

A single node in the task DAG.

Constructed by Planner and stored inside a TaskGraph. The scheduler drives each node through its TaskStatus lifecycle.

Examples

use zeph_orchestration::{TaskNode, TaskStatus, ExecutionMode};

let node = TaskNode::new(0, "fetch data", "Download the dataset from source.");
assert_eq!(node.status, TaskStatus::Pending);
assert!(node.depends_on.is_empty());
assert_eq!(node.execution_mode, ExecutionMode::Parallel);
assert!(node.network_scope.is_none());
assert!(node.asset_sensitivity.is_none());

Fields

id: TaskId

Dense zero-based index. Invariant: tasks[i].id == TaskId(i).

title: String

Short, human-readable task title.

description: String

Full task description passed verbatim to the assigned sub-agent as its prompt.

agent_hint: Option<String>

Preferred agent name suggested by the planner; None lets the router decide.

status: TaskStatus

Current lifecycle status.

depends_on: Vec<TaskId>

Indices of tasks this node depends on.

result: Option<TaskResult>

Result populated by the scheduler after the sub-agent finishes.

assigned_agent: Option<String>

Agent name actually assigned by the router at dispatch time.

retry_count: u32

Number of times this task has been retried so far (execution retries only).

predicate_rerun_count: u32

Number of predicate-driven re-runs for this task (independent of retry_count).

failure_strategy: Option<FailureStrategy>

Per-task failure strategy override; None means use TaskGraph::default_failure_strategy.

max_retries: Option<u32>

Maximum retry attempts for this task; None means use TaskGraph::default_max_retries.

execution_mode: ExecutionMode

LLM planner annotation. Old SQLite-stored JSON without this field deserialises to the default (Parallel).

verify_predicate: Option<VerifyPredicate>

Per-subtask verification predicate (predicate gate).

When Some, the task’s output must satisfy this criterion before downstream tasks may consume it. The scheduler emits SchedulerAction::VerifyPredicate after task completion and blocks downstream dispatch until predicate_outcome.is_some().

predicate_outcome: Option<PredicateOutcome>

Outcome of the most recent predicate evaluation.

None means the gate has not been evaluated yet (in-memory only; restart re-evaluates any pending predicates). The scheduler re-emits VerifyPredicate on every tick while this is None and verify_predicate.is_some().

execution_environment: Option<String>

Named execution environment from [[execution.environments]] to use when dispatching shell tool calls for this task. None inherits the executor default.

token_budget_cents: Option<f64>

Per-task cost budget in US cents. None = use OrchestrationConfig::default_task_budget_cents.

On task completion the scheduler checks whether this budget was exceeded and emits a tracing::warn!. Hard enforcement is deferred post-v1.0.0.

network_scope: Option<NetworkScope>

Per-task network egress policy. Advisory only for spawned sub-agents.

None / Inherit = inherit the executor/global allow_network default. See NetworkScope for enforcement caveats and specs/069-threat-model/spec.md §5.

asset_sensitivity: Option<AssetSensitivity>

Sensitivity level of assets accessed by this task.

Used by the orchestration planner to annotate tasks that touch sensitive resources (vault keys, user credentials, private memory). Advisory only in the current implementation — the dispatcher does not yet auto-restrict the tool allow-list based on this field. See specs/069-threat-model/spec.md §5.

Implementations

impl TaskNode

pub fn new( id: u32, title: impl Into<String>, description: impl Into<String>, ) -> Self

Create a new pending task with the given index.

Trait Implementations

impl Clone for TaskNode

fn clone(&self) -> TaskNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TaskNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.