Struct Context 

pub struct Context {
    pub items: Vec<AdmittedItem>,
    pub evicted: Vec<EvictionRecord>,
    pub budget: TokenBudget,
}

Γ — the exact admitted token window. Immutable, fully attributed.

Example

use boundgraph_core::{AdmittedItem, Context, ContextSource, Digest, EvictionReason,
                EvictionRecord, TokenBudget};

let ctx = Context::new(
    vec![AdmittedItem {
        source: ContextSource::Prompt,
        digest: Digest::of(b"task"),
        tokens: 120,
        reason: "declared by the step".into(),
    }],
    vec![EvictionRecord {
        source: ContextSource::Retrieval,
        digest: Digest::of(b"a long document"),
        tokens: 9_000,
        reason: EvictionReason::BudgetExhausted { needed: 9_000, remaining: 880 },
    }],
    TokenBudget(1_000),
)?;

assert_eq!(ctx.admitted_tokens(), 120);
// The law is auditable: we can say exactly what was withheld, and why.
assert_eq!(ctx.evicted.len(), 1);

Fields

items: Vec<AdmittedItem>

What the reasoner actually saw.

evicted: Vec<EvictionRecord>

What it did not, and why.

budget: TokenBudget

The ceiling this admission ran against.

Implementations

impl Context

pub fn new( items: Vec<AdmittedItem>, evicted: Vec<EvictionRecord>, budget: TokenBudget, ) -> Result<Self, ContextOverBudget>

Build a context, enforcing the budget invariant.

Errors

Returns ContextOverBudget if the admitted items exceed budget. This is deliberately a hard error rather than a silent truncation: an admitter that overruns has broken Law II, and quietly dropping the tail would hide that while also losing the eviction record that explains it.

pub fn empty(budget: TokenBudget) -> Self

An empty window under a given ceiling.

pub fn admitted_tokens(&self) -> u32

Tokens actually admitted. Never exceeds Context::budget.

pub fn headroom(&self) -> u32

Tokens left unused under the ceiling.

pub fn evicted_tokens(&self) -> u32

Tokens that were considered and refused.

A large number here against small headroom means the budget was the binding constraint; a large number against ample headroom means something was withheld for another reason, which is usually the more interesting case when debugging.

pub fn why_evicted(&self, digest: &Digest) -> Option<&EvictionReason>

Whether this item was considered and refused, and if so why.

This is the “why did the agent not know X?” query.

pub fn admitted(&self, digest: &Digest) -> bool

Whether this item made it into the window.

Trait Implementations

impl Clone for Context

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 Context

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Context

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Context

impl PartialEq for Context

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Context

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 Context