Struct Graph 

pub struct Graph {

    pub candidates: usize,
    pub judges: usize,
    pub deliberate_rounds: usize,
    pub reviewers: usize,
    pub review_rounds: usize,
    pub max_parallel: usize,
    pub language: String,
    pub sessions: bool,
    pub timeout_implement: u64,
    pub timeout_judge: u64,
    pub timeout_review: u64,
    pub timeout_fix: u64,
    pub retries: usize,
    pub worktree_root: Option<PathBuf>,
    pub land: bool,
    pub land_rounds: usize,
    pub land_approval: bool,
    pub answer_timeout: u64,
}

Graph shape and limits.

Fields

candidates: usize

Parallel implementations of the same task.

judges: usize

Independent judges.

deliberate_rounds: usize

Deliberation rounds when the judges’ first choices disagree.

reviewers: usize

Reviewers per review round.

review_rounds: usize

Maximum review+fix rounds before the run is declared blocked.

max_parallel: usize

Maximum agent processes running at once.

language: String

Language for the prose the agents write (en / ja / any language name).

sessions: bool

Keep one CLI conversation per seat, so a judge remembers its own argument across deliberation rounds and the fixer remembers its own implementation across review rounds.

Sessions are scoped to a seat, never to an agent id: the same model sitting as implementer and as judge gets two unrelated conversations, which is what keeps blind judging blind.

timeout_implement: u64

Per-node timeouts, seconds.

timeout_judge: u64

Per-node timeouts, seconds.

timeout_review: u64

Per-node timeouts, seconds.

timeout_fix: u64

Per-node timeouts, seconds.

retries: usize

Retries for an agent invocation that fails or returns nothing usable.

worktree_root: Option<PathBuf>

Root for candidate / judge worktrees. Defaults to ~/wt/magi.

land: bool

After the pull request is open, keep going: watch its checks and reviews, run a fix round when they are unhappy, and ask to merge.

On, because stopping at an open pull request left the operator doing the watching by hand - six times in the session this was built in - and that is the work the loop exists to take. It only engages for merge = "pr"; every other merge mode ends the run as before.

Turning this on does not hand magi the merge button: Graph::land_approval is on too, and nothing merges without an explicit answer. Setting both to their non-defaults is the only way to get an unattended merge, and it has to be chosen twice.

land_rounds: usize

Land rounds - watch, fix, push - before the run is left for a human.

land_approval: bool

Ask the owner before merging, showing what is about to land.

On, and it is what makes land safe to have on: the question carries a rendered panel - the diffstat, the patch, the checks, the review comments that were addressed, and the subject the squash will use - so the decision is made on evidence rather than on trust, from wherever the operator happens to be.

Silence is a hold. An unanswered approval never merges, and neither does any answer other than the word merge.

answer_timeout: u64

How long to wait for an owner to answer a question before the run is abandoned, seconds. A parked run costs nothing, so this is generous; it exists so a forgotten question cannot pin a worktree forever.

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Graph

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.