Struct ReviewPlan 

pub struct ReviewPlan {
    pub mode: ReasoningMode,
    pub mode_source: String,
    pub materiality: Materiality,
    pub confidence: ReasoningConfidence,
    pub capabilities: Vec<String>,
    pub budget: usize,
    pub outcome: PlanOutcome,
    pub reason: String,
    pub selected: Vec<SelectedAdvisor>,
    pub excluded: Vec<ExcludedAdvisor>,
    pub available: usize,
    pub local_review: Vec<String>,
}

The plan: the decision with its reasons attached. It carries what it answered (mode, materiality, confidence, capabilities), the budget, the outcome with one sentence of why, every advisor selected or excluded, and the local review when one is due.

use majordomus_cli::reasoning::availability::{ModeResolution, ReasoningMode};
use majordomus_cli::reasoning::policy::{plan, Materiality, PlanRequest, ReviewPlan, LOCAL_REVIEW};

let mode = ModeResolution { mode: ReasoningMode::Offline, source: "MAJORDOMUS_REASONING_MODE".into() };
let request = PlanRequest { materiality: Materiality::Material, ..Default::default() };
let p: ReviewPlan = plan(&request, &mode, &[]);
assert_eq!(p.mode_source, "MAJORDOMUS_REASONING_MODE");
assert_eq!(p.capabilities, ["independent_reasoning"]);
assert_eq!((p.budget, p.available), (1, 0));
assert_eq!(p.local_review.len(), LOCAL_REVIEW.len());
assert!(p.reason.starts_with("no available advisor offers"));

Fields

mode: ReasoningMode

The mode it was made under.

mode_source: String

What decided the mode.

materiality: Materiality

The materiality it answered.

confidence: ReasoningConfidence

The confidence it answered.

capabilities: Vec<String>

The capabilities review was asked for.

budget: usize

How many advisors the mode and materiality allow.

outcome: PlanOutcome

What to do.

reason: String

Why, in one sentence.

selected: Vec<SelectedAdvisor>

The advisors to consult, in selection order.

excluded: Vec<ExcludedAdvisor>

Every advisor not selected, with its reason.

available: usize

Advisors available when the plan was made, whatever was selected.

local_review: Vec<String>

The structured local review to perform, when material uncertainty meets no advisor.

Trait Implementations

impl Clone for ReviewPlan

fn clone(&self) -> ReviewPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReviewPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReviewPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReviewPlan

impl JsonSchema for ReviewPlan

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 ReviewPlan

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

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 ReviewPlan