Struct Measurement 

pub struct Measurement {

    pub measured_at: String,
    pub model: String,
    pub disposition: String,
    pub reason: String,
    pub selection: TallyRecord,
    pub holdout: TallyRecord,
    pub work_baseline: u64,
    pub work_candidate: u64,
    pub episodes: Vec<String>,
    pub holdout_episodes: Vec<String>,
    pub seed: u64,
    pub diverged: Vec<String>,
    pub replay_caveats: Vec<String>,
    pub skipped: usize,
}

What the counterfactual replay measured, kept whole on the candidate.

Fields

measured_at: String

model: String

disposition: String

accept | propose | reject — the gate’s own verdict, which is not the candidate’s status: a propose verdict stages for a human.

reason: String

The gate’s reason, empty for accept.

selection: TallyRecord

holdout: TallyRecord

work_baseline: u64

work_candidate: u64

episodes: Vec<String>

Session ids paired and judged, selection slice first.

holdout_episodes: Vec<String>

Which of those were the holdout, and the seed the uniform draw used.

Recorded rather than recomputed, because it can no longer be recomputed. The split used to be is_holdout(id, holdout_in) — a pure function of the episode id, so any later reader could reconstruct which episodes confirmed a result. Drawing uniformly from a pool makes the split depend on the corpus as it stood at measurement time, which is gone the moment another session is written. Without these two fields “which episodes was this confirmed on” stops being answerable, which is the property the drawing was introduced to protect: a sample nobody can redraw is a sample nobody can check.

seed: u64

diverged: Vec<String>

Sessions dropped because an arm left the recording — a divergent replay’s stats describe a truncated run, and scoring one would let a behaviour-visible change be graded on the fraction it tracked. Bare ids, and they stay that way: episodes/holdout_episodes’s own contract (a sample nobody can redraw is one nobody can check) holds here too, and anything resolving an entry back to a session path must not have to parse annotation out of it first.

replay_caveats: Vec<String>

What the replay was compromising on, per episode that carried a compromise — “id — attached N times; replayed under the first config” — whatever became of the episode, skipped ones included (the caveat is computed at prepare time, before any arm drives): a dropped one’s divergence may say more about the compromise than about the change, and a cleanly paired one feeds the tally that gates acceptance, which is the more consequential place for the decider reading mecha harness show to know the replay was compromising. Beside diverged rather than folded into it, so the ids stay joinable.

skipped: usize

Sessions that could not be replayed at all (unreadable, no recorded calls, tool surface moved). Never evidence for either arm.

Implementations

impl Measurement

pub fn record( judgement: &Judgement, model: &str, measured_at: String, drawn: Drawn, ) -> Measurement

Trait Implementations

impl Clone for Measurement

fn clone(&self) -> Measurement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Measurement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Measurement

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Measurement

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

where __S: Serializer,

Serialize this value into the given Serde serializer.