Struct Daemon 

pub struct Daemon {
    pub max_concurrent_runs: usize,
    pub pause_for_interrupts: bool,
}

How the daemon loop itself behaves, as opposed to what one run does.

Machine-layer material in the same sense Repos::roots is: how many competitions this machine’s own loop is willing to babysit at once is a fact about the machine running magi serve, not about any one repository’s task, so it belongs in <config_dir>/magi/config.toml rather than a repository’s own magi.toml - though, like Repos::roots, nothing stops a repository from setting it too, since a scalar field takes whichever layer has the highest precedence.

Fields

max_concurrent_runs: usize

How many runs magi serve may have actively in flight at once. One by default - today’s behaviour, one run at a time.

This is a different knob from Graph::max_parallel, and the two must not be confused: max_parallel bounds how many agent processes one run starts inside itself (implementers, judges, reviewers - candidates competing on a single task); this field bounds how many runs - whole competitions, each with its own max_parallel budget - the loop drives side by side, possibly across different tasks and different repositories. Raising max_parallel buys a bigger panel for one task; raising this buys more tasks worked at once. A config file that meant one and wrote the other would either starve a competition of judges or leave the rest of the backlog waiting for no reason.

A run parked waiting on the operator’s land-merge approval - see crate::land - does not hold one of these slots while it waits: the whole point of parking there is to let the loop spend the slot on something runnable instead of sitting on a decision only a human can make. So even at the default of 1, an approval that comes back does not queue behind whatever else the loop happens to be running.

pause_for_interrupts: bool

Let a task marked crate::queue::Task::interrupt (magi task interrupt) cut ahead of whatever magi serve already has in flight, instead of waiting for it to finish.

Off by default. When enabled, a run that is in flight and is not itself the interrupt candidate may be paused at its next safe node boundary - see crate::graph::Runner::park_here - so the marked task can run alone; the paused run resumes automatically, through the same path any other parked run does, the moment the interrupting task’s own run reaches a terminal status. This is opt-in because it bends the loop’s own “one run at a time” principle (see this repository’s magi serve help) for a specific, explicit operator request, and a repository that never files an interrupt task pays nothing for having it on - but an operator who does not want any run of theirs preempted, ever, should leave this false.

Trait Implementations

impl Clone for Daemon

fn clone(&self) -> Daemon

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Daemon

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

Formats the value using the given formatter.

impl Default for Daemon

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Daemon

where Daemon: 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 Daemon

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

where __S: Serializer,

Serialize this value into the given Serde serializer.