Enum LoopFailure 

pub enum LoopFailure {
    EngineUnavailable,
    Cancelled,
    Infrastructure,
    Configuration,
    NeedsAuth,
    Execution,
    Verification,
    BudgetExhausted,
}

Why a loop run ended without green checks.

One axis: “what stopped this from passing”. Descriptive, not prescriptive — each variant records what happened, never what to do next. See LoopOutcome::failure for why, and do not read a retry instruction out of any variant here.

Produced by four modules (external_loop, native_loop, foreman_loop, rpc), so “the worker” below means whatever ran the work — an external CLI, the native inference loop, or a foreman farm-out.

The first two are knowable before the contract can say anything: no work was attempted, so there is nothing to evaluate. The rest describe a run that produced work. Where a loop can evaluate the contract it does so before classifying — a transport that dies mid-run must not pronounce a session failed while the contract might already be green, because the worktree is the state, not the process. (rpc’s agent-build path is the exception: it has no shell contract to evaluate, only scenario results.)

Variants

EngineUnavailable

The worker could not be started, or never received the task — missing binary, unready CLI, pipes or prompt delivery that failed before handoff. Nothing was attempted, so the caller is free to try a different engine.

Cancelled

The user cancelled. Terminal, and explicitly NOT a fallback trigger: substituting another engine would run work the human just stopped.

Infrastructure

The machinery failed rather than the work: an invocation that died mid-run, or a backbone that stopped answering. Edits may be partially applied.

Configuration

The configured routing constraints leave no model eligible. No provider was invoked and no work was attempted, so this belongs to daemon configuration rather than the item being healed.

NeedsAuth

The run needs the human to sign in, and nobody did within the window.

Split out of Infrastructure because the two call for opposite responses: an outage is not worth waiting on, whereas this resolves in seconds if someone is asked. Folding them together is what made an expired 15-minute token discard a 29-minute session — the run did not need to end, it needed to ask. Edits survive in the worktree; re-running after car auth login resumes from there.

Execution

The worker ran, reported its own error, and the checks are still red.

Verification

The worker ran clean and the checks are still red — the implementation was wrong, not the machinery.

BudgetExhausted

A loop hit its wall-clock ceiling and the next iteration was not admitted.

Distinct from Verification because a harness-imposed cut is not a task loss, and a scorer needs to tell them apart: ab::ArmOutcome::scorable exists precisely to keep “the harness stopped it” out of the scored denominator, and the alternative to a typed cause is another compare against error prose — which this enum was introduced to end.

It does NOT protect the recurrence/skill machinery, despite the obvious guess: record_failure and record_recurrence run at the END of a red iteration, while admission is denied at the START of the next one, so a cut-off approach has already been written to skill memory as a failure before this variant exists. Fixing that is a separate change.

Trait Implementations

impl Clone for LoopFailure

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LoopFailure

impl Debug for LoopFailure

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

Formats the value using the given formatter.

impl Eq for LoopFailure

impl PartialEq for LoopFailure

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LoopFailure