Struct ExecutionStep 

pub struct ExecutionStep {
    pub phase: Arc<str>,
    pub iteration: u32,
    pub step_type: Box<str>,
    pub timestamp: String,
    pub outcome: StepOutcome,
    pub agent: Option<Arc<str>>,
    pub duration_secs: Option<u64>,
    pub checkpoint_saved_at: Option<String>,
    pub git_commit_oid: Option<String>,
    pub modified_files_detail: Option<ModifiedFilesDetail>,
    pub prompt_used: Option<String>,
    pub issues_summary: Option<IssuesSummary>,
}

A single execution step in the pipeline history.

Memory Optimization

This struct uses Arc for phase and agent fields to reduce memory usage through string interning. Phase names and agent names are repeated frequently across execution history entries, so sharing allocations via Arc significantly reduces heap usage.

Serialization/deserialization is backward-compatible - Arc is serialized as a regular string and can be deserialized from both old (String) and new (Arc) checkpoint formats.

Fields

phase: Arc<str>

Phase this step belongs to (interned via Arc)

iteration: u32

Iteration number (for development/review iterations)

step_type: Box<str>

Type of step (e.g., “review”, “fix”, “commit”)

timestamp: String

When this step was executed (ISO 8601 format string)

outcome: StepOutcome

Outcome of the step

agent: Option<Arc<str>>

Agent that executed this step (interned via Arc)

duration_secs: Option<u64>

Duration in seconds (if available)

checkpoint_saved_at: Option<String>

When a checkpoint was saved during this step (ISO 8601 format string)

git_commit_oid: Option<String>

Git commit OID created during this step (if any)

modified_files_detail: Option<ModifiedFilesDetail>

Detailed information about files modified

prompt_used: Option<String>

The prompt text used for this step (for deterministic replay)

issues_summary: Option<IssuesSummary>

Issues summary (found and fixed counts)

Implementations

impl ExecutionStep

pub fn new( phase: &str, iteration: u32, step_type: &str, outcome: StepOutcome, ) -> Self

Create a new execution step.

Performance Note

For optimal memory usage, use new_with_pool to intern repeated phase and agent names via a StringPool. This constructor creates new Arc allocations for each call.

pub fn new_with_pool( phase: &str, iteration: u32, step_type: &str, outcome: StepOutcome, pool: StringPool, ) -> (Self, StringPool)

Create a new execution step using a StringPool for interning.

This is the preferred constructor when creating many ExecutionSteps, as it reduces memory usage by sharing allocations for repeated phase and agent names.

pub fn with_agent(self, agent: &str) -> Self

Set the agent that executed this step.

pub fn with_agent_pooled( self, agent: &str, pool: StringPool, ) -> (Self, StringPool)

Set the agent using a StringPool for interning.

pub const fn with_duration(self, duration_secs: u64) -> Self

Set the duration of this step.

pub fn with_git_commit_oid(self, oid: &str) -> Self

Set the git commit OID created during this step.

Trait Implementations

impl Clone for ExecutionStep

fn clone(&self) -> ExecutionStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecutionStep

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExecutionStep

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExecutionStep

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ExecutionStep

impl StructuralPartialEq for ExecutionStep