Enum AttemptState 

pub enum AttemptState {
    Allocated,
    JitReceived,
    Starting,
    Idle,
    Busy,
    Finished,
    Failed,
    Orphaned,
    Cleaned,
}

The runner-attempt lifecycle, exactly as 04-subsystem-contracts.md draws it after its 2026-08-21 amendment:

allocated -> jit_received -> starting -> idle | busy
idle -> busy
allocated | jit_received | starting -> failed | orphaned
idle | busy -> finished | failed | orphaned
finished | failed | orphaned -> cleaned

idle means the runner process is registered and awaiting its single job assignment. It is short-lived and is not an idle persistent runner — this product has none, by D7.

Every transition outside that diagram is rejected, which b1’s Definition of Done requires. cleaned is absorbing, which is correct and intended.

The last two edge sets were added by amendment, and the reasons matter to anyone reading this state machine. b1 first implemented the original diagram faithfully and surfaced its gaps as an explicit NoLegalTransition decision rather than inventing edges; the amendment closed them at the design level, and that decision value is gone with them:

• idle -> busy. e3’s Scope step 4 moves an attempt through jit_received, starting, idle, busy in sequence, and the definition of idle above describes a state that by construction precedes a job. Without this edge a runner observed idle and then assigned a job had nowhere legal to go.
• Terminal edges out of the three pre-registration states. An attempt counts against host capacity for exactly as long as it is non-terminal (Self::counts_against_capacity), so an attempt that could not reach a terminal state held a host capacity slot permanently: two failed JIT requests on a host_capacity: 2 host wedged that host into starting zero runners, with no error state and no cleanup path. orphaned is included for the restart case, where a pre-registration attempt is found after the agent restarts.

Those edges are also what make seven of the nine FailureReason variants reachable at all — JitRequestFailed, JitExpired, RunnerPackageUnverified, RunnerVersionRejected, ProcessStartFailed, RegistrationTimedOut and TerminatedAfterRegistrationTimeout each occur at a pre-registration state. 03-control-flows.md flow 2 names the first five as conditions the agent must record; the last two are named by no document and are this crate’s own, added because recovery_decision needs to say “alive, past its deadline, still unregistered” without calling it a crash, and because e3 then needs to say what became of that runner without calling a process it stopped itself either a crash or still running.

Variants

Allocated

JitReceived

Starting

Idle

Busy

Finished

Failed

Orphaned

Cleaned

Implementations

impl AttemptState

pub const ALL: [AttemptState; 9]

pub const LEGAL: &'static [(AttemptState, AttemptState)]

The complete legal transition list. A self-transition is not in it.

pub const CONCLUDABLE_FROM: &'static [AttemptState]

The five states an attempt can still be concluded from: every non-terminal state. After the amendment this is exactly “not Self::is_terminal”, which is what closed the permanently-held capacity slot — but it is written out rather than derived, because the two are only equal while the diagram gives every live state a terminal edge, and that equality is a property worth failing loudly on.

pub fn can_transition_to(self, next: AttemptState) -> bool

pub const fn is_terminal(self) -> bool

Terminal states, at which capacity is reclaimed.

e1: “capacity is reclaimed only when an attempt reaches a terminal state.” cleaned is included because it follows a terminal state.

pub const fn counts_against_capacity(self) -> bool

Whether this attempt still occupies one of the host’s capacity slots.

This is the term the reconciliation formula subtracts, and getting it wrong is silent: counting a terminal attempt starves the host, and failing to count a starting one starts a second runner for a job already being served.

pub const fn is_concluded(self) -> bool

The three terminal states that require an outcome before cleaned.

Trait Implementations

impl Clone for AttemptState

fn clone(&self) -> AttemptState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AttemptState

impl Debug for AttemptState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AttemptState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AttemptState

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

Formats the value using the given formatter.

impl Eq for AttemptState

impl Hash for AttemptState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AttemptState

fn cmp(&self, other: &AttemptState) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for AttemptState

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for AttemptState

fn partial_cmp(&self, other: &AttemptState) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for AttemptState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AttemptState