Struct Plan 

pub struct Plan {

    pub format_version: u32,
    pub assets: BTreeMap<AssetId, WorkspaceAsset>,
    pub workspace: Workspace,
    pub revision: u64,
    pub projects: BTreeMap<ProjectId, Project>,
    pub work_items: BTreeMap<WorkItemId, WorkItem>,
    pub requirements: BTreeMap<RequirementId, Requirement>,
    pub artifacts: BTreeMap<ArtifactId, Artifact>,
    pub decisions: BTreeMap<DecisionId, Decision>,
    pub risks: BTreeMap<RiskId, Risk>,
    pub dependencies: Vec<Dependency>,
    pub external_references: BTreeMap<ExternalReferenceId, ExternalReference>,
    pub links: Vec<WorkLink>,
    pub calendars: Option<Calendars>,
}

Authoritative graph and revision; scheduling and completion views are derived.

Fields

format_version: u32

Portable domain format version; unsupported formats are rejected.

assets: BTreeMap<AssetId, WorkspaceAsset>

Assets shared across code and non-code work.

workspace: Workspace

Namespace containing the graph.

revision: u64

Wrapping operation sequence for optimistic concurrency.

projects: BTreeMap<ProjectId, Project>

Projects indexed by stable identifier.

work_items: BTreeMap<WorkItemId, WorkItem>

Work indexed by stable identifier.

requirements: BTreeMap<RequirementId, Requirement>

Requirements indexed by stable identifier.

artifacts: BTreeMap<ArtifactId, Artifact>

Evidence indexed by stable identifier.

decisions: BTreeMap<DecisionId, Decision>

Decision gates indexed by stable identifier.

risks: BTreeMap<RiskId, Risk>

Risks indexed by stable identifier.

dependencies: Vec<Dependency>

Directed temporal constraints; cycles are rejected.

external_references: BTreeMap<ExternalReferenceId, ExternalReference>

External tracker objects linked to work; context only, never evidence or gates.

links: Vec<WorkLink>

Contextual work relationships that never gate readiness, scheduling or progress.

calendars: Option<Calendars>

Working calendars; every hour is working time when absent.

Implementations

impl Plan

pub fn work_calendar(&self, work: &WorkItem) -> Option<ResolvedCalendar>

Calendar and executor a projection uses for work, or None without a calendars block.

pub fn lag_end( &self, edge: &Dependency, event_at: DateTime<Utc>, hours: f64, ) -> Option<DateTime<Utc>>

When a dependency’s positive lag after event_at has passed: elapsed hours, or working hours of the successor’s calendar for a working-time lag. None when out of range.

impl Plan

pub fn applicability(&self) -> BTreeMap<WorkItemId, Applicability>

Applicability of every work item; time-independent, so reviews can compare two plans.

pub fn effective_decision(&self, id: DecisionId) -> Option<&Decision>

The decision whose outcome currently stands for id, following replacements.

impl Plan

pub fn empty(name: impl Into<String>) -> Self

Create an empty namespace at revision zero.

pub fn find_work_by_key(&self, key: &str) -> Option<&WorkItem>

Find authoritative work by its human-readable key.

pub fn find_work_by_key_mut(&mut self, key: &str) -> Option<&mut WorkItem>

Mutably find authoritative work; callers must validate edits.

pub fn find_dependency(&self, id: DependencyId) -> Option<&Dependency>

Find a temporal constraint by its stable identity.

pub fn enforced_dependencies(&self) -> impl Iterator<Item = &Dependency>

Constraints that currently gate execution and remaining projections; waived edges are omitted.

pub fn find_decision_by_key(&self, key: &str) -> Option<&Decision>

Find a gate by its human-readable key.

impl Plan

pub fn validate(&self) -> Result<(), ValidationError>

Validate references, keys, containment, execution contracts, and numerical inputs.

Call this at import, command, and persistence boundaries. It does not mutate the plan.

Trait Implementations

impl Clone for Plan

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 Plan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plan

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for Plan

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Plan

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 Plan