Struct IntentView 

pub struct IntentView {

    pub id: String,
    pub title: String,
    pub statement: String,
    pub invariants: Vec<String>,
    pub stage: IntentStage,
    pub milestones: Vec<IntentMilestone>,
    pub satisfaction: Vec<IntentCriterion>,
    pub met: usize,
    pub verdict: IntentVerdict,
    pub governance: Vec<String>,
    pub non_goals: Vec<String>,
    pub superseded_by: Option<String>,
    pub source: String,
}

One intent, as its record declares it and as the plan and the ledger derive it: the statement and invariants as authored, each milestone with its derived status, each criterion with the state of its evidence, the stage that follows from both, and the verdict that follows from the evidence alone.

use majordomus_cli::intent::{verdict, IntentStage, IntentVerdictState, IntentView};
let view = IntentView {
    id: "intent-lifecycle".into(),
    title: "Work is traceable to the intent it serves".into(),
    statement: "A reader can ask what work is for.".into(),
    invariants: vec!["no intent status is stored".into()],
    stage: IntentStage::Declared,
    milestones: vec![],
    satisfaction: vec![],
    met: 0,
    verdict: verdict(&[]),
    governance: vec!["adr:adr-0070".into()],
    non_goals: vec![],
    superseded_by: None,
    source: ".ai/repo/project/intents/intent-lifecycle.yaml".into(),
};
// a record naming no milestone that resolves has not been planned
assert_eq!(view.stage, IntentStage::Declared);
// and one declaring no criterion cannot be settled by evidence
assert_eq!(view.verdict.state, IntentVerdictState::Unknown);

Fields

id: String

The identity, which is also the file name.

title: String

One line.

statement: String

What must become true.

invariants: Vec<String>

What must stay true.

stage: IntentStage

Derived: the stage.

milestones: Vec<IntentMilestone>

The milestones, each with its derived status.

satisfaction: Vec<IntentCriterion>

The criteria, each with its evidence state.

met: usize

Derived: how many criteria are met.

verdict: IntentVerdict

Derived from the criteria alone, never from the plan: whether the evidence settles the intent, and which criteria hold it back.

governance: Vec<String>

The governance a worker on this intent loads.

non_goals: Vec<String>

What is deliberately not required.

superseded_by: Option<String>

The replacement, when the record names one.

source: String

Repository-relative path of the record.

Trait Implementations

impl Clone for IntentView

fn clone(&self) -> IntentView

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IntentView

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntentView

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IntentView

impl JsonSchema for IntentView

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 IntentView

fn eq(&self, other: &IntentView) -> 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 IntentView

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 IntentView