Struct AgentEvent 

pub struct AgentEvent {
    pub run_id: i64,
    pub step: u32,
    pub kind: String,
    pub child_run_id: Option<i64>,
    pub detail: Option<String>,
    pub tokens: Option<u64>,
    pub remaining: Option<u64>,
}

One event in a tree of agents: a parent spawning a child, a spawn refused by the containment boundary, or a draw against the tree’s shared spend ceiling.

Together with each run’s parent_run_id these make the tree a reconstructable graph — who spawned whom, what was refused, and what the tree spent — long after the process that ran it has exited.

use io_harness::{AgentEvent, Store};

// The only audit of what each step drew against the tree's *shared* ceiling.
// A run's own token total does not show this: the ceiling is tree-wide, so
// what matters is how fast `remaining` is falling for everyone.
let events = store.agent_events(run_id)?;

let drawn: u64 = events.iter().filter_map(|e| e.tokens).sum();
let left = events.iter().filter_map(|e| e.remaining).last();
assert_eq!(drawn, 9_280);
// 720 left after three steps that averaged over 3,000: this tree ends in
// `BudgetCeilingReached` next step, and the row says so before it happens.
assert_eq!(left, Some(720));

// The same table carries the shape of the tree and what it was denied.
let children: Vec<i64> = events.iter().filter_map(|e| e.child_run_id).collect();
let refusals: Vec<&str> = events
    .iter()
    .filter(|e| e.kind == "spawn_refused")
    .filter_map(|e| e.detail.as_deref())
    .collect();
assert_eq!(children, [2]);
// A parent that wanted a second child and hit the agent cap — a run doing
// less work than it planned to, which is invisible in its outcome.
assert_eq!(refusals, ["agents"]);

Fields

run_id: i64

The agent this event belongs to (the parent, for a spawn; the drawing agent, for a budget draw).

step: u32

The step it occurred on.

kind: String

"spawn", "spawn_refused", or "budget_draw".

child_run_id: Option<i64>

The spawned child’s run id, for a "spawn".

detail: Option<String>

Free-form detail: the child’s goal for a spawn, the breached cap for a refusal.

tokens: Option<u64>

Tokens drawn, for a "budget_draw".

remaining: Option<u64>

The tree’s remaining tokens after the draw.

Implementations

impl AgentEvent

pub fn spawn( run_id: i64, step: u32, child_run_id: i64, goal: impl Into<String>, ) -> Self

A parent spawned a child.

pub fn spawn_refused(run_id: i64, step: u32, cap: &str) -> Self

A spawn was refused by the containment boundary.

pub fn budget_draw(run_id: i64, step: u32, tokens: u64, remaining: u64) -> Self

An agent drew tokens against the tree, leaving remaining.

Trait Implementations

impl Clone for AgentEvent

fn clone(&self) -> AgentEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentEvent

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

Formats the value using the given formatter.

impl Eq for AgentEvent

impl PartialEq for AgentEvent

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AgentEvent