Enum GraphDiff 

#[non_exhaustive]
pub enum GraphDiff {
    AddNode {
        node: TaskNode,
    },
    RemoveNode {
        id: NodeId,
    },
    SplitNode {
        id: NodeId,
        into: Vec<TaskNode>,
    },
    RerouteEdge {
        node_id: NodeId,
        old_dep: NodeId,
        new_dep: NodeId,
    },
    SetRole {
        id: NodeId,
        role: Option<RoleId>,
    },
    SetTools {
        id: NodeId,
        tool_allowlist: Vec<String>,
    },
    WrapInTeam {
        ids: Vec<NodeId>,
        team_id: NodeId,
        team_goal: String,
    },
}

A single mutation to apply to a TaskGraph at runtime.

Produced by the steering LLM (gglib_agent::council::steering) and applied via TaskGraph::apply_diff. Each variant mutates the graph and then triggers re-validation to ensure the graph stays well-formed.

The #[non_exhaustive] attribute allows new variants to be added in future minor versions without breaking match arms in external crates.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AddNode

Add a new node.

The node’s depends_on carries all its incoming edges.

Fields

node: TaskNode

Node to insert.

RemoveNode

Remove a node and strip all edges that pointed to it.

Any node whose depends_on contains id will have that entry removed.

Fields

id: NodeId

Id of the node to remove.

SplitNode

Replace one node with multiple nodes.

The original is removed; each entry in into is inserted. Any node that depended on the original will be updated to depend on all replacements.

Fields

id: NodeId

Id of the node to replace.

into: Vec<TaskNode>

Replacement nodes (at least one entry required).

RerouteEdge

Redirect one dependency edge.

In node_id’s depends_on list, replaces old_dep with new_dep.

Fields

node_id: NodeId

Node whose dependency is being changed.

old_dep: NodeId

Dependency to remove.

new_dep: NodeId

Dependency to add in its place.

SetRole

Set or clear a node’s specialist role.

Fields

id: NodeId

Target node id.

role: Option<RoleId>

New role (None clears the current role).

SetTools

Replace a node’s entire tool allowlist.

Fields

id: NodeId

Target node id.

tool_allowlist: Vec<String>

New tool allowlist (replaces the current list entirely).

WrapInTeam

Wrap a set of nodes into a new TaskNodeKind::Team node.

The wrapped nodes become the team’s subgraph. The team_id node inherits all external in-edges (from nodes NOT in ids) and any node outside ids that depended on a wrapped node will be updated to depend on team_id instead.

Fields

ids: Vec<NodeId>

Ids of the nodes to wrap (all must exist in the graph).

team_id: NodeId

Unique id for the new Team wrapper node.

team_goal: String

High-level goal text for the new Team node.

Trait Implementations

impl Clone for GraphDiff

fn clone(&self) -> GraphDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphDiff

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphDiff

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GraphDiff

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

where __S: Serializer,

Serialize this value into the given Serde serializer.