How restructuring works

Changing the graph's shape mid-project: adding or removing nodes and edges, redirecting dependencies. Tree handles each as a graph operation.

Restructuring is the process of changing the graph's shape mid-project: adding nodes, removing nodes, adding edges, removing edges, or redirecting edges to point at different prerequisites or dependents. Tree handles all of these as graph operations, with the affected node states re-evaluated automatically.

Adding a node

Adding a node creates the node in a default state (locked if it has any incomplete prerequisites, available if it has none). The graph evaluates its position and assigns the appropriate state immediately.

Removing a node

Removing a node deletes it and every edge connected to it. The dependents of the removed node re-evaluate their state, since they may have lost a blocking prerequisite. If the removed node was a dependent's only locked prerequisite, that dependent transitions to available.

Adding an edge

Adding an edge connects two existing nodes with a directed dependency. The downstream node re-evaluates its state. If the new edge introduces a prerequisite that isn't complete, the downstream node moves from available (or in-progress, in unusual cases) to locked.

Removing an edge

Removing an edge disconnects two nodes. The previously downstream node re-evaluates whether its remaining prerequisites are all complete. If yes, it transitions to available.

Redirecting an edge

Redirecting an edge is a remove plus an add. Tree handles it as a single operation, with state evaluation running once after the change rather than twice.

The DAG constraint

Restructuring is constrained by the DAG rule. Tree refuses any operation that would create a cycle in the graph. This prevents users from accidentally making a node depend on itself transitively, which would break the rest of the mechanics.

Why this is cheap in Tree

Most project tools handle restructuring poorly because their data model treats dependencies as metadata on tasks rather than as first-class objects. Tree's edge-first architecture makes restructuring cheap: graph operations are native, and the implications propagate automatically.

LAST UPDATED · 2026-05-11