Struct ReviewRound 

pub struct ReviewRound {

    pub round: usize,
    pub head: String,
    pub verified_head: Option<String>,
    pub verified_at: Option<Timestamp>,
    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>

The commit e2e was actually attempted against. Set whenever an attempt was dispatched (e2e_status() reads Passed, Failed, or ResourceBlocked), naming that commit even when it equals head — never left implicit, because an implicit “must have been head” is exactly what let a later round quote an earlier round’s result without saying which commit it came from. A resource-blocked attempt still targeted a specific commit even though no command finished, and leaving that unrecorded is exactly what made a fresh blocked attempt read the same as an untracked one from before schema 8. None only when nothing was attempted at all (NotConfigured, Deferred). See SCHEMA’s doc for schema 8 for why this broadened from only the catch-up-on-a-different-commit case.

verified_at: Option<Timestamp>

When the attempt behind verified_head actually ran. None on every record written before schema 8, and on a round where nothing ran — both read as “unknown”, not as “now” or “never asked”.

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. A resource-blocked attempt is checked first and ahead of both: e2e is non-empty for it too, but CommandOutcome::resource_blocked says no command actually ran, and reading that as Failed is exactly how shared build-cache contention gets misreported as a verdict on the patch (see CommandOutcome::resource_blocked’s own doc).

pub fn verification_summary( &self, current_head: &str, ) -> Option<VerificationSummary>

Facts about this round’s verification leg, judged against current_head — the commit whoever is asking is actually looking at right now. None when there is nothing worth surfacing: no verify.e2e configured, or the round’s own check came back green (a passing result needs no skepticism attached to it, and an unread None is exactly what keeps a quiet round quiet instead of padding every prompt with “everything was fine”).

This is the single place that turns e2e/e2e_deferred/ verified_head/verified_at into text. Every prompt and report that shows a round’s verification result must build its wording from this, not re-derive its own summary at the call site — a hand-rolled version at one more place is exactly how “an old red read as today’s answer” comes back through a different door (see the incident this type exists to prevent, recorded alongside SCHEMA’s doc for schema 8).

Trait Implementations

impl Clone for ReviewRound

fn clone(&self) -> Self

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.