Struct Panel 

pub struct Panel {
    pub turn_number: usize,
    pub role: Role,
    pub timestamp: Timestamp,
    pub model: Option<String>,
    pub effort: Option<String>,
    pub blocks: Vec<Block>,
    pub usage: Option<Usage>,
    pub is_sidechain: bool,
    pub is_meta: bool,
}

One speaker’s contribution as displayed. Folding the wire-level turns into panels is where harness scaffolding is filtered and tool results are reunited with the assistant that called them, so the renderer walks an already-clean stream and never re-derives any of it.

Fields

turn_number: usize

The 1-based position of this panel’s leading turn in the raw stream. Gaps between successive panels mark turns that were folded in or dropped, so a panel that spans several turns still has one stable label.

role: Role

timestamp: Timestamp

model: Option<String>

effort: Option<String>

How hard the model was asked to think, where the harness records it.

blocks: Vec<Block>

usage: Option<Usage>

What the panel’s leading turn cost. The tool-result turns folded in carry none of their own: the assistant turn that called the tool is where the harness records what the exchange cost.

is_sidechain: bool

True for panels belonging to a subagent running inside this session.

is_meta: bool

True for panels the harness injected rather than the user typing them.

Implementations

impl Panel

pub fn kind(&self) -> PanelKind

The panel’s content kind, preferring the most user-facing thing it carries: visible prose reads as the speaker, otherwise a tool exchange, otherwise bare reasoning.

Trait Implementations

impl Debug for Panel

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

Formats the value using the given formatter.