Struct ReviewRound 

pub struct ReviewRound {

    pub round: usize,
    pub head: String,
    pub verified_head: Option<String>,
    pub reviews: Vec<ReviewRecord>,
    pub e2e: Vec<CommandOutcome>,
    pub verify_retried: bool,
    pub e2e_deferred: bool,
    pub e2e_defer_reason: Option<String>,
    pub fix: Option<FixRecord>,
    pub blocking: usize,
    pub answered: usize,
    pub expected: usize,
    pub clean: bool,
    pub progressed: bool,
    pub vote_split: bool,
    pub reconsideration: Vec<ReviewRevoteRecord>,
    pub verdict: Option<ReviewVote>,
}

One review + verify + fix round.

Fields

round: usize

1-based round number.

head: String

Commit the round reviewed.

verified_head: Option<String>

Commit actually checked by a catch-up e2e, when it differs from the reviewed commit. Kept separate so reports never attribute a command result to a review target the command did not inspect.

reviews: Vec<ReviewRecord>

Reviewer reports.

e2e: Vec<CommandOutcome>

E2E command outcomes for this round.

verify_retried: bool

True when the first verify attempt this round could not build or link, and e2e above holds a second attempt run before concluding. A run must never be decided on a red it could not tell from an unrelated build race.

e2e_deferred: bool

True when e2e was intentionally left empty this round: the round already had blocking findings and another round was available, so graph::Runner::review_loop sent the fixer straight at them instead of spending a full verify run on a head it already knew would need another fix. Distinct from an e2e that is simply empty because verify.e2e has no commands configured — e2e.is_empty() alone cannot tell those apart, and conflating them is exactly how a deferred check would get painted green. A record written before this field existed defaults to false, which is the truth for it: every round used to run e2e unconditionally.

e2e_defer_reason: Option<String>

Why e2e was deferred, set only when Self::e2e_deferred is true. Carried to the fixer’s prompt and shown in the report so “deferred” never reads as silence.

fix: Option<FixRecord>

Fixer response, absent when the round was already clean.

blocking: usize

Findings that hold the merge.

answered: usize

Reviewer seats that answered (did not time out, crash, or return something unparsable).

expected: usize

Reviewer seats the round expected an answer from — normally graph.reviewers, but recorded per round so a config change between runs never has to be inferred from history.

clean: bool

Round ended with no blocking findings and green verification, judged against the seats that answered. See Self::incomplete for whether that verdict is missing input.

progressed: bool

Did the tree actually move against base this round, comparing the diff after the fix to the diff the reviewers saw at the start of the round?

Never derived from the fixer’s own addressed/rejected count: that self-report has been caught lying twice on this workload (runs b455 and 6218, both of which committed a real, substantial diff while reporting 0 addressed). git does not lie about whether the tree changed, so this is what graph::Runner::review_loop counts rounds of no progress against. Absent on a round with no fix attempt (already clean, or the round the budget ran out on), where it defaults to false and is not consulted.

vote_split: bool

Did the seats’ initial votes (ReviewRecord::vote) disagree?

reconsideration: Vec<ReviewRevoteRecord>

One round of revoting, run only when vote_split: each seat that cast an initial vote reads every seat’s findings and votes, then revotes. Empty when the initial votes already agreed, the same as a solo candidate leaving deliberation empty.

verdict: Option<ReviewVote>

The round’s verdict: the most cautious vote among the seats that answered, using each seat’s revote where reconsideration ran and its initial vote otherwise. None when no seat produced a usable vote — including every record written before votes existed, which is the truth for those rounds, not a gap in this one.

Implementations

impl ReviewRound

pub fn incomplete(&self) -> bool

Did at least one reviewer seat fail to answer this round?

pub fn e2e_status(&self) -> E2eStatus

The honest state of this round’s e2e leg.

Never derive this from e2e.is_empty() alone anywhere else in the codebase — NotConfigured and Deferred both leave it empty, and only this method (backed by Self::e2e_deferred) tells them apart.

Trait Implementations

impl Clone for ReviewRound

fn clone(&self) -> ReviewRound

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReviewRound

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReviewRound

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ReviewRound

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

where __S: Serializer,

Serialize this value into the given Serde serializer.