Struct ContextUse 

pub struct ContextUse {
    pub frame: FrameId,
    pub selected: bool,
    pub rendered: bool,
    pub cited: bool,
}

What actually became of one served frame, as three independent observations (the context_use vocabulary of ADR 0007).

They are deliberately not a single enum or a score. Each is a distinct, separately-observable fact, and collapsing them would destroy the signal that matters most: a frame that was selected and rendered but never cited is the interesting case — the host paid its tokens and the model read it, and it changed nothing. A single “used/unused” flag cannot express that, and a 0–1 usefulness score would invent a precision nobody measured.

The three are ordered by inclusion in practice — a frame is rendered only if selected, cited only if rendered — but that is an observation about honest hosts, not an invariant this type enforces. See is_coherent.

Fields

frame: FrameId

The frame this record is about — the same identity the usage report billed and verify revalidates, never a separate attribution id.

selected: bool

The host chose this frame from the fan-out results: it survived consent, the budget audit, and ranking.

rendered: bool

The frame’s content was actually composed into the prompt the model saw. Distinct from selected: a frame can win ranking and still be dropped by budget packing before it reaches the prompt.

cited: bool

The model’s output referred to this frame — by citation label, or by whatever attribution the host can observe.

A claim about observable output, never an inference about influence. Whether a frame changed the model’s reasoning is unobservable from outside; recording “it was cited” is a fact, recording “it helped” would be a guess wearing a fact’s clothes.

Implementations

impl ContextUse

pub fn selected(frame: FrameId) -> Self

A record for a frame the host selected but has not yet observed further.

pub fn rendered(self) -> Self

Mark the frame as having reached the prompt.

pub fn cited(self) -> Self

Mark the frame as referred to by the model’s output.

pub fn is_coherent(&self) -> bool

Whether the three observations are mutually consistent: a frame cannot be cited without having been rendered, nor rendered without having been selected.

A host that reports an incoherent record has an accounting bug, and scoring on it would silently mis-attribute value — so this is checkable rather than assumed.

pub fn is_rendered_but_uncited(&self) -> bool

The frame reached the prompt and earned nothing observable — the case worth paying attention to, because it is pure spent budget.

Trait Implementations

impl Clone for ContextUse

fn clone(&self) -> ContextUse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContextUse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContextUse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ContextUse

impl PartialEq for ContextUse

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ContextUse

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 ContextUse