made-core 0.8.0

Domain core of MADE: entities, value objects, events, ports. No IO.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Is the review actually independent?
//!
//! A rule between two roles only bites where the two roles meet, and
//! where they meet is one composed ceremony. Two participants are not
//! independent when they are the same participant, and — the case that
//! matters for agents — when they are two names for one opinion, which
//! is what an independence group declares.

use std::collections::BTreeSet;

use crate::entities::AgenticSystemParts;
use crate::value_objects::{
    AgenticSystemValidationFinding, AgenticSystemValidationLocus, IndependenceRule, ParticipantId,
    SystemCeremonyId, SystemRoleId,
};

use super::references;

pub(super) fn collect(
    parts: AgenticSystemParts<'_>,
    findings: &mut Vec<AgenticSystemValidationFinding>,
) {
    for rule in parts.supervision.independence() {
        for (ceremony, composition) in parts.ceremonies {
            let seated: BTreeSet<&ParticipantId> = composition.role_bindings().values().collect();
            check_one_meeting(parts, rule, ceremony, &seated, findings);
        }
    }
}

fn check_one_meeting(
    parts: AgenticSystemParts<'_>,
    rule: &IndependenceRule,
    ceremony: &SystemCeremonyId,
    seated: &BTreeSet<&ParticipantId>,
    findings: &mut Vec<AgenticSystemValidationFinding>,
) {
    let reviewers = seated_of_role(parts, rule.reviewer(), seated);
    let reviewed = seated_of_role(parts, rule.reviewed(), seated);
    if reviewers.is_empty() || reviewed.is_empty() {
        return;
    }
    for reviewer in &reviewers {
        for subject in &reviewed {
            if let Some(reason) = why_not_independent(parts, reviewer, subject) {
                findings.push(AgenticSystemValidationFinding::refusal(
                    AgenticSystemValidationLocus::independence(
                        rule.reviewer().clone(),
                        rule.reviewed().clone(),
                    ),
                    format!("in ceremony `{ceremony}`, {reason}"),
                ));
            }
        }
    }
}

fn seated_of_role<'design>(
    parts: AgenticSystemParts<'design>,
    role: &'design SystemRoleId,
    seated: &BTreeSet<&ParticipantId>,
) -> Vec<&'design ParticipantId> {
    references::participants_of_role(parts, role)
        .map(crate::value_objects::LogicalParticipant::id)
        .filter(|participant| seated.contains(participant))
        .collect()
}

fn why_not_independent(
    parts: AgenticSystemParts<'_>,
    reviewer: &ParticipantId,
    subject: &ParticipantId,
) -> Option<String> {
    if reviewer == subject {
        return Some(format!(
            "participant `{reviewer}` would review its own work"
        ));
    }
    let group = parts
        .participants
        .get(reviewer)?
        .binding()
        .independence_group()?;
    let other = parts
        .participants
        .get(subject)?
        .binding()
        .independence_group()?;
    (group == other).then(|| {
        format!(
            "participants `{reviewer}` and `{subject}` are both in independence group `{group}`"
        )
    })
}