Struct TaskExecutionStep 

pub struct TaskExecutionStep {

    pub id: String,
    pub required_capability: Option<String>,
    pub template: Option<String>,
    pub execution_profile: Option<String>,
    pub builtin: Option<String>,
    pub enabled: bool,
    pub repeatable: bool,
    pub is_guard: bool,
    pub cost_preference: Option<CostPreference>,
    pub prehook: Option<StepPrehookConfig>,
    pub tty: bool,
    pub outputs: Vec<String>,
    pub pipe_to: Option<String>,
    pub command: Option<String>,
    pub chain_steps: Vec<TaskExecutionStep>,
    pub scope: Option<StepScope>,
    pub behavior: StepBehavior,
    pub max_parallel: Option<usize>,
    pub stagger_delay_ms: Option<u64>,
    pub timeout_secs: Option<u64>,
    pub stall_timeout_secs: Option<u64>,
    pub item_select_config: Option<ItemSelectConfig>,
    pub store_inputs: Vec<StoreInputConfig>,
    pub store_outputs: Vec<StoreOutputConfig>,
    pub step_vars: Option<HashMap<String, String>>,
}

Task execution step (runtime representation)

Fields

id: String

Stable step identifier used in plans, logs, and references.

required_capability: Option<String>

Required agent capability when this is an agent-dispatched step.

template: Option<String>

Reference to a StepTemplate resource name

execution_profile: Option<String>

Named execution profile applied to this step.

builtin: Option<String>

Builtin step implementation to invoke instead of agent dispatch.

enabled: bool

Enables or disables the step without removing it from the plan.

repeatable: bool

Allows the step to run again in later workflow cycles.

is_guard: bool

Marks the step as a loop guard that can terminate execution.

cost_preference: Option<CostPreference>

Optional agent-cost preference used during selection.

prehook: Option<StepPrehookConfig>

Runtime prehook controlling whether and how the step runs.

tty: bool

Requests a TTY when the step launches a command.

outputs: Vec<String>

Named outputs this step produces (for pipeline variable passing)

pipe_to: Option<String>

Pipe this step’s output to the named step as input

command: Option<String>

Build command for builtin build/test/lint steps

chain_steps: Vec<TaskExecutionStep>

Sub-steps to execute in sequence for smoke_chain step

scope: Option<StepScope>

Execution scope override (defaults based on step type)

behavior: StepBehavior

Declarative step behavior (on_failure, captures, post_actions, etc.)

max_parallel: Option<usize>

Maximum parallel items for item-scoped steps (per-step override)

stagger_delay_ms: Option<u64>

Stagger delay in ms between parallel agent spawns (per-step override)

timeout_secs: Option<u64>

Per-step timeout in seconds (overrides global safety.step_timeout_secs)

stall_timeout_secs: Option<u64>

Per-step stall auto-kill threshold in seconds (overrides global safety.stall_timeout_secs)

item_select_config: Option<ItemSelectConfig>

WP03: Configuration for item_select builtin step

store_inputs: Vec<StoreInputConfig>

Store inputs: read values from workflow stores before step execution

store_outputs: Vec<StoreOutputConfig>

Store outputs: write pipeline vars to workflow stores after step execution

step_vars: Option<HashMap<String, String>>

Step-scoped variable overrides applied as a temporary overlay on pipeline variables during this step’s execution. Does not modify global pipeline state.

Implementations

impl TaskExecutionStep

pub fn resolved_scope(&self) -> StepScope

Returns the resolved scope: explicit override or default based on step id, falling back to required_capability when the id is not a known step type.

pub fn effective_execution_mode(&self) -> Cow<'_, ExecutionMode>

Returns the authoritative execution mode for this step.

If the step shape implies a specific mode, this always returns it regardless of what behavior.execution says:

• chain_steps => Chain
• known builtin => Builtin { name }
• command => Builtin { name: self.id }

This is the single consolidated entry point for dispatch decisions.

Unlike normalize_step_execution_mode in config::step, which mutates stored state, this method is read-only and is always authoritative at dispatch time, even if renormalization hasn’t run yet.

pub fn renormalize_execution_mode(&mut self)

Corrects behavior.execution when stored state drifts from the step shape.

After deserializing from SQLite the behavior.execution field may carry the serde #[default] value (ExecutionMode::Agent) even though self.builtin names a known builtin step. This method is the single source of truth for healing that mismatch:

• If the step contains chain_steps, force behavior.execution to Chain.
• If self.builtin names a known builtin, force behavior.execution to Builtin { name } and clear required_capability.
• If the step is a command step, force behavior.execution to Builtin { name: self.id } so dispatch uses the command path.
• Recurse into child chain steps.

Trait Implementations

impl Clone for TaskExecutionStep

fn clone(&self) -> TaskExecutionStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskExecutionStep

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskExecutionStep

fn deserialize<__D>( __deserializer: __D, ) -> Result<TaskExecutionStep, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TaskExecutionStep

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

where __S: Serializer,

Serialize this value into the given Serde serializer.