Function prior_on_subject 

pub fn prior_on_subject<'a>(
    loaded: &'a Loaded,
    assessment: &ReasoningRecord,
) -> Option<&'a ReasoningRecord>

A standing conclusion on the same subject as an assessment, from any task: what a later session reuses instead of asking again.

Subjects match when they are equal after collapsing whitespace and ignoring case. The latest other assessment with a standing conclusion wins; an assessment never finds itself, and a record that is not an assessment finds nothing.

use majordomus_cli::reasoning::record::*;
use majordomus_cli::reasoning::store::{prior_on_subject, Loaded};

fn record(id: &str, at: &str, body: ReasoningBody) -> ReasoningRecord {
    ReasoningRecord {
        schema: RECORD_SCHEMA.into(),
        version: RECORD_VERSION,
        id: id.into(),
        task: "t".into(),
        recorded_at: at.into(),
        head: None,
        redacted: vec![],
        body,
    }
}
let assessment = |s: &str| {
    ReasoningBody::Assessment(AssessmentInput { subject: s.into(), ..Default::default() })
};
let mut loaded = Loaded::default();
loaded.records.push(record("assessment-1", "2026-10-01T00:00:01Z", assessment("Lock  scope")));
loaded.records.push(record(
    "conclusion-1",
    "2026-10-01T00:00:02Z",
    ReasoningBody::Conclusion(StoredConclusion {
        input: ConclusionInput {
            assessment: "assessment-1".into(),
            decision: "keep the lock".into(),
            rationale: "measured".into(),
            ..Default::default()
        },
        reviewed_by: vec![],
        independent_review_count: 0,
    }),
));
let later = record("assessment-2", "2026-10-02T00:00:00Z", assessment("lock scope"));
assert_eq!(prior_on_subject(&loaded, &later).unwrap().id, "conclusion-1");

let other = record("assessment-3", "2026-10-02T00:00:00Z", assessment("retry policy"));
assert!(prior_on_subject(&loaded, &other).is_none());