Struct PlanNode 

pub struct PlanNode {
    pub id: StepId,
    pub capability: Capability,
    pub depends_on: Vec<StepId>,
    pub args: BTreeMap<String, ArgSource>,
    pub terminal: bool,
    pub verifies: bool,
}

One unit of work in a plan.

A panel is several nodes, not a field on one

There is deliberately no quorum here. A panel is k judgements of one piece of work and an aggregator that tallies them — a shape the graph already expresses exactly: k nodes depending on the subject, each verifies, and a terminal node depending on all of them that decides with Quorum. A field would be a second spelling of it, and one the runtime cannot execute: there is no way to hand a node a lens, so the declaration would ride inside the plan digest with its behaviour living nowhere.

Fields

id: StepId

capability: Capability

What this node needs done. Resolved against registered skills.

depends_on: Vec<StepId>

Nodes that must complete first.

Structural, not conversational: a node cannot run before its predecessors’ outputs are bound to its inputs, which is how “one agent ignored another’s result” stops being possible rather than discouraged.

args: BTreeMap<String, ArgSource>

Each argument and where it comes from.

terminal: bool

Whether the plan is complete once this node is done.

verifies: bool

Whether this node checks another’s work.

Named so the contract can require one: nothing checking the work is a fifth of observed multi-agent failures. Structural rather than advisory — a node claiming it verifies must depend on what it checks, and RuntimeBuilder::require_verifier makes “every plan carries one” a condition of admission, on a replanner’s successor as much as on the plan an embedder wrote.

Implementations

impl PlanNode

pub fn new(id: u32, capability: impl Into<Capability>) -> Self

pub fn arg(self, name: impl Into<String>, source: ArgSource) -> Self

Bind an argument, recording the dependency it implies.

pub fn after(self, step: u32) -> Self

pub fn terminal(self) -> Self

pub fn verifies(self) -> Self

Trait Implementations

impl Clone for PlanNode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PlanNode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for PlanNode

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 PlanNode