Struct ContextEvent 

pub struct ContextEvent {
    pub step: u32,
    pub kind: String,
    pub detail: Option<String>,
    pub est_tokens: Option<u64>,
    pub reported_tokens: Option<u64>,
}

One decision the context assembler made: the section it built for a turn, or a stale read it re-read (or was refused).

One row per turn plus one per re-read — never one per elided observation, which would put a row explosion in the trace to say nothing new. Together they answer “why did the model not see the thing it read at step 3”, and est_tokens beside reported_tokens is what records the estimator’s drift from the provider’s own count (see crate::context::estimate_tokens).

use io_harness::{ContextEvent, Store};

let events = store.context_events(run_id)?;

// Why the model did not see something it read earlier: five observations were
// stubbed to fit the budget, and one stale read could not be refreshed at all
// because the policy now refuses that path.
let refused: Vec<&str> = events
    .iter()
    .filter(|e| e.kind == "reread_refused")
    .filter_map(|e| e.detail.as_deref())
    .collect();
assert_eq!(refused, ["secrets/id_rsa: denied by policy"]);

// And the pair that makes the budget trustworthy: what the assembler
// estimated, beside what the provider actually charged for the same turn.
// Drift here is the estimator being wrong, not the budget being generous.
let assembled = events.iter().find(|e| e.kind == "assembled").expect("one per turn");
assert_eq!((assembled.est_tokens, assembled.reported_tokens), (Some(4_100), Some(4_690)));

Fields

step: u32

The step it belongs to.

kind: String

"assembled", "reread", or "reread_refused".

detail: Option<String>

For "assembled", the turn’s summary (carried=3 stubbed=5 reread=1); for a re-read, the path and why it was or was not re-read.

est_tokens: Option<u64>

The assembler’s own estimate for the section it built.

reported_tokens: Option<u64>

What the provider said the request actually cost, when it says anything.

Implementations

impl ContextEvent

pub fn assembled(step: u32, detail: impl Into<String>, est_tokens: u64) -> Self

The section built for one turn.

pub fn reread(step: u32, detail: impl Into<String>) -> Self

A stale read was re-read at assembly time.

pub fn reread_refused(step: u32, detail: impl Into<String>) -> Self

A stale read could not be re-read — the policy refused it, or it is gone.

pub fn memory_write(step: u32, detail: impl Into<String>) -> Self

The agent recorded a durable note for later runs over this workspace.

pub fn memory_evict(step: u32, detail: impl Into<String>) -> Self

A note was dropped to hold the workspace’s memory caps.

pub fn memory_recall(step: u32, detail: impl Into<String>) -> Self

Notes from earlier runs were carried into this turn’s context.

pub fn served(step: u32, provider: impl Into<String>) -> Self

Which provider actually answered this step.

Recorded only when the answer is not obvious from configuration — a Fallback that fell over. runs.provider is one label for a whole run and stops being true the moment a run can use two.

pub fn replan(step: u32, detail: impl Into<String>) -> Self

The agent made no progress and was told once to change approach. The run continues.

Split from Self::stalled in 0.12.0. Both were recorded under the one "stalled" kind, distinguishable only by prose in detail — so anything scoring a run could not tell “was nudged and carried on” from “gave up” without string-matching an English sentence the crate never promised.

pub fn stalled(step: u32, detail: impl Into<String>) -> Self

The agent made no progress, had already been told once, and the run is ending here. Terminal.

A nudge that did not work is Self::replan; see there for why the two are separate kinds since 0.12.0.

Trait Implementations

impl Clone for ContextEvent

fn clone(&self) -> ContextEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContextEvent

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

Formats the value using the given formatter.

impl Eq for ContextEvent

impl PartialEq for ContextEvent

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ContextEvent