Struct LiveCoderRunner 

pub struct LiveCoderRunner {
    pub state: Arc<ServerState>,
    pub generator: Arc<dyn TurnGenerator>,
    pub state_dir: PathBuf,
    pub reviewers: Vec<Arc<dyn Reviewer>>,
    pub max_wall_secs: u64,
    pub max_iterations: Option<u32>,
    pub engine: EngineChoice,
    pub model: Option<String>,
    pub routing_exclusions: Vec<String>,
    pub canonical_model: Arc<dyn Fn(&str) -> String + Send + Sync>,
    pub github: Arc<dyn GitHubApi>,
}

The live runner.

Fields

state: Arc<ServerState>

generator: Arc<dyn TurnGenerator>

state_dir: PathBuf

reviewers: Vec<Arc<dyn Reviewer>>

The panel. Empty means no panel, which super::heal_gate::decide refuses outright rather than treating as unanimous consent.

max_wall_secs: u64

max_iterations: Option<u32>

engine: EngineChoice

Which engine runs the work.

An operator knob, not a test hook. Auto picks per task from the detected external CLIs, so an unattended loop on a machine with Claude Code or Codex installed silently runs a different engine than the same loop on a machine without them — and the user has asked for foreman on this path specifically. Naming it makes that choice visible and configurable instead of implicit in what happens to be on PATH.

model: Option<String>

Pin the coder’s own model, or None for the operator’s coder.toml default and then adaptive routing.

Worth naming for an unattended loop for the same reason the engine is: adaptive routing picks a provider per request, so a loop can silently spend a whole 45-minute session against a credential that has expired while a working one sits beside it. An operator who has decided which model does this work should be able to say so.

routing_exclusions: Vec<String>

Canonical ModelSchema.name values for every review-panel seat. These become strict exclusions only on the unpinned adaptive native loop.

canonical_model: Arc<dyn Fn(&str) -> String + Send + Sync>

Resolve a model name or id to the registry’s canonical id.

Injected rather than reached for, the same way coder_on_panel injects it: the self-review gate is then testable without standing up an inference registry, and reaching for one here would force get_inference_engine’s worker-subprocess init on every test that runs a session. heal_service supplies the engine-backed resolver.

github: Arc<dyn GitHubApi>

The GitHub client delivery runs through.

Owned here rather than by LiveTickIo because this is the only place that calls GitHub now: one owner, so gh cannot be reached through two handles configured differently.

Trait Implementations

impl CoderRunner for LiveCoderRunner

fn run<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, target: &'life1 HealTarget, item: &'life2 Candidate, seed: &'life3 SessionSeed, ) -> Pin<Box<dyn Future<Output = Result<Attempt, RunFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Run the session, evaluate the outcome contract, and poll the review panel. Returns the evidence; the verdict is computed by the caller.

fn deliver<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, target: &'life1 HealTarget, item: &'life2 Candidate, session_id: &'life3 str, body: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<PrDeliveryOutcome, DeliverRefusal>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Commit, push, and reconcile exactly one pull request for the item.

fn abandon<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Close a session out without delivering, releasing its worktree.