Struct Plan 

pub struct Plan {
    pub project: PlanProject,
    pub statuses: PlanVocabulary,
    pub milestones: Vec<PlanMilestone>,
    pub issues: Vec<PlanIssue>,
    pub waves: Vec<PlanWave>,
    pub edges: Vec<PlanEdge>,
    pub milestone_edges: Vec<PlanEdge>,
    pub findings: Vec<PlanFinding>,
}

The whole derived plan: what every plan capability answers out of.

Fields

project: PlanProject

The plan’s header, with the active milestone derived.

statuses: PlanVocabulary

The declared status vocabularies.

milestones: Vec<PlanMilestone>

Every milestone, in id order.

issues: Vec<PlanIssue>

Every issue, in id order.

waves: Vec<PlanWave>

The execution waves, lowest first.

edges: Vec<PlanEdge>

The issue dependency graph, sorted.

milestone_edges: Vec<PlanEdge>

The milestone dependency graph, sorted.

findings: Vec<PlanFinding>

Every finding, in derivation order.

Implementations

impl Plan

pub fn issue(&self, id: &str) -> Option<&PlanIssue>

One issue by id.

pub fn milestone(&self, id: &str) -> Option<&PlanMilestone>

One milestone by id.

pub fn failures(&self) -> usize

How many findings are failures. A model with one is invalid.

pub fn warnings(&self) -> usize

How many findings are warnings.

pub fn is_present(&self) -> bool

Whether this repository holds a canonical project model at all.

pub fn roadmap(&self) -> Vec<&PlanMilestone>

The milestone ids in roadmap order: rank, then order, then id. Derived from the graph; no list of versions is maintained anywhere.

pub fn next_ready(&self, milestone: Option<&str>) -> Option<&PlanIssue>

The one issue a worker should take now: the lowest-wave READY issue of the active milestone, highest priority first, then id.

The active milestone can have nothing ready while another one does — a milestone waiting on its own acceptance evidence, for instance — so the search widens to the whole plan rather than answering “none” and sending a worker away from executable work. mj_pj_next_ready in lib/project.sh does exactly this.

pub fn build(index: &Index) -> Plan

Build the plan from an index. A walk of values already in memory: no file is opened, no subprocess is started, nothing is cached.

pub fn after(index: &Index, id: &str, transition: Transition, now: &str) -> Plan

The plan as it will read once transition has been written to id.

The same records, the same derive, one timestamp changed: the status a caller is told after a write is computed by the one derivation every reader uses, never announced by the writer. This matters because the resulting status is not a function of the transition alone — a done whose required evidence is absent stays VERIFY, and a record marked cancelled stays CANCELLED whatever is written to it.

Nothing is read from disk and nothing is written: this is the projection of a write, and transition is what performs one.

use majordomus_cli::plan::{Plan, Transition};
let before = Plan::build(index);
let after = Plan::after(index, "I0001", Transition::Done, "2026-09-11T12:00:00Z");
// The status is derived both times, so an issue whose evidence is incomplete is
// still VERIFY afterwards and the caller can see that before writing anything.
assert_eq!(before.issue("I0001").is_some(), after.issue("I0001").is_some());

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

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: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Plan

impl JsonSchema for Plan

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Plan

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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