Struct LoopCfg 

pub struct LoopCfg {

    pub max_rounds: u32,
    pub auto_merge: bool,
    pub first_implementor: Option<String>,
    pub base_branch: String,
    pub worktrees: bool,
    pub keep_worktrees: bool,
    pub state_store: StateStore,
    pub branch_prefix: String,
    pub followups: Followups,
    pub file_non_blocking: bool,
    pub max_followups: usize,
    pub file_nits: bool,
    pub close_skipped: bool,
    pub parallel_triage: bool,
    pub min_number: i64,
    pub absorb_new_issues: u32,
    pub max_issue_chars: usize,
    pub max_triage_chars: usize,
    pub effort_schedule: EffortSchedule,
}

Every field takes its value from LoopCfg::default() when a config does not mention it, rather than from a per-field function saying the same thing in a second place. Two places is how a default goes stale.

Fields

max_rounds: u32

auto_merge: bool

first_implementor: Option<String>

base_branch: String

worktrees: bool

keep_worktrees: bool

state_store: StateStore

branch_prefix: String

followups: Followups

file_non_blocking: bool

File a non-blocking finding as a follow-up.

Off by default, and this is the setting that stops a run breeding. A thorough reviewer always finds improvements, and turning each one into a tracker item made a single issue spawn ten, which spawned more: mean offspring above one never terminates. Not gating a merge is not the same as being worth somebody’s triage queue.

max_followups: usize

Most follow-ups one run may record before it stops and says what it dropped. A backstop, not a target.

file_nits: bool

Nits stay in the PR thread by default. A filed nit is somebody else’s notification: a run on a production codebase once opened an issue titled “Log wording”.

close_skipped: bool

Close an issue that both agents independently declined, after posting the shared reasoning. One agent’s opinion is never enough.

parallel_triage: bool

Ask both agents to triage at the same time. They only read during triage, so there is nothing to serialise.

min_number: i64

Ignore issues and pull requests numbered below this when spar is picking for itself. 0 is no floor.

A repository that has been going a while carries a tail of old issues nobody is going to reach, and since spar takes the lowest numbered open items it walks straight into them. A number you name explicitly is still honoured: naming it is the point.

absorb_new_issues: u32

Waves of newly filed follow-ups to fold back into the same run, rather than leaving them for the next one.

Off by default because it multiplies what a run costs, and because each wave can file follow-ups of its own. Every wave is triaged like any other issue, so both agents still have to agree it is worth doing.

max_issue_chars: usize

The most of one issue body that reaches a prompt.

Sized so that no issue a person wrote is ever cut. It was 2000 for triage and 6000 for implement, silently, and both were small enough to clip an ordinary bug report: an agent given half an issue judges and implements the half it saw and has no way to know the rest existed. When this does fire it is said out loud, in the log and in the prompt.

max_triage_chars: usize

The most every issue body together may add to one triage prompt.

Triage reads the whole queue at once, so the only unbounded thing here is the queue. Past this, whole issues are left for the next run rather than every issue being shortened: a verdict is posted on the issue and can close it, so judging one on part of its body is worse than not reaching it yet.

effort_schedule: EffortSchedule

Trait Implementations

impl Clone for LoopCfg

fn clone(&self) -> LoopCfg

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoopCfg

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

Formats the value using the given formatter.

impl Default for LoopCfg

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LoopCfg

where LoopCfg: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LoopCfg

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

where __S: Serializer,

Serialize this value into the given Serde serializer.