Enum ApplyVerdict 

pub enum ApplyVerdict {
    Apply {
        winner_composite: f64,
        incumbent_mean: f64,
        margin: f64,
        drift: f64,
        paired: Option<PairedEffect>,
    },
    IncumbentStands {
        incumbent_mean: f64,
    },
    WithinDrift {
        margin: f64,
        drift: f64,
    },
    PairedDisagrees {
        wins: usize,
        losses: usize,
    },
    Uncalibrated,
    Contaminated {
        unmeasured_runs: usize,
    },
}

What an apply attempt decided, and the numbers it decided on.

Refusals are first-class outcomes, not errors: each names the evidence that was missing or contrary, because “the gate said no” is only useful if it says what would have changed the answer.

Variants

Apply

The winner cleared every gate and may be stored as this model’s measured defaults.

Fields

winner_composite: f64

The winning candidate’s composite.

incumbent_mean: f64

Mean composite of the incumbent pair.

margin: f64

winner_composite − incumbent_mean.

drift: f64

The calibration pair’s gap — the run’s own drift.

paired: Option<PairedEffect>

The winner-versus-incumbent paired comparison.

IncumbentStands

The best candidate is the incumbent: the model’s current defaults beat every swept candidate, and there is nothing to apply. Not a failure — the run answered its question.

Fields

incumbent_mean: f64

The incumbent pair’s mean composite.

WithinDrift

The winner’s margin over the incumbent is inside the run’s own drift. Unresolved, not absent — the fix is more tasks or a re-run, never a smaller threshold.

Fields

margin: f64

winner_composite − incumbent_mean.

drift: f64

The calibration pair’s gap.

PairedDisagrees

The margin clears the drift, but the per-task paired comparison runs the other way — the winner’s mean rests on a minority of tasks. A mean and its pairs disagreeing is exactly the shape a lucky outlier task produces.

Fields

wins: usize

Pairs the winner took.

losses: usize

Pairs the incumbent took.

Uncalibrated

The run carries no incumbent pair, so nothing calibrates it — a run from before the calibration pair existed, or one whose incumbents never completed. Nothing can be applied from it.

Contaminated

The winner or an incumbent has runs that never reached the model, so their composites are contaminated by a knowable amount and the comparison is not trustworthy.

Fields

unmeasured_runs: usize

Unmeasured runs across the compared candidates.

Implementations

impl ApplyVerdict

pub const fn applies(&self) -> bool

Whether this verdict licenses writing the winner.

pub const fn rationale(&self) -> &'static str

Why the gate decided this, in one sentence.

Split from Display because the two surfaces want different amounts: a table column wants the numbers, a detail view wants the numbers and the reasoning. Keeping them apart lets both read from one source instead of each restating the gate’s rules in its own words — which is how three renderers came to disagree about what a refusal meant.

Every sentence here says what would resolve the refusal, because a gate that only says “no” teaches nobody anything.

Trait Implementations

impl Clone for ApplyVerdict

fn clone(&self) -> ApplyVerdict

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ApplyVerdict

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ApplyVerdict

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ApplyVerdict

The verdict’s headline: what happened, with the numbers that decided it.

Deliberately unstyled and single-line so every surface can wrap it in its own presentation. Pair with ApplyVerdict::rationale where there is room to explain.

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

Formats the value using the given formatter.

impl PartialEq for ApplyVerdict

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ApplyVerdict

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 ApplyVerdict