Struct Deliberation 

pub struct Deliberation { /* private fields */ }

Aggregate root: one deliberation over one task.

Implementations

impl Deliberation

pub fn start( task_id: TaskId, specialty: Specialty, rounds_budget: Rounds, now: OffsetDateTime, ) -> Self

pub fn task_id(&self) -> &TaskId

pub fn specialty(&self) -> &Specialty

pub fn rounds_budget(&self) -> Rounds

pub fn phase(&self) -> DeliberationPhase

pub fn proposals(&self) -> &BTreeMap<ProposalId, Proposal>

pub fn outcomes(&self) -> &BTreeMap<ProposalId, ValidationOutcome>

pub fn started_at(&self) -> OffsetDateTime

pub fn completed_at(&self) -> Option<OffsetDateTime>

pub fn add_proposal(&mut self, proposal: Proposal) -> Result<(), DomainError>

Add a new proposal. Only allowed while Proposing. Duplicate proposal ids are rejected.

pub fn revise_proposal( &mut self, proposal_id: &ProposalId, new_content: impl Into<ProposalContent>, now: OffsetDateTime, ) -> Result<(), DomainError>

Revise an existing proposal. Only allowed in the Revising phase.

pub fn attach_outcome( &mut self, proposal_id: &ProposalId, outcome: ValidationOutcome, ) -> Result<(), DomainError>

Attach a validation outcome for a proposal. Only allowed in Validating. Every proposal must receive exactly one outcome before advancing to Scoring.

pub fn advance(&mut self) -> Result<DeliberationPhase, DomainError>

Advance to the next phase, enforcing the preconditions of the transition:

• Proposing -> Revising: at least one proposal present.
• Validating -> Scoring: every proposal has an outcome.
• Other transitions are unconditional.

pub fn complete( &mut self, now: OffsetDateTime, ) -> Result<Vec<RankedOutcome>, DomainError>

Compute the ranking and mark the deliberation complete. Only allowed from Scoring. The winning proposal gets rank 0; ties are broken by proposal id to keep the ordering deterministic.

pub fn reprioritize( &mut self, ranking: Vec<ProposalId>, ) -> Result<Vec<RankedOutcome>, DomainError>

Reorder the final ranking after completion while preserving the same proposal set. This lets the application layer impose a deterministic post-scoring preference (for example, valid structured outputs before invalid ones) without mutating proposals or outcomes.

pub fn duration(&self) -> Option<DurationMs>

Total duration from start to completion, when completed.

pub fn ranking(&self) -> &[ProposalId]

pub fn ranked_outcomes(&self) -> Result<Vec<RankedOutcome>, DomainError>

Reconstruct RankedOutcomes from the persisted ranking + the stored proposals and outcomes. Useful when an upstream caller (e.g. RunCouncilDecisionUseCase in Warn mode) needs to read a completed deliberation back from a repository without re-running the algorithm.

Fails with DomainError::InvalidTransition if the deliberation is not yet in the Completed phase.

Trait Implementations

impl Clone for Deliberation

fn clone(&self) -> Deliberation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Deliberation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Deliberation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Deliberation

impl PartialEq for Deliberation

fn eq(&self, other: &Deliberation) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Deliberation

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 Deliberation