Struct ConclusionInput 

pub struct ConclusionInput {
    pub assessment: String,
    pub decision: String,
    pub rationale: String,
    pub evidence: Vec<ReasoningEvidence>,
    pub consultations: Vec<String>,
    pub disagreements: Vec<String>,
    pub rejected: Vec<String>,
    pub assumptions: Vec<String>,
    pub risks: Vec<String>,
    pub validation_plan: Vec<String>,
    pub confidence: ReasoningConfidence,
    pub supersedes: Option<String>,
}

The engineering conclusion an assessment reaches.

A conclusion names its decision and why. On material uncertainty it must also carry evidence and a validation plan, and it must weigh every completed consultation of its assessment. The review count is not part of the input: the store computes it.

use majordomus_cli::reasoning::policy::ReasoningConfidence;
use majordomus_cli::reasoning::record::ConclusionInput;

let c = ConclusionInput {
    assessment: "assessment-1".into(),
    decision: "keep the lock".into(),
    rationale: "no caller holds it across an await".into(),
    ..Default::default()
};
assert_eq!(c.confidence, ReasoningConfidence::Medium);
assert!(c.consultations.is_empty() && c.supersedes.is_none());
// a review count is computed by the store, so the input has no field for one
let typed = serde_json::json!({
    "assessment": "a", "decision": "d", "rationale": "r", "independent_review_count": 3,
});
assert!(serde_json::from_value::<ConclusionInput>(typed).is_err());

Fields

assessment: String

The assessment it concludes.

decision: String

The decision.

rationale: String

Why, from the evidence.

evidence: Vec<ReasoningEvidence>

The evidence it rests on. Required for material uncertainty.

consultations: Vec<String>

The completed consultations it weighed.

disagreements: Vec<String>

The resolved disagreements it rests on.

rejected: Vec<String>

Alternatives considered and rejected, each with why.

assumptions: Vec<String>

Assumptions it still depends on.

risks: Vec<String>

Risks that remain.

validation_plan: Vec<String>

How the decision will be proven. Required for material uncertainty.

confidence: ReasoningConfidence

Confidence in it.

supersedes: Option<String>

An earlier conclusion this one replaces, because new evidence overturned it.

Trait Implementations

impl Clone for ConclusionInput

fn clone(&self) -> ConclusionInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConclusionInput

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

Formats the value using the given formatter.

impl Default for ConclusionInput

fn default() -> ConclusionInput

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ConclusionInput

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ConclusionInput

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 Serialize for ConclusionInput

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.