Struct TurnStateMachine 

pub struct TurnStateMachine { /* private fields */ }

State machine for turn orchestration.

This is the core abstraction that unifies turn logic between in-memory and durable execution. It tracks the current phase, determines the next action, and handles state transitions.

Thread Safety

The state machine is not thread-safe. For durable execution, each task execution creates its own state machine from serialized state.

Implementations

impl TurnStateMachine

pub fn new(context: TurnContext, max_iterations: usize) -> Self

Create a new state machine for a turn.

Arguments

• context - Turn context with session, turn, and agent IDs
• max_iterations - Maximum Reason → Act cycles before stopping

pub fn context(&self) -> &TurnContext

Get the turn context.

pub fn phase(&self) -> TurnPhase

Get the current phase.

pub fn current_iteration(&self) -> usize

Get the current iteration count.

pub fn total_tool_calls(&self) -> usize

Get the total tool calls made so far.

pub fn next_action(&self) -> TurnAction

Determine the next action to take.

This is the core dispatch method. Call this in a loop and execute the returned action until TurnAction::Complete is returned.

pub fn on_input_completed(&mut self)

Record that input processing completed.

Call this after successfully executing the input atom.

pub fn on_reason_completed( &mut self, response: String, has_tool_calls: bool, tool_call_count: usize, success: bool, error: Option<String>, has_pending_user_messages: bool, )

Record that reasoning completed.

Arguments

• response - The text response from the LLM (may be empty)
• has_tool_calls - Whether the LLM requested tool calls
• tool_call_count - Number of tool calls (0 if none)
• success - Whether the LLM call succeeded
• error - Error message if success is false
• has_pending_user_messages - Whether new user messages arrived during this turn (steering signals). When true and reason would otherwise complete (no tool calls, success), the turn stays in PendingReason so the next iteration picks up the new messages from the conversation history. This is “in-turn steering” — matching Claude Code behavior.

pub fn on_act_completed(&mut self)

Record that action (tool execution) completed.

Call this after successfully executing the act atom. The turn then loops back to Reason for another iteration.

pub fn seal(&mut self, reason: SealReason)

Deliberately seal the turn, stopping further scheduling (EVE-534).

Call this between atoms when the engine decides to stop a turn to prevent waste — e.g. the work budget is exhausted (SealReason::Budget). The turn transitions to Completed and next_action resolves to TurnOutcome::Sealed. Sealing is idempotent and the first reason wins.

pub fn is_completed(&self) -> bool

Check if the turn has completed.

Trait Implementations

impl Debug for TurnStateMachine

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

Formats the value using the given formatter.