Skip to main content

magi/
land.rs

1//! Landing the winner: watch the pull request, fix what it complains about,
2//! and merge it.
3//!
4//! Opening the pull request used to be where magi stopped and the operator
5//! started: watch the checks, read what the review bots found, push a fix,
6//! wait again, merge. That loop is mechanical, it takes an hour of wall-clock
7//! time per pull request, and doing it by hand six times in one session is how
8//! a queue that drains unattended stops being unattended. So it lives here.
9//!
10//! # Shape
11//!
12//! [`PrState`] is one observation of a pull request and [`decide`] is the whole
13//! policy as a *pure* function of it. Nothing in [`decide`] talks to `gh`,
14//! which is what makes "green with an unresolved comment is a fix, not a merge"
15//! an assertion in a test rather than a claim in a comment. [`land`] is the
16//! only part that performs I/O: observe, decide, act, repeat.
17//!
18//! # What it refuses to do
19//!
20//! Merging is the one irreversible thing magi can do to a repository, so the
21//! loop is built to stop rather than to guess:
22//!
23//! * A red pull request is never merged. When the budget runs out the pull
24//!   request is left open with a comment naming what is still failing, because
25//!   a magi that force-merges a red pull request is worse than one that stops.
26//! * A pull request whose checks cannot be read at all (`gh` reported no
27//!   rollup) is not merged either. Landing is for repositories with CI; with no
28//!   signal there is nothing to be green.
29//! * A pull request a human merged or closed underneath us is
30//!   [`Step::Done`] - the person won, and their decision is not an error.
31//!
32//! # Why `--subject` is not optional
33//!
34//! A candidate branch holds one commit whose subject is
35//! `magi: candidate A (uncommitted work)`, and `gh pr merge --squash` prefers a
36//! single commit's message over the pull request title. Merging without
37//! [`merge_argv`]'s explicit `--subject` therefore writes a `main` history that
38//! says nothing about what landed. `AGENTS.md` records the trap; this module is
39//! where it is prevented.
40
41use std::collections::{BTreeMap, BTreeSet};
42use std::fmt::Write as _;
43use std::path::{Path, PathBuf};
44use std::sync::Arc;
45use std::time::Duration;
46
47use anyhow::{Context as _, Result, bail};
48use jiff::Timestamp;
49use serde::{Deserialize, Serialize};
50
51use crate::agent::{self, Invocation, SeatState};
52use crate::ask;
53use crate::config::MergeMode;
54use crate::git;
55use crate::proc::Quiet as _;
56use crate::prompt;
57use crate::run::{
58    ContestedHandoff, LandApproval, LandReruns, MergeOutcome, RunState, RunStatus, tail,
59};
60
61/// How often the pull request is re-read while its checks are still running.
62///
63/// Thirty seconds: a CI matrix takes minutes, so anything shorter is spent
64/// entirely on `gh` invocations, and anything much longer adds latency to every
65/// single round of a loop that already waits for agents.
66pub const POLL: Duration = Duration::from_secs(30);
67
68/// How long one wait may last before landing gives up on the checks finishing.
69///
70/// A workflow that has not settled in forty-five minutes is stuck on a runner
71/// queue, a missing approval, or a hung job - none of which more polling fixes,
72/// and all of which a person needs to see.
73pub const WAIT_CEILING: Duration = Duration::from_secs(45 * 60);
74
75/// How long the checks may stay unreadable before landing gives up on them.
76///
77/// GitHub registers a workflow run some seconds after the branch is pushed, so
78/// immediately after a pull request is opened "no checks" and "no CI in this
79/// repository" look identical. Measured on run 01c2: magi opened pull request
80/// 22, read `unknown` four seconds later, refused to merge on a guess and
81/// marked the run blocked - and every check on that pull request was green
82/// minutes afterwards, with the whole competition then re-run from scratch for
83/// a task that was already finished. Three minutes is well past the observed
84/// registration delay and still bounded, so a repository that genuinely has no
85/// checks costs one three-minute wait and then says so.
86pub const CHECKS_GRACE: Duration = Duration::from_secs(3 * 60);
87
88/// Bytes of failing log kept per check. The fixer needs the assertion and the
89/// frame around it, not the forty thousand lines of `cargo` output above it.
90const LOG_TAIL: usize = 4_000;
91
92/// Failing checks whose logs are fetched. Beyond a handful the failures share a
93/// cause, and fetching each one costs a `gh` round trip.
94const MAX_LOGS: usize = 3;
95
96/// Marker carried by every comment magi posts on a pull request.
97///
98/// Without it magi's own "still failing" comment is indistinguishable from a
99/// reviewer's, and the next observation would hand magi's own prose to the
100/// fixer as a finding.
101pub const MARKER: &str = "<!-- magi:land -->";
102
103/// Markers a bot puts in a comment to say that the comment is not a review.
104///
105/// CodeRabbit labels its own machinery in HTML comments - the trigger notice,
106/// the walkthrough summary, the "thanks for using" footer - and its actual
107/// findings arrive as *inline* review comments with a path and a line. Taking
108/// the bot at its word is more honest than guessing from prose, and it is the
109/// difference between a fix round that has something to fix and one that asks
110/// an agent to act on a quota notice.
111const NOT_A_REVIEW: [&str; 3] = [
112    "skip review by coderabbit.ai",
113    "summarize by coderabbit.ai",
114    "<!-- tips_start -->",
115];
116
117/// Where a pull request is in its life.
118#[derive(Debug, Clone, Copy, PartialEq, Eq)]
119pub enum PrLifecycle {
120    /// Still ours to land.
121    Open,
122    /// Already merged, by us or by a person.
123    Merged,
124    /// Closed without merging.
125    Closed,
126}
127
128/// The aggregate verdict of a pull request's checks.
129#[derive(Debug, Clone, Copy, PartialEq, Eq)]
130pub enum Checks {
131    /// At least one check has not finished.
132    Pending,
133    /// Every check passed (a skipped check counts as passed: the review
134    /// workflow skips release and bot pull requests by design).
135    Green,
136    /// At least one check finished without passing.
137    Red,
138    /// Nothing readable - no rollup at all, or a status magi does not know.
139    Unknown,
140}
141
142impl PrLifecycle {
143    /// Stable lower-case name, as the API and the reports spell it.
144    pub fn as_str(self) -> &'static str {
145        match self {
146            Self::Open => "open",
147            Self::Merged => "merged",
148            Self::Closed => "closed",
149        }
150    }
151}
152
153impl Checks {
154    /// Stable lower-case name, as the API and the reports spell it.
155    pub fn as_str(self) -> &'static str {
156        match self {
157            Self::Pending => "pending",
158            Self::Green => "green",
159            Self::Red => "red",
160            Self::Unknown => "unknown",
161        }
162    }
163}
164
165/// One outstanding review comment, human or bot.
166#[derive(Debug, Clone, PartialEq, Eq)]
167pub struct ReviewComment {
168    /// Login of whoever wrote it.
169    pub author: String,
170    /// File it was left on, for inline review comments.
171    pub path: Option<String>,
172    /// Line it was left on, when the comment is inline and still anchored.
173    pub line: Option<u64>,
174    /// The comment itself, as written.
175    pub body: String,
176}
177
178/// One observation of a pull request.
179#[derive(Debug, Clone, PartialEq, Eq)]
180pub struct PrState {
181    /// Pull request url, as `gh` reports it.
182    pub url: String,
183    /// Pull request number.
184    pub number: u64,
185    /// Open, merged, or closed.
186    pub state: PrLifecycle,
187    /// Aggregate check verdict.
188    pub checks: Checks,
189    /// Names of the checks that finished without passing.
190    pub failing: Vec<String>,
191    /// Comments that still want an answer, human and bot.
192    pub review_comments: Vec<ReviewComment>,
193    /// Whether the forge itself considers the failures blocking.
194    pub blocking: Blocking,
195}
196
197/// Whether a failing check actually stands between the pull request and
198/// `main`, according to the forge.
199///
200/// The rollup lists every check equally, so `coverage` going red on a
201/// repository that deliberately does not require it looked exactly like a
202/// broken build - and magi answered by spending a fix round on a change that
203/// was fine. Pull request 37 had to be merged by hand for that reason: the
204/// only red check was `editorconfig`, which was failing because the *action*
205/// could not fetch its own binary, and which the repository does not require.
206///
207/// `mergeStateStatus` is where GitHub applies the required-check set, so it
208/// is the one field that can tell the difference.
209#[derive(Debug, Clone, Copy, PartialEq, Eq)]
210pub enum Blocking {
211    /// Required checks are satisfied and the branch merges cleanly.
212    No,
213    /// Something required is failing or missing.
214    Yes,
215    /// The branch no longer merges: the base moved under it.
216    Conflict,
217    /// The forge requires the head to include the current base.
218    Behind,
219    /// The forge did not say - an older `gh`, or a token without the scope.
220    /// Treated as `Yes`, because refusing to guess is the rule everywhere
221    /// else in this module.
222    Unsaid,
223}
224
225impl Blocking {
226    /// Read `mergeStateStatus`, which is upper-case in `gh`'s output.
227    fn of(raw: &str) -> Self {
228        match raw.to_ascii_uppercase().as_str() {
229            // Mergeable. `UNSTABLE` is the interesting one: mergeable, with a
230            // non-required check failing or still running.
231            "CLEAN" | "UNSTABLE" | "HAS_HOOKS" => Self::No,
232            "DIRTY" => Self::Conflict,
233            "BEHIND" => Self::Behind,
234            "" | "UNKNOWN" => Self::Unsaid,
235            // BLOCKED, DRAFT: something has to change first.
236            _ => Self::Yes,
237        }
238    }
239
240    /// Does this stand between the pull request and the base branch?
241    #[must_use]
242    pub fn stops_a_merge(self) -> bool {
243        !matches!(self, Self::No)
244    }
245}
246
247/// What the loop decided to do next. Pure, so the policy is testable.
248#[derive(Debug, Clone, PartialEq, Eq)]
249pub enum Step {
250    /// Checks are still running; re-read the pull request after [`POLL`].
251    Wait,
252    /// The base moved and the branch no longer merges: rebase it.
253    ///
254    /// Not a fix round. Nothing is wrong with the change - a competition
255    /// that runs for two hours against a repository merging pull requests
256    /// all day conflicts on the way in, and that is arithmetic rather than a
257    /// defect. Pull requests 35 and 37 were both rebased by hand for exactly
258    /// this.
259    Rebase,
260    /// Red checks or unresolved comments; run a fix round.
261    Fix {
262        /// What is unhappy, in one line, for the run log and the fix prompt.
263        reason: String,
264    },
265    /// Green and nothing outstanding; merge it.
266    Merge,
267    /// The pull request left our hands.
268    Done {
269        /// Did it land, or was it closed?
270        merged: bool,
271    },
272    /// Stop and leave the pull request to a person.
273    GiveUp {
274        /// Why magi stopped, in one line.
275        reason: String,
276    },
277}
278
279/// The outcome to record when `gh pr merge` exits non-zero, given what the
280/// pull request looked like immediately afterwards.
281///
282/// `gh pr merge` merges server-side first and only then does local work -
283/// deleting the branch, switching back to a base branch - so a non-zero exit
284/// does not mean the merge did not happen. In a jj-colocated repository it
285/// reliably does not mean that: git HEAD is detached, and `--delete-branch`
286/// ends with "could not determine current branch: not on any branch" *after*
287/// the merge has landed. Run ec12 merged pull request 28 into `main` and
288/// recorded `ok: false`, and its task was held waiting for a merge that was
289/// already done.
290///
291/// So the forge is asked, and its answer wins - the same authority [`decide`]
292/// gives the pull request's own state over everything else. The recorded
293/// detail carries both facts, because "the command failed and the merge
294/// happened anyway" is exactly what someone reading the run later needs to
295/// know.
296///
297/// `None` means the merge really did not happen, including when the pull
298/// request could not be read at all: an unreadable answer is not evidence of
299/// success.
300pub(crate) fn merged_after_all(
301    argv: &[String],
302    stderr: &str,
303    after: Option<PrLifecycle>,
304) -> Option<MergeOutcome> {
305    if after? != PrLifecycle::Merged {
306        return None;
307    }
308    Some(MergeOutcome {
309        mode: MergeMode::Pr,
310        ok: true,
311        detail: format!(
312            "gh {} (the command reported `{}`, but the pull request is merged)",
313            argv.join(" "),
314            stderr.trim()
315        ),
316        empty: false,
317    })
318}
319
320/// Decide the next step. No I/O.
321///
322/// `round` counts the fix rounds already spent, so `round == budget` means the
323/// budget is gone. A wait never spends a round: waiting is free, and a slow CI
324/// must not consume the allowance meant for actual fixes.
325///
326/// The order of the tests is the policy:
327///
328/// 1. **The pull request's own state wins.** A merge or a close that happened
329///    underneath us is the end of the story regardless of what the checks say.
330/// 2. **Pending beats red.** A check that is still running may yet fail, and one
331///    fix round that addresses every failure is cheaper than two that each
332///    address half - the fix pushes and restarts the whole suite anyway.
333/// 3. **Comments outrank green.** An unresolved comment holds the merge even
334///    when CI is happy; that is what a review is for.
335/// 4. **Unreadable is not absent.** Checks that cannot be read yet are waited
336///    on for [`CHECKS_GRACE`], because a pull request opened a moment ago has
337///    not been given its workflow runs yet. Past the grace they are treated as
338///    genuinely missing and magi stops rather than merge on a guess.
339pub fn decide(pr: &PrState, round: usize, budget: usize, waited: Duration) -> Step {
340    decide_with(pr, round, budget, waited, CiExpectation::Expected)
341}
342
343/// Whether the repository's CI is expected to report on this pull request.
344#[derive(Debug, Clone, Copy, PartialEq, Eq)]
345pub enum CiExpectation {
346    /// Checks will come: wait for them, judge them (the default, and what
347    /// [`decide`] always uses).
348    Expected,
349    /// The repository explicitly disables CI expectations with `[merge] ci = "none"`.
350    /// Ignore all check statuses while retaining conflicts and review comments.
351    Absent,
352}
353
354/// [`decide`] with the CI expectation made explicit. `Absent` ignores the
355/// rollup, but still requires conflicts and review comments to be resolved.
356pub fn decide_with(
357    pr: &PrState,
358    round: usize,
359    budget: usize,
360    waited: Duration,
361    ci: CiExpectation,
362) -> Step {
363    match pr.state {
364        PrLifecycle::Merged => return Step::Done { merged: true },
365        PrLifecycle::Closed => return Step::Done { merged: false },
366        PrLifecycle::Open => {}
367    }
368
369    // Before the checks: every check on a branch that cannot land is an
370    // answer about a state that cannot land.
371    if matches!(pr.blocking, Blocking::Conflict | Blocking::Behind) {
372        return Step::Rebase;
373    }
374
375    let spent = round >= budget;
376    let checks = match ci {
377        CiExpectation::Expected => pr.checks,
378        CiExpectation::Absent => Checks::Green,
379    };
380    match checks {
381        Checks::Pending => Step::Wait,
382        Checks::Unknown if waited < CHECKS_GRACE => Step::Wait,
383        Checks::Unknown => Step::GiveUp {
384            reason: format!(
385                "no check status is readable on the pull request after {} minute(s); \
386                 refusing to merge on a guess",
387                CHECKS_GRACE.as_secs() / 60
388            ),
389        },
390        // Red, but the forge says it does not stand in the way: the failing
391        // checks are ones this repository chose not to require. Spending a fix
392        // round on them asks an agent to repair something nobody is gating on
393        // - and pull request 37's only red check was an *action* that could
394        // not fetch its own binary. Merge, and name them so the record is
395        // honest about what was red when it landed.
396        Checks::Red if pr.blocking == Blocking::Unsaid && waited < CHECKS_GRACE => Step::Wait,
397        Checks::Red if !pr.blocking.stops_a_merge() && pr.review_comments.is_empty() => Step::Merge,
398        Checks::Red => {
399            let what = format!(
400                "{} check(s) failing: {}",
401                pr.failing.len(),
402                pr.failing.join(", ")
403            );
404            if spent {
405                Step::GiveUp {
406                    reason: format!("{what} — still red after {budget} fix round(s)"),
407                }
408            } else {
409                Step::Fix { reason: what }
410            }
411        }
412        Checks::Green if pr.review_comments.is_empty() => Step::Merge,
413        Checks::Green => {
414            let what = format!(
415                "{} but {} review comment(s) are unresolved: {}",
416                if ci == CiExpectation::Absent {
417                    "CI is not expected"
418                } else {
419                    "checks are green"
420                },
421                pr.review_comments.len(),
422                authors(&pr.review_comments)
423            );
424            if spent {
425                Step::GiveUp {
426                    reason: format!("{what} — still unresolved after {budget} fix round(s)"),
427                }
428            } else {
429                Step::Fix { reason: what }
430            }
431        }
432    }
433}
434
435/// Distinct comment authors, in the order they first appear.
436fn authors(comments: &[ReviewComment]) -> String {
437    let mut seen: Vec<&str> = Vec::new();
438    for c in comments {
439        if !seen.contains(&c.author.as_str()) {
440            seen.push(&c.author);
441        }
442    }
443    seen.join(", ")
444}
445
446/// The argv magi merges with, minus the program name.
447///
448/// `--subject` is the point of this function existing: see the module docs.
449pub fn merge_argv(number: u64, subject: &str) -> Vec<String> {
450    vec![
451        "pr".to_owned(),
452        "merge".to_owned(),
453        number.to_string(),
454        "--squash".to_owned(),
455        "--delete-branch".to_owned(),
456        "--subject".to_owned(),
457        subject.to_owned(),
458    ]
459}
460
461/// [`merge_argv`] pinned to the commit the decision was made about.
462///
463/// `--match-head-commit` makes the forge refuse the merge if the branch moved
464/// after it was observed, so a push landing between the look and the merge is
465/// never merged unseen.
466pub fn merge_argv_at(number: u64, subject: &str, head: &str) -> Vec<String> {
467    let mut argv = merge_argv(number, subject);
468    argv.push("--match-head-commit".to_owned());
469    argv.push(head.to_owned());
470    argv
471}
472
473/// Take auto-merge back. magi no longer arms auto-merge, but a run recorded by
474/// an older build may still have one standing on the forge, so the disarm
475/// paths (and `RunState::land_armed_head`) stay. Run before anything that changes the head, so an
476/// armed merge never outlives the commit that was approved for it.
477pub fn disable_automerge_argv(number: u64) -> Vec<String> {
478    ["pr", "merge", &number.to_string(), "--disable-auto"]
479        .map(str::to_owned)
480        .to_vec()
481}
482
483/// May the direct merge go ahead, judged from a fresh read?
484///
485/// The pull request must still be open on the approved head, the checks must
486/// have been read for that very head, and the policy must still say merge.
487/// Pure, so the head guard is asserted without a forge.
488fn direct_merge_is_safe(
489    fresh: Option<&Seen>,
490    approved_head: &str,
491    shown: &BTreeSet<String>,
492    round: usize,
493    budget: usize,
494    waited: Duration,
495    ci: CiExpectation,
496) -> bool {
497    let Some(fresh) = fresh else {
498        return false;
499    };
500    if fresh.pr.state != PrLifecycle::Open {
501        return false;
502    }
503    let Some(bound) = bound_head(&fresh.head, &fresh.rollup_head, None) else {
504        return false;
505    };
506    if !bound.eq_ignore_ascii_case(approved_head) {
507        return false;
508    }
509    let mut pr = fresh.pr.clone();
510    pr.review_comments.retain(|c| !shown.contains(&c.body));
511    decide_with(&pr, round, budget, waited, ci) == Step::Merge
512}
513
514/// What GitHub is still waiting for, for the stop reason when an armed merge
515/// does not happen in time. No I/O.
516///
517/// Required checks that are pending or failing are named. A check whose
518/// required-ness could not be read is never assumed optional: every unsettled
519/// check is listed and the reason says so.
520fn waiting_on(
521    merge_state: &str,
522    contexts: &[CheckInfo],
523    required_set: Option<&BTreeSet<String>>,
524) -> String {
525    let state = if merge_state.is_empty() {
526        "unknown"
527    } else {
528        merge_state
529    };
530    let tag = |c: &CheckInfo| match c.verdict {
531        Verdict::Fail => "failed",
532        _ => "pending",
533    };
534    let unsettled: Vec<&CheckInfo> = contexts
535        .iter()
536        .filter(|c| c.verdict != Verdict::Pass)
537        .collect();
538    let required: Vec<String> = unsettled
539        .iter()
540        .filter(|c| c.required == Some(true))
541        .map(|c| format!("{} ({})", c.label, tag(c)))
542        .collect();
543    let unknown: Vec<String> = unsettled
544        .iter()
545        .filter(|c| c.required.is_none())
546        .map(|c| format!("{} ({})", c.label, tag(c)))
547        .collect();
548    // Required contexts the rollup never listed: nothing reported them, so no
549    // pending/failing entry exists to name. Matched case-insensitively against
550    // the labels as the rollup spells them, and no further.
551    let never: Vec<&str> = required_set
552        .map(|set| {
553            set.iter()
554                .filter(|name| !contexts.iter().any(|c| c.label.eq_ignore_ascii_case(name)))
555                .map(String::as_str)
556                .collect()
557        })
558        .unwrap_or_default();
559    let mut out = format!("merge state: {state}");
560    if !never.is_empty() {
561        let _ = write!(
562            out,
563            "; required checks never reported: {}",
564            never.join(", ")
565        );
566    }
567    if !required.is_empty() {
568        let _ = write!(
569            out,
570            "; required checks not passing: {}",
571            required.join(", ")
572        );
573    }
574    if !unknown.is_empty() {
575        let _ = write!(
576            out,
577            "; whether these are required could not be read, so they may be: {}",
578            unknown.join(", ")
579        );
580    }
581    if required.is_empty() && unknown.is_empty() && never.is_empty() {
582        if required_set.is_some() {
583            out.push_str(
584                "; no required check is pending, failing or unreported, so GitHub is probably \
585                 waiting for a review or another branch rule",
586            );
587        } else {
588            out.push_str(
589                "; the required check list could not be read, so a required check that was \
590                 never reported cannot be ruled out",
591            );
592        }
593    }
594    out
595}
596
597/// The squash subject to merge under.
598///
599/// The pull request title, unless it is empty or is a candidate branch's commit
600/// subject that leaked into the title - in which case the task's own first line
601/// is used, because `magi: candidate A (uncommitted work)` in `main` tells a
602/// reader nothing about what landed.
603pub fn merge_subject(pr_title: &str, instruction: &str) -> String {
604    let title = pr_title.trim();
605    if !title.is_empty() && !title.starts_with("magi: candidate") {
606        return title.to_owned();
607    }
608    let first = instruction
609        .lines()
610        .map(str::trim)
611        .find(|l| !l.is_empty())
612        .unwrap_or("magi: land the winning candidate");
613    first.trim_start_matches(['#', ' ']).to_owned()
614}
615
616/// The choice that lets the merge happen, verbatim as the owner taps it.
617pub const APPROVE: &str = "merge";
618
619/// The choice that leaves the pull request open.
620pub const HOLD: &str = "hold";
621
622/// A bounded repair followed by a new review and a fresh owner decision.
623pub const REPAIR: &str = "fix findings and re-review";
624
625/// Whether review evidence offers a meaningful repair choice. This does not
626/// decide whether owner approval is required.
627pub fn repair_available(state: &RunState) -> bool {
628    state.reviews.last().is_some_and(|r| {
629        state.open_findings().iter().any(|f| f.severity.blocks())
630            || r.final_votes()
631                .iter()
632                .any(|(_, _, v)| *v == crate::verdict::ReviewVote::Reject)
633    })
634}
635
636/// All applicable reasons for consulting the owner, independent of repair choices.
637#[derive(Debug, Clone, Copy, PartialEq, Eq)]
638pub enum ApprovalReason {
639    /// Universal owner approval is enabled for every merge.
640    EveryMerge,
641    /// Contested-merge approval is enabled and blocking findings remain open.
642    OpenBlockingFindings,
643    /// Contested-merge approval is enabled and a final reviewer vote rejects.
644    FinalReject,
645    /// An existing owner decision must be honored even if controls change.
646    ExistingDecision,
647    /// Merge repair requires a fresh owner decision, even on the same head.
648    AfterRepair,
649}
650
651/// Disabling fresh approval controls never bypasses an existing owner decision
652/// or the fresh decision owed after repair, even if repair kept the same head.
653pub fn approval_reasons(state: &RunState) -> Vec<ApprovalReason> {
654    let mut reasons = Vec::new();
655    if state.owner_hold(crate::config::OwnerHold::LandApproval) {
656        reasons.push(ApprovalReason::EveryMerge);
657    }
658    if state.owner_hold(crate::config::OwnerHold::HoldContestedMerge) {
659        if state.open_findings().iter().any(|f| f.severity.blocks()) {
660            reasons.push(ApprovalReason::OpenBlockingFindings);
661        }
662        if state.reviews.last().is_some_and(|r| {
663            r.final_votes()
664                .iter()
665                .any(|(_, _, v)| *v == crate::verdict::ReviewVote::Reject)
666        }) {
667            reasons.push(ApprovalReason::FinalReject);
668        }
669    }
670    if state.land_approval.is_some() {
671        reasons.push(ApprovalReason::ExistingDecision);
672    }
673    if !state.merge_repairs.is_empty() || !state.repair_grants.is_empty() {
674        reasons.push(ApprovalReason::AfterRepair);
675    }
676    reasons
677}
678
679/// Bound free-form approval evidence by characters, including an explicit
680/// ellipsis when abbreviated. Keep UTF-8 text intact in questions and panels.
681fn approval_excerpt(text: &str, max_chars: usize) -> String {
682    if text.chars().count() <= max_chars {
683        text.to_owned()
684    } else {
685        let mut excerpt: String = text.chars().take(max_chars.saturating_sub(1)).collect();
686        excerpt.push('…');
687        excerpt
688    }
689}
690
691/// Persisted verbatim in the question and panel at creation. Deputies and
692/// resumed questions use that snapshot, never reconstruct past policy from
693/// today's settings. Fixer claims and successful gates are not resolutions.
694fn approval_evidence(state: &RunState) -> String {
695    const TITLE_CHARS: usize = 100;
696    const REASON_CHARS: usize = 300;
697    let reason = |text: &str| approval_excerpt(text, REASON_CHARS);
698    let ja = words(&state.config.graph.language).html_lang == "ja";
699    let mut s = if ja {
700        "承認が必要な理由:\n"
701    } else {
702        "Approval required because:\n"
703    }
704    .to_owned();
705    for reason in approval_reasons(state) {
706        let label = match (reason, ja) {
707            (ApprovalReason::EveryMerge, false) => {
708                "land_approval=true: owner approval for every merge"
709            }
710            (ApprovalReason::EveryMerge, true) => {
711                "land_approval=true: すべてのマージに所有者の承認が必要"
712            }
713            (ApprovalReason::OpenBlockingFindings, false) => {
714                "hold_contested_merge=true: open Major-or-above internal findings"
715            }
716            (ApprovalReason::OpenBlockingFindings, true) => {
717                "hold_contested_merge=true: Major 以上の内部指摘が未解決"
718            }
719            (ApprovalReason::FinalReject, false) => {
720                "hold_contested_merge=true: final reviewer reject after reconsideration (even without Major findings)"
721            }
722            (ApprovalReason::FinalReject, true) => {
723                "hold_contested_merge=true: 再考後の最終票が reject(Major 指摘がなくても承認が必要)"
724            }
725            (ApprovalReason::ExistingDecision, false) => {
726                "existing owner decision: changing controls cannot bypass it"
727            }
728            (ApprovalReason::ExistingDecision, true) => {
729                "既存の所有者判断: 設定変更では迂回できません"
730            }
731            (ApprovalReason::AfterRepair, false) => {
732                "fresh owner approval after merge repair, even with an unchanged head"
733            }
734            (ApprovalReason::AfterRepair, true) => {
735                "マージ修復後の新しい所有者承認(head に変更がなくても必要)"
736            }
737        };
738        let control = match reason {
739            ApprovalReason::EveryMerge => Some(crate::config::OwnerHold::LandApproval),
740            ApprovalReason::OpenBlockingFindings | ApprovalReason::FinalReject => {
741                Some(crate::config::OwnerHold::HoldContestedMerge)
742            }
743            _ => None,
744        };
745        let source = control
746            .filter(|c| !c.base_value(&state.config.graph))
747            .and_then(|c| state.branch_owner_holds.iter().find(|h| h.control == c));
748        if let Some(source) = source {
749            if ja {
750                let _ = writeln!(
751                    s,
752                    "- {}=true(レビュー対象ブランチの {} 由来, {})",
753                    source.control.key(),
754                    source.file,
755                    source.head
756                );
757            } else {
758                let _ = writeln!(
759                    s,
760                    "- {}=true from the reviewed branch's {} ({})",
761                    source.control.key(),
762                    source.file,
763                    source.head
764                );
765            }
766        }
767        let _ = writeln!(s, "- {label}");
768    }
769    s.push_str(if ja {
770        "\n再考後の各レビュアーの最終票:\n"
771    } else {
772        "\nFinal reviewer votes after reconsideration:\n"
773    });
774    if let Some(round) = state.reviews.last() {
775        let votes = round.final_votes();
776        for r in &round.reviews {
777            let vote = votes
778                .iter()
779                .find(|(seat, _, _)| *seat == r.reviewer)
780                .map(|(_, _, v)| v.label())
781                .unwrap_or(if ja { "記録なし" } else { "not recorded" });
782            let _ = writeln!(s, "#{} ({}): {vote}", r.reviewer, r.agent);
783            let rv = round
784                .reconsideration
785                .iter()
786                .find(|rv| rv.reviewer == r.reviewer);
787            if let Some(rv) = rv.filter(|rv| rv.vote.is_some()) {
788                let initial = r.vote.map(|v| v.label()).unwrap_or("?");
789                let _ = writeln!(
790                    s,
791                    "  {}: {initial} → {vote}",
792                    if ja { "再考" } else { "reconsideration" }
793                );
794                let _ = writeln!(
795                    s,
796                    "  {}: {}",
797                    if ja { "理由" } else { "reason" },
798                    reason(if rv.reason.trim().is_empty() {
799                        if ja { "記録なし" } else { "not recorded" }
800                    } else {
801                        &rv.reason
802                    })
803                );
804            } else {
805                let _ = writeln!(
806                    s,
807                    "  {}: {}",
808                    if ja {
809                        "初回票を保持・理由"
810                    } else {
811                        "initial vote retained; reason"
812                    },
813                    reason(if r.summary.trim().is_empty() {
814                        if ja { "記録なし" } else { "not recorded" }
815                    } else {
816                        &r.summary
817                    })
818                );
819                if let Some(rv) = rv {
820                    let _ = writeln!(
821                        s,
822                        "  {}: {}",
823                        if ja {
824                            "再投票の回答なし"
825                        } else {
826                            "no reconsideration vote"
827                        },
828                        reason(rv.failed.as_deref().unwrap_or(if ja {
829                            "理由の記録なし"
830                        } else {
831                            "reason not recorded"
832                        }))
833                    );
834                }
835            }
836            if let Some(failed) = &r.failed {
837                let _ = writeln!(
838                    s,
839                    "  {}: {}",
840                    if ja { "回答なし" } else { "no answer" },
841                    reason(failed)
842                );
843            }
844        }
845    } else {
846        s.push_str(if ja {
847            "レビュー記録なし\n"
848        } else {
849            "No review recorded\n"
850        });
851    }
852    s.push_str(if ja { "\n内部レビュー指摘(最終ラウンド): 採用申告や gate 成功だけでは個別指摘の解決確認にはなりません。\n" } else { "\nInternal review findings (last round): adoption claims or a passing gate alone do not confirm individual resolution.\n" });
853    let findings = state.last_round_findings();
854    for f in &findings {
855        let _ = writeln!(
856            s,
857            "[{}] {} {}:{}: {}\n{}",
858            f.id,
859            f.severity,
860            f.file.as_deref().unwrap_or("?"),
861            f.line.map(|l| l.to_string()).unwrap_or_else(|| "?".into()),
862            approval_excerpt(&f.title, TITLE_CHARS),
863            reason(&f.detail)
864        );
865        let mut evidence = false;
866        for fix in state.reviews.iter().filter_map(|r| r.fix.as_ref()).chain(
867            state
868                .operator_fixes
869                .iter()
870                .filter_map(|request| request.fix.as_ref()),
871        ) {
872            if fix.addressed.contains(&f.id) {
873                evidence = true;
874                let _ = writeln!(
875                    s,
876                    "  {} ({}): {}",
877                    if ja {
878                        "採用申告(解決未確認)"
879                    } else {
880                        "claimed addressed (resolution unconfirmed)"
881                    },
882                    fix.agent,
883                    reason(&fix.notes)
884                );
885            }
886            for rejection in fix.rejected.iter().filter(|r| r.id == f.id) {
887                evidence = true;
888                let _ = writeln!(
889                    s,
890                    "  {}: {}",
891                    if ja { "不採用理由" } else { "declined" },
892                    reason(&rejection.why)
893                );
894            }
895        }
896        if !evidence {
897            s.push_str(if ja {
898                "  採用・解決確認の記録なし\n"
899            } else {
900                "  No adoption or resolution evidence recorded\n"
901            });
902        }
903    }
904    if findings.is_empty() {
905        s.push_str(if ja {
906            "最終ラウンドに指摘の記録なし\n"
907        } else {
908            "No findings recorded in the last round\n"
909        });
910    }
911    s
912}
913
914/// Shared choices for web, CLI and consultation questions.
915pub fn approval_choices(state: &RunState) -> Vec<String> {
916    let mut choices = vec![
917        APPROVE.to_owned(),
918        HOLD.to_owned(),
919        REPAIR.to_owned(),
920        crate::merge_decision::WITHDRAW.to_owned(),
921        crate::merge_decision::DISMISS.to_owned(),
922    ];
923    choices.extend(
924        state
925            .config
926            .agents
927            .iter()
928            .map(|a| format!("{}{id}", crate::merge_decision::REIMPLEMENT, id = a.id)),
929    );
930    choices
931}
932
933/// Extend unanswered legacy cards in place. Answered cards keep their choices;
934/// a legacy repair answer gains only its missing dispatch action.
935pub fn upgrade_repair_choice(q: &mut ask::Question, state: &RunState) -> bool {
936    if q.node != APPROVAL_NODE
937        || !state
938            .land_approval
939            .as_ref()
940            .is_some_and(|a| a.question == q.id)
941    {
942        return false;
943    }
944    let before = (q.choices.clone(), q.actions.clone(), q.merge_target.clone());
945    if q.status.open() {
946        // Older cards attached Resume to hold; a hold must remain answerable
947        // without dispatching a question action.
948        q.actions.remove(HOLD);
949        for choice in approval_choices(state) {
950            if !q.choices.contains(&choice) {
951                q.choices.push(choice);
952            }
953        }
954        if q.merge_target.is_none() {
955            q.merge_target = state.pr.as_ref().map(|pr| crate::merge_decision::Target {
956                pr: pr.url.clone(),
957                head: state.land_approval.as_ref().unwrap().head.clone(),
958                language: state.config.graph.language.clone(),
959            });
960        }
961    }
962    for choice in q.choices.clone() {
963        if (q.status.open()
964            && crate::merge_decision::stops(&choice)
965            && choice != HOLD
966            && choice != crate::merge_decision::DISMISS)
967            || (choice == REPAIR && (q.status.open() || q.resolution().as_deref() == Some(REPAIR)))
968        {
969            q.actions.insert(
970                choice,
971                ask::ChoiceAction::Resume {
972                    run: state.id.clone(),
973                },
974            );
975        }
976    }
977    before != (q.choices.clone(), q.actions.clone(), q.merge_target.clone())
978}
979
980/// Graph node recorded on the approval question.
981///
982/// The phone keys its high-stakes card off this rather than off the choice
983/// strings, so renaming a button cannot silently downgrade the card that
984/// guards the one irreversible action magi takes.
985pub const APPROVAL_NODE: &str = "land-approval";
986
987/// Unified diff lines carried in the panel before it is truncated.
988///
989/// Four hundred: the panel is read on a 390px phone, where a diff line often
990/// wraps to two rows, so this is already a few thousand rows of scrolling -
991/// past that nobody is reading, and the bytes still count against the panel's
992/// 8 MiB cap. A larger diff is not hidden: the note says how many lines were
993/// cut and which worktree holds the whole patch.
994pub const DIFF_MAX_LINES: usize = 400;
995
996/// What the owner's answer to the approval question means.
997#[derive(Debug, Clone, Copy, PartialEq, Eq)]
998pub enum Approval {
999    /// The owner said [`APPROVE`]. Merge.
1000    Merge,
1001    /// Repair the existing PR, then ask again; never approval to merge.
1002    Repair,
1003    /// Anything else, including silence. Leave the pull request open.
1004    Hold,
1005}
1006
1007/// Read the owner's answer, where `None` is an unanswered question.
1008///
1009/// Silence is a hold. A timed-out question means the owner never saw it or
1010/// never decided, and defaulting an irreversible merge to "yes" would make this
1011/// gate worse than no gate at all: it would merge unattended while claiming to
1012/// have asked. Only the exact [`APPROVE`] choice merges, so an answer this
1013/// function does not recognise holds too.
1014pub fn approval(answer: Option<&str>) -> Approval {
1015    match answer {
1016        Some(a) if a.trim().eq_ignore_ascii_case(APPROVE) => Approval::Merge,
1017        Some(a) if a.trim() == REPAIR => Approval::Repair,
1018        _ => Approval::Hold,
1019    }
1020}
1021
1022/// What [`approval_gate`] found on one check of the owner's merge decision.
1023#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1024enum ApprovalGate {
1025    /// The owner said [`APPROVE`]. Merge.
1026    Approved,
1027    /// The owner explicitly requested repair, without authorizing a merge.
1028    Repair,
1029    /// The owner said anything else, the question timed out, or it was
1030    /// closed with no decision recorded.
1031    Held,
1032    /// Filed and still waiting - the caller parks rather than blocking on it.
1033    Pending,
1034}
1035
1036/// Escape text for HTML, including both quote characters.
1037///
1038/// Every string in the panel is agent-influenced: a branch name, a file path, a
1039/// commit subject, a review comment. The sandboxed frame stops such text from
1040/// *running*, but it does not stop a `<` from ending the document early or a
1041/// `"` from ending an attribute and inventing a new one - the panel would then
1042/// render a lie, or not render at all. Both quotes are escaped because the same
1043/// function is used inside attributes, where remembering which quote style the
1044/// caller used is one mistake away from an injected attribute.
1045fn esc(s: &str) -> String {
1046    let mut out = String::with_capacity(s.len());
1047    for c in s.chars() {
1048        match c {
1049            '&' => out.push_str("&amp;"),
1050            '<' => out.push_str("&lt;"),
1051            '>' => out.push_str("&gt;"),
1052            '"' => out.push_str("&quot;"),
1053            '\'' => out.push_str("&#39;"),
1054            _ => out.push(c),
1055        }
1056    }
1057    out
1058}
1059
1060/// One row of the diffstat table.
1061#[derive(Debug, Clone, PartialEq, Eq)]
1062struct StatRow {
1063    path: String,
1064    /// `None` for a binary file, which `git` reports as `-`.
1065    added: Option<u64>,
1066    removed: Option<u64>,
1067}
1068
1069impl StatRow {
1070    /// Lines touched, for sorting. A binary file counts as zero rather than as
1071    /// unknown, which puts it at the bottom where it needs no attention.
1072    fn churn(&self) -> u64 {
1073        self.added.unwrap_or(0) + self.removed.unwrap_or(0)
1074    }
1075}
1076
1077/// Parse `git diff --numstat` into rows, biggest churn first.
1078///
1079/// `--numstat` and not `--stat`: the `+++---` bar in `--stat` is *scaled* to the
1080/// terminal width, so counting its characters would print fabricated numbers in
1081/// the one table an operator approves an irreversible action from.
1082fn parse_numstat(numstat: &str) -> Vec<StatRow> {
1083    let mut rows: Vec<StatRow> = numstat
1084        .lines()
1085        .filter_map(|line| {
1086            let mut parts = line.splitn(3, '\t');
1087            let added = parts.next()?.trim();
1088            let removed = parts.next()?.trim();
1089            let path = parts.next()?.trim();
1090            if path.is_empty() {
1091                return None;
1092            }
1093            Some(StatRow {
1094                path: path.to_owned(),
1095                added: added.parse().ok(),
1096                removed: removed.parse().ok(),
1097            })
1098        })
1099        .collect();
1100    // Path breaks the tie so the same change always renders the same table; an
1101    // operator comparing two panels should not see rows shuffle.
1102    rows.sort_by(|a, b| b.churn().cmp(&a.churn()).then_with(|| a.path.cmp(&b.path)));
1103    rows
1104}
1105
1106/// How one diff line is shown: a gutter character, a style, and the body to
1107/// print - which is the line minus its marker, so the marker appears exactly
1108/// once, in the gutter.
1109///
1110/// The gutter is why this exists at all. The operator may be colour blind, or
1111/// reading in sunlight with the screen dimmed, so an added line is never
1112/// distinguished by its background alone: `+` and `-` sit in a fixed column,
1113/// the same mark they already read in a terminal.
1114fn diff_row(line: &str) -> (&'static str, &'static str, &str) {
1115    if line.starts_with("+++") || line.starts_with("---") {
1116        (" ", "color:#57606a;font-weight:600", line)
1117    } else if let Some(body) = line.strip_prefix('+') {
1118        ("+", "background:#e6ffec;color:#0a3622", body)
1119    } else if let Some(body) = line.strip_prefix('-') {
1120        ("-", "background:#ffebe9;color:#5c1a17", body)
1121    } else if line.starts_with("@@") {
1122        ("~", "background:#eef2ff;color:#3730a3", line)
1123    } else if let Some(body) = line.strip_prefix(' ') {
1124        (" ", "", body)
1125    } else {
1126        (" ", "color:#57606a;font-weight:600", line)
1127    }
1128}
1129
1130/// The handful of words the approval panel says in its own voice.
1131///
1132/// magi's own text, not an agent's, so `[graph] language` has to reach it too:
1133/// the operator asked why the merge question spoke English on a repository
1134/// configured for Japanese, and "because that string is a literal in Rust" is
1135/// not an answer. Only the languages magi can actually check are translated;
1136/// anything else falls back to English rather than shipping a guess, and that
1137/// fallback is deliberate.
1138struct Words {
1139    html_lang: &'static str,
1140    task: &'static str,
1141    what_changed: &'static str,
1142    review_verdict: &'static str,
1143    reviewer: &'static str,
1144    reviewer_no_answer: &'static str,
1145    checks: &'static str,
1146    nothing_failing: &'static str,
1147    files_changed: &'static str,
1148    commits: &'static str,
1149    no_commits: &'static str,
1150    comments: &'static str,
1151    no_comments: &'static str,
1152    diff: &'static str,
1153    truncated: &'static str,
1154    lands_as: &'static str,
1155}
1156
1157const EN: Words = Words {
1158    html_lang: "en",
1159    task: "Task",
1160    what_changed: "What changed",
1161    review_verdict: "Review verdict",
1162    reviewer: "Reviewer",
1163    reviewer_no_answer: "produced no answer",
1164    checks: "Checks",
1165    nothing_failing: "Nothing failing.",
1166    files_changed: "file(s) changed",
1167    commits: "Commits being squashed",
1168    no_commits: "No commit subjects could be read from the branch.",
1169    comments: "External PR review comments",
1170    no_comments: "No unaddressed external PR comments at this observation. This does not mean internal findings are resolved.",
1171    diff: "Diff",
1172    truncated: "Truncated",
1173    lands_as: "They land as one commit titled",
1174};
1175
1176const JA: Words = Words {
1177    html_lang: "ja",
1178    task: "タスク",
1179    what_changed: "変更内容",
1180    review_verdict: "レビューの結論",
1181    reviewer: "レビュアー",
1182    reviewer_no_answer: "回答なし",
1183    checks: "チェック",
1184    nothing_failing: "失敗しているものはありません。",
1185    files_changed: "ファイル変更",
1186    commits: "squash されるコミット",
1187    no_commits: "ブランチからコミット件名を読めませんでした。",
1188    comments: "外部 PR レビューコメント",
1189    no_comments: "この時点で未対応の外部 PR コメントはありません。内部指摘の解決を意味するものではありません。",
1190    diff: "差分",
1191    truncated: "省略",
1192    lands_as: "これらは次の件名の1コミットとして入ります:",
1193};
1194
1195impl Words {
1196    /// The clause after the merge subject. Split out because word order moves:
1197    /// Japanese puts the subject before the verb, so a shared template with a
1198    /// hole in the middle would read as machine translation.
1199    fn lands_as_tail(&self) -> &'static str {
1200        if self.html_lang == "ja" {
1201            "。この件名も承認の対象です。"
1202        } else {
1203            ", which you are approving too."
1204        }
1205    }
1206
1207    /// The question's own one-line summary, which is what a phone shows first.
1208    fn approval_summary(&self, number: u64, subject: &str) -> String {
1209        if self.html_lang == "ja" {
1210            format!("プルリクエスト #{number} をマージ: {subject}")
1211        } else {
1212            format!("merge pull request #{number}: {subject}")
1213        }
1214    }
1215
1216    /// The body under the summary, above the panel.
1217    fn approval_detail(
1218        &self,
1219        url: &str,
1220        base: &str,
1221        subject: &str,
1222        contested: Option<&ContestedHandoff>,
1223    ) -> String {
1224        let body = if self.html_lang == "ja" {
1225            format!(
1226                "{url} はチェックが緑で、`{base}` へ `{subject}` として squash \
1227                 できる状態です。差分の要約・パッチ・squash されるコミットは\
1228                 下のパネルにあります。"
1229            )
1230        } else {
1231            format!(
1232                "{url} is green and ready to squash into `{base}` as `{subject}`. \
1233                 The panel holds the diffstat, the patch and the commits being squashed."
1234            )
1235        };
1236        match contested {
1237            Some(c) => format!("{}\n\n{body}", self.contested_reason(url, c)),
1238            None => body,
1239        }
1240    }
1241
1242    /// Why this question exists although merge approvals are off: the open
1243    /// blocking findings and who rejected. Short enough for a phone.
1244    fn contested_reason(&self, url: &str, c: &ContestedHandoff) -> String {
1245        const SHOWN: usize = 5;
1246        const TITLE_CHARS: usize = 100;
1247        let ja = self.html_lang == "ja";
1248        let mut out = if ja {
1249            format!(
1250                "{url} は、マージ承認がオフでも保留しています。レビューが予算切れで終わった\
1251                 時点で、却下票を伴う重大な未解決の指摘が残っているためです。\n"
1252            )
1253        } else {
1254            format!(
1255                "{url} is held for approval although merge approvals are off: the \
1256                 review ended with blocking findings still open and a reviewer \
1257                 voting reject.\n"
1258            )
1259        };
1260        for f in c.findings.iter().take(SHOWN) {
1261            let at = match (&f.file, f.line) {
1262                (Some(file), Some(line)) => format!("{file}:{line}"),
1263                (Some(file), None) => file.clone(),
1264                _ => (if ja { "場所未指定" } else { "no location" }).to_owned(),
1265            };
1266            let title: String = f.title.chars().take(TITLE_CHARS).collect();
1267            let _ = writeln!(out, "- {} {} {at}: {title}", f.id, f.severity);
1268        }
1269        if c.findings.len() > SHOWN {
1270            let more = c.findings.len() - SHOWN;
1271            let _ = writeln!(
1272                out,
1273                "{}",
1274                if ja {
1275                    format!("- ほか {more} 件")
1276                } else {
1277                    format!("- and {more} more")
1278                }
1279            );
1280        }
1281        let seats: Vec<String> = c
1282            .rejecters
1283            .iter()
1284            .map(|(seat, agent)| format!("#{seat} ({agent})"))
1285            .collect();
1286        let _ = write!(
1287            out,
1288            "{} {}",
1289            if ja {
1290                "却下したレビュアー:"
1291            } else {
1292                "Rejected by reviewer:"
1293            },
1294            seats.join(", ")
1295        );
1296        out
1297    }
1298
1299    /// The truncation note, written whole in each language for the same reason.
1300    fn truncated_note(
1301        &self,
1302        omitted: usize,
1303        total: usize,
1304        shown: usize,
1305        where_: &str,
1306        base: &str,
1307        head: &str,
1308    ) -> String {
1309        if self.html_lang == "ja" {
1310            format!(
1311                "先頭 {shown} 行のあと、差分 {total} 行のうち {omitted} 行を省略しました。\
1312                 全体は <code>{where_}</code>(<code>git diff {base}...{head}</code>)と\
1313                 プルリクエストにあります。"
1314            )
1315        } else {
1316            format!(
1317                "{omitted} of {total} diff lines omitted after the first {shown}. \
1318                 The whole patch is in <code>{where_}</code> \
1319                 (<code>git diff {base}...{head}</code>) and on the pull request."
1320            )
1321        }
1322    }
1323}
1324
1325/// Pick the panel's language. Codes and names both, because `[graph] language`
1326/// has always accepted either.
1327fn words(language: &str) -> &'static Words {
1328    if crate::lang::is_japanese(language) {
1329        &JA
1330    } else {
1331        &EN
1332    }
1333}
1334
1335/// The approval panel's html: what is about to land, and the evidence for it.
1336///
1337/// Pure, so the whole document is asserted in tests without `gh`, without a
1338/// network and without a repository. The caller gathers `diffstat`
1339/// (`git diff --numstat`), `diff` (the unified patch), `commits` (the subjects
1340/// being squashed) and `subject` (what the squash will be called) from the
1341/// winner's worktree.
1342///
1343/// It emits no `<script>`, no `<form>` and no remote url, because the frame's
1344/// content security policy blocks all three: anything of the sort here would be
1345/// dead markup that misleads the next reader into thinking it works.
1346pub fn approval_panel(
1347    state: &RunState,
1348    pr: &PrState,
1349    diffstat: &str,
1350    diff: &str,
1351    commits: &[String],
1352    subject: &str,
1353) -> String {
1354    let rows = parse_numstat(diffstat);
1355    let w = words(&state.config.graph.language);
1356    let mut h = String::with_capacity(4_096 + diff.len().min(200_000));
1357
1358    let _ = writeln!(
1359        h,
1360        "<!doctype html>\n<html lang=\"{}\">\n<head>\n<meta charset=\"utf-8\">\n\
1361         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
1362        w.html_lang
1363    );
1364    let _ = writeln!(
1365        h,
1366        "<title>merge #{} — {}</title>\n</head>",
1367        pr.number,
1368        esc(subject)
1369    );
1370    h.push_str(
1371        "<body style=\"margin:0;padding:12px;font:15px/1.5 -apple-system,\
1372         'Segoe UI',system-ui,sans-serif;color:#1f2328;background:#fff;\
1373         word-break:break-word\">\n",
1374    );
1375
1376    // The decision, in the words the operator is approving.
1377    let _ = writeln!(
1378        h,
1379        "<h1 style=\"margin:0 0 4px;font-size:19px\">Merge #{} into \
1380         <code style=\"background:#f6f8fa;padding:1px 4px;border-radius:4px\">{}</code></h1>\n\
1381         <p style=\"margin:0 0 4px;font-size:17px;font-weight:600\">{}</p>\n\
1382         <p style=\"margin:0 0 12px;font-size:13px;color:#57606a\">squash merge · run {} · \
1383         <a href=\"{}\" target=\"_blank\" rel=\"noopener noreferrer\" style=\"color:#0969da\">{}</a></p>",
1384        pr.number,
1385        esc(&state.base_branch),
1386        esc(subject),
1387        esc(&state.id),
1388        esc(&pr.url),
1389        esc(&pr.url),
1390    );
1391
1392    let _ = writeln!(
1393        h,
1394        "<section style=\"padding:12px;background:#fff8c5;border:1px solid #9a6700;border-radius:6px;white-space:pre-wrap\">{}</section>",
1395        esc(&approval_evidence(state))
1396    );
1397
1398    // The task, verbatim: the operator's own words for what was asked, so the
1399    // panel does not make them reconstruct the request from a diffstat.
1400    let _ = writeln!(
1401        h,
1402        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>\n\
1403         <p style=\"margin:0;font-size:13px;white-space:pre-wrap\">{}</p>",
1404        w.task,
1405        esc(&state.instruction)
1406    );
1407
1408    // The winner's own account of what it did and why, when there is one.
1409    if let Some(summary) = state
1410        .winner()
1411        .map(|c| c.summary.as_str())
1412        .filter(|s| !s.is_empty())
1413    {
1414        let _ = writeln!(
1415            h,
1416            "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>\n\
1417             <p style=\"margin:0;font-size:13px;white-space:pre-wrap\">{}</p>",
1418            w.what_changed,
1419            esc(summary)
1420        );
1421    }
1422
1423    // Only the last round's reviewer prose is current. Its votes and
1424    // remaining findings are shown explicitly in the evidence above.
1425    if let Some(round) = state.reviews.last() {
1426        let _ = writeln!(
1427            h,
1428            "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>",
1429            w.review_verdict
1430        );
1431        for r in &round.reviews {
1432            // A seat the review loop counted as answered has real prose in
1433            // `summary`; one it counted against `incomplete` (see
1434            // `graph::Runner::review_loop`) never produced any and left it
1435            // empty - which must not be read back as a blank verdict, since
1436            // an empty box here looks like "nothing to say" rather than
1437            // "never answered".
1438            let body = match &r.failed {
1439                Some(reason) => format!("{}: {}", w.reviewer_no_answer, esc(reason)),
1440                None => esc(&r.summary),
1441            };
1442            let _ = writeln!(
1443                h,
1444                "<div style=\"margin:0 0 8px;padding:8px;background:#f6f8fa;\
1445                 border-radius:6px\">\
1446                 <div style=\"font-size:12px;color:#57606a\">{} {} · {}</div>\
1447                 <div style=\"white-space:pre-wrap;font-size:13px\">{}</div></div>",
1448                w.reviewer,
1449                r.reviewer,
1450                esc(&r.agent),
1451                body,
1452            );
1453        }
1454    }
1455
1456    let _ = writeln!(
1457        h,
1458        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}: {}</h2>",
1459        w.checks,
1460        esc(pr.checks.as_str())
1461    );
1462    if pr.failing.is_empty() {
1463        let _ = writeln!(
1464            h,
1465            "<p style=\"margin:0;font-size:13px;color:#57606a\">{}</p>",
1466            w.nothing_failing
1467        );
1468    } else {
1469        h.push_str("<ul style=\"margin:0;padding-left:20px;font-size:13px\">\n");
1470        for f in &pr.failing {
1471            let _ = writeln!(h, "<li>{}</li>", esc(f));
1472        }
1473        h.push_str("</ul>\n");
1474    }
1475
1476    // Diffstat as a real table, so a phone reads what moved without scrolling
1477    // sideways through a terminal bar chart.
1478    let _ = writeln!(
1479        h,
1480        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{} {}</h2>",
1481        rows.len(),
1482        w.files_changed
1483    );
1484    h.push_str(
1485        "<table style=\"width:100%;border-collapse:collapse;font-size:13px\">\n\
1486         <thead><tr>\
1487         <th style=\"text-align:left;border-bottom:1px solid #d0d7de;padding:4px 2px\">file</th>\
1488         <th style=\"text-align:right;border-bottom:1px solid #d0d7de;padding:4px 2px\">added</th>\
1489         <th style=\"text-align:right;border-bottom:1px solid #d0d7de;padding:4px 2px\">removed\
1490         </th></tr></thead>\n<tbody>\n",
1491    );
1492    let mut total_added = 0u64;
1493    let mut total_removed = 0u64;
1494    for r in &rows {
1495        total_added += r.added.unwrap_or(0);
1496        total_removed += r.removed.unwrap_or(0);
1497        let cell = |n: Option<u64>| match n {
1498            Some(n) => n.to_string(),
1499            None => "bin".to_owned(),
1500        };
1501        let _ = writeln!(
1502            h,
1503            "<tr>\
1504             <td style=\"padding:4px 2px;border-bottom:1px solid #eaeef2;\
1505             font-family:ui-monospace,monospace\">{}</td>\
1506             <td style=\"padding:4px 2px;border-bottom:1px solid #eaeef2;text-align:right;\
1507             color:#0a3622\">{}</td>\
1508             <td style=\"padding:4px 2px;border-bottom:1px solid #eaeef2;text-align:right;\
1509             color:#5c1a17\">{}</td></tr>",
1510            esc(&r.path),
1511            cell(r.added),
1512            cell(r.removed),
1513        );
1514    }
1515    let _ = writeln!(
1516        h,
1517        "</tbody>\n<tfoot><tr style=\"font-weight:600\">\
1518         <td style=\"padding:4px 2px\">total</td>\
1519         <td style=\"padding:4px 2px;text-align:right\">{total_added}</td>\
1520         <td style=\"padding:4px 2px;text-align:right\">{total_removed}</td>\
1521         </tr></tfoot>\n</table>"
1522    );
1523
1524    // The commits being squashed, and the subject that replaces them.
1525    let _ = writeln!(
1526        h,
1527        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>",
1528        w.commits
1529    );
1530    if commits.is_empty() {
1531        h.push_str(&format!(
1532            "<p style=\"margin:0;font-size:13px;color:#57606a\">{}</p>\n",
1533            w.no_commits
1534        ));
1535    } else {
1536        h.push_str("<ol style=\"margin:0;padding-left:20px;font-size:13px\">\n");
1537        for c in commits {
1538            let _ = writeln!(h, "<li>{}</li>", esc(c));
1539        }
1540        h.push_str("</ol>\n");
1541    }
1542    let _ = writeln!(
1543        h,
1544        "<p style=\"margin:8px 0 0;font-size:13px\">{} <strong>{}</strong>{}</p>",
1545        w.lands_as,
1546        esc(subject),
1547        w.lands_as_tail()
1548    );
1549
1550    // The review comments that shaped this branch, and who asked for them.
1551    let _ = writeln!(
1552        h,
1553        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>",
1554        w.comments
1555    );
1556    if pr.review_comments.is_empty() {
1557        h.push_str(&format!(
1558            "<p style=\"margin:0;font-size:13px;color:#57606a\">{}</p>\n",
1559            w.no_comments
1560        ));
1561    } else {
1562        for c in &pr.review_comments {
1563            let anchor = match (&c.path, c.line) {
1564                (Some(p), Some(l)) => format!("{p}:{l}"),
1565                (Some(p), None) => p.clone(),
1566                _ => "pull request thread".to_owned(),
1567            };
1568            let _ = writeln!(
1569                h,
1570                "<div style=\"margin:0 0 8px;padding:8px;background:#f6f8fa;border-radius:6px\">\
1571                 <div style=\"font-size:12px;color:#57606a\">{} · {}</div>\
1572                 <div style=\"white-space:pre-wrap;font-size:13px\">{}</div></div>",
1573                esc(&c.author),
1574                esc(&anchor),
1575                esc(&tail(&c.body, 800)),
1576            );
1577        }
1578    }
1579
1580    // The patch itself.
1581    let total = diff.lines().count();
1582    let shown = total.min(DIFF_MAX_LINES);
1583    let _ = writeln!(
1584        h,
1585        "<h2 style=\"margin:16px 0 6px;font-size:15px\">{}</h2>",
1586        w.diff
1587    );
1588    h.push_str(
1589        "<div style=\"font:12px/1.45 ui-monospace,SFMono-Regular,Menlo,monospace;\
1590         border:1px solid #d0d7de;border-radius:6px;overflow-x:auto\">\n",
1591    );
1592    for line in diff.lines().take(shown) {
1593        let (gutter, style, body) = diff_row(line);
1594        let _ = writeln!(
1595            h,
1596            "<div style=\"display:flex;{style}\">\
1597             <span style=\"flex:0 0 1.4em;text-align:center;user-select:none;\
1598             border-right:1px solid #d0d7de\">{gutter}</span>\
1599             <span style=\"white-space:pre;padding-left:6px\">{}</span></div>",
1600            esc(body),
1601        );
1602    }
1603    h.push_str("</div>\n");
1604    if total > shown {
1605        let omitted = total - shown;
1606        let head = state.winner().map_or("HEAD", |w| w.branch.as_str());
1607        let where_ = state.winner().map_or_else(
1608            || state.repo.display().to_string(),
1609            |w| w.worktree.display().to_string(),
1610        );
1611        let _ = writeln!(
1612            h,
1613            "<p style=\"margin:8px 0 0;padding:8px;background:#fff8c5;border-radius:6px;\
1614             font-size:13px\">{}: {}</p>",
1615            w.truncated,
1616            w.truncated_note(
1617                omitted,
1618                total,
1619                shown,
1620                &esc(&where_),
1621                &esc(&state.base_branch),
1622                &esc(head),
1623            ),
1624        );
1625    }
1626
1627    h.push_str("</body>\n</html>\n");
1628    h
1629}
1630
1631/// Historical contested hand-off evidence for the question detail. Approval
1632/// itself is decided by `approval_reasons`, including reject-only cases.
1633fn contested_to_ask(state: &RunState) -> Option<ContestedHandoff> {
1634    if state.owner_hold(crate::config::OwnerHold::HoldContestedMerge) {
1635        state.contested_handoff.clone()
1636    } else {
1637        None
1638    }
1639}
1640
1641/// What a merge-approval question's deputy is told: the pull request, the run,
1642/// what each answer does, and the evidence saved when the question was filed.
1643///
1644/// Rebuilt for every deputy turn, it is still a snapshot of that moment, so it
1645/// says so and points at `magi show` / `gh pr view` for anything current.
1646/// `state` is `None` for a run that cannot be read; what is missing is named as
1647/// missing, and no past approval basis is rebuilt from today's state.
1648pub fn deputy_brief(q: &ask::Question, state: Option<&RunState>) -> String {
1649    let mut s = format!(
1650        "This is the merge approval for run {run} (`magi show {run}`). The question's \
1651         own text above names the pull request. Answering `{APPROVE}` squash-merges \
1652         it into the base branch; `{HOLD}` leaves the pull request open. Silence is a \
1653         hold: the owner not answering never merges. When the owner tells you to \
1654         merge, in whatever words, settle `{APPROVE}`; when they ask for what another \
1655         offered choice does, settle that one. If you cannot tell what they want, ask \
1656         with `magi ask --thread`.\n\n\
1657         This brief is a snapshot from when your turn started: check `magi show {run}` \
1658         and `gh pr view` (read-only) before telling the owner anything current. The \
1659         driver carries out the merge, repair, withdrawal or replacement: do not \
1660         change files, branches or the pull request yourself.",
1661        run = q.run
1662    );
1663    if let Some(target) = &q.merge_target {
1664        s.push_str(&format!("\n\nThis decision names PR {} at head `{}`. A settled `{APPROVE}` merges exactly that head; a newer head is never merged on this answer. Withdrawal explicitly closes the PR and ends the task. Replacement closes the old PR before dispatching a new attempt with the selected implementer; do not start a separate task for it yourself.", target.pr, target.head));
1665    }
1666    if q.choices.iter().any(|c| c == REPAIR) {
1667        s.push_str("\n\n`fix findings and re-review` requests one repair and bounded re-review on the existing PR. It never approves a merge. The driver performs the repair; do not edit or queue another task for it. Updated review and gate results require a fresh merge decision.");
1668    }
1669    if q.detail.contains("Approval required because:") || q.detail.contains("承認が必要な理由:")
1670    {
1671        s.push_str("\n\nSaved approval evidence (at question creation):\n");
1672        s.push_str(&q.detail);
1673    } else {
1674        s.push_str("\n\nApproval reasons and final review evidence were not recorded in this legacy question. Do not infer its original trigger from current settings; consult the saved panel and review history.");
1675    }
1676    let Some(state) = state else {
1677        s.push_str(
1678            "\n\nThe run's record could not be read, so the pull request, the panel \
1679             summary and any contested findings are not known to you beyond the \
1680             question's own text. Say so to the owner rather than guessing.",
1681        );
1682        return s;
1683    };
1684    if let Some(pr) = &state.pr {
1685        s.push_str(&format!(
1686            "\n\nPull request #{} {} (recorded state: {}, last seen).",
1687            pr.number, pr.url, pr.state
1688        ));
1689    }
1690    s.push_str(&format!("\nBase branch: `{}`.", state.base_branch));
1691    if let Some(w) = state.winner() {
1692        s.push_str(&format!("\nWinning branch: `{}`.", w.branch));
1693    }
1694
1695    s
1696}
1697
1698// Releasing a task permits work to resume; it does not renew merge consent.
1699// Check the persisted operator decision both when reusing a card and at the
1700// final merge boundary, since a hold/release can arrive between those reads.
1701fn merge_consent_superseded(state: &RunState, question: &ask::Question) -> Result<bool> {
1702    if !question.status.open() && approval(question.resolution().as_deref()) != Approval::Merge {
1703        return Ok(false);
1704    }
1705    let Some(task_id) = state
1706        .origin
1707        .as_ref()
1708        .and_then(|origin| origin.task.as_ref())
1709    else {
1710        return Ok(false);
1711    };
1712    let task = crate::queue::Queue::open()
1713        .get(task_id)
1714        .context("cannot verify operator decisions for the merge approval")?;
1715    Ok(task
1716        .operator_decided_at
1717        .is_some_and(|at| at > question.answered_at.unwrap_or(question.asked_at)))
1718}
1719
1720/// Ask the owner before merging, with the whole case attached as a panel.
1721///
1722/// The evidence is gathered from the winner's own worktree with the `git` CLI,
1723/// never from the network, so a phone on a slow link gets the diff magi is
1724/// looking at rather than a link it has to go and open.
1725///
1726/// Never blocks. `land` used to sit inside [`ask::ask_and_wait`]'s poll loop
1727/// for up to a day right here, which held the whole run's task claim - and
1728/// the daemon's one slot with it - for exactly as long as the owner took to
1729/// notice their phone. [`ApprovalGate::Pending`] is the answer that lets the
1730/// caller park the run and hand the slot back instead: the question is on
1731/// disk either way, so nothing about the wait itself changes, only who is
1732/// blocked on it.
1733///
1734/// Idempotent across resumes: called again for a run already waiting on its
1735/// own question, this finds that question by [`crate::ask::Questions::list`]
1736/// rather than filing a second one - asking twice would double the
1737/// notification for one decision, and leave the first question's panel an
1738/// orphan nobody's answer ever reaches.
1739async fn approval_gate(
1740    state: &mut RunState,
1741    pr: &PrState,
1742    subject: &str,
1743    contested: Option<&ContestedHandoff>,
1744    head: &str,
1745) -> Result<ApprovalGate> {
1746    let _chat_merge = crate::chat_merge::target_lock_wait(&crate::run::home(), &pr.url).await?;
1747    let store = ask::Questions::open();
1748    // An answer belongs to the commit its panel showed. A question recorded
1749    // for another head - or none recorded at all, as for a question filed
1750    // before heads were tracked - is never reused: a fix or rebase push made
1751    // a commit the owner has not seen, and their word does not carry over.
1752    let reusable = state.land_approval.as_ref().and_then(|a| {
1753        store
1754            .list_for_effects()
1755            .into_iter()
1756            .find(|q| q.id == a.question)
1757            .filter(|q| {
1758                q.status != ask::QuestionStatus::Abandoned
1759                    && state
1760                        .repair_grants
1761                        .last()
1762                        .is_none_or(|g| q.asked_at > g.receipt.at)
1763                    && (a.head.eq_ignore_ascii_case(head)
1764                        || q.resolution()
1765                            .as_deref()
1766                            .is_some_and(crate::merge_decision::stops))
1767            })
1768    });
1769    let reusable = match reusable {
1770        Some(q) if merge_consent_superseded(state, &q)? => None,
1771        other => other,
1772    };
1773    if reusable.is_none() {
1774        for stale in store.list_for_effects().into_iter().filter(|q| {
1775            q.run == state.id
1776                && q.node == APPROVAL_NODE
1777                && q.status.open()
1778                && !store.held_reply(&q.id)
1779        }) {
1780            let why =
1781                "the pull request head or operator decision changed; asked again for approval";
1782            if let Err(e) = store.update(&stale.id, |q| {
1783                q.abandon(why);
1784                Ok(())
1785            }) {
1786                tracing::warn!("could not retire the superseded approval question: {e:#}");
1787            }
1788        }
1789    }
1790
1791    let q = match reusable {
1792        Some(mut q) => {
1793            if upgrade_repair_choice(&mut q, state) {
1794                q = store
1795                    .update(&q.id, |current| {
1796                        upgrade_repair_choice(current, state);
1797                        Ok(())
1798                    })?
1799                    .0;
1800            }
1801            q
1802        }
1803        None => {
1804            let worktree = match state.winner() {
1805                Some(w) => w.worktree.clone(),
1806                None => state.repo.clone(),
1807            };
1808            // The diff is built from the commit being approved, not from the
1809            // branch name, which may already point somewhere else.
1810            let head = if head.is_empty() {
1811                state
1812                    .winner()
1813                    .map_or_else(|| "HEAD".to_owned(), |w| w.branch.clone())
1814            } else {
1815                head.to_owned()
1816            };
1817            // The diff is against what the remote's base holds, never the
1818            // local branch of that name; unreadable means less evidence.
1819            let remote = &state.config.merge.remote;
1820            let tracking = format!("{remote}/{}", state.base_branch);
1821            let base = if git::rev_exists(&worktree, &tracking).await {
1822                tracking
1823            } else {
1824                String::new()
1825            };
1826            let range = format!("{base}...{head}");
1827            // A failed `git` must not decide the merge: the panel degrades to
1828            // less evidence and the owner still chooses. Merging because the
1829            // diff could not be read would be the worst of both.
1830            let numstat = if base.is_empty() {
1831                String::new()
1832            } else {
1833                git::git_raw(&worktree, &["diff", "--numstat", "-M", &range])
1834                    .await
1835                    .map(|o| o.stdout)
1836                    .unwrap_or_default()
1837            };
1838            let diff = if base.is_empty() {
1839                String::new()
1840            } else {
1841                git::diff(&worktree, &base, &head).await.unwrap_or_default()
1842            };
1843            let commits: Vec<String> = if base.is_empty() {
1844                Vec::new()
1845            } else {
1846                git::git_raw(
1847                    &worktree,
1848                    &[
1849                        "log",
1850                        "--reverse",
1851                        "--format=%s",
1852                        &format!("{base}..{head}"),
1853                    ],
1854                )
1855                .await
1856                .map(|o| o.stdout)
1857                .unwrap_or_default()
1858                .lines()
1859                .filter(|l| !l.trim().is_empty())
1860                .map(str::to_owned)
1861                .collect()
1862            };
1863
1864            let w = words(&state.config.graph.language);
1865            let html = approval_panel(state, pr, &numstat, &diff, &commits, subject);
1866            let mut fresh = ask::Question::new(
1867                state.id.clone(),
1868                APPROVAL_NODE.to_owned(),
1869                "land".to_owned(),
1870                w.approval_summary(pr.number, subject),
1871                format!(
1872                    "{}\n\n{}",
1873                    approval_evidence(state),
1874                    w.approval_detail(&pr.url, &state.base_branch, subject, contested)
1875                ),
1876                approval_choices(state),
1877            );
1878            fresh.merge_target = Some(crate::merge_decision::Target {
1879                pr: pr.url.clone(),
1880                head: head.clone(),
1881                language: state.config.graph.language.clone(),
1882            });
1883            if fresh.choices.iter().any(|c| c == REPAIR) {
1884                fresh.actions.insert(
1885                    REPAIR.to_owned(),
1886                    ask::ChoiceAction::Resume {
1887                        run: state.id.clone(),
1888                    },
1889                );
1890                fresh.detail.push_str("\n\n`fix findings and re-review` runs one repair and bounded review on this PR; it does not approve a merge. A fresh decision follows the updated review and gate.");
1891            }
1892            for choice in fresh.choices.clone() {
1893                if crate::merge_decision::stops(&choice)
1894                    && choice != HOLD
1895                    && choice != crate::merge_decision::DISMISS
1896                {
1897                    fresh.actions.insert(
1898                        choice,
1899                        ask::ChoiceAction::Resume {
1900                            run: state.id.clone(),
1901                        },
1902                    );
1903                }
1904            }
1905            store
1906                .put_panel(&mut fresh, &html, &[])
1907                .context("write the merge approval panel")?;
1908            store
1909                .put_executable(&mut fresh)
1910                .context("file the merge approval question")?;
1911            state.land_approval = Some(LandApproval {
1912                question: fresh.id.clone(),
1913                head: head.clone(),
1914            });
1915            state.event(
1916                "land",
1917                format!("asking for merge approval ({})", fresh.short()),
1918            );
1919            state.save()?;
1920            if let Err(e) = ask::notify(&state.config.notify, &fresh).await {
1921                // A broken webhook is not a reason to lose the merge: the
1922                // question is already on disk and the web UI already shows
1923                // it, so the operator still has a way in.
1924                tracing::warn!(
1925                    "could not notify about merge approval question {}: {e:#} - \
1926                     the web UI is the only surface for it now",
1927                    fresh.short()
1928                );
1929            }
1930            fresh
1931        }
1932    };
1933
1934    Ok(match q.status {
1935        ask::QuestionStatus::Open => ApprovalGate::Pending,
1936        // Nobody answered before `state.config.graph.answer_timeout` passed,
1937        // or the question was closed with no decision recorded underneath
1938        // this run - either way there is nothing left to wait on.
1939        ask::QuestionStatus::Abandoned => ApprovalGate::Held,
1940        // The merge gate does not speak `--thread`: an owner who talked back
1941        // instead of choosing never reaches `Answered`, so this arm only
1942        // ever sees an actual decision.
1943        ask::QuestionStatus::Answered => match approval(q.resolution().as_deref()) {
1944            Approval::Merge => ApprovalGate::Approved,
1945            Approval::Repair if !state.reviews.is_empty() => {
1946                if !state.merge_repairs.iter().any(|r| r.question == q.id) {
1947                    state.merge_repairs.push(crate::run::MergeRepair {
1948                        question: q.id.clone(),
1949                        head: head.to_owned(),
1950                        pr: pr.url.clone(),
1951                        reviews: state.reviews.clone(),
1952                        gate: state.gate.clone(),
1953                        gate_head: state.gate_head.clone(),
1954                        gate_fixes: state.gate_fixes.clone(),
1955                        pre_gate: state.pre_gate.clone(),
1956                        phase: crate::run::MergeRepairPhase::Requested,
1957                        failure: None,
1958                    });
1959                    state.land_approval = None;
1960                    state.event(
1961                        "repair",
1962                        "owner requested fix findings and re-review; merge is not approved",
1963                    );
1964                    state.save()?;
1965                }
1966                ApprovalGate::Repair
1967            }
1968            Approval::Repair | Approval::Hold => ApprovalGate::Held,
1969        },
1970    })
1971}
1972
1973/// Fold a rollup's entries into one verdict plus the failing checks' labels.
1974/// No I/O. An empty rollup is `Unknown`, never green.
1975fn rollup_verdict(rollup: &[GhCheck]) -> (Checks, Vec<String>) {
1976    let mut failing = Vec::new();
1977    let mut pending = false;
1978    let mut unknown = false;
1979    for check in rollup {
1980        match check.verdict() {
1981            Verdict::Pass => {}
1982            Verdict::Pending => pending = true,
1983            Verdict::Fail => failing.push(check.label()),
1984            Verdict::Unknown => unknown = true,
1985        }
1986    }
1987    let checks = if rollup.is_empty() {
1988        Checks::Unknown
1989    } else if pending {
1990        Checks::Pending
1991    } else if !failing.is_empty() {
1992        Checks::Red
1993    } else if unknown {
1994        Checks::Unknown
1995    } else {
1996        Checks::Green
1997    };
1998    (checks, failing)
1999}
2000
2001/// Parse `gh pr view --json url,number,state,statusCheckRollup,reviews,comments`
2002/// output into a [`PrState`]. No I/O.
2003pub fn parse_pr(json: &str) -> Result<PrState> {
2004    let raw: GhPr = serde_json::from_str(json).context("parse `gh pr view --json ...` output")?;
2005    let state = match raw.state.to_ascii_uppercase().as_str() {
2006        "OPEN" => PrLifecycle::Open,
2007        "MERGED" => PrLifecycle::Merged,
2008        "CLOSED" => PrLifecycle::Closed,
2009        other => bail!("unknown pull request state `{other}`"),
2010    };
2011
2012    let (checks, failing) = rollup_verdict(&raw.status_check_rollup);
2013
2014    let mut review_comments = Vec::new();
2015    for r in raw.reviews {
2016        push_if_outstanding(
2017            &mut review_comments,
2018            ReviewComment {
2019                author: r.author.login,
2020                path: None,
2021                line: None,
2022                body: r.body,
2023            },
2024        );
2025    }
2026    for c in raw.comments {
2027        push_if_outstanding(
2028            &mut review_comments,
2029            ReviewComment {
2030                author: c.author.login,
2031                path: None,
2032                line: None,
2033                body: c.body,
2034            },
2035        );
2036    }
2037
2038    Ok(PrState {
2039        url: raw.url,
2040        number: raw.number,
2041        state,
2042        checks,
2043        failing,
2044        review_comments,
2045        blocking: Blocking::of(&raw.merge_state_status),
2046    })
2047}
2048
2049/// One rollup entry as the release watcher reads it.
2050#[derive(Debug, Clone, PartialEq, Eq)]
2051pub(crate) struct CheckView {
2052    pub name: String,
2053    pub verdict: Verdict,
2054    /// Workflow run behind the check, when its url names one.
2055    pub run: Option<String>,
2056    pub url: Option<String>,
2057}
2058
2059/// A pull request's lifecycle, head commit and per-check verdicts, without
2060/// [`rollup_verdict`]'s aggregation (a pending check anywhere hides a failure
2061/// from it, which is exactly what the release watcher must not inherit).
2062#[derive(Debug, Clone, PartialEq, Eq)]
2063pub(crate) struct RollupView {
2064    pub url: String,
2065    pub number: u64,
2066    pub state: PrLifecycle,
2067    pub head: String,
2068    pub checks: Vec<CheckView>,
2069}
2070
2071/// Parse `gh pr view --json url,number,state,headRefOid,statusCheckRollup`
2072/// output. No I/O.
2073pub(crate) fn parse_rollup(json: &str) -> Result<RollupView> {
2074    let raw: GhPr = serde_json::from_str(json).context("parse `gh pr view --json ...` output")?;
2075    let state = match raw.state.to_ascii_uppercase().as_str() {
2076        "OPEN" => PrLifecycle::Open,
2077        "MERGED" => PrLifecycle::Merged,
2078        "CLOSED" => PrLifecycle::Closed,
2079        other => bail!("unknown pull request state `{other}`"),
2080    };
2081    let checks = raw
2082        .status_check_rollup
2083        .iter()
2084        .map(|c| CheckView {
2085            name: c.label(),
2086            verdict: c.verdict(),
2087            run: c.url().and_then(run_of),
2088            url: c.url().map(str::to_owned),
2089        })
2090        .collect();
2091    Ok(RollupView {
2092        url: raw.url,
2093        number: raw.number,
2094        state,
2095        head: raw.head_ref_oid,
2096        checks,
2097    })
2098}
2099
2100/// Read just a pull request's lifecycle state - open, merged, or closed -
2101/// with none of the checks/reviews/comments [`land`] itself needs to decide
2102/// what to do next.
2103///
2104/// For a caller that only ever wants one fact and must not risk anything
2105/// else: `magi fold --merged` uses this to confirm a URL the operator hands
2106/// it is actually a merged pull request *before* touching a run's state, so a
2107/// typo or a still-open PR fails loudly instead of quietly recording a merge
2108/// that never happened.
2109pub async fn lifecycle(repo: &Path, pr_url: &str) -> Result<PrLifecycle> {
2110    let view = gh(
2111        repo,
2112        &[
2113            "pr".to_owned(),
2114            "view".to_owned(),
2115            pr_url.to_owned(),
2116            "--json".to_owned(),
2117            "state".to_owned(),
2118        ],
2119    )
2120    .await?;
2121    if !view.0 {
2122        bail!("gh pr view {pr_url}: {}", view.1);
2123    }
2124    // `parse_pr` reads every other field of `GhPr` as its serde default
2125    // (empty string, empty vec, zero) when this narrower `--json` selection
2126    // does not carry them - harmless, since only `.state` is read back.
2127    Ok(parse_pr(&view.1)?.state)
2128}
2129
2130/// A pull request the operator merged outside of `land::land`'s own loop,
2131/// found by asking GitHub about the run's own winning branch rather than
2132/// requiring the operator to go and find the URL themselves.
2133#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
2134pub struct ExternalMerge {
2135    /// The pull request's URL, ready to hand to [`correct_manual_merge`].
2136    pub url: String,
2137    /// The pull request's number.
2138    pub number: u64,
2139}
2140
2141#[derive(Debug, Deserialize)]
2142#[serde(rename_all = "camelCase")]
2143struct GhMergedPr {
2144    url: String,
2145    number: u64,
2146    merged_at: String,
2147    base_ref_name: String,
2148}
2149
2150/// Pure half of [`find_external_merge`]: given the raw `gh pr list --head
2151/// <branch> --state merged --json url,number,mergedAt,baseRefName` output,
2152/// decide whether exactly one of the pull requests it lists could actually
2153/// be *this* run's.
2154///
2155/// A branch name alone does not prove it: [`RunState::branch_for`] derives it
2156/// from the run's own short id, so a collision with some other, unrelated
2157/// task's merged pull request from a same-named branch is rare but not
2158/// impossible once branches are deleted and ids run out. Filtering on
2159/// `base_ref_name` (the branch this run actually targets) and `merged_at`
2160/// (which cannot predate the run itself) rules that case out. More than one
2161/// survivor is exactly as uninformative as zero — something this run cannot
2162/// tell apart from another — so only a unique survivor is returned.
2163fn pick_merged_pr(
2164    json: &str,
2165    base_branch: &str,
2166    created_at: Timestamp,
2167) -> Result<Option<ExternalMerge>> {
2168    let raw: Vec<GhMergedPr> =
2169        serde_json::from_str(json).context("parse `gh pr list ... --json ...` output")?;
2170    let mut matches: Vec<ExternalMerge> = Vec::new();
2171    for pr in raw {
2172        if pr.base_ref_name != base_branch {
2173            continue;
2174        }
2175        let Ok(merged_at) = pr.merged_at.parse::<Timestamp>() else {
2176            continue;
2177        };
2178        if merged_at < created_at {
2179            continue;
2180        }
2181        matches.push(ExternalMerge {
2182            url: pr.url,
2183            number: pr.number,
2184        });
2185    }
2186    if matches.len() == 1 {
2187        Ok(matches.pop())
2188    } else {
2189        Ok(None)
2190    }
2191}
2192
2193/// What `gh pr list --head <branch> --base <base> --state open` found.
2194#[derive(Debug, Clone, PartialEq, Eq)]
2195pub enum OpenPr {
2196    /// Nothing open: the caller creates one.
2197    None,
2198    /// Exactly one: the caller adopts it instead of creating a second.
2199    One {
2200        /// The pull request's URL.
2201        url: String,
2202        /// Its current title.
2203        title: String,
2204    },
2205    /// More than one: magi does not pick between them.
2206    Many(Vec<String>),
2207}
2208
2209#[derive(Debug, Deserialize)]
2210#[serde(rename_all = "camelCase")]
2211struct GhOpenPr {
2212    // `url` and `baseRefName` are required: a record missing either must be a
2213    // parse error, not a pull request that silently fails the base filter and
2214    // reads as "none open" (which would go on to create a duplicate).
2215    url: String,
2216    #[serde(default)]
2217    title: String,
2218    base_ref_name: String,
2219    // A fork's branch of the same name is not the task head; `gh pr list --head`
2220    // matches by branch name alone, so the filter has to be ours.
2221    #[serde(default)]
2222    is_cross_repository: bool,
2223}
2224
2225/// Pure half of [`find_open_pr`]: classify the raw `--json
2226/// number,url,title,baseRefName` output. Entries whose base is not `base` are
2227/// dropped even though the query already filtered on it, so a stub or an old
2228/// `gh` that ignores `--base` cannot get a pull request into the wrong branch
2229/// adopted.
2230pub fn pick_open_pr(json: &str, base: &str) -> Result<OpenPr> {
2231    let raw: Vec<GhOpenPr> =
2232        serde_json::from_str(json).context("parse `gh pr list ... --json ...` output")?;
2233    let mut hits: Vec<GhOpenPr> = raw
2234        .into_iter()
2235        .filter(|p| p.base_ref_name == base && !p.is_cross_repository)
2236        .collect();
2237    Ok(match hits.len() {
2238        0 => OpenPr::None,
2239        1 => {
2240            let p = hits.remove(0);
2241            OpenPr::One {
2242                url: p.url,
2243                title: p.title,
2244            }
2245        }
2246        _ => OpenPr::Many(hits.into_iter().map(|p| p.url).collect()),
2247    })
2248}
2249
2250/// Open pull requests whose head is `branch` and whose base is `base`. A
2251/// failing `gh` is an error carrying its own output, never "none": guessing
2252/// there is how a duplicate gets created.
2253pub async fn find_open_pr(repo: &Path, branch: &str, base: &str) -> Result<OpenPr> {
2254    let (ok, out) = gh(
2255        repo,
2256        &[
2257            "pr".to_owned(),
2258            "list".to_owned(),
2259            "--head".to_owned(),
2260            branch.to_owned(),
2261            "--base".to_owned(),
2262            base.to_owned(),
2263            "--state".to_owned(),
2264            "open".to_owned(),
2265            "--json".to_owned(),
2266            "number,url,title,baseRefName,isCrossRepository".to_owned(),
2267        ],
2268    )
2269    .await?;
2270    if !ok {
2271        bail!("gh pr list failed: {out}");
2272    }
2273    pick_open_pr(&out, base)
2274}
2275
2276#[derive(Debug, Deserialize)]
2277#[serde(rename_all = "camelCase")]
2278struct GhPrHead {
2279    head_ref_name: String,
2280    base_ref_name: String,
2281    state: String,
2282    // Required, like `GhOpenPr`'s fields: a record that cannot say whether the
2283    // head lives in a fork must be a parse error, never "same repository".
2284    is_cross_repository: bool,
2285    // Required too: it is what ties the pull request to the commits that were
2286    // actually proven to be on the base.
2287    head_ref_oid: String,
2288}
2289
2290/// Why [`closable`] said no, and whether asking again later could say yes.
2291#[derive(Debug, Clone, PartialEq, Eq)]
2292pub struct Refusal {
2293    /// A later attempt may succeed (the head moved, the view was unreadable);
2294    /// `false` means this pull request is simply not the run's to close.
2295    pub retry: bool,
2296    /// What was wrong.
2297    pub why: String,
2298}
2299
2300impl Refusal {
2301    fn final_(why: String) -> Self {
2302        Self { retry: false, why }
2303    }
2304}
2305
2306/// Pure half of [`close_superseded_pr`]: read `gh pr view --json
2307/// headRefName,baseRefName,state,isCrossRepository` and say whether closing
2308/// is safe, `Err` carrying the reason when it is not.
2309///
2310/// Closing is outward-facing, so every property is checked on what the forge
2311/// says now, not on what magi recorded: the head must be exactly `branch` in
2312/// this repository (a fork's branch of the same name is somebody else's), the
2313/// base must be `base`, and the pull request must still be open.
2314pub fn closable(
2315    json: &str,
2316    branch: &str,
2317    base: &str,
2318    verified: &[String],
2319) -> std::result::Result<(), Refusal> {
2320    let pr: GhPrHead = serde_json::from_str(json).map_err(|e| Refusal {
2321        retry: true,
2322        why: format!("could not read the pull request ({e})"),
2323    })?;
2324    if pr.head_ref_name != branch {
2325        return Err(Refusal::final_(format!(
2326            "its head is `{}`, not this run's `{branch}`",
2327            pr.head_ref_name
2328        )));
2329    }
2330    if pr.is_cross_repository {
2331        return Err(Refusal::final_("its head lives in a fork".to_owned()));
2332    }
2333    if pr.base_ref_name != base {
2334        return Err(Refusal::final_(format!(
2335            "it targets `{}`, not `{base}`",
2336            pr.base_ref_name
2337        )));
2338    }
2339    if !pr.state.eq_ignore_ascii_case("open") {
2340        return Err(Refusal::final_(format!(
2341            "it is already {}",
2342            pr.state.to_ascii_lowercase()
2343        )));
2344    }
2345    // Last, so a pull request that is not this run's at all is reported as
2346    // such. A head that is this branch but not a commit checked against the
2347    // base (somebody pushed since) may well get checked next time: retry.
2348    if !verified.contains(&pr.head_ref_oid) {
2349        return Err(Refusal {
2350            retry: true,
2351            why: format!(
2352                "its head {} is not a commit this run checked against the base",
2353                crate::already::short_sha(&pr.head_ref_oid)
2354            ),
2355        });
2356    }
2357    Ok(())
2358}
2359
2360/// Does `remote` point at something a forge could host - a URL or an scp-style
2361/// `user@host:path` - rather than a filesystem path or nothing at all? Judged
2362/// from the URL alone, so it answers the same on every machine, whatever `gh`
2363/// happens to be installed or logged in to.
2364async fn remote_is_forge(repo: &Path, remote: &str) -> bool {
2365    let Ok(url) = git::git(repo, &["remote", "get-url", remote]).await else {
2366        return false;
2367    };
2368    is_forge_url(url.trim())
2369}
2370
2371fn is_forge_url(url: &str) -> bool {
2372    url.contains("://") && !url.starts_with("file://")
2373        || url
2374            .split_once(':')
2375            .is_some_and(|(host, _)| host.contains('@') && !host.contains(['/', '\\']))
2376}
2377
2378/// Does this `gh` failure mean there is no GitHub to ask, as opposed to a
2379/// request that failed?
2380fn forge_unavailable(message: &str) -> bool {
2381    message.contains("known GitHub host") || message.contains("spawn gh")
2382}
2383
2384/// The comment left on a pull request closed because its change is already on
2385/// the base.
2386pub fn superseded_comment(base: &str, evidence: &crate::already::Evidence) -> String {
2387    let how = match evidence.proof {
2388        crate::already::Proof::PatchId => format!(
2389            "carried by commit {} on `{base}` with the same patch",
2390            evidence.names()
2391        ),
2392        crate::already::Proof::Ancestry => {
2393            format!("already in the history of `{base}` as {}", evidence.names())
2394        }
2395        crate::already::Proof::Tree => format!(
2396            "already part of `{base}` (merging this branch changes nothing at {})",
2397            crate::already::short_sha(&evidence.tip)
2398        ),
2399    };
2400    format!(
2401        "Closing: everything this branch adds is {how}, so there is nothing left to \
2402         land. This pull request was closed automatically after that was verified; \
2403         reopen it if you disagree."
2404    )
2405}
2406
2407/// Close the open pull request for `branch`, if there is one and it is
2408/// provably this run's, with a comment naming what supersedes it. `Ok(Ok(url))` is
2409/// the URL closed; `Ok(Err(why))` is a final "nothing to close" (no pull request,
2410/// not this run's, no forge); `Err` is anything a later attempt could resolve (a
2411/// failed `gh` call, a head that moved since it was checked), which the caller
2412/// must not treat as settled.
2413///
2414/// The recorded `state.pr` is preferred, else the forge is asked for an open
2415/// pull request on `branch`; either way the candidate is re-read and passed
2416/// through [`closable`] before anything is written; `verified` lists the
2417/// commits proven to be on the base, and the pull request's head must be one.
2418pub async fn close_superseded_pr(
2419    state: &mut RunState,
2420    branch: &str,
2421    evidence: &crate::already::Evidence,
2422    verified: &[String],
2423) -> Result<std::result::Result<String, String>> {
2424    let repo = state.repo.clone();
2425    let base = state.base_branch.clone();
2426    let url = match state.pr.as_ref().filter(|p| p.state == "open") {
2427        Some(p) => p.url.clone(),
2428        // No recorded pull request. A forge that cannot be asked at all (no
2429        // GitHub remote, no `gh`) says nothing about this run, so that is
2430        // "none found"; any other lookup failure is an error, because "could
2431        // not look" is not "nothing there" and the caller must retry.
2432        None if !remote_is_forge(&repo, &state.config.merge.remote).await => {
2433            return Ok(Err(
2434                "the remote is not a forge, so there is no pull request".to_owned(),
2435            ));
2436        }
2437        None => match find_open_pr(&repo, branch, &base).await {
2438            Err(e) if forge_unavailable(&format!("{e:#}")) => {
2439                return Ok(Err(format!("no forge to ask: {e:#}")));
2440            }
2441            Err(e) => return Err(e),
2442            Ok(OpenPr::One { url, .. }) => url,
2443            Ok(OpenPr::None) => return Ok(Err("no open pull request".to_owned())),
2444            Ok(OpenPr::Many(urls)) => {
2445                return Ok(Err(format!(
2446                    "{} open pull requests name it; not choosing between them",
2447                    urls.len()
2448                )));
2449            }
2450        },
2451    };
2452    let (ok, view) = gh(
2453        &repo,
2454        &[
2455            "pr".to_owned(),
2456            "view".to_owned(),
2457            url.clone(),
2458            "--json".to_owned(),
2459            "headRefName,headRefOid,baseRefName,state,isCrossRepository".to_owned(),
2460        ],
2461    )
2462    .await?;
2463    if !ok {
2464        bail!("gh pr view {url} failed: {view}");
2465    }
2466    if let Err(refusal) = closable(&view, branch, &base, verified) {
2467        // A pull request whose head cannot be tied to what was proven is not
2468        // one to walk away from: the caller keeps the run resumable.
2469        if refusal.retry {
2470            bail!("left {url} open: {}", refusal.why);
2471        }
2472        return Ok(Err(format!("left {url} open: {}", refusal.why)));
2473    }
2474    let (ok, out) = gh(
2475        &repo,
2476        &[
2477            "pr".to_owned(),
2478            "close".to_owned(),
2479            url.clone(),
2480            "--comment".to_owned(),
2481            superseded_comment(&base, evidence),
2482        ],
2483    )
2484    .await?;
2485    if !ok {
2486        bail!("gh pr close {url} failed: {out}");
2487    }
2488    if let Some(p) = state.pr.as_mut().filter(|p| p.url == url) {
2489        p.state = "closed".to_owned();
2490    }
2491    Ok(Ok(url))
2492}
2493
2494/// `gh pr edit <url> --title <title>`, for an adopted pull request whose title
2495/// differs from the one this run computed. Only the title: the body may have
2496/// been edited by the owner and cannot be compared.
2497pub async fn set_pr_title(state: &mut RunState, repo: &Path, url: &str, title: &str) -> Result<()> {
2498    let (title, _) = crate::github_text::prepare(state, title, "");
2499    edit_pr_title(repo, url, &title).await
2500}
2501
2502/// [`set_pr_title`] for a title the owner explicitly chose to post unmodified
2503/// (`github_text::POST_ORIGINAL` or `github_text::USE_REWRITE`): the posting
2504/// gate is skipped on purpose.
2505pub async fn set_pr_title_verbatim(repo: &Path, url: &str, title: &str) -> Result<()> {
2506    edit_pr_title(repo, url, title).await
2507}
2508
2509/// Post both fields of the owner's chosen rewrite to an adopted pull request,
2510/// unmodified and without the posting gate.
2511pub async fn set_pr_text_verbatim(repo: &Path, url: &str, title: &str, body: &str) -> Result<()> {
2512    let (ok, _) = gh(
2513        repo,
2514        &[
2515            "pr".to_owned(),
2516            "edit".to_owned(),
2517            url.to_owned(),
2518            "--title".to_owned(),
2519            title.to_owned(),
2520            "--body".to_owned(),
2521            body.to_owned(),
2522        ],
2523    )
2524    .await
2525    .map_err(|_| anyhow::anyhow!("could not run gh pr edit for the chosen rewrite"))?;
2526    if !ok {
2527        // Command output may echo the chosen text; keep it out of run events.
2528        bail!("gh pr edit failed while posting the chosen rewrite");
2529    }
2530    Ok(())
2531}
2532
2533async fn edit_pr_title(repo: &Path, url: &str, title: &str) -> Result<()> {
2534    let (ok, out) = gh(
2535        repo,
2536        &[
2537            "pr".to_owned(),
2538            "edit".to_owned(),
2539            url.to_owned(),
2540            "--title".to_owned(),
2541            title.to_owned(),
2542        ],
2543    )
2544    .await?;
2545    if !ok {
2546        bail!("gh pr edit failed: {out}");
2547    }
2548    Ok(())
2549}
2550
2551/// Ask GitHub whether this run's winning candidate branch was actually merged
2552/// somewhere `land::land`'s own loop never saw — the gap `magi fold
2553/// --merged` exists to close, minus the operator having to find the URL by
2554/// hand.
2555///
2556/// `Ok(None)` covers every case where nothing can be said with confidence: no
2557/// winner decided yet (nothing to check a branch for), no merged pull request
2558/// found, or [`pick_merged_pr`] found more than one candidate and would not
2559/// guess between them. Never wired to a weaker, URL-less signal like
2560/// [`branch_is_ancestor`] — a caller wanting that has to ask for it
2561/// separately, precisely because it cannot drive an automatic correction on
2562/// its own (see that function's own doc).
2563pub async fn find_external_merge(state: &RunState) -> Result<Option<ExternalMerge>> {
2564    let Some(winner) = state.winner() else {
2565        return Ok(None);
2566    };
2567    let branch = state.pr_branch().unwrap_or(&winner.branch).to_owned();
2568    let out = gh(
2569        &state.repo,
2570        &[
2571            "pr".to_owned(),
2572            "list".to_owned(),
2573            "--head".to_owned(),
2574            branch.clone(),
2575            "--state".to_owned(),
2576            "merged".to_owned(),
2577            "--json".to_owned(),
2578            "url,number,mergedAt,baseRefName".to_owned(),
2579        ],
2580    )
2581    .await?;
2582    if !out.0 {
2583        bail!("gh pr list --head {branch}: {}", out.1);
2584    }
2585    pick_merged_pr(&out.1, &state.base_branch, state.created_at)
2586}
2587
2588/// Whether `branch` is, right now, an ancestor of `base_branch` in the local
2589/// git graph — the weaker, URL-less signal that a branch landed somewhere.
2590///
2591/// Deliberately never consulted by [`find_external_merge`]: a base branch
2592/// that has moved since the run started can make an old, abandoned branch
2593/// look like an ancestor of the *current* base for reasons that have nothing
2594/// to do with a merge (a later commit that happens to supersede it, an
2595/// unrelated squash), and there is no pull request URL here to confirm
2596/// against or to land through anyway. Its only honest use is a weaker
2597/// notice — "this looks merged, go check" — never an automatic rewrite of
2598/// `status`/`merge`.
2599pub async fn branch_is_ancestor(repo: &Path, branch: &str, base_branch: &str) -> Result<bool> {
2600    let out = tokio::process::Command::new("git")
2601        .args(["merge-base", "--is-ancestor", branch, base_branch])
2602        .current_dir(repo)
2603        .quiet()
2604        .stdin(std::process::Stdio::null())
2605        .output()
2606        .await
2607        .context("spawn git merge-base --is-ancestor")?;
2608    Ok(out.status.success())
2609}
2610
2611/// Parse `host/owner/repo` out of a forge URL, with no network access.
2612///
2613/// The host is part of the slug, not discarded: `owner/repo` alone would
2614/// treat `github.example.com/o/r` and `github.com/o/r` as the same
2615/// repository, which is exactly the mix-up the same-repo guard exists to
2616/// catch. Returns `None` for anything that doesn't have a `<host>/<path>`
2617/// shape at all.
2618fn forge_slug(url: &str) -> Option<(String, &str)> {
2619    let rest = url.rsplit("://").next()?;
2620    let (host, path) = rest.split_once('/')?;
2621    if host.is_empty() {
2622        return None;
2623    }
2624    Some((host.to_ascii_lowercase(), path))
2625}
2626
2627/// Parse `host/owner/repo` out of a GitHub pull request URL, with no network
2628/// access - the first half of the same-repo guard [`correct_manual_merge`]
2629/// applies before it writes anything.
2630///
2631/// Returns `None` for anything that does not look like
2632/// `https://<host>/<owner>/<repo>/pull/<n>`, which the caller treats as
2633/// fail-closed: a URL this cannot make sense of refuses rather than guesses.
2634pub(crate) fn slug_of_pr_url(url: &str) -> Option<String> {
2635    let (host, path) = forge_slug(url)?;
2636    let mut segments = path.split('/');
2637    let owner = segments.next()?;
2638    let repo = segments.next()?;
2639    let kind = segments.next()?;
2640    if owner.is_empty() || repo.is_empty() || kind != "pull" {
2641        return None;
2642    }
2643    Some(format!("{host}/{owner}/{repo}"))
2644}
2645
2646/// Parse `host/owner/repo` out of a plain repository URL (no `/pull/<n>`
2647/// suffix), the shape `gh repo view --json url` returns - the other half of
2648/// the same-repo guard, matched against [`slug_of_pr_url`]'s output.
2649fn slug_of_repo_url(url: &str) -> Option<String> {
2650    let (host, path) = forge_slug(url)?;
2651    let mut segments = path.split('/');
2652    let owner = segments.next()?;
2653    let repo = segments.next()?;
2654    if owner.is_empty() || repo.is_empty() {
2655        return None;
2656    }
2657    Some(format!("{host}/{owner}/{repo}"))
2658}
2659
2660/// Refuse to correct a run against a pull request from a different
2661/// repository than the one it is recorded against.
2662///
2663/// This is the guard the shun/8c75 incident argued for: an operator ran
2664/// `magi fold --merged <shun PR url>` meaning to correct an old `Blocked` run
2665/// in a different repository, omitted the run id, and the id defaulted to
2666/// this machine's most recently created run - an unrelated, still-in-progress
2667/// run in a completely different repository - which then had its `status`
2668/// rewritten to `merged` from a pull request it had nothing to do with.
2669/// `correct_manual_merge` now requires an explicit id (see `magi fold`'s own
2670/// CLI help), but a mistyped or stale id could still name a run in a
2671/// different repository than the one the URL belongs to, so this checks that
2672/// independently rather than trusting the id alone.
2673///
2674/// Comparison is case-insensitive - GitHub owner/repo names are - and a
2675/// mismatch names both slugs rather than just refusing, so an operator whose
2676/// local checkout's `origin` is a fork of the repository the pull request was
2677/// opened against (a legitimate setup this cannot tell apart from a genuine
2678/// mix-up) can judge for themselves rather than being blocked with no way to
2679/// see why.
2680pub(crate) fn ensure_same_repo(run_repo_slug: &str, pr_repo_slug: &str) -> Result<()> {
2681    if run_repo_slug.eq_ignore_ascii_case(pr_repo_slug) {
2682        return Ok(());
2683    }
2684    bail!(
2685        "refusing to correct this run: it is recorded against {run_repo_slug}, but the pull \
2686         request URL belongs to {pr_repo_slug} - pass the run id whose repository the URL \
2687         actually belongs to (or, if `origin` is a fork opened against a different upstream, \
2688         verify by hand before treating this as a false positive)"
2689    );
2690}
2691
2692/// Ask the forge which `host/owner/repo` a local checkout's `origin` remote
2693/// actually resolves to, for the same-repo guard in [`correct_manual_merge`].
2694///
2695/// Asking `gh` rather than parsing `git remote -v` locally is deliberate: it
2696/// normalizes case, SSH vs. HTTPS remotes, and a renamed or transferred
2697/// repository the same way GitHub itself would recognize it, so the
2698/// comparison in [`ensure_same_repo`] is against the same canonical slug on
2699/// both sides. Reads `url` rather than `nameWithOwner` so the host is part of
2700/// the answer too - `nameWithOwner` alone cannot tell a `github.com` repo from
2701/// a same-named one on a GitHub Enterprise host.
2702async fn repo_slug(repo: &Path) -> Result<String> {
2703    let out = gh(
2704        repo,
2705        &[
2706            "repo".to_owned(),
2707            "view".to_owned(),
2708            "--json".to_owned(),
2709            "url".to_owned(),
2710        ],
2711    )
2712    .await?;
2713    if !out.0 {
2714        bail!("gh repo view --json url: {}", out.1);
2715    }
2716    #[derive(Debug, Deserialize)]
2717    struct GhRepo {
2718        url: String,
2719    }
2720    let parsed: GhRepo = serde_json::from_str(&out.1)
2721        .with_context(|| format!("parse `gh repo view` output: {}", out.1))?;
2722    slug_of_repo_url(&parsed.url)
2723        .with_context(|| format!("could not parse a host/owner/repo out of {}", parsed.url))
2724}
2725
2726/// Confirm `url` is actually a merged pull request, then rewrite `state`'s
2727/// `status` and `merge` exactly as the automatic land loop (`land::land`)
2728/// would have written them had magi opened and merged this pull request
2729/// itself.
2730///
2731/// This is `magi fold --merged`'s whole implementation, and also what the
2732/// web `fold-merged` route calls once it has a URL in hand — an operator
2733/// recovery path for a merge magi could not finish on its own: a PR title too
2734/// long for the GraphQL mutation, `gh pr create` unreachable, a stale token -
2735/// closed by hand with a pull request magi never opened and so never
2736/// recorded. Reusing `land::land` rather than writing `status`/`merge`
2737/// directly keeps this one authoritative: a merged pull request decides
2738/// `Step::Done { merged: true }` on the very first read, before any of
2739/// `land`'s own checks/fix/rebase machinery can run, which is what makes it
2740/// safe to call here even though this pull request was never magi's own.
2741///
2742/// [`ensure_same_repo`] is checked before anything else: a pull request from
2743/// a different repository than the one `state` is recorded against is
2744/// refused outright, regardless of its lifecycle. This is the guard for a
2745/// URL an *operator* hands in - the CLI or the web route - where a stale or
2746/// mistyped run id could otherwise get corrected from an unrelated
2747/// repository's pull request (see the shun/8c75 incident in `magi fold`'s own
2748/// CLI help). The automatic janitor sweep (`clean::reconcile_external_merges`)
2749/// goes through [`correct_confirmed_external_merge`] instead, which skips
2750/// this check: its `url` was never operator-supplied, it comes from
2751/// [`find_external_merge`] querying `gh` from inside `state.repo` itself, so
2752/// it is already guaranteed to name a pull request in that same repository -
2753/// re-deriving and re-checking the repository here would only be a second
2754/// `gh repo view` call that can fail for reasons that have nothing to do with
2755/// correctness (a rate limit, a network blip), turning a self-heal that would
2756/// otherwise have succeeded into a run left `Blocked` for another pass.
2757///
2758/// [`lifecycle`] is checked next and separately so a mistyped or still-open
2759/// URL fails loudly without writing anything, rather than handing an open
2760/// pull request to the full autonomous loop by accident.
2761///
2762/// Correcting `status` this way does not run `bump::after_merge`
2763/// (`src/bump.rs`): that call is made only from `graph::Runner::run_land`,
2764/// which this path never goes through. A release version bump the change
2765/// might have earned is therefore not filed automatically and has to be
2766/// requested by hand - recorded as an event on the run so the gap is visible
2767/// to whoever reads it later, not just wherever this was called from. Follow-up
2768/// tasks for findings the merge left open (`crate::followup`) *are* filed here.
2769///
2770/// Returns the status before and after, so every caller (CLI, janitor, web
2771/// route) can build its own log line or response from the same pair rather
2772/// than each re-deriving it.
2773pub async fn correct_manual_merge(
2774    state: &mut RunState,
2775    url: &str,
2776) -> Result<(RunStatus, RunStatus)> {
2777    let Some(pr_slug) = slug_of_pr_url(url) else {
2778        bail!(
2779            "could not parse an owner/repo out of {url}; refusing to guess which repository \
2780             this pull request belongs to"
2781        );
2782    };
2783    let run_slug = repo_slug(&state.repo).await?;
2784    ensure_same_repo(&run_slug, &pr_slug)?;
2785    correct_merge(state, url).await
2786}
2787
2788/// The janitor's own entry point into the same correction
2789/// [`correct_manual_merge`] performs for an operator-supplied URL, minus the
2790/// same-repo guard - see that function's own doc for why skipping it here is
2791/// safe rather than a hole: [`clean::reconcile_external_merges`] only ever
2792/// calls this with a `url` [`find_external_merge`] already found by querying
2793/// `state.repo`'s own remote, so the guard could never do anything here but
2794/// fail on its own transient errors.
2795///
2796/// [`crate::clean`] is the only caller; `pub(crate)` rather than private only
2797/// because it lives in a different module.
2798pub(crate) async fn correct_confirmed_external_merge(
2799    state: &mut RunState,
2800    url: &str,
2801) -> Result<(RunStatus, RunStatus)> {
2802    correct_merge(state, url).await
2803}
2804
2805/// Same pull request, same repository: the url, or the number within one repo.
2806fn names_same_pr(a: &RunState, url: &str, number: u64, repo: &Path) -> bool {
2807    let Some(pr) = a.pr.as_ref() else {
2808        return false;
2809    };
2810    if !url.is_empty()
2811        && pr
2812            .url
2813            .trim_end_matches('/')
2814            .eq_ignore_ascii_case(url.trim_end_matches('/'))
2815    {
2816        return true;
2817    }
2818    number > 0
2819        && pr.number == number
2820        && match (a.repo.canonicalize(), repo.canonicalize()) {
2821            (Ok(x), Ok(y)) => x == y,
2822            _ => a.repo == repo,
2823        }
2824}
2825
2826/// Rewrite `pr.state` to a final state on every run record under `home` that
2827/// `decide` picks, and report how many were rewritten.
2828///
2829/// Lifecycle writes through to other runs are deliberately narrow (task-head
2830/// ownership is recorded separately): only a **terminal** run (never one a
2831/// driver may still be writing), only a proven-stopped driver with no daemon
2832/// claim (the shared liveness judge), only a record
2833/// whose `pr.state` is still `open`, and only `merged` / `closed` ever goes in.
2834/// The record is read as folding reads it (no schema check: every bump so far
2835/// only added fields, and the whole struct round-trips) and written through
2836/// [`RunState::save_under`], the path every record uses, so nothing but
2837/// `pr.state` and an event line changes (and `updated_at`, as for any save).
2838/// A run that cannot be read or written is skipped with a warning.
2839fn rewrite_open_prs(
2840    home: &Path,
2841    decide: &mut dyn FnMut(&RunState) -> Option<PrLifecycle>,
2842) -> usize {
2843    let now = Timestamp::now();
2844    let mut changed = 0;
2845    for id in crate::run::list_ids_in(&home.join("runs")) {
2846        let Ok(_owner) = crate::pr_head::owner_lock(home, &id) else {
2847            continue;
2848        };
2849        let path = home.join("runs").join(&id).join("run.json");
2850        let Ok(body) = std::fs::read_to_string(&path) else {
2851            continue;
2852        };
2853        let Ok(mut state) = serde_json::from_str::<RunState>(&body) else {
2854            continue;
2855        };
2856        if !state.status.done()
2857            || state.pr.as_ref().is_none_or(|p| p.state != "open")
2858            || state.liveness_under(home, crate::daemon::is_working_on(home, &id, now))
2859                != crate::run::Liveness::Dead
2860        {
2861            continue;
2862        }
2863        let Some(to @ (PrLifecycle::Merged | PrLifecycle::Closed)) = decide(&state) else {
2864            continue;
2865        };
2866        if let Some(pr) = state.pr.as_mut() {
2867            pr.state = to.as_str().to_owned();
2868        }
2869        let url = state.pr.as_ref().map(|p| p.url.clone()).unwrap_or_default();
2870        state.event(
2871            "land",
2872            format!("recorded {url} as {}: another run settled it", to.as_str()),
2873        );
2874        match state.save_under(home) {
2875            Ok(()) => changed += 1,
2876            Err(e) => tracing::warn!("write pr state through to run {id}: {e:#}"),
2877        }
2878    }
2879    changed
2880}
2881
2882/// A run reached a final state for its pull request: tell every other terminal
2883/// run in the same repository that names the same pull request (handed-over
2884/// predecessors, blocked attempts, anything), so their records stop saying
2885/// `open`. Best effort; `run`'s own record is the caller's.
2886pub(crate) fn write_pr_state_through(run: &RunState, to: PrLifecycle) {
2887    if to == PrLifecycle::Open {
2888        return;
2889    }
2890    let Some(home) = crate::run::try_home() else {
2891        return;
2892    };
2893    write_pr_state_through_in(&home, run, to);
2894}
2895
2896pub(crate) fn write_pr_state_through_in(home: &Path, run: &RunState, to: PrLifecycle) -> usize {
2897    let Some(pr) = run.pr.as_ref() else {
2898        return 0;
2899    };
2900    let (url, number) = (pr.url.clone(), pr.number);
2901    rewrite_open_prs(home, &mut |other| {
2902        (other.id != run.id && names_same_pr(other, &url, number, &run.repo)).then_some(to)
2903    })
2904}
2905
2906/// Terminal runs whose record still says their pull request is open, as
2907/// `(run id, repo, url)`, for [`repair_stale_pr_states`].
2908pub(crate) fn stale_open_prs(home: &Path) -> Vec<(String, PathBuf, String)> {
2909    let now = Timestamp::now();
2910    let mut out = Vec::new();
2911    for id in crate::run::list_ids_in(&home.join("runs")) {
2912        let path = home.join("runs").join(&id).join("run.json");
2913        let Ok(body) = std::fs::read_to_string(&path) else {
2914            continue;
2915        };
2916        let Ok(state) = serde_json::from_str::<RunState>(&body) else {
2917            continue;
2918        };
2919        if let Some(pr) = state.pr.as_ref()
2920            && state.status.done()
2921            && pr.state == "open"
2922            && !pr.url.is_empty()
2923            && !crate::daemon::is_working_on(home, &id, now)
2924        {
2925            out.push((id, state.repo.clone(), pr.url.clone()));
2926        }
2927    }
2928    out
2929}
2930
2931/// Apply forge answers (`pr url -> state`) to every stale terminal record.
2932/// A url with no answer (the forge was unreadable) changes nothing.
2933pub(crate) fn apply_pr_states(home: &Path, known: &BTreeMap<String, PrLifecycle>) -> usize {
2934    rewrite_open_prs(home, &mut |s| {
2935        s.pr.as_ref().and_then(|p| known.get(&p.url)).copied()
2936    })
2937}
2938
2939/// One-time (and idempotent) repair of records that froze an `open` pull
2940/// request: ask the forge about each distinct pull request that a terminal run
2941/// still calls open - at most `max_lookups` of them - and rewrite the merged
2942/// and closed ones. A genuinely open pull request is left alone, and a lookup
2943/// that fails is "unknown, change nothing". Returns `(records rewritten,
2944/// lookups that failed)`.
2945pub async fn repair_stale_pr_states(home: &Path, max_lookups: usize) -> (usize, usize) {
2946    let mut known = BTreeMap::new();
2947    let mut failed = 0;
2948    let mut seen = BTreeSet::new();
2949    for (_, repo, url) in stale_open_prs(home) {
2950        if known.len() + failed >= max_lookups || !seen.insert(url.clone()) {
2951            continue;
2952        }
2953        match lifecycle(&repo, &url).await {
2954            Ok(state) => {
2955                known.insert(url, state);
2956            }
2957            Err(e) => {
2958                tracing::warn!("repair pr state of {url}: {e:#}");
2959                failed += 1;
2960            }
2961        }
2962    }
2963    (apply_pr_states(home, &known), failed)
2964}
2965
2966async fn correct_merge(state: &mut RunState, url: &str) -> Result<(RunStatus, RunStatus)> {
2967    match lifecycle(&state.repo, url).await? {
2968        PrLifecycle::Merged => {}
2969        other => bail!(
2970            "{url} is {}, not merged; refusing to record {} as merged on a guess",
2971            other.as_str(),
2972            state.id
2973        ),
2974    }
2975    let before = state.status;
2976    if let Err(e) = land(state, url).await {
2977        // `land` sets `status` to `Landing` and saves before its first read
2978        // of the pull request — see its own doc — so a failure here (a
2979        // transient `gh` hiccup between the two forge reads this function
2980        // makes) can leave the run stuck on that in-between value with
2981        // nothing left driving it. Land it on the same terminal shape an
2982        // automated `land` failure lands on instead of leaving it stuck.
2983        state.status = RunStatus::Blocked;
2984        state.event("fold", format!("manual-merge correction failed: {e:#}"));
2985        state.save()?;
2986        return Err(e).context(format!("confirming the merge of {url}"));
2987    }
2988    state.event(
2989        "fold",
2990        "operator recorded this pull request as a manual merge; this run never \
2991         re-entered `land`, so `bump::after_merge` did not run for it - a release \
2992         bump this change might warrant has to be filed by hand",
2993    );
2994    // Unlike the bump, the findings the merge left open are filed on this
2995    // path too: nothing else would ever carry them forward.
2996    if state.status == RunStatus::Merged {
2997        crate::followup::after_merge(state, url).await;
2998    }
2999    state.save()?;
3000    Ok((before, state.status))
3001}
3002
3003/// Parse `gh api repos/{owner}/{repo}/pulls/<n>/comments` into inline review
3004/// comments. No I/O.
3005///
3006/// `gh pr view` does not surface inline comments, and inline is exactly where
3007/// both review bots put their findings - a landing loop that read only the
3008/// top-level thread would never see the thing it is supposed to fix.
3009pub fn parse_inline_comments(json: &str) -> Result<Vec<ReviewComment>> {
3010    let raw: Vec<GhInline> =
3011        serde_json::from_str(json).context("parse `gh api .../pulls/<n>/comments` output")?;
3012    let mut out = Vec::new();
3013    for c in raw {
3014        push_if_outstanding(
3015            &mut out,
3016            ReviewComment {
3017                author: c.user.login,
3018                path: c.path,
3019                line: c.line,
3020                body: c.body,
3021            },
3022        );
3023    }
3024    Ok(out)
3025}
3026
3027/// Keep a comment only when it asks for something.
3028///
3029/// An inline comment always does: it names a file and a line. A top-level
3030/// comment is dropped when it is empty, when it is magi's own, or when it is
3031/// [noise](is_noise).
3032fn push_if_outstanding(out: &mut Vec<ReviewComment>, comment: ReviewComment) {
3033    if comment.body.trim().is_empty() || comment.body.contains(MARKER) {
3034        return;
3035    }
3036    if comment.path.is_none() && is_noise(&comment.body) {
3037        return;
3038    }
3039    out.push(comment);
3040}
3041
3042/// Is this comment body machinery rather than a finding?
3043///
3044/// Two tests, both structural, because guessing from prose is how a "looks
3045/// good to me" turns into a fix round:
3046///
3047/// 1. The bot said so - the body carries one of the [`NOT_A_REVIEW`] markers
3048///    with which CodeRabbit labels its trigger notice, its walkthrough, and its
3049///    footer.
3050/// 2. It asks for nothing - once HTML comments, `<details>` blocks, headings,
3051///    horizontal rules, and the bot's own status banner are removed, every
3052///    remaining line is a task-list item. That is exactly the shape of the
3053///    comment the Claude review job posts while it is still working.
3054///
3055/// Anything else is input, including bot prose. A bot that writes a paragraph
3056/// has said something, and the fix prompt tells the fixer it may decline a
3057/// comment with an argument - a wasted sentence in a prompt is cheaper than a
3058/// missed finding.
3059pub fn is_noise(body: &str) -> bool {
3060    if NOT_A_REVIEW.iter().any(|m| body.contains(m)) {
3061        return true;
3062    }
3063    let mut content = false;
3064    for line in strip_blocks(body).lines() {
3065        let line = unquote(line);
3066        if line.is_empty() || is_checklist(line) || is_decoration(line) || is_banner(line) {
3067            continue;
3068        }
3069        content = true;
3070        break;
3071    }
3072    !content
3073}
3074
3075/// Remove HTML comments and collapsed `<details>` blocks.
3076fn strip_blocks(body: &str) -> String {
3077    let mut out = String::with_capacity(body.len());
3078    let mut rest = body;
3079    loop {
3080        let open = ["<!--", "<details>"]
3081            .iter()
3082            .filter_map(|tag| rest.find(tag).map(|i| (i, *tag)))
3083            .min_by_key(|(i, _)| *i);
3084        let Some((at, tag)) = open else {
3085            out.push_str(rest);
3086            return out;
3087        };
3088        out.push_str(&rest[..at]);
3089        let after = &rest[at + tag.len()..];
3090        let close = if tag == "<!--" { "-->" } else { "</details>" };
3091        match after.find(close) {
3092            Some(end) => rest = &after[end + close.len()..],
3093            // Unterminated: the rest of the body is inside the block.
3094            None => return out,
3095        }
3096    }
3097}
3098
3099/// Strip blockquote markers, which both bots wrap their callouts in.
3100fn unquote(line: &str) -> &str {
3101    let mut s = line.trim();
3102    while let Some(rest) = s.strip_prefix('>') {
3103        s = rest.trim_start();
3104    }
3105    s.trim()
3106}
3107
3108/// `- [ ]` / `- [x]`, in any of the bullet styles GitHub renders.
3109fn is_checklist(line: &str) -> bool {
3110    let rest = line
3111        .strip_prefix("- ")
3112        .or_else(|| line.strip_prefix("* "))
3113        .unwrap_or("");
3114    let rest = rest.trim_start();
3115    matches!(
3116        rest.get(..3),
3117        Some("[ ]") | Some("[x]") | Some("[X]") | Some("[*]")
3118    )
3119}
3120
3121/// A heading, a horizontal rule, or a callout tag - shape, never content.
3122fn is_decoration(line: &str) -> bool {
3123    line.starts_with('#')
3124        || line.starts_with("[!")
3125        || (line.len() >= 3 && line.chars().all(|c| matches!(c, '-' | '=' | '*' | '_')))
3126}
3127
3128/// A line that is nothing but emphasis and links.
3129///
3130/// Both review jobs open with a status banner
3131/// (`**Claude finished ... in 4m 14s** —— [View job](url)`). It reads as prose
3132/// to a line-based test and asks for nothing, so it is measured the same way a
3133/// heading is: strip the markup, and if no word survives, it was decoration.
3134fn is_banner(line: &str) -> bool {
3135    let plain = drop_spans(line, "**", "**");
3136    let plain = if plain.contains("](") {
3137        drop_spans(&plain, "[", ")")
3138    } else {
3139        plain
3140    };
3141    !plain.chars().any(char::is_alphanumeric)
3142}
3143
3144/// Remove every `open` .. `close` span, including the delimiters. An
3145/// unterminated span swallows the rest of the input, which is what a reader
3146/// sees too.
3147fn drop_spans(s: &str, open: &str, close: &str) -> String {
3148    let mut out = String::with_capacity(s.len());
3149    let mut rest = s;
3150    while let Some(at) = rest.find(open) {
3151        out.push_str(&rest[..at]);
3152        let after = &rest[at + open.len()..];
3153        match after.find(close) {
3154            Some(end) => rest = &after[end + close.len()..],
3155            None => return out,
3156        }
3157    }
3158    out.push_str(rest);
3159    out
3160}
3161
3162/// The lock that keeps at most one run per repository actually moving the
3163/// base branch at a time: a rebase push, or `gh pr merge`.
3164///
3165/// Deliberately narrow. Everything else in [`land`]'s loop - watching CI,
3166/// running a fix round in the winner's own worktree, waiting on the owner's
3167/// approval - touches nothing a *different* run in the same repository could
3168/// collide with, and holding a lock across any of that would serialise one
3169/// run's CI wait (up to [`WAIT_CEILING`]) against another run's land-approval
3170/// resume, which is precisely the "must not wait on another task" property
3171/// the daemon's slot-freeing exists to give a resume. Only the two moments
3172/// that actually write to the shared base branch need mutual exclusion, and
3173/// both are brief.
3174///
3175/// One entry per repository, each its own `tokio::sync::Mutex`, so two
3176/// different repositories' runs never wait on each other. The outer
3177/// `std::sync::Mutex` guards only the map itself, held long enough to find or
3178/// insert an entry and clone its `Arc`, never across an `.await`.
3179fn repo_merge_lock(repo: &Path) -> Arc<tokio::sync::Mutex<()>> {
3180    static LOCKS: std::sync::LazyLock<
3181        std::sync::Mutex<BTreeMap<PathBuf, Arc<tokio::sync::Mutex<()>>>>,
3182    > = std::sync::LazyLock::new(|| std::sync::Mutex::new(BTreeMap::new()));
3183    LOCKS
3184        .lock()
3185        .unwrap_or_else(std::sync::PoisonError::into_inner)
3186        .entry(repo.to_path_buf())
3187        .or_insert_with(|| Arc::new(tokio::sync::Mutex::new(())))
3188        .clone()
3189}
3190
3191/// `owner/repo` out of a pull request url, falling back to the checkout's
3192/// directory name when the url is not the usual `host/owner/repo/pull/N`.
3193fn repo_label(repo: &Path, pr_url: &str) -> String {
3194    let parts: Vec<&str> = pr_url.split('/').collect();
3195    if let Some(at) = parts.iter().rposition(|p| *p == "pull")
3196        && at >= 2
3197        && !parts[at - 1].is_empty()
3198        && !parts[at - 2].is_empty()
3199    {
3200        return format!("{}/{}", parts[at - 2], parts[at - 1]);
3201    }
3202    repo.file_name()
3203        .map(|n| n.to_string_lossy().into_owned())
3204        .unwrap_or_default()
3205}
3206
3207/// The operator-facing sentence for a merge that went ahead with red checks,
3208/// or `None` when the checks were not red. Judged on `checks`, not on
3209/// `failing`, which can be non-empty on a green observation.
3210fn red_merge_summary(repo_name: &str, pr: &PrState) -> Option<String> {
3211    (pr.checks == Checks::Red).then(|| {
3212        let details = crate::notices::format_list(&pr.failing)
3213            .map(|names| format!(": {names}"))
3214            .unwrap_or_default();
3215        format!(
3216            "Merged {repo_name} PR #{} with red checks{details} ({})",
3217            pr.number, pr.url
3218        )
3219    })
3220}
3221
3222/// After a merge that succeeded: record which checks were red and tell the
3223/// operator. The decision to merge is already made; this only makes it audible.
3224/// Best-effort - a broken notifier never fails the run.
3225async fn announce_red_merge(state: &mut RunState, pr: &PrState) {
3226    let repo_name = repo_label(&state.repo, &pr.url);
3227    let Some(summary) = red_merge_summary(&repo_name, pr) else {
3228        return;
3229    };
3230    if let Some(rec) = state.pr.as_mut() {
3231        rec.red_at_merge = pr.failing.clone();
3232    }
3233    state.event("land", summary.clone());
3234    // The notice pages through `[notify]` itself, once, unless a question
3235    // already carries the cause.
3236    crate::notices::raise_with(
3237        crate::notices::merged_red(&state.id, &summary),
3238        &state.config.notify,
3239    );
3240}
3241
3242/// Run the loop against a real pull request until it merges or the budget runs
3243/// out.
3244///
3245/// The caller decides whether landing happens at all: this is only reached when
3246/// `graph.land` is on. Returns the last observation, so the caller can report
3247/// what magi was looking at when it stopped.
3248pub async fn land(state: &mut RunState, pr_url: &str) -> Result<PrState> {
3249    land_with(state, pr_url, &GhForge).await
3250}
3251
3252/// The forge calls whose timing the loop's decisions depend on, behind a seam
3253/// so a test can script what the pull request looks like from one observation
3254/// to the next. Comments, logs and rebases stay on `gh` and `git` directly.
3255trait Forge {
3256    async fn close(&self, repo: &Path, pr_url: &str, comment: &str) -> Result<()> {
3257        let (ok, out) = gh(
3258            repo,
3259            &[
3260                "pr".into(),
3261                "close".into(),
3262                pr_url.into(),
3263                "--comment".into(),
3264                comment.into(),
3265            ],
3266        )
3267        .await?;
3268        if !ok {
3269            bail!("PR closure failed: {out}");
3270        }
3271        Ok(())
3272    }
3273    async fn attribution(&self, _state: &RunState, _seen: &Seen) -> Option<CiEvidence> {
3274        None
3275    }
3276    async fn view(&self, repo: &Path, pr_url: &str) -> Result<Seen>;
3277    async fn merge(&self, repo: &Path, argv: &[String]) -> Result<(bool, String)>;
3278    async fn poll(&self);
3279    /// Rerun the failed jobs of one workflow run.
3280    async fn rerun(&self, repo: &Path, run: &str) -> Result<()>;
3281    /// Unix seconds, behind the seam so a test owns the clock.
3282    fn now(&self) -> i64;
3283    /// The check contexts the base branch requires, for a stop reason only.
3284    /// `None` when they could not be read, which is not the same as none.
3285    async fn required_contexts(&self, repo: &Path, base: &str) -> Option<BTreeSet<String>>;
3286    #[allow(clippy::too_many_arguments)]
3287    async fn fix(
3288        &self,
3289        state: &mut RunState,
3290        pr: &PrState,
3291        round: usize,
3292        budget: usize,
3293        reason: &str,
3294        logs: &str,
3295    ) -> Result<Fixed>;
3296}
3297
3298struct GhForge;
3299
3300impl Forge for GhForge {
3301    async fn attribution(&self, state: &RunState, seen: &Seen) -> Option<CiEvidence> {
3302        collect_ci_evidence(state, seen).await
3303    }
3304    async fn view(&self, repo: &Path, pr_url: &str) -> Result<Seen> {
3305        observe(repo, pr_url).await
3306    }
3307    async fn merge(&self, repo: &Path, argv: &[String]) -> Result<(bool, String)> {
3308        gh(repo, argv).await
3309    }
3310    async fn poll(&self) {
3311        tokio::time::sleep(POLL).await;
3312    }
3313    async fn rerun(&self, repo: &Path, run: &str) -> Result<()> {
3314        let args = [
3315            "run".to_owned(),
3316            "rerun".to_owned(),
3317            run.to_owned(),
3318            "--failed".to_owned(),
3319        ];
3320        let (ok, out) = gh(repo, &args).await?;
3321        if !ok {
3322            bail!("gh run rerun {run}: {out}");
3323        }
3324        Ok(())
3325    }
3326    fn now(&self) -> i64 {
3327        jiff::Timestamp::now().as_second()
3328    }
3329    async fn required_contexts(&self, repo: &Path, base: &str) -> Option<BTreeSet<String>> {
3330        required_contexts_of(repo, base).await
3331    }
3332    async fn fix(
3333        &self,
3334        state: &mut RunState,
3335        pr: &PrState,
3336        round: usize,
3337        budget: usize,
3338        reason: &str,
3339        logs: &str,
3340    ) -> Result<Fixed> {
3341        fix_round(state, pr, round, budget, reason, logs).await
3342    }
3343}
3344
3345/// Percent-encode a branch name for a URL path segment (`/` included).
3346fn encode_path_segment(s: &str) -> String {
3347    let mut out = String::new();
3348    for b in s.bytes() {
3349        if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
3350            out.push(b as char);
3351        } else {
3352            let _ = write!(out, "%{b:02X}");
3353        }
3354    }
3355    out
3356}
3357
3358/// Read the required contexts of `base` from classic branch protection and
3359/// from rulesets, once, for a stop reason. Organisation-level rulesets that
3360/// these two endpoints do not list are missed. Any unreadable source makes the
3361/// whole answer `None`: a partial set would read as a complete one.
3362async fn required_contexts_of(repo: &Path, base: &str) -> Option<BTreeSet<String>> {
3363    let enc = encode_path_segment(base);
3364    let mut all = BTreeSet::new();
3365    // Classic protection answers 404 for an unprotected branch, which is
3366    // "nothing required here", not a failure to read.
3367    let classic = gh(
3368        repo,
3369        &[
3370            "api".to_owned(),
3371            format!("repos/{{owner}}/{{repo}}/branches/{enc}/protection/required_status_checks"),
3372        ],
3373    )
3374    .await
3375    .ok()?;
3376    if classic.0 {
3377        all.extend(parse_classic_required(&classic.1)?);
3378    } else if !classic.1.contains("404") {
3379        return None;
3380    }
3381    let rules = gh(
3382        repo,
3383        &[
3384            "api".to_owned(),
3385            format!("repos/{{owner}}/{{repo}}/rules/branches/{enc}"),
3386        ],
3387    )
3388    .await
3389    .ok()?;
3390    if !rules.0 {
3391        return None;
3392    }
3393    all.extend(parse_ruleset_required(&rules.1)?);
3394    Some(all)
3395}
3396
3397/// `required_status_checks` of classic protection: `contexts` plus the
3398/// `checks[].context` form.
3399fn parse_classic_required(json: &str) -> Option<BTreeSet<String>> {
3400    let v: serde_json::Value = serde_json::from_str(json).ok()?;
3401    let mut out = BTreeSet::new();
3402    for c in v.get("contexts")?.as_array()? {
3403        out.insert(c.as_str()?.to_owned());
3404    }
3405    for c in v
3406        .get("checks")
3407        .and_then(|c| c.as_array())
3408        .into_iter()
3409        .flatten()
3410    {
3411        if let Some(name) = c.get("context").and_then(|n| n.as_str()) {
3412            out.insert(name.to_owned());
3413        }
3414    }
3415    Some(out)
3416}
3417
3418/// `rules/branches/<base>`: every `required_status_checks` rule's contexts.
3419fn parse_ruleset_required(json: &str) -> Option<BTreeSet<String>> {
3420    let v: serde_json::Value = serde_json::from_str(json).ok()?;
3421    let mut out = BTreeSet::new();
3422    for rule in v.as_array()? {
3423        if rule.get("type").and_then(|t| t.as_str()) != Some("required_status_checks") {
3424            continue;
3425        }
3426        let checks = rule
3427            .pointer("/parameters/required_status_checks")?
3428            .as_array()?;
3429        for c in checks {
3430            out.insert(c.get("context")?.as_str()?.to_owned());
3431        }
3432    }
3433    Some(out)
3434}
3435
3436/// Is the observation older than the commit a fix round pushed?
3437///
3438/// The forge takes a few seconds to move the pull request to a new head and
3439/// attach that head's check runs, and until it has, the rollup is the previous
3440/// head's - all green, which is exactly what a merge decision must not read.
3441/// An absent or different head counts as not yet: guessing "close enough"
3442/// would reopen the hole.
3443fn awaiting_new_head(awaiting: Option<&str>, observed: &str) -> bool {
3444    awaiting.is_some_and(|want| !observed.eq_ignore_ascii_case(want))
3445}
3446
3447/// The commit an observation may be decided on, or `None` while it cannot be
3448/// trusted to describe one.
3449///
3450/// `None` when a pushed commit is awaited and the pull request is not on it,
3451/// when the head is unreadable, or when the rollup (`statusCheckRollup` is the
3452/// last commit's) is not the head's: that is the previous commit's checks. The
3453/// caller re-polls on `None`. A rollup that cannot be read (including one
3454/// longer than a page) leaves `rollup_head` empty, so the wait runs to
3455/// [`WAIT_CEILING`] and stops - a safe failure, never a merge.
3456fn bound_head<'a>(
3457    seen_head: &'a str,
3458    rollup_head: &str,
3459    awaiting: Option<&str>,
3460) -> Option<&'a str> {
3461    if seen_head.is_empty()
3462        || awaiting_new_head(awaiting, seen_head)
3463        || !rollup_head.eq_ignore_ascii_case(seen_head)
3464    {
3465        return None;
3466    }
3467    Some(seen_head)
3468}
3469
3470/// What a refused `gh pr merge` means.
3471#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3472enum Refused {
3473    /// An open PR on the observed head has a proven stale base.
3474    Behind,
3475    /// The branch policy is not satisfied *yet*: go back to waiting.
3476    Pending,
3477    /// Checks have settled and the merge state still says no, seen for the
3478    /// first time. The forge updates `mergeStateStatus` a moment after the last
3479    /// check finishes, so one more look is allowed before believing it.
3480    Recheck,
3481    /// Nothing is in flight and the policy still refuses: a person has to
3482    /// supply what it asks for (a review, say).
3483    Final,
3484}
3485
3486/// Judged from the pull request's state after the refusal, never from the
3487/// refusal's wording, which belongs to the forge and changes.
3488fn classify_refusal(
3489    after: Option<&Seen>,
3490    rechecked: bool,
3491    observed_head: &str,
3492    ci: CiExpectation,
3493) -> Refused {
3494    let Some(after) = after else {
3495        // Unreadable is not evidence of anything; the next loop reads again.
3496        return Refused::Pending;
3497    };
3498    if after.pr.state != PrLifecycle::Open {
3499        return Refused::Final;
3500    }
3501    // The branch moved after it was observed (the forge refuses a merge pinned
3502    // to the old commit): not a verdict on anything, look again.
3503    if !after.head.eq_ignore_ascii_case(observed_head) {
3504        return Refused::Pending;
3505    }
3506    if Blocking::of(&after.merge_state) == Blocking::Behind {
3507        return Refused::Behind;
3508    }
3509    // The same binding the loop applies: checks of another commit say nothing.
3510    if bound_head(&after.head, &after.rollup_head, None).is_none() {
3511        return Refused::Pending;
3512    }
3513    let state = after.merge_state.to_ascii_uppercase();
3514    if (ci == CiExpectation::Expected
3515        && matches!(after.pr.checks, Checks::Pending | Checks::Unknown))
3516        || state.is_empty()
3517        || state == "UNKNOWN"
3518    {
3519        return Refused::Pending;
3520    }
3521    if rechecked {
3522        Refused::Final
3523    } else {
3524        Refused::Recheck
3525    }
3526}
3527
3528/// Take auto-merge back from the forge and forget that it was armed.
3529///
3530/// `Err` carries the forge's message: the caller must not push or move on, as
3531/// an armed merge left behind could still fire for a commit nobody approved.
3532async fn disarm<F: Forge>(
3533    forge: &F,
3534    state: &mut RunState,
3535    repo: &Path,
3536    number: u64,
3537) -> std::result::Result<(), String> {
3538    let argv = disable_automerge_argv(number);
3539    let out = {
3540        let merge_lock = repo_merge_lock(repo);
3541        let _merge_slot = merge_lock.lock().await;
3542        forge.merge(repo, &argv).await
3543    };
3544    match out {
3545        Ok((true, _)) => {
3546            state.land_armed_head = None;
3547            state.event("land", "auto-merge disabled");
3548            state.save().map_err(|e| format!("{e:#}"))?;
3549            Ok(())
3550        }
3551        Ok((false, msg)) => Err(msg),
3552        Err(e) => Err(format!("{e:#}")),
3553    }
3554}
3555
3556/// [`stop`], first taking back an armed auto-merge so a pull request magi
3557/// gave up on does not merge on its own later. A failure to disarm is added
3558/// to the reason rather than hiding it.
3559async fn stop_disarmed<F: Forge>(
3560    forge: &F,
3561    state: &mut RunState,
3562    repo: &Path,
3563    pr: &PrState,
3564    why: &str,
3565) -> Result<()> {
3566    if state.land_armed_head.is_none() {
3567        return stop(state, repo, pr, why).await;
3568    }
3569    match disarm(forge, state, repo, pr.number).await {
3570        Ok(()) => stop(state, repo, pr, why).await,
3571        Err(e) => {
3572            let why = format!("{why} (auto-merge could not be disabled and may still fire: {e})");
3573            stop(state, repo, pr, &why).await
3574        }
3575    }
3576}
3577
3578/// Check the persisted card again around awaits that can outlive an owner tap.
3579fn owner_requested_stop(state: &RunState) -> Result<bool> {
3580    let Some(binding) = &state.land_approval else {
3581        return Ok(false);
3582    };
3583    let q = ask::Questions::open().get_for_effects(&binding.question)?;
3584    Ok(q.run == state.id
3585        && q.node == APPROVAL_NODE
3586        && q.resolution()
3587            .as_deref()
3588            .is_some_and(crate::merge_decision::stops))
3589}
3590
3591/// Read stop choices before checks, repair or rebase. These are about stopping
3592/// ownership, so a changed head never cancels them as it cancels merge consent.
3593async fn owner_stop<F: Forge>(state: &mut RunState, pr: &mut PrState, forge: &F) -> Result<bool> {
3594    use crate::merge_decision as md;
3595    let Some(binding) = &state.land_approval else {
3596        return Ok(false);
3597    };
3598    let q = ask::Questions::open().get_for_effects(&binding.question)?;
3599    let Some(choice) = q.resolution().filter(|c| md::stops(c)) else {
3600        return Ok(false);
3601    };
3602    if q.run != state.id || q.node != APPROVAL_NODE {
3603        bail!("stop decision names another run");
3604    }
3605    let target = q.merge_target.clone().unwrap_or_else(|| md::Target {
3606        pr: pr.url.clone(),
3607        head: binding.head.clone(),
3608        language: state.config.graph.language.clone(),
3609    });
3610    if target.pr != pr.url {
3611        bail!("stop decision names another PR");
3612    }
3613    if state.merge_decision.is_none() {
3614        state.merge_decision = Some(md::Decision {
3615            question: q.id.clone(),
3616            target,
3617            choice: choice.clone(),
3618            closed: false,
3619            replacement_run: None,
3620            replacement_pr: None,
3621        });
3622        state.save()?;
3623    }
3624    let repo = state.repo.clone();
3625    // Always disable, including arms left by an older driver.
3626    if let Err(e) = disarm(forge, state, &repo, pr.number).await {
3627        stop(state, &repo, pr, &format!("owner stop requested, but auto-merge could not be disabled: {e}; no repair or replacement started")).await?;
3628        return Ok(true);
3629    }
3630    if choice.eq_ignore_ascii_case(HOLD) {
3631        stop(
3632            state,
3633            &repo,
3634            pr,
3635            "owner held the decision: PR left open; no further repair or merge work",
3636        )
3637        .await?;
3638        return Ok(true);
3639    }
3640    if md::selected_agent(&choice).is_some()
3641        || state
3642            .origin
3643            .as_ref()
3644            .and_then(|o| o.task.as_ref())
3645            .is_some()
3646    {
3647        let owners: Vec<_> = crate::queue::Queue::open()
3648            .list()
3649            .into_iter()
3650            .filter(|task| task.execution_runs().last() == Some(&state.id))
3651            .collect();
3652        let owner = (owners.len() == 1).then(|| &owners[0]);
3653        if !owner.is_some_and(|task| {
3654            task.execution_runs().last() == Some(&state.id)
3655                && (!task
3656                    .operator_decided_at
3657                    .is_some_and(|at| at > q.answered_at.unwrap_or(q.asked_at))
3658                    || task.resumption.as_ref().is_some_and(|release| {
3659                        release.question_id.as_deref() == Some(q.id.as_str())
3660                            && task.operator_decided_at == Some(release.at)
3661                    }))
3662        }) {
3663            stop(state, &repo, pr, "replacement requires the current original queue task owner and an unsuperseded answer; PR left open").await?;
3664            return Ok(true);
3665        }
3666    }
3667    if pr.state == PrLifecycle::Merged {
3668        stop(
3669            state,
3670            &repo,
3671            pr,
3672            "PR already merged; withdrawal/replacement cannot be applied",
3673        )
3674        .await?;
3675        return Ok(true);
3676    }
3677    let comment = format!(
3678        "{MARKER}\nOwner decision on question {}: {}. Previous attempt: `{}`. Original instruction and review history remain in the task record.",
3679        q.id, choice, state.id
3680    );
3681    if pr.state == PrLifecycle::Open {
3682        if let Err(e) = forge.close(&repo, &pr.url, &comment).await {
3683            stop(
3684                state,
3685                &repo,
3686                pr,
3687                &format!(
3688                    "owner requested closure but it failed: {e}; task held, no replacement started"
3689                ),
3690            )
3691            .await?;
3692            return Ok(true);
3693        }
3694    }
3695    let confirmed = forge.view(&repo, &pr.url).await?;
3696    if confirmed.pr.state != PrLifecycle::Closed {
3697        stop(
3698            state,
3699            &repo,
3700            pr,
3701            "PR closure was not confirmed; task held, no replacement started",
3702        )
3703        .await?;
3704        return Ok(true);
3705    }
3706    *pr = confirmed.pr;
3707    state.merge_decision.as_mut().unwrap().closed = true;
3708    if let Some(record) = &mut state.pr {
3709        record.state = "closed".into();
3710    }
3711    state.status = RunStatus::Superseded;
3712    state.merge = Some(MergeOutcome {
3713        mode: MergeMode::Pr,
3714        ok: false,
3715        detail: format!("owner decision: {choice}; PR closure confirmed"),
3716        empty: false,
3717    });
3718    state.event(
3719        "land",
3720        format!(
3721            "{} applied: PR closure confirmed; old execution retired",
3722            choice
3723        ),
3724    );
3725    state.save()?;
3726    Ok(true)
3727}
3728
3729/// Keep an unstarted verification resumable without charging a task attempt.
3730fn check_landing_resources(
3731    state: &mut RunState,
3732    node: &str,
3733    outcomes: &[crate::run::CommandOutcome],
3734) -> Result<()> {
3735    if let Some(blocked) = outcomes.iter().find(|outcome| outcome.resource_blocked) {
3736        let detail = format!("{}: {}", blocked.command, blocked.output_tail);
3737        state
3738            .resource_block
3739            .get_or_insert_with(|| crate::run::ResourceBlock {
3740                cause: crate::run::ResourceBlockCause::Other,
3741                node: node.into(),
3742                kind: "shared build cache".into(),
3743                detail: detail.clone(),
3744                at: jiff::Timestamp::now(),
3745            });
3746        state.event("resource", &detail);
3747        state.save()?;
3748        bail!("landing verification could not start: {detail}");
3749    }
3750    Ok(())
3751}
3752
3753/// Gate the local winner and publish that exact SHA, retaining the saved lease.
3754/// A push completed before a crash is recoverable only when its SHA was gated.
3755async fn publish_landing_head<F: Forge>(
3756    state: &mut RunState,
3757    observed: &str,
3758    pr_url: &str,
3759    forge: &F,
3760) -> Result<String> {
3761    crate::pr_head::ensure_owner(state)?;
3762    let winner = state.winner().cloned().context("landing has no winner")?;
3763    let head = git::rev_parse(&winner.worktree, "HEAD").await?;
3764    let expected = state.pr_pushed_head.as_deref().unwrap_or(observed);
3765    anyhow::ensure!(
3766        observed == expected
3767            || (observed == head
3768                && state.gate_head.as_deref() == Some(&head)
3769                && state.gate_allows_progress()),
3770        "public head moved outside this run; refusing to overwrite it"
3771    );
3772    anyhow::ensure!(
3773        git::is_clean(&winner.worktree).await?,
3774        "landing worktree is dirty"
3775    );
3776    if state.gate_head.as_deref() != Some(&head)
3777        || !state.gate_ran
3778        || !state.gate_commands_allow_progress()
3779    {
3780        state.reconcile_verification_head(&head);
3781        state.gate.clear();
3782        state.gate_head = None;
3783        state.gate_ran = false;
3784        state.pre_gate.clear();
3785        state.pre_gate_commit = None;
3786        state.save()?;
3787        let inherited = crate::repo_lock::WaitPolicy::current();
3788        let wait = crate::repo_lock::WaitPolicy::new(
3789            Duration::from_secs(state.config.graph.timeout_resource_wait),
3790            move || inherited.cancelled(),
3791        );
3792        let mut outcomes = crate::graph::run_landing_gate(state, &winner, &wait).await?;
3793        loop {
3794            if outcomes.iter().any(|outcome| outcome.resource_blocked) {
3795                state.gate = outcomes.clone();
3796                check_landing_resources(state, "gate", &outcomes)?;
3797            }
3798            if outcomes.iter().all(|o| o.ok()) {
3799                break;
3800            }
3801            match Box::pin(crate::graph::repair_landing_gate(state, &winner, &outcomes)).await? {
3802                crate::graph::GateFix::Retry => {
3803                    outcomes = crate::graph::run_landing_gate(state, &winner, &wait).await?;
3804                }
3805                crate::graph::GateFix::Stop => break,
3806                crate::graph::GateFix::Defer => {
3807                    // The repair checks e2e immediately, before the next gate.
3808                    // Preserve a cache wait here as well as below; otherwise
3809                    // the daemon charges an attempt for unstarted verification.
3810                    if let Some(e2e) = &state.gate_repair_e2e {
3811                        let outcomes = e2e.outcomes.clone();
3812                        check_landing_resources(state, "e2e", &outcomes)?;
3813                    }
3814                    bail!("landing gate repair deferred");
3815                }
3816            }
3817        }
3818        state.gate = outcomes;
3819        state.gate_ran = true;
3820        state.save()?;
3821    }
3822    let inherited = crate::repo_lock::WaitPolicy::current();
3823    let wait = crate::repo_lock::WaitPolicy::new(
3824        Duration::from_secs(state.config.graph.timeout_resource_wait),
3825        move || inherited.cancelled(),
3826    );
3827    let checked = state
3828        .gate_head
3829        .clone()
3830        .context("landing gate has no checked SHA")?;
3831    anyhow::ensure!(
3832        git::rev_parse(&winner.worktree, "HEAD").await? == checked
3833            && git::is_clean(&winner.worktree).await?,
3834        "landing tree changed after gate"
3835    );
3836    let e2e = crate::graph::check_gate_repair_e2e(state, &winner, &wait).await?;
3837    if matches!(e2e, crate::graph::GateFix::Defer) {
3838        let outcomes = state
3839            .gate_repair_e2e
3840            .as_ref()
3841            .context("deferred landing e2e has no outcomes")?
3842            .outcomes
3843            .clone();
3844        check_landing_resources(state, "e2e", &outcomes)?;
3845    }
3846    anyhow::ensure!(
3847        matches!(e2e, crate::graph::GateFix::Retry),
3848        "post-repair e2e has not passed on the landing head; nothing published"
3849    );
3850    anyhow::ensure!(
3851        git::rev_parse(&winner.worktree, "HEAD").await? == checked
3852            && git::is_clean(&winner.worktree).await?,
3853        "landing tree changed during post-repair e2e"
3854    );
3855    anyhow::ensure!(
3856        crate::graph::verify_current_head(state, &winner, &wait).await?,
3857        "current head e2e has not passed; nothing published"
3858    );
3859    anyhow::ensure!(
3860        state.gate_allows_progress(),
3861        "landing gate failed; nothing published"
3862    );
3863    crate::pr_head::ensure_owner(state)?;
3864    if owner_requested_stop(state)? {
3865        bail!("owner requested stop before publication");
3866    }
3867    let current = forge.view(&state.repo, pr_url).await?;
3868    anyhow::ensure!(
3869        current.pr.state == PrLifecycle::Open,
3870        "PR closed or merged while gating; nothing published"
3871    );
3872    anyhow::ensure!(
3873        current.head == observed || current.head == checked,
3874        "PR head changed while gating; nothing published"
3875    );
3876    anyhow::ensure!(
3877        crate::foreign_checkout::write_back(state, &checked).await?,
3878        "foreign checkout delivery is blocked; see the run events"
3879    );
3880    let public = state.pr_branch().unwrap_or(&winner.branch).to_owned();
3881    let lease = format!("--force-with-lease=refs/heads/{public}:{observed}");
3882    let refspec = format!("{checked}:refs/heads/{public}");
3883    let lock = repo_merge_lock(&state.repo);
3884    let _slot = lock.lock().await;
3885    let pushed = git::git_raw(
3886        &winner.worktree,
3887        &["push", &lease, &state.config.merge.remote, &refspec],
3888    )
3889    .await?;
3890    anyhow::ensure!(
3891        pushed.ok(),
3892        "publishing gated landing head failed: {}",
3893        pushed.stderr
3894    );
3895    state.pr_pushed_head = Some(checked.clone());
3896    state.land_sync_pending = false;
3897    state.save()?;
3898    Ok(checked)
3899}
3900
3901/// A scratch rebase moves the winner ref before its index and files. Recover
3902/// only a tree proven unchanged since the saved start; never discard edits.
3903async fn restore_landing_worktree(state: &mut RunState) -> Result<()> {
3904    let winner = state.winner().cloned().context("landing has no winner")?;
3905    let inherited = crate::repo_lock::WaitPolicy::current();
3906    let wait = crate::repo_lock::WaitPolicy::new(
3907        Duration::from_secs(state.config.graph.timeout_resource_wait),
3908        move || inherited.cancelled(),
3909    );
3910    let _coordination = crate::repo_lock::SeatLease::operation_with(
3911        &winner.worktree,
3912        state.config.coordination.as_ref(),
3913        &wait,
3914    )
3915    .await?;
3916    if !git::is_clean(&winner.worktree).await? {
3917        let from = state
3918            .land_rebase_from
3919            .as_deref()
3920            .context("landing worktree is dirty")?;
3921        let head = git::rev_parse(&winner.worktree, "HEAD").await?;
3922        anyhow::ensure!(head != from, "landing worktree is dirty");
3923        for args in [
3924            vec!["diff", "--cached", "--quiet", from],
3925            vec!["diff", "--quiet"],
3926        ] {
3927            anyhow::ensure!(
3928                git::git_raw(&winner.worktree, &args).await?.ok(),
3929                "landing worktree has edits beyond the interrupted rebase"
3930            );
3931        }
3932        // Preserve build artifacts and local files, including ignored ones.
3933        // read-tree can overwrite ignored paths, so reject collisions with
3934        // the new tree (including file/directory conflicts) before updating.
3935        let untracked = git::git(&winner.worktree, &["ls-files", "--others", "-z"]).await?;
3936        let tracked = git::git(
3937            &winner.worktree,
3938            &["ls-tree", "-r", "--name-only", "-z", "HEAD"],
3939        )
3940        .await?;
3941        for local in untracked.split('\0').filter(|p| !p.is_empty()) {
3942            anyhow::ensure!(
3943                !tracked.split('\0').filter(|p| !p.is_empty()).any(|path| {
3944                    path == local
3945                        || path
3946                            .strip_prefix(local)
3947                            .is_some_and(|rest| rest.starts_with('/'))
3948                        || local
3949                            .strip_prefix(path)
3950                            .is_some_and(|rest| rest.starts_with('/'))
3951                }),
3952                "landing worktree has an untracked or ignored path conflicting with HEAD: {local}"
3953            );
3954        }
3955        git::git(&winner.worktree, &["read-tree", "-m", "-u", "HEAD"]).await?;
3956    }
3957    if let (Some(checkout), Some(from)) = (&state.foreign_checkout, &state.land_rebase_from) {
3958        anyhow::ensure!(
3959            git::is_ancestor(&winner.worktree, &checkout.synced_head, from).await,
3960            "landing synchronization started outside the foreign checkout history"
3961        );
3962        if !git::is_ancestor(&winner.worktree, from, "HEAD").await {
3963            // The rebase's tree already includes the base and the fixer's
3964            // resolutions. Retain that exact tree, but join the pre-sync
3965            // history so delivery remains fast-forward. Keep the checkpoint
3966            // until this succeeds: a crash after rebase (or after this merge)
3967            // must recover through this same idempotent path before gating.
3968            git::git(
3969                &winner.worktree,
3970                &[
3971                    "-c",
3972                    "core.hooksPath=/dev/null",
3973                    "merge",
3974                    "--strategy=ours",
3975                    "--no-ff",
3976                    "--no-autostash",
3977                    "--no-edit",
3978                    "-m",
3979                    "Merge pre-sync history into the repaired landing tree",
3980                    from,
3981                ],
3982            )
3983            .await?;
3984        }
3985    }
3986    crate::worktree_setup::prepare(&state.config, &state.repo, &winner.worktree).await?;
3987    state.land_rebase_from = None;
3988    state.save()?;
3989    Ok(())
3990}
3991
3992async fn rebase_landing_worktree(
3993    state: &mut RunState,
3994    onto: &str,
3995) -> Result<crate::rebase::Rebased> {
3996    restore_landing_worktree(state).await?;
3997    let winner = state.winner().cloned().context("landing has no winner")?;
3998    let scratch = state.dir().join("rebase");
3999    let target = match state.land_sync_target.clone() {
4000        Some(target) => {
4001            crate::rebase::prepare(state, &scratch, &winner.branch).await?;
4002            target
4003        }
4004        // Older records lack the target checkpoint, but Git retains the
4005        // exact target of an interrupted operation. It is a continuation too.
4006        None if git::rebase_in_progress(&scratch).await => {
4007            crate::rebase::rebase_target(&scratch).await?
4008        }
4009        None => {
4010            anyhow::ensure!(
4011                state.land_sync_attempts < state.config.graph.land_rounds,
4012                "landing base synchronization budget exhausted"
4013            );
4014            let target = git::rev_parse(&state.repo, onto).await?;
4015            crate::rebase::prepare(state, &scratch, &winner.branch).await?;
4016            state.land_sync_attempts += 1;
4017            state.land_sync_target = Some(target.clone());
4018            target
4019        }
4020    };
4021    state.land_sync_target = Some(target.clone());
4022    state.land_sync_pending = true;
4023    state.land_rebase_from = Some(git::rev_parse(&winner.worktree, "HEAD").await?);
4024    state.save()?;
4025    // A continuation owns the attempt already charged above, including a
4026    // crash before the scratch rebase started. Finish its pinned base first;
4027    // a newer base must use another attempt on the next observation.
4028    let result = crate::rebase::rebase_prepared(state, &scratch, &winner.branch, &target).await?;
4029    state.land_sync_target = None;
4030    state.save()?;
4031    if result == crate::rebase::Rebased::Applied {
4032        restore_landing_worktree(state).await?;
4033    }
4034    Ok(result)
4035}
4036
4037/// Reconcile a stopped landing before changing its branch. This also handles
4038/// old records whose graph status or merge detail no longer identifies land.
4039async fn resume_landing_head<F: Forge>(
4040    state: &mut RunState,
4041    observed: &str,
4042    pr_url: &str,
4043    forge: &F,
4044    reason: Option<Blocking>,
4045) -> Result<String> {
4046    crate::pr_head::ensure_owner(state)?;
4047    let winner = state.winner().cloned().context("landing has no winner")?;
4048    let local = git::rev_parse(&winner.worktree, "HEAD").await?;
4049    let expected = state
4050        .pr_pushed_head
4051        .as_deref()
4052        .or(state.gate_head.as_deref())
4053        .context("missing public head lease")?;
4054    anyhow::ensure!(
4055        observed == expected
4056            || (observed == local
4057                && ((state.gate_head.as_deref() == Some(&local) && state.gate_allows_progress())
4058                    || git::is_ancestor(&winner.worktree, expected, &local).await)),
4059        "public head moved outside this run; refusing to sync"
4060    );
4061    // An operator may have extended and published the winner while approval
4062    // was pending. Matching local/public history can be adopted as the lease,
4063    // but publish_landing_head must gate its new SHA before proceeding. A
4064    // remote-only or divergent update still cannot be overwritten.
4065    // Save reconciliation before rebasing again; a prior push may have reached
4066    // the remote immediately before the previous driver's last save.
4067    state.pr_pushed_head = Some(observed.to_owned());
4068    state.save()?;
4069    restore_landing_worktree(state).await?;
4070    // Recover a rebase that finished before its completion checkpoint was
4071    // saved. Restoration above has already reconciled its files and ancestry.
4072    if let Some(target) = &state.land_sync_target
4073        && !git::rebase_in_progress(&state.dir().join("rebase")).await
4074        && git::ancestry(&winner.worktree, target, &local).await?
4075    {
4076        state.land_sync_target = None;
4077        state.save()?;
4078    }
4079    let remote = state.config.merge.remote.clone();
4080    let base = state.base_branch.clone();
4081    let fetched = git::fetch(&state.repo, &remote, &base).await?;
4082    anyhow::ensure!(
4083        fetched.ok(),
4084        "cannot fetch landing base: {}",
4085        fetched.stderr
4086    );
4087    anyhow::ensure!(
4088        !owner_requested_stop(state)?,
4089        "owner requested stop before base synchronization"
4090    );
4091    let onto = format!("{remote}/{base}");
4092    let tip = git::rev_parse(&state.repo, &onto).await?;
4093    let contains_base = git::ancestry(&state.repo, &tip, &local)
4094        .await
4095        .context("could not determine whether the landing head contains the fetched base")?;
4096    anyhow::ensure!(
4097        reason != Some(Blocking::Behind) || !contains_base,
4098        "BEHIND reported but the fetched base is already included; synchronization made no progress"
4099    );
4100    if !contains_base || reason == Some(Blocking::Conflict) {
4101        match rebase_landing_worktree(state, &onto).await? {
4102            crate::rebase::Rebased::Applied => {}
4103            crate::rebase::Rebased::Stopped(why) => bail!("landing rebase stopped: {why}"),
4104        }
4105    }
4106    if reason == Some(Blocking::Behind) {
4107        anyhow::ensure!(
4108            git::rev_parse(&winner.worktree, "HEAD").await? != local,
4109            "BEHIND synchronization left the head unchanged"
4110        );
4111    }
4112    publish_landing_head(state, observed, pr_url, forge).await
4113}
4114
4115/// Share the synchronization path with structured evidence retained after a refusal.
4116async fn synchronize_landing<F: Forge>(
4117    state: &mut RunState,
4118    pr: &mut PrState,
4119    observed: &str,
4120    pr_url: &str,
4121    forge: &F,
4122) -> Result<Option<String>> {
4123    if owner_stop(state, pr, forge).await? {
4124        return Ok(None);
4125    }
4126    state.event(
4127        "land",
4128        format!("{} base synchronization: {:?}", pr.url, pr.blocking),
4129    );
4130    state.save()?;
4131    let synced = resume_landing_head(state, observed, pr_url, forge, Some(pr.blocking)).await;
4132    if owner_stop(state, pr, forge).await? {
4133        return Ok(None);
4134    }
4135    match synced {
4136        Ok(head) => {
4137            if let Some(branch) = state.winner().map(|w| w.branch.clone()) {
4138                crate::graph::refresh_reviewed_commits(state, &branch).await;
4139            }
4140            Ok(Some(head))
4141        }
4142        Err(e) if e.is::<crate::repo_lock::ResourceBlocked>() => Err(e),
4143        Err(e) => {
4144            let repo = state.repo.clone();
4145            stop(
4146                state,
4147                &repo,
4148                pr,
4149                &format!("could not synchronize landing base: {e:#}"),
4150            )
4151            .await?;
4152            Ok(None)
4153        }
4154    }
4155}
4156
4157async fn land_with<F: Forge>(state: &mut RunState, pr_url: &str, forge: &F) -> Result<PrState> {
4158    crate::pr_head::ensure_owner(state)?;
4159    state.land_unrelated = None;
4160    let reopening_hold = crate::merge_decision::resumable_hold(state);
4161    let repo = state.repo.clone();
4162    let budget = state.config.graph.land_rounds;
4163    let mut round = 0usize;
4164    let ci = state.config.merge.ci.expectation();
4165    if ci == CiExpectation::Absent {
4166        state.event(
4167            "land",
4168            "CI not expected ([merge] ci = \"none\"); check status ignored",
4169        );
4170    }
4171    let mut waited = Duration::ZERO;
4172    // Comment bodies the fixer has already been shown. A comment is
4173    // outstanding until it has been handed over once; after that it is a
4174    // recorded decision, not an open question, and re-feeding it would loop the
4175    // budget away on a comment the fixer already declined with an argument.
4176    let mut shown: BTreeSet<String> = BTreeSet::new();
4177    // Await the last successfully published head, including across resumes.
4178    let mut awaiting_head: Option<String> = state.pr_pushed_head.clone();
4179    // Whether a settled-checks refusal has already been given its one re-look.
4180    let mut rechecked = false;
4181
4182    // Marks the run resumable through exactly this function, not through a
4183    // fresh competition: `RunStatus::resumable` excludes only `Merged`,
4184    // `Ready` and `Failed`, and `merge`'s own re-entry guard looks for this
4185    // status specifically to know a resumed run belongs back in `land`
4186    // rather than at a second `gh pr create`. Set on every entry - fresh or
4187    // resumed - because a resume that parked here again must keep reading
4188    // `Landing`, not whatever a first pass through `merge` left behind.
4189    state.status = RunStatus::Landing;
4190    state.event("land", format!("watching {pr_url}"));
4191    state.save()?;
4192
4193    // An armed merge recorded by an earlier pass may or may not have reached
4194    // the forge (the record is written before the call). It is taken back on
4195    // the first observation, where a pull request is known to stop with.
4196    let mut resumed_armed = state.land_armed_head.is_some();
4197
4198    'landing: loop {
4199        let seen = forge.view(&repo, pr_url).await?;
4200        let mut pr = seen.pr.clone();
4201        pr.review_comments.retain(|c| !shown.contains(&c.body));
4202        state.pr = Some(crate::run::PrRecord {
4203            url: pr.url.clone(),
4204            number: pr.number,
4205            state: pr.state.as_str().to_owned(),
4206            checks: pr.checks.as_str().to_owned(),
4207            round,
4208            rounds: budget,
4209            red_at_merge: Vec::new(),
4210        });
4211        state.save()?;
4212
4213        if pr.state == PrLifecycle::Open {
4214            state.observe_branch_owner_holds(&seen.head).await;
4215            state.save()?;
4216        }
4217        crate::pr_head::ensure_owner(state)?;
4218        if reopening_hold {
4219            anyhow::ensure!(
4220                pr.state == PrLifecycle::Open,
4221                "held PR is no longer open; cannot request a fresh decision"
4222            );
4223            // An explicit resume authorizes a fresh question only. Preserve the
4224            // answered card, and never enter repair/rebase/merge on this pass.
4225            disarm(forge, state, &repo, pr.number)
4226                .await
4227                .map_err(anyhow::Error::msg)?;
4228            let previous = state.merge_decision.take();
4229            let binding = state.land_approval.take();
4230            state.config.graph.land_approval = true;
4231            let subject = merge_subject(
4232                crate::graph::landing_title(state, &seen.title),
4233                &crate::graph::landing_subject_source(state),
4234            );
4235            let contested = contested_to_ask(state);
4236            if let Err(error) =
4237                approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head).await
4238            {
4239                state.merge_decision = previous;
4240                state.land_approval = binding;
4241                return Err(error);
4242            }
4243            state.end_pass_parked(crate::run::ParkCause::Question);
4244            state.parked = true;
4245            state.event("land", format!("explicit resume reopened held decision {}; parked awaiting a fresh owner answer", previous.as_ref().map(|d| d.question.as_str()).unwrap_or_default()));
4246            state.save()?;
4247            return Ok(pr);
4248        }
4249        if owner_stop(state, &mut pr, forge).await? {
4250            return Ok(pr);
4251        }
4252
4253        if std::mem::take(&mut resumed_armed) && pr.state == PrLifecycle::Open {
4254            // An approval already given for the same head is reused, so
4255            // nothing is asked twice. A failed disable
4256            // stops the run with the record kept: pushing on could change the
4257            // head under an arm that is still live.
4258            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4259                let why = format!(
4260                    "a previous pass may have armed auto-merge and it could not be disabled \
4261                     on resume: {e}"
4262                );
4263                stop(state, &repo, &pr, &why).await?;
4264                return Ok(pr);
4265            }
4266        }
4267
4268        // The head moved away from the one auto-merge was armed on, by
4269        // someone other than this loop. The arm is pinned and would refuse to
4270        // merge the new commit, but the approval was for the old one: take it
4271        // back and go through the normal path again.
4272        if pr.state == PrLifecycle::Open
4273            && !seen.head.is_empty()
4274            && state
4275                .land_armed_head
4276                .as_deref()
4277                .is_some_and(|armed| !armed.eq_ignore_ascii_case(&seen.head))
4278        {
4279            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4280                let why = format!(
4281                    "the head moved while auto-merge was armed and it could not be disabled: {e}"
4282                );
4283                stop(state, &repo, &pr, &why).await?;
4284                return Ok(pr);
4285            }
4286        }
4287
4288        if state.land_sync_pending && pr.state == PrLifecycle::Open {
4289            // Disarming can outlive an owner answer. Consume it before our
4290            // own rebase invalidates the head shown on the decision card.
4291            if owner_stop(state, &mut pr, forge).await? {
4292                return Ok(pr);
4293            }
4294            let repair_answer = state.land_approval.as_ref().is_some_and(|binding| {
4295                binding.head.eq_ignore_ascii_case(&seen.head)
4296                    && ask::Questions::open()
4297                        .get_for_effects(&binding.question)
4298                        .is_ok_and(|q| {
4299                            q.run == state.id
4300                                && q.node == APPROVAL_NODE
4301                                && q.status == ask::QuestionStatus::Answered
4302                                && matches!(approval(q.resolution().as_deref()), Approval::Repair)
4303                        })
4304            });
4305            if repair_answer {
4306                let subject = merge_subject(
4307                    crate::graph::landing_title(state, &seen.title),
4308                    &crate::graph::landing_subject_source(state),
4309                );
4310                let contested = contested_to_ask(state);
4311                if matches!(
4312                    approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head).await?,
4313                    ApprovalGate::Repair
4314                ) {
4315                    if let Err(why) = disarm(forge, state, &repo, pr.number).await {
4316                        state.event("repair", format!("auto-merge could not be disabled: {why}; repair preflight will retry"));
4317                        state.save()?;
4318                    }
4319                    return Ok(pr);
4320                }
4321            }
4322            let synced = resume_landing_head(state, &seen.head, pr_url, forge, None).await;
4323            // A stop detected before publication must apply its durable
4324            // decision, even when verification returned an error meanwhile.
4325            if owner_stop(state, &mut pr, forge).await? {
4326                return Ok(pr);
4327            }
4328            let head = synced?;
4329            awaiting_head = Some(head);
4330            waited = Duration::ZERO;
4331            rechecked = false;
4332            // Read CI and approvals afresh, never from the pre-push observation.
4333            continue;
4334        }
4335
4336        // A stale base is independent of the CI rollup. Keep the public-head
4337        // lease, but synchronize before waiting for checks on the old tree.
4338        if pr.state == PrLifecycle::Open
4339            && pr.blocking == Blocking::Behind
4340            && bound_head(&seen.head, &seen.head, awaiting_head.as_deref()).is_some()
4341        {
4342            let synced = synchronize_landing(state, &mut pr, &seen.head, pr_url, forge).await?;
4343            let Some(head) = synced else {
4344                return Ok(pr);
4345            };
4346            awaiting_head = Some(head);
4347            rechecked = false;
4348            waited = Duration::ZERO;
4349            continue;
4350        }
4351
4352        if pr.state == PrLifecycle::Open {
4353            if bound_head(&seen.head, &seen.rollup_head, awaiting_head.as_deref()).is_none() {
4354                if waited >= WAIT_CEILING {
4355                    let want = awaiting_head.as_deref().unwrap_or_default();
4356                    let why = format!(
4357                        "the pull request's checks were still not about one readable head after \
4358                         {} minutes (expected {}, pull request points at {}, checks are for {}); \
4359                         someone may have pushed over it",
4360                        WAIT_CEILING.as_secs() / 60,
4361                        if want.is_empty() { "any" } else { want },
4362                        if seen.head.is_empty() {
4363                            "nothing readable"
4364                        } else {
4365                            &seen.head
4366                        },
4367                        if seen.rollup_head.is_empty() {
4368                            "nothing readable"
4369                        } else {
4370                            &seen.rollup_head
4371                        },
4372                    );
4373                    stop_disarmed(forge, state, &repo, &pr, &why).await?;
4374                    return Ok(pr);
4375                }
4376                waited += POLL;
4377                forge.poll().await;
4378                continue;
4379            }
4380            // Reset once, when the awaited head first shows up; resetting on
4381            // every re-observation would let a standing refusal wait forever.
4382            if awaiting_head.take().is_some() {
4383                // The checks now being read belong to the new head; give them
4384                // the same grace a fresh pull request gets.
4385                waited = Duration::ZERO;
4386            }
4387        }
4388
4389        // The merge-state grace is head-bound and durable. Reruns reset the
4390        // checks clock, but must not extend this deadline across resumes.
4391        let decision_wait = if pr.checks == Checks::Red && pr.blocking == Blocking::Unsaid {
4392            let first = state
4393                .land_unsaid
4394                .get_or_insert_with(|| (seen.head.clone(), forge.now()));
4395            if !first.0.eq_ignore_ascii_case(&seen.head) {
4396                *first = (seen.head.clone(), forge.now());
4397            }
4398            let elapsed = Duration::from_secs(forge.now().saturating_sub(first.1).max(0) as u64);
4399            state.save()?;
4400            elapsed
4401        } else {
4402            waited
4403        };
4404        let proposed = decide_with(&pr, round, budget, decision_wait, ci);
4405        if pr.checks == Checks::Red && pr.blocking == Blocking::Unsaid && proposed == Step::Wait {
4406            if waited >= WAIT_CEILING {
4407                stop_disarmed(
4408                    forge,
4409                    state,
4410                    &repo,
4411                    &pr,
4412                    "merge state remained unreadable; refusing to merge on a guess",
4413                )
4414                .await?;
4415                return Ok(pr);
4416            }
4417            waited += POLL;
4418            forge.poll().await;
4419            continue;
4420        }
4421
4422        // A failed workflow run is rerun once, judged by its own run rather
4423        // than by the rollup's aggregate: another run still pending, or a fix
4424        // budget already spent, must not keep a flaky failure from its one
4425        // rerun. It spends no round and no attempt.
4426        if ci == CiExpectation::Expected
4427            && pr.state == PrLifecycle::Open
4428            && state.config.graph.rerun_flaky_checks
4429        {
4430            let include_optional = pr.checks == Checks::Red
4431                && matches!(proposed, Step::Fix { .. } | Step::GiveUp { .. });
4432            let failing = rerunnable_with(&seen.contexts, include_optional);
4433            let now = forge.now();
4434            match rerun_step(&failing, state.land_reruns.as_ref(), &seen.head, now) {
4435                RerunStep::Rerun(runs) => {
4436                    let rec = state.land_reruns.get_or_insert_with(Default::default);
4437                    if !rec.head.eq_ignore_ascii_case(&seen.head) {
4438                        *rec = LandReruns {
4439                            head: seen.head.clone(),
4440                            runs: BTreeMap::new(),
4441                        };
4442                    }
4443                    for run in &runs {
4444                        rec.runs.insert(run.clone(), now);
4445                    }
4446                    // Durable before the call: a restart must not
4447                    // rerun the same run twice. A save that fails
4448                    // means no rerun.
4449                    state.save()?;
4450                    let mut any = false;
4451                    for run in &runs {
4452                        let names = failing
4453                            .iter()
4454                            .filter(|(_, r)| r.as_deref() == Some(run))
4455                            .map(|(l, _)| l.as_str())
4456                            .collect::<Vec<_>>()
4457                            .join(", ");
4458                        match forge.rerun(&repo, run).await {
4459                            Ok(()) => {
4460                                any = true;
4461                                state.event(
4462                                    "land",
4463                                    format!("reran failed check(s) {names} (run {run})"),
4464                                );
4465                            }
4466                            // Stays recorded: never a retry loop.
4467                            Err(e) => state.event(
4468                                "land",
4469                                format!("could not rerun check(s) {names} (run {run}): {e:#}"),
4470                            ),
4471                        }
4472                    }
4473                    state.save()?;
4474                    if any {
4475                        waited = Duration::ZERO;
4476                        forge.poll().await;
4477                        continue;
4478                    }
4479                }
4480                RerunStep::Grace => {
4481                    if waited >= WAIT_CEILING {
4482                        let why = format!(
4483                            "checks were still failing after a rerun and {} minutes",
4484                            WAIT_CEILING.as_secs() / 60
4485                        );
4486                        stop(state, &repo, &pr, &why).await?;
4487                        return Ok(pr);
4488                    }
4489                    waited += POLL;
4490                    forge.poll().await;
4491                    continue;
4492                }
4493                RerunStep::Fix => {}
4494            }
4495        }
4496
4497        let step = proposed;
4498        // Armed on exactly this head: the forge is doing the waiting. A
4499        // decision to merge (or keep waiting) is only watched, never re-armed
4500        // and never re-approved; anything else - a red check, a comment, a
4501        // conflict - falls through to its own arm, which disarms first.
4502        let armed_here = state
4503            .land_armed_head
4504            .as_deref()
4505            .is_some_and(|armed| armed.eq_ignore_ascii_case(&seen.head));
4506        if armed_here && matches!(step, Step::Merge | Step::Wait) {
4507            if waited >= WAIT_CEILING {
4508                let required = if seen.base.is_empty() {
4509                    None
4510                } else {
4511                    forge.required_contexts(&repo, &seen.base).await
4512                };
4513                let why = format!(
4514                    "auto-merge was armed on {} but the pull request did not merge within {} \
4515                     minutes ({})",
4516                    seen.head,
4517                    WAIT_CEILING.as_secs() / 60,
4518                    waiting_on(&seen.merge_state, &seen.contexts, required.as_ref())
4519                );
4520                stop_disarmed(forge, state, &repo, &pr, &why).await?;
4521                return Ok(pr);
4522            }
4523            waited += POLL;
4524            forge.poll().await;
4525            continue;
4526        }
4527        if armed_here && !matches!(step, Step::Done { .. }) {
4528            // Not merging or waiting any more: whatever is next may change the
4529            // head or give up, and neither may leave the arm standing.
4530            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4531                let why = format!("auto-merge could not be disabled: {e}");
4532                stop(state, &repo, &pr, &why).await?;
4533                return Ok(pr);
4534            }
4535        }
4536        if pr.checks == Checks::Red
4537            && matches!(step, Step::Fix { .. } | Step::GiveUp { .. })
4538            && pr.review_comments.is_empty()
4539            && let Some(evidence) = forge.attribution(state, &seen).await
4540            && evidence.unrelated(&seen.head, &pr.failing)
4541        {
4542            if owner_stop(state, &mut pr, forge).await? {
4543                return Ok(pr);
4544            }
4545            // Attribution does not authorize action against an unseen push.
4546            let fresh = forge.view(&repo, pr_url).await?;
4547            if fresh.head != seen.head
4548                || fresh.rollup_head != seen.rollup_head
4549                || fresh.pr.state != PrLifecycle::Open
4550                || fresh.pr.checks != Checks::Red
4551                || fresh.pr.failing != pr.failing
4552                || fresh
4553                    .pr
4554                    .review_comments
4555                    .iter()
4556                    .any(|c| !shown.contains(&c.body))
4557            {
4558                continue;
4559            }
4560            hold_unrelated(state, &pr, evidence).await?;
4561            return Ok(pr);
4562        }
4563        match step {
4564            Step::Wait => {
4565                if waited >= WAIT_CEILING {
4566                    let why = format!(
4567                        "checks were still running after {} minutes",
4568                        WAIT_CEILING.as_secs() / 60
4569                    );
4570                    stop(state, &repo, &pr, &why).await?;
4571                    return Ok(pr);
4572                }
4573                waited += POLL;
4574                forge.poll().await;
4575            }
4576            Step::Done { merged } => {
4577                if merged {
4578                    state.pr_merged_head = (!seen.head.is_empty()).then(|| seen.head.clone());
4579                }
4580                // Auto-merge is pinned to the approved head, but the forge's
4581                // own handling of a later push is not something magi can
4582                // see: if the pull request merged on another commit, say so
4583                // loudly rather than record a clean landing.
4584                if let Some(armed) = state.land_armed_head.take() {
4585                    if merged && !seen.head.is_empty() && !armed.eq_ignore_ascii_case(&seen.head) {
4586                        let msg = format!(
4587                            "{} merged on {} but the owner approved {armed}; review what landed",
4588                            pr.url, seen.head
4589                        );
4590                        tracing::warn!("{msg}");
4591                        state.event("land", msg);
4592                        // Only an arm left by an older build can get here.
4593                        // The wording is fixed so a repeat does not relight
4594                        // the notice.
4595                        crate::notices::raise_with(
4596                            crate::notices::Notice::warn(
4597                                &format!("merged-unapproved-head:{}", state.id),
4598                                "A pull request merged on a commit the owner did not approve; \
4599                                 review what landed",
4600                            )
4601                            .link(crate::notices::Link::Run {
4602                                id: state.id.clone(),
4603                            }),
4604                            &state.config.notify,
4605                        );
4606                    }
4607                }
4608                state.status = if merged {
4609                    RunStatus::Merged
4610                } else {
4611                    RunStatus::Ready
4612                };
4613                let detail = if merged {
4614                    format!("{} was merged", pr.url)
4615                } else {
4616                    format!("{} was closed without merging", pr.url)
4617                };
4618                state.merge = Some(MergeOutcome {
4619                    mode: MergeMode::Pr,
4620                    ok: merged,
4621                    detail: detail.clone(),
4622                    empty: false,
4623                });
4624                state.event("land", detail);
4625                state.save()?;
4626                write_pr_state_through(state, pr.state);
4627                return Ok(pr);
4628            }
4629            Step::Merge => {
4630                state.check_delivery_evidence(&seen.head)?;
4631                let subject = merge_subject(
4632                    crate::graph::landing_title(state, &seen.title),
4633                    &crate::graph::landing_subject_source(state),
4634                );
4635                // The owner sees the panel before the one irreversible step,
4636                // and an unanswered question is a hold: silence never merges.
4637                //
4638                // The dedicated policy includes existing consent and post-repair
4639                // decisions; repair choice availability never grants merge authority.
4640                let contested = contested_to_ask(state);
4641                if !approval_reasons(state).is_empty() {
4642                    match approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head)
4643                        .await?
4644                    {
4645                        ApprovalGate::Approved => {}
4646                        ApprovalGate::Repair => {
4647                            // The driver consumes the saved request under the existing
4648                            // run/task claim. No merge, no second run or task.
4649                            if let Err(why) = disarm(forge, state, &repo, pr.number).await {
4650                                state.event("repair", format!("auto-merge could not be disabled: {why}; repair preflight will retry"));
4651                                state.save()?;
4652                            }
4653                            return Ok(pr);
4654                        }
4655                        ApprovalGate::Held => {
4656                            // Another entry point may have saved a stop after
4657                            // the first read above. Apply its durable action.
4658                            if owner_stop(state, &mut pr, forge).await? {
4659                                return Ok(pr);
4660                            }
4661                            stop(
4662                                state,
4663                                &repo,
4664                                &pr,
4665                                "the owner did not approve the merge (held or unanswered)",
4666                            )
4667                            .await?;
4668                            return Ok(pr);
4669                        }
4670                        // Filed (or still standing from an earlier visit) and
4671                        // not yet answered. Park here rather than wait: the
4672                        // question survives on disk, the daemon hands this
4673                        // run's slot to something else, and a later resume
4674                        // re-enters `land`, finds the same question, and
4675                        // either merges or stops depending on what it says
4676                        // by then.
4677                        ApprovalGate::Pending => {
4678                            state.end_pass_parked(crate::run::ParkCause::Question);
4679                            state.parked = true;
4680                            state.event(
4681                                "land",
4682                                "parked awaiting merge approval - resumes once answered",
4683                            );
4684                            state.save()?;
4685                            return Ok(pr);
4686                        }
4687                    }
4688                }
4689                // Open and past the gate above, so `seen.head` is the commit
4690                // the checks were bound to and the owner approved.
4691                //
4692                // Merge directly, bound to that commit. Auto-merge is not
4693                // armed any more: the forge checks `--match-head-commit` only
4694                // when the request is made, so an arm outlives the head it
4695                // was made for, and a push of another commit whose
4696                // requirements are met first would merge without approval.
4697                // A direct merge is checked by the forge at the moment it
4698                // happens, so only the approved head can land.
4699                let observed_head = seen.head.clone();
4700                // Read the pull request again just before: the state seen
4701                // above can be a moment old.
4702                {
4703                    let fresh = forge.view(&repo, pr_url).await.ok();
4704                    if fresh.as_ref().is_some_and(|current| {
4705                        current.pr.state == PrLifecycle::Open
4706                            && current.head.eq_ignore_ascii_case(&observed_head)
4707                            && Blocking::of(&current.merge_state) == Blocking::Behind
4708                    }) {
4709                        pr.blocking = Blocking::Behind;
4710                        let synced =
4711                            synchronize_landing(state, &mut pr, &observed_head, pr_url, forge)
4712                                .await?;
4713                        let Some(head) = synced else {
4714                            return Ok(pr);
4715                        };
4716                        awaiting_head = Some(head);
4717                        rechecked = false;
4718                        waited = Duration::ZERO;
4719                        continue 'landing;
4720                    }
4721                    if !direct_merge_is_safe(
4722                        fresh.as_ref(),
4723                        &observed_head,
4724                        &shown,
4725                        round,
4726                        budget,
4727                        waited,
4728                        ci,
4729                    ) {
4730                        if waited >= WAIT_CEILING {
4731                            let why = "the pull request did not settle on the approved head \
4732                                       before it could be merged";
4733                            stop(state, &repo, &pr, why).await?;
4734                            return Ok(pr);
4735                        }
4736                        state.event(
4737                            "land",
4738                            "the pull request changed before merging; looking again",
4739                        );
4740                        waited += POLL;
4741                        forge.poll().await;
4742                        continue;
4743                    }
4744                }
4745                let argv = merge_argv_at(pr.number, &subject, &observed_head);
4746                let out = {
4747                    let merge_lock = repo_merge_lock(&repo);
4748                    let _merge_slot = merge_lock.lock().await;
4749                    crate::pr_head::ensure_owner(state)?;
4750                    if let Some(task_id) = state
4751                        .origin
4752                        .as_ref()
4753                        .and_then(|origin| origin.task.as_ref())
4754                    {
4755                        let task = crate::queue::Queue::open()
4756                            .get(task_id)
4757                            .context("cannot verify the task owner immediately before merge")?;
4758                        if task.execution_runs().last() != Some(&state.id)
4759                            || task.operator_held()
4760                            || task.status == crate::queue::TaskStatus::Done
4761                        {
4762                            bail!(
4763                                "task ownership or an operator hold superseded this merge approval"
4764                            );
4765                        }
4766                    }
4767                    if let Some(binding) = &state.land_approval {
4768                        let current = ask::Questions::open().get_for_effects(&binding.question)?;
4769                        if merge_consent_superseded(state, &current)?
4770                            || current.run != state.id
4771                            || !binding.head.eq_ignore_ascii_case(&observed_head)
4772                            || approval(current.resolution().as_deref()) != Approval::Merge
4773                            || current.merge_target.as_ref().is_some_and(|t| {
4774                                t.pr != pr.url || !t.head.eq_ignore_ascii_case(&observed_head)
4775                            })
4776                        {
4777                            bail!(
4778                                "merge decision is stale or no longer authorizes the reviewed head"
4779                            );
4780                        }
4781                    }
4782                    forge.merge(&repo, &argv).await?
4783                };
4784                if out.0 {
4785                    // Exit 0 is not proof of a merge: with a merge queue `gh`
4786                    // enqueues (or reports the pull request already queued)
4787                    // and succeeds while it is still open. Ask the forge; an
4788                    // unreadable answer is not a confirmation either, so it
4789                    // is looked at again rather than recorded as merged.
4790                    let confirmed = forge.view(&repo, pr_url).await.is_ok_and(|c| {
4791                        if c.pr.state == PrLifecycle::Merged {
4792                            state.pr_merged_head = (!c.head.is_empty()).then_some(c.head);
4793                            true
4794                        } else {
4795                            false
4796                        }
4797                    });
4798                    if !confirmed {
4799                        if waited >= WAIT_CEILING {
4800                            let why = "the merge request succeeded but the pull request \
4801                                       could not be confirmed merged after waiting";
4802                            stop(state, &repo, &pr, why).await?;
4803                            return Ok(pr);
4804                        }
4805                        state.event(
4806                            "land",
4807                            "merge accepted but the pull request is not confirmed merged yet; waiting",
4808                        );
4809                        state.save()?;
4810                        waited += POLL;
4811                        forge.poll().await;
4812                        continue;
4813                    }
4814                    pr.state = PrLifecycle::Merged;
4815                    state.status = RunStatus::Merged;
4816                    state.merge = Some(MergeOutcome {
4817                        mode: MergeMode::Pr,
4818                        ok: true,
4819                        detail: format!("gh {}", argv.join(" ")),
4820                        empty: false,
4821                    });
4822                    // The last `state.pr` snapshot is whatever the poll before
4823                    // this merge observed - still `open` - and nothing below
4824                    // refreshes it from GitHub again, so the UI's round rail
4825                    // would otherwise keep animating a merged run forever.
4826                    if let Some(pr_record) = state.pr.as_mut() {
4827                        pr_record.state = pr.state.as_str().to_owned();
4828                    }
4829                    state.event("land", format!("merged {} as `{subject}`", pr.url));
4830                    announce_red_merge(state, &pr).await;
4831                    state.save()?;
4832                    write_pr_state_through(state, pr.state);
4833                    return Ok(pr);
4834                }
4835                let after_seen = forge.view(&repo, pr_url).await.ok();
4836                let after = after_seen.as_ref().map(|s| s.pr.state);
4837                if let Some(outcome) = merged_after_all(&argv, &out.1, after) {
4838                    state.pr_merged_head = after_seen
4839                        .as_ref()
4840                        .map(|s| s.head.clone())
4841                        .filter(|h| !h.is_empty());
4842                    pr.state = PrLifecycle::Merged;
4843                    state.status = RunStatus::Merged;
4844                    state.merge = Some(outcome);
4845                    if let Some(pr_record) = state.pr.as_mut() {
4846                        pr_record.state = pr.state.as_str().to_owned();
4847                    }
4848                    state.event("land", format!("merged {} as `{subject}`", pr.url));
4849                    announce_red_merge(state, &pr).await;
4850                    state.save()?;
4851                    write_pr_state_through(state, pr.state);
4852                    return Ok(pr);
4853                }
4854                let verdict = classify_refusal(after_seen.as_ref(), rechecked, &observed_head, ci);
4855                match verdict {
4856                    Refused::Behind => {
4857                        pr.blocking = Blocking::Behind;
4858                        let synced =
4859                            synchronize_landing(state, &mut pr, &observed_head, pr_url, forge)
4860                                .await?;
4861                        let Some(head) = synced else {
4862                            return Ok(pr);
4863                        };
4864                        awaiting_head = Some(head);
4865                        rechecked = false;
4866                        waited = Duration::ZERO;
4867                        continue 'landing;
4868                    }
4869                    Refused::Final => {
4870                        let merge_state = after_seen
4871                            .as_ref()
4872                            .map(|s| s.merge_state.as_str())
4873                            .filter(|m| !m.is_empty())
4874                            .unwrap_or("unknown");
4875                        // Which refusal this was decides what a person has to
4876                        // do about it, so the two are worded apart; both carry
4877                        // the forge's own message.
4878                        let why = format!(
4879                            "the merge was refused: {} (merge state: {merge_state})",
4880                            out.1
4881                        );
4882                        stop(state, &repo, &pr, &why).await?;
4883                        return Ok(pr);
4884                    }
4885                    verdict => {
4886                        // Back to the top, which re-decides and passes the
4887                        // approval gate again, a poll later. `waited` is not
4888                        // reset here: only a pushed fix restarts it, or a
4889                        // standing refusal would wait forever.
4890                        if waited >= WAIT_CEILING {
4891                            let why = format!(
4892                                "the merge was still refused after {} minutes: {}",
4893                                WAIT_CEILING.as_secs() / 60,
4894                                out.1
4895                            );
4896                            stop(state, &repo, &pr, &why).await?;
4897                            return Ok(pr);
4898                        }
4899                        if verdict == Refused::Recheck {
4900                            rechecked = true;
4901                        }
4902                        state.event(
4903                            "land",
4904                            "merge refused while the branch policy is not satisfied yet; waiting",
4905                        );
4906                        state.save()?;
4907                        waited += POLL;
4908                        forge.poll().await;
4909                    }
4910                }
4911            }
4912            Step::Rebase => {
4913                let synced = synchronize_landing(state, &mut pr, &seen.head, pr_url, forge).await?;
4914                let Some(head) = synced else {
4915                    return Ok(pr);
4916                };
4917                awaiting_head = Some(head);
4918                rechecked = false;
4919                waited = Duration::ZERO;
4920                continue 'landing;
4921            }
4922            Step::GiveUp { reason } => {
4923                stop(state, &repo, &pr, &reason).await?;
4924                return Ok(pr);
4925            }
4926            Step::Fix { reason } => {
4927                round += 1;
4928                waited = Duration::ZERO;
4929                for c in &pr.review_comments {
4930                    shown.insert(c.body.clone());
4931                }
4932                state.event("land", format!("round {round}: {reason}"));
4933                state.save()?;
4934
4935                let logs = failing_logs(&repo, &seen.failing_urls).await;
4936                let was_red = pr.checks == Checks::Red;
4937                if owner_stop(state, &mut pr, forge).await? {
4938                    return Ok(pr);
4939                }
4940                let fixed = forge.fix(state, &pr, round, budget, &reason, &logs).await?;
4941                if owner_stop(state, &mut pr, forge).await? {
4942                    return Ok(pr);
4943                }
4944                match fixed {
4945                    Fixed::Committed { head } => {
4946                        // Whatever the next look shows may still be the
4947                        // previous head; see `awaiting_new_head`.
4948                        state.pr_pushed_head = Some(head.clone());
4949                        awaiting_head = Some(head);
4950                        rechecked = false;
4951                        waited = Duration::ZERO;
4952                        forge.poll().await;
4953                    }
4954                    Fixed::Declined if was_red => {
4955                        // Review comments may have required this round even
4956                        // when CI was unrelated. Once the fixer has read them,
4957                        // use the same structural attribution before charging
4958                        // a no-commit stop to the task.
4959                        if let Some(evidence) = forge.attribution(state, &seen).await
4960                            && evidence.unrelated(&seen.head, &pr.failing)
4961                        {
4962                            let fresh = forge.view(&repo, pr_url).await?;
4963                            if fresh.head != seen.head
4964                                || fresh.rollup_head != seen.rollup_head
4965                                || fresh.pr.state != PrLifecycle::Open
4966                                || fresh.pr.checks != Checks::Red
4967                                || fresh.pr.failing != pr.failing
4968                                || fresh
4969                                    .pr
4970                                    .review_comments
4971                                    .iter()
4972                                    .any(|c| !shown.contains(&c.body))
4973                            {
4974                                continue;
4975                            }
4976                            if owner_stop(state, &mut pr, forge).await? {
4977                                return Ok(pr);
4978                            }
4979                            hold_unrelated(state, &pr, evidence).await?;
4980                            return Ok(pr);
4981                        }
4982                        let why = format!(
4983                            "the fixer produced no commit while {} check(s) were failing \
4984                             ({}); stopping instead of looping on an unchanged tree",
4985                            pr.failing.len(),
4986                            pr.failing.join(", ")
4987                        );
4988                        stop(state, &repo, &pr, &why).await?;
4989                        return Ok(pr);
4990                    }
4991                    // Comment-driven round with no commit: the fixer read the
4992                    // comments and changed nothing, which is a decision it is
4993                    // allowed to make. The comments are recorded as shown, so
4994                    // the next observation sees a clean pull request.
4995                    Fixed::Declined => state.event(
4996                        "land",
4997                        format!("round {round}: fixer declined the comments, nothing committed"),
4998                    ),
4999                    Fixed::Deferred => {
5000                        // No fixer was available to judge these comments or
5001                        // checks. Keep the previous completed-round count and
5002                        // return without handing the PR off as a task failure.
5003                        state.status = RunStatus::Blocked;
5004                        state.save()?;
5005                        return Ok(pr);
5006                    }
5007                    Fixed::Failed(why) => {
5008                        stop(state, &repo, &pr, &format!("the fix round failed: {why}")).await?;
5009                        return Ok(pr);
5010                    }
5011                }
5012                state.save()?;
5013            }
5014        }
5015    }
5016}
5017
5018/// Owner decision for a CI failure independently reproduced on the base.
5019pub const CI_HOLD_NODE: &str = "land-ci-unrelated";
5020
5021/// Durable machine-hold evidence, bound to one observed PR head.
5022#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5023pub struct CiHold {
5024    /// Head that exhibited the independently reproduced failures.
5025    pub head: String,
5026    /// Typed owner question controlling resumption.
5027    pub question: String,
5028    /// Complete structured facts used to attribute the failures.
5029    pub evidence: CiEvidence,
5030}
5031
5032/// Only structured forge annotations are compared, never log prose.
5033#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
5034struct CiFailure {
5035    path: String,
5036    start_line: u64,
5037    end_line: u64,
5038    title: String,
5039    message: String,
5040}
5041
5042#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5043struct CiCheckEvidence {
5044    label: String,
5045    head_check: u64,
5046    base_check: u64,
5047    app: u64,
5048    run: String,
5049    base_run: String,
5050    head_failures: Vec<CiFailure>,
5051    base_failures: Vec<CiFailure>,
5052    rerun_exhausted: bool,
5053}
5054
5055/// Pinned Git diff and forge failure annotations used for CI attribution.
5056#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5057pub struct CiEvidence {
5058    head: String,
5059    base: String,
5060    changed: Vec<String>,
5061    checks: Vec<CiCheckEvidence>,
5062}
5063
5064impl CiEvidence {
5065    /// Every red check must have the same located failure on the base, outside
5066    /// the diff. Changes to CI/build configuration invalidate this inference.
5067    fn unrelated(&self, head: &str, failing: &[String]) -> bool {
5068        if self.head != head
5069            || self.base.is_empty()
5070            || failing.is_empty()
5071            || self.changed.iter().any(|p| {
5072                p.starts_with(".github/")
5073                    || p.starts_with(".config/")
5074                    || p.starts_with(".cargo/")
5075                    || matches!(
5076                        p.rsplit('/').next().unwrap_or(p),
5077                        "Cargo.toml"
5078                            | "Cargo.lock"
5079                            | "Makefile.toml"
5080                            | "build.rs"
5081                            | "rust-toolchain.toml"
5082                    )
5083            })
5084        {
5085            return false;
5086        }
5087        failing.iter().all(|label| {
5088            let matches: Vec<_> = self.checks.iter().filter(|c| &c.label == label).collect();
5089            matches.len() == 1
5090                && matches[0].rerun_exhausted
5091                && !matches[0].head_failures.is_empty()
5092                && matches[0].head_failures.iter().all(|f| {
5093                    // Workflow-level exit-code annotations do not identify a
5094                    // failing test or source file, and prove nothing here.
5095                    !f.path.is_empty()
5096                        && !f.path.starts_with('.')
5097                        && !f.path.contains("..")
5098                        && !f.path.starts_with('/')
5099                        && !self.changed.contains(&f.path)
5100                        && matches[0].base_failures.contains(f)
5101                })
5102        })
5103    }
5104}
5105
5106async fn ci_json(repo: &Path, endpoint: String) -> Option<serde_json::Value> {
5107    let (ok, body) = gh(repo, &["api".into(), endpoint]).await.ok()?;
5108    if !ok {
5109        return None;
5110    }
5111    serde_json::from_str(&body).ok()
5112}
5113
5114async fn ci_annotations(repo: &Path, check: &serde_json::Value) -> Option<Vec<CiFailure>> {
5115    let count = check.pointer("/output/annotations_count")?.as_u64()?;
5116    if count == 0 || count >= 100 {
5117        return None;
5118    }
5119    let id = check.get("id")?.as_u64()?;
5120    let value = ci_json(
5121        repo,
5122        format!("repos/{{owner}}/{{repo}}/check-runs/{id}/annotations?per_page=100"),
5123    )
5124    .await?;
5125    let annotations = value.as_array()?;
5126    if annotations.len() != count as usize {
5127        return None;
5128    }
5129    annotations
5130        .iter()
5131        .filter(|a| a["annotation_level"] == "failure")
5132        .map(|a| {
5133            Some(CiFailure {
5134                path: a["path"].as_str()?.into(),
5135                start_line: a["start_line"].as_u64()?,
5136                end_line: a["end_line"].as_u64()?,
5137                title: a["title"].as_str()?.into(),
5138                message: a["message"].as_str()?.into(),
5139            })
5140        })
5141        .collect()
5142}
5143
5144async fn ci_runs(repo: &Path, sha: &str) -> Option<Vec<serde_json::Value>> {
5145    let value = ci_json(
5146        repo,
5147        format!("repos/{{owner}}/{{repo}}/commits/{sha}/check-runs?per_page=100&filter=latest"),
5148    )
5149    .await?;
5150    let runs = value["check_runs"].as_array()?;
5151    if value["total_count"].as_u64()? != runs.len() as u64 || runs.len() >= 100 {
5152        return None;
5153    }
5154    Some(runs.clone())
5155}
5156
5157async fn collect_ci_evidence(state: &RunState, seen: &Seen) -> Option<CiEvidence> {
5158    let repo = &state.repo;
5159    let base_ref = format!("refs/remotes/{}/{}", state.config.merge.remote, seen.base);
5160    let base = git::git_raw(repo, &["rev-parse", "--verify", &base_ref])
5161        .await
5162        .ok()?;
5163    if !base.ok() {
5164        return None;
5165    }
5166    let range = format!("{}...{}", base.stdout, seen.head);
5167    // No rename detection: both old and new paths must count as changed.
5168    let diff = git::git_raw(
5169        repo,
5170        &["diff", "--no-renames", "--name-only", "-z", &range, "--"],
5171    )
5172    .await
5173    .ok()?;
5174    if !diff.ok() {
5175        return None;
5176    }
5177    let head_runs = ci_runs(repo, &seen.head).await?;
5178    let base_runs = ci_runs(repo, &base.stdout).await?;
5179    let mut checks = Vec::new();
5180    for label in &seen.pr.failing {
5181        let matching = |runs: &[serde_json::Value]| {
5182            runs.iter()
5183                .filter(|r| r["name"].as_str() == Some(label))
5184                .cloned()
5185                .collect::<Vec<_>>()
5186        };
5187        let heads = matching(&head_runs);
5188        let bases = matching(&base_runs);
5189        if heads.len() != 1 || bases.len() != 1 {
5190            return None;
5191        }
5192        let h = &heads[0];
5193        let b = &bases[0];
5194        if h["conclusion"] != "failure"
5195            || b["conclusion"] != "failure"
5196            || h["status"] != "completed"
5197            || b["status"] != "completed"
5198            || h["head_sha"].as_str()? != seen.head
5199            || b["head_sha"].as_str()? != base.stdout
5200            || h.pointer("/app/id")?.as_u64()? != b.pointer("/app/id")?.as_u64()?
5201        {
5202            return None;
5203        }
5204        let run = run_of(h["details_url"].as_str()?)?;
5205        let contexts: Vec<_> = seen.contexts.iter().filter(|c| &c.label == label).collect();
5206        if contexts.len() != 1
5207            || contexts[0].run.as_ref() != Some(&run)
5208            || contexts[0].verdict != Verdict::Fail
5209        {
5210            return None;
5211        }
5212        // A persisted request alone is not a completed rerun: require the
5213        // workflow's structured attempt number as well.
5214        let workflow =
5215            ci_json(repo, format!("repos/{{owner}}/{{repo}}/actions/runs/{run}")).await?;
5216        let base_run = run_of(b["details_url"].as_str()?)?;
5217        let base_workflow = ci_json(
5218            repo,
5219            format!("repos/{{owner}}/{{repo}}/actions/runs/{base_run}"),
5220        )
5221        .await?;
5222        if base_workflow["head_sha"].as_str()? != base.stdout
5223            || base_workflow["head_branch"].as_str()? != seen.base
5224            || base_workflow["status"] != "completed"
5225            || base_workflow["conclusion"] != "failure"
5226            || base_workflow["workflow_id"].as_u64()? != workflow["workflow_id"].as_u64()?
5227        {
5228            return None;
5229        }
5230        let exhausted = state
5231            .land_reruns
5232            .as_ref()
5233            .is_some_and(|r| r.head == seen.head && r.runs.contains_key(&run))
5234            && workflow["head_sha"].as_str()? == seen.head
5235            && workflow["run_attempt"].as_u64()? > 1
5236            && workflow["status"] == "completed";
5237        checks.push(CiCheckEvidence {
5238            label: label.clone(),
5239            head_check: h["id"].as_u64()?,
5240            base_check: b["id"].as_u64()?,
5241            app: h.pointer("/app/id")?.as_u64()?,
5242            run,
5243            base_run,
5244            head_failures: ci_annotations(repo, h).await?,
5245            base_failures: ci_annotations(repo, b).await?,
5246            rerun_exhausted: exhausted,
5247        });
5248    }
5249    Some(CiEvidence {
5250        head: seen.head.clone(),
5251        base: base.stdout,
5252        changed: diff
5253            .stdout
5254            .split('\0')
5255            .filter(|p| !p.is_empty())
5256            .map(str::to_owned)
5257            .collect(),
5258        checks,
5259    })
5260}
5261
5262async fn hold_unrelated(state: &mut RunState, pr: &PrState, evidence: CiEvidence) -> Result<()> {
5263    let detail = serde_json::to_string(&evidence)?;
5264    let resume = "daemon: CI を確認して同じ run を再開する".to_owned();
5265    let hold = "operator: 保留して後で判断する".to_owned();
5266    let mut q = ask::Question::new(
5267        state.id.clone(),
5268        CI_HOLD_NODE.into(),
5269        "land".into(),
5270        "base でも再現する CI の失敗を検出したため、試行を消費せず保留しました".into(),
5271        format!(
5272            "必須チェックや承認は省略しません。再開時にも同じ workflow run は自動再実行しません。\n構造化された判定根拠:\n{detail}"
5273        ),
5274        vec![resume.clone(), hold.clone()],
5275    );
5276    q.actions.insert(
5277        resume,
5278        ask::ChoiceAction::Resume {
5279            run: state.id.clone(),
5280        },
5281    );
5282    q.actions.insert(hold, ask::ChoiceAction::Hold);
5283    ask::Questions::open().put_executable(&mut q)?;
5284    state.land_unrelated = Some(CiHold {
5285        head: evidence.head.clone(),
5286        question: q.id.clone(),
5287        evidence,
5288    });
5289    state.event("land", format!("[ci-unrelated] base reproduces every located failure after rerun; owner question {}: {detail}", q.id));
5290    state.end_pass_parked(crate::run::ParkCause::Question);
5291    state.parked = true;
5292    state.save()?;
5293    if let Err(e) = ask::notify(&state.config.notify, &q).await {
5294        tracing::warn!("could not notify about CI hold: {e:#}");
5295    }
5296    // A durable question and evidence are sufficient even if commenting fails.
5297    let body = stop_comment(
5298        &state.id,
5299        "CI failures independently reproduced on the base; awaiting an owner decision without charging the task attempt",
5300    );
5301    let (_, body) = crate::github_text::prepare(state, "", &body);
5302    gh(
5303        &state.repo,
5304        &[
5305            "pr".into(),
5306            "comment".into(),
5307            pr.number.to_string(),
5308            "--body".into(),
5309            body,
5310        ],
5311    )
5312    .await
5313    .ok();
5314    Ok(())
5315}
5316
5317/// One observation, plus the two things [`PrState`] deliberately does not carry:
5318/// the title (needed for the squash subject) and where the failing checks'
5319/// logs live.
5320#[derive(Clone)]
5321struct Seen {
5322    pr: PrState,
5323    title: String,
5324    failing_urls: Vec<(String, String)>,
5325    /// `headRefOid`: the commit this observation, checks included, is about.
5326    head: String,
5327    /// The commit the checks belong to, read from the same GraphQL node as
5328    /// the checks themselves. Empty when unreadable.
5329    rollup_head: String,
5330    /// `mergeStateStatus` as the forge spelled it. [`Blocking`] folds BLOCKED
5331    /// and DRAFT together, and a stop reason has to say which.
5332    merge_state: String,
5333    /// Every check of the rollup, for naming what an armed merge waits on.
5334    contexts: Vec<CheckInfo>,
5335    /// `baseRefName`, to look up which contexts the base requires.
5336    base: String,
5337}
5338
5339/// One check of the rollup as far as a stop reason needs it.
5340#[derive(Clone)]
5341struct CheckInfo {
5342    label: String,
5343    verdict: Verdict,
5344    required: Option<bool>,
5345    /// The workflow run the check belongs to; `None` for an external status.
5346    run: Option<String>,
5347}
5348
5349/// What to do with a red head before a fix round is spent on it.
5350#[derive(Debug, Clone, PartialEq, Eq)]
5351enum RerunStep {
5352    /// Rerun these workflow runs (each not yet rerun for this head).
5353    Rerun(Vec<String>),
5354    /// Reran already and the forge may still report the old failure: wait.
5355    Grace,
5356    /// Nothing to rerun, or the rerun did not help: the fixer's turn.
5357    Fix,
5358}
5359
5360/// Failed checks a rerun may help: a failure of a check that blocks (`required`
5361/// unreadable counts), as `(label, run)`. Judged one workflow run at a time;
5362/// pending checks in another run do not delay this run's rerun.
5363#[cfg(test)]
5364fn rerunnable(contexts: &[CheckInfo]) -> Vec<(String, Option<String>)> {
5365    rerunnable_with(contexts, false)
5366}
5367
5368fn rerunnable_with(
5369    contexts: &[CheckInfo],
5370    include_optional: bool,
5371) -> Vec<(String, Option<String>)> {
5372    contexts
5373        .iter()
5374        .filter(|c| c.verdict == Verdict::Fail && (include_optional || c.required != Some(false)))
5375        // `gh run rerun --failed` refuses a run with a job still going.
5376        .filter(|c| {
5377            c.run.as_ref().is_none_or(|r| {
5378                !contexts.iter().any(|o| {
5379                    matches!(o.verdict, Verdict::Pending | Verdict::Unknown)
5380                        && o.run.as_ref() == Some(r)
5381                })
5382            })
5383        })
5384        .map(|c| (c.label.clone(), c.run.clone()))
5385        .collect()
5386}
5387
5388/// Pure: rerun once per run id, wait out the grace, then hand over.
5389fn rerun_step(
5390    failing: &[(String, Option<String>)],
5391    record: Option<&LandReruns>,
5392    head: &str,
5393    now: i64,
5394) -> RerunStep {
5395    // A failure with no workflow run (an external status) cannot be rerun, and
5396    // the fixer's push re-runs everything anyway.
5397    if failing.is_empty() || failing.iter().any(|(_, run)| run.is_none()) {
5398        return RerunStep::Fix;
5399    }
5400    // Reruns belong to the head they were made on.
5401    let record = record.filter(|r| r.head.eq_ignore_ascii_case(head));
5402    let mut fresh: Vec<String> = Vec::new();
5403    let mut recent = false;
5404    for run in failing.iter().filter_map(|(_, run)| run.as_deref()) {
5405        match record.and_then(|r| r.runs.get(run)) {
5406            None => {
5407                if !fresh.iter().any(|f| f == run) {
5408                    fresh.push(run.to_owned());
5409                }
5410            }
5411            Some(&at) if now - at < crate::release_watch::RERUN_GRACE => recent = true,
5412            Some(_) => {}
5413        }
5414    }
5415    if !fresh.is_empty() {
5416        RerunStep::Rerun(fresh)
5417    } else if recent {
5418        RerunStep::Grace
5419    } else {
5420        RerunStep::Fix
5421    }
5422}
5423
5424/// Read the pull request: `gh pr view` for the top-level thread and merge
5425/// state, `gh api graphql` for the last commit and its checks, `gh api` for the
5426/// inline review comments `gh pr view` does not report.
5427async fn observe(repo: &Path, pr_url: &str) -> Result<Seen> {
5428    let view = gh(
5429        repo,
5430        &[
5431            "pr".to_owned(),
5432            "view".to_owned(),
5433            pr_url.to_owned(),
5434            "--json".to_owned(),
5435            "url,number,state,title,reviews,comments,mergeStateStatus,headRefOid,baseRefName"
5436                .to_owned(),
5437        ],
5438    )
5439    .await?;
5440    if !view.0 {
5441        bail!("gh pr view {pr_url}: {}", view.1);
5442    }
5443    let number = parse_pr(&view.1)?.number;
5444    let node = last_commit_node(repo, number).await;
5445    let mut seen = seen_from(&view.1, node.as_deref())?;
5446
5447    let inline = gh(
5448        repo,
5449        &[
5450            "api".to_owned(),
5451            format!("repos/{{owner}}/{{repo}}/pulls/{}/comments", seen.pr.number),
5452        ],
5453    )
5454    .await?;
5455    if inline.0 {
5456        match parse_inline_comments(&inline.1) {
5457            Ok(mut comments) => seen.pr.review_comments.append(&mut comments),
5458            // An unreadable inline thread must not end a landing: the rollup
5459            // and the top-level thread are still real signal.
5460            Err(e) => tracing::warn!("inline review comments unreadable: {e}"),
5461        }
5462    } else {
5463        tracing::warn!("gh api pulls/{}/comments: {}", seen.pr.number, inline.1);
5464    }
5465    Ok(seen)
5466}
5467
5468/// Build a [`Seen`] from the `gh pr view` json and the last-commit node
5469/// response. No I/O.
5470///
5471/// The commit oid and the checks are read from the *same* node, so the rollup
5472/// is bound to the commit it belongs to by construction; two reads that agree
5473/// before and after another response prove nothing about what that response
5474/// held. The view's own rollup is never used. A node that is missing,
5475/// unreadable, carries GraphQL errors, or whose checks run past the page
5476/// leaves `rollup_head` empty and the checks `Unknown`, which the loop treats
5477/// as "look again" and never as a reason to merge.
5478fn seen_from(view_json: &str, node_json: Option<&str>) -> Result<Seen> {
5479    let mut pr = parse_pr(view_json)?;
5480    let raw: GhPr = serde_json::from_str(view_json).context("re-read pull request json")?;
5481
5482    let mut rollup_head = String::new();
5483    let mut failing_urls = Vec::new();
5484    let mut contexts = Vec::new();
5485    let mut checks = Checks::Unknown;
5486    let mut failing = Vec::new();
5487    if let Some((oid, rollup)) = node_json.and_then(parse_last_commit_node) {
5488        (checks, failing) = rollup_verdict(&rollup);
5489        failing_urls = rollup
5490            .iter()
5491            .filter(|c| c.verdict() == Verdict::Fail)
5492            .filter_map(|c| c.url().map(|u| (c.label(), u.to_owned())))
5493            .collect();
5494        contexts = rollup
5495            .iter()
5496            .map(|c| CheckInfo {
5497                label: c.label(),
5498                verdict: c.verdict(),
5499                required: c.is_required,
5500                run: c.url().and_then(run_of),
5501            })
5502            .collect();
5503        rollup_head = oid;
5504    }
5505    pr.checks = checks;
5506    pr.failing = failing;
5507
5508    Ok(Seen {
5509        pr,
5510        title: raw.title,
5511        failing_urls,
5512        head: raw.head_ref_oid,
5513        rollup_head,
5514        merge_state: raw.merge_state_status,
5515        contexts,
5516        base: raw.base_ref_name,
5517    })
5518}
5519
5520/// The last commit's oid and its checks from one GraphQL response, `None`
5521/// when anything about it cannot be trusted.
5522fn parse_last_commit_node(json: &str) -> Option<(String, Vec<GhCheck>)> {
5523    let v: serde_json::Value = serde_json::from_str(json).ok()?;
5524    if v.get("errors").is_some_and(|e| !e.is_null()) {
5525        return None;
5526    }
5527    let commit = v.pointer("/data/repository/pullRequest/commits/nodes/0/commit")?;
5528    let oid = commit.get("oid")?.as_str().filter(|o| !o.is_empty())?;
5529    let contexts = commit.pointer("/statusCheckRollup/contexts");
5530    let Some(contexts) = contexts.filter(|c| !c.is_null()) else {
5531        // No rollup at all: the commit has no checks.
5532        return Some((oid.to_owned(), Vec::new()));
5533    };
5534    if contexts.pointer("/pageInfo/hasNextPage")?.as_bool()? {
5535        return None;
5536    }
5537    let nodes = contexts.get("nodes")?.as_array()?;
5538    let rollup = nodes
5539        .iter()
5540        .map(|n| serde_json::from_value::<GhCheck>(n.clone()))
5541        .collect::<Result<Vec<_>, _>>()
5542        .ok()?;
5543    Some((oid.to_owned(), rollup))
5544}
5545
5546/// The pull request's last commit and its checks, in one response. `None`
5547/// when the forge could not be asked.
5548async fn last_commit_node(repo: &Path, number: u64) -> Option<String> {
5549    let out = gh(
5550        repo,
5551        &[
5552            "api".to_owned(),
5553            "graphql".to_owned(),
5554            "-F".to_owned(),
5555            "owner={owner}".to_owned(),
5556            "-F".to_owned(),
5557            "repo={repo}".to_owned(),
5558            "-F".to_owned(),
5559            format!("number={number}"),
5560            "-f".to_owned(),
5561            "query=query($owner:String!,$repo:String!,$number:Int!){repository(owner:$owner,\
5562             name:$repo){pullRequest(number:$number){commits(last:1){nodes{commit{oid \
5563             statusCheckRollup{contexts(first:100){pageInfo{hasNextPage} nodes{\
5564             ... on CheckRun{name status conclusion detailsUrl \
5565             isRequired(pullRequestNumber:$number)} \
5566             ... on StatusContext{context state targetUrl \
5567             isRequired(pullRequestNumber:$number)}}}}}}}}}}"
5568                .to_owned(),
5569        ],
5570    )
5571    .await
5572    .ok()?;
5573    out.0.then_some(out.1)
5574}
5575
5576/// What a fix round did.
5577#[doc(hidden)]
5578#[derive(Debug, PartialEq)]
5579pub enum Fixed {
5580    /// The fixer committed something, and this is the head that was pushed.
5581    Committed {
5582        /// The commit now at the tip of the pushed branch.
5583        head: String,
5584    },
5585    /// The fixer ran and chose to change nothing.
5586    Declined,
5587    /// Machine availability prevented a result; retry this round on resume.
5588    Deferred,
5589    /// The fixer could not run, or said nothing usable.
5590    Failed(String),
5591}
5592
5593/// Hand the failures and the comments to the fixer, then commit and push.
5594///
5595/// The fixer works in the winner's own worktree so its commits land on the
5596/// branch the pull request is built from, and it runs with `allow_write` for
5597/// the same reason.
5598#[doc(hidden)]
5599pub async fn fix_round(
5600    state: &mut RunState,
5601    pr: &PrState,
5602    round: usize,
5603    budget: usize,
5604    reason: &str,
5605    logs: &str,
5606) -> Result<Fixed> {
5607    let winner = state
5608        .winner()
5609        .cloned()
5610        .context("landing needs a winning candidate; none is recorded on this run")?;
5611    let roles = state
5612        .config
5613        .resolve_roles()
5614        .context("resolve the roster for the fix round")?;
5615    // Same chain as the review loop (see `crate::fixer`): the configured
5616    // fixers in order, otherwise the winner's own author continuing its own
5617    // conversation - the competition is over, so its context is pure benefit.
5618    let attempts = crate::fixer::attempts(state, &roles, &winner);
5619    let ids: Vec<String> = attempts.iter().map(|(s, _)| s.id.clone()).collect();
5620
5621    let prompt = fix_prompt(state, pr, round, budget, reason, logs);
5622    let mut artifacts = agent::artifacts_dir(&state.dir());
5623    if let Some(request) = state
5624        .merge_repairs
5625        .last()
5626        .filter(|r| r.phase == crate::run::MergeRepairPhase::Fixing)
5627    {
5628        artifacts = artifacts.join(format!("merge-repair-{}", request.question));
5629    }
5630    let prompt = if state.config.cache_dir().is_some() {
5631        format!("{prompt}\n\n{}", prompt::build_cache_note("fix", true))
5632    } else {
5633        prompt
5634    };
5635    // Read before the fixer runs: it normally commits for itself, so HEAD has
5636    // already moved by the time it returns and a later read would see no
5637    // progress (run 20261004-041622-5769 stopped on a fix that had landed).
5638    let before = git::rev_parse(&winner.worktree, "HEAD").await?;
5639    // Each id at most once, forward only: the next one is asked only when the
5640    // call advances, and only the last attempt's result is judged below, so an
5641    // exhausted chain ends as a single failed fixer does.
5642    let mut last = None;
5643    for (i, (spec, seat_key)) in attempts.into_iter().enumerate() {
5644        if owner_requested_stop(state)? {
5645            return Ok(Fixed::Declined);
5646        }
5647        let mut seat = seat_of(state, &seat_key, &spec.id);
5648        let stem = if i == 0 {
5649            format!("land-{round}")
5650        } else {
5651            format!("land-{round}-{}", spec.id)
5652        };
5653        let out = agent::invoke(
5654            &spec,
5655            &mut seat,
5656            &Invocation {
5657                coordination: state.config.coordination.as_ref(),
5658                fetched_base: state.fetched_base.as_ref(),
5659                cwd: &winner.worktree,
5660                prompt: &prompt,
5661                timeout: Duration::from_secs(state.config.graph.timeout_fix),
5662                allow_write: true,
5663                sessions: state.config.graph.sessions,
5664                artifacts: &artifacts,
5665                stem: &stem,
5666                run: &state.id,
5667                node: "land",
5668                cache_dir: state.config.cache_dir().as_deref(),
5669                attachments: &[],
5670                writable: &[],
5671            },
5672        )
5673        .await;
5674        state.seats.insert(seat.key.clone(), seat);
5675        if let Some(next) = ids.get(i + 1)
5676            && agent::chain_advances(&out)
5677        {
5678            let (class, why) = crate::fixer::failure_of(&out);
5679            crate::graph::record_handover(state, "land", &seat_key, &spec.id, next, &class, &why);
5680            continue;
5681        }
5682        last = Some((seat_key, out));
5683        break;
5684    }
5685    let (seat_key, out) = last.expect("the fixer chain always has an entry");
5686
5687    match out {
5688        Ok(o) if o.quota_exhausted() => {
5689            let loss = crate::run::QuotaLoss::from_report(seat_key, "land", o.quota.as_ref());
5690            crate::graph::block_machine_outage(state, "land", std::slice::from_ref(&loss));
5691            state.quota.push(loss);
5692            state.status = RunStatus::Blocked;
5693            state.save()?;
5694            // Keep partial edits reachable on the winner branch and leave a
5695            // clean tree for resume_landing_head. The resumed landing gates
5696            // this new commit before it can publish it; no push happens here.
5697            let inherited = crate::repo_lock::WaitPolicy::current();
5698            let wait = crate::repo_lock::WaitPolicy::new(
5699                Duration::from_secs(state.config.graph.timeout_resource_wait),
5700                move || inherited.cancelled(),
5701            );
5702            let _coordination = crate::repo_lock::SeatLease::operation_with(
5703                &winner.worktree,
5704                state.config.coordination.as_ref(),
5705                &wait,
5706            )
5707            .await?;
5708            let rescue = git::rescue_commit(
5709                &winner.worktree,
5710                &format!("magi: deferred land round {round} (uncommitted work)"),
5711            )
5712            .await?;
5713            state.note_withheld("land", &rescue.withheld);
5714            state.save()?;
5715            return Ok(Fixed::Deferred);
5716        }
5717        Ok(o) if !o.usable() => {
5718            return Ok(Fixed::Failed(format!(
5719                "the fixer produced nothing usable ({})",
5720                crate::notices::turn_status(o.exit_code, o.timed_out, o.quota_exhausted())
5721            )));
5722        }
5723        Ok(_) => {}
5724        Err(e) if e.is::<crate::repo_lock::ResourceBlocked>() => return Err(e),
5725        Err(e) => return Ok(Fixed::Failed(format!("{e:#}"))),
5726    }
5727
5728    if owner_requested_stop(state)? {
5729        return Ok(Fixed::Declined);
5730    }
5731
5732    // An agent that edited files but never committed would otherwise push
5733    // nothing and look like a refusal.
5734    let wait = crate::repo_lock::WaitPolicy::new(
5735        Duration::from_secs(state.config.graph.timeout_resource_wait),
5736        || false,
5737    );
5738    let coordination = crate::repo_lock::SeatLease::operation_with(
5739        &winner.worktree,
5740        state.config.coordination.as_ref(),
5741        &wait,
5742    )
5743    .await?;
5744    match git::rescue_commit(
5745        &winner.worktree,
5746        &format!("magi: land round {round} fixes (uncommitted work)"),
5747    )
5748    .await
5749    {
5750        Ok(r) => state.note_withheld("land", &r.withheld),
5751        Err(e)
5752            if state
5753                .merge_repairs
5754                .last()
5755                .is_some_and(|r| r.phase == crate::run::MergeRepairPhase::Fixing) =>
5756        {
5757            return Ok(Fixed::Failed(format!("saving repair commit failed: {e:#}")));
5758        }
5759        Err(_) => {}
5760    }
5761    let after = git::rev_parse(&winner.worktree, "HEAD").await?;
5762    drop(coordination);
5763    if after == before {
5764        return Ok(Fixed::Declined);
5765    }
5766
5767    if owner_requested_stop(state)? {
5768        return Ok(Fixed::Declined);
5769    }
5770    crate::pr_head::ensure_owner(state)?;
5771    let remote = state.config.merge.remote.clone();
5772    anyhow::ensure!(
5773        crate::foreign_checkout::write_back(state, &after).await?,
5774        "foreign checkout delivery is blocked; see the run events"
5775    );
5776    let public_head = state.pr_branch().unwrap_or(&winner.branch).to_owned();
5777    let push = if state.pr_head.is_some() {
5778        let expected = state
5779            .pr_pushed_head
5780            .as_deref()
5781            .context("missing public head lease")?;
5782        git::push_as(
5783            &winner.worktree,
5784            &remote,
5785            &winner.branch,
5786            &public_head,
5787            expected,
5788        )
5789        .await?
5790    } else {
5791        git::push(&winner.worktree, &remote, &winner.branch).await?
5792    };
5793    if !push.ok() {
5794        return Ok(Fixed::Failed(format!(
5795            "pushing {} to {remote} failed: {}",
5796            public_head, push.stderr
5797        )));
5798    }
5799    state.event(
5800        "land",
5801        format!("round {round}: pushed a fix to {public_head}"),
5802    );
5803    state.pr_pushed_head = Some(after.clone());
5804    state.save()?;
5805    Ok(Fixed::Committed { head: after })
5806}
5807
5808/// Fetch or create a seat, keeping its conversation across nodes.
5809pub(crate) fn seat_of(state: &mut RunState, key: &str, agent: &str) -> SeatState {
5810    crate::fixer::seat_for(state, key, agent)
5811}
5812
5813/// Recheck the live PR and local worktree before spending the requested fix.
5814/// A moved/closed PR is held, never repaired using obsolete evidence.
5815pub(crate) async fn repair_preflight(state: &RunState, url: &str, head: &str) -> Result<PrState> {
5816    let seen = observe(&state.repo, url).await?;
5817    let winner = state.winner().context("no winning branch to repair")?;
5818    if seen.pr.state != PrLifecycle::Open || seen.head != head {
5819        anyhow::bail!(
5820            "PR is closed or its head changed; review the current head before requesting repair again"
5821        );
5822    }
5823    if git::rev_parse(&winner.worktree, "HEAD").await? != head
5824        || !git::is_clean(&winner.worktree).await?
5825    {
5826        anyhow::bail!(
5827            "repair worktree is missing, dirty or at a different head; restore the reviewed branch and resume this run"
5828        );
5829    }
5830    // Always disable any forge-side reservation, including one not recorded
5831    // by this run. A repair request is never merge authorization.
5832    let view = gh(
5833        &state.repo,
5834        &[
5835            "pr".into(),
5836            "view".into(),
5837            url.into(),
5838            "--json".into(),
5839            "autoMergeRequest,headRefOid,state,headRefName,baseRefName,isCrossRepository".into(),
5840        ],
5841    )
5842    .await?;
5843    if !view.0 {
5844        bail!("cannot check auto-merge: {}", view.1);
5845    }
5846    let live: serde_json::Value = serde_json::from_str(&view.1)?;
5847    let public = state.pr_branch().unwrap_or(&winner.branch);
5848    if live["state"] != "OPEN"
5849        || live["headRefOid"] != head
5850        || live["headRefName"] != public
5851        || live["baseRefName"] != state.base_branch
5852        || live["isCrossRepository"] != false
5853    {
5854        bail!("PR changed during repair preflight; review its current head explicitly");
5855    }
5856    let auto_merge = live
5857        .get("autoMergeRequest")
5858        .context("cannot read the PR auto-merge reservation; repair held")?;
5859    if !auto_merge.is_null() {
5860        let out = gh(&state.repo, &disable_automerge_argv(seen.pr.number)).await?;
5861        if !out.0 {
5862            bail!("cannot disable auto-merge; repair held: {}", out.1);
5863        }
5864    }
5865    Ok(seen.pr)
5866}
5867
5868/// What the fixer is told.
5869fn fix_prompt(
5870    state: &RunState,
5871    pr: &PrState,
5872    round: usize,
5873    budget: usize,
5874    reason: &str,
5875    logs: &str,
5876) -> String {
5877    let mut s = format!(
5878        "Your patch is open as a pull request and it is not landing. Land round \
5879         {round} of {budget}.\n\n\
5880         Pull request: {}\n\n\
5881         What is holding it: {reason}\n\n\
5882         # The task\n\n{}\n",
5883        pr.url, state.instruction
5884    );
5885
5886    if pr.failing.is_empty() {
5887        s.push_str("\n# Failing checks\n\n(none)\n");
5888    } else {
5889        let _ = write!(s, "\n# Failing checks\n\n- {}\n", pr.failing.join("\n- "));
5890        if logs.trim().is_empty() {
5891            s.push_str(
5892                "\nNo log could be read; investigate the failure with necessary focused checks.\n",
5893            );
5894        } else {
5895            let _ = write!(s, "\n## Failing log tails\n\n{logs}\n");
5896        }
5897    }
5898
5899    if pr.review_comments.is_empty() {
5900        s.push_str("\n# Review comments\n\n(none)\n");
5901    } else {
5902        s.push_str("\n# Review comments\n");
5903        for c in &pr.review_comments {
5904            let where_ = match (&c.path, c.line) {
5905                (Some(p), Some(l)) => format!(" ({p}:{l})"),
5906                (Some(p), None) => format!(" ({p})"),
5907                _ => String::new(),
5908            };
5909            let _ = write!(s, "\n## {}{where_}\n\n{}\n", c.author, c.body.trim());
5910        }
5911    }
5912
5913    s.push_str(
5914        "\n# Rules\n\n\
5915         1. Fix the cause, never the symptom. Do not delete, skip, or weaken a \
5916            failing test; do not silence a lint with an allow attribute; do not \
5917            stretch a timeout to hide a race. If the check is right, the code is \
5918            wrong.\n\
5919         2. Change nothing the checks and the comments did not raise. A \
5920            drive-by refactor turns a one-line fix into a pull request that \
5921            needs reviewing again.\n\
5922         3. If a comment is wrong, say so with a checkable argument and change \
5923            nothing for it. A declined comment with a reason is a correct \
5924            outcome; a change made to appease a reviewer is not.\n\
5925         4. Commit in this worktree. magi pushes to the pull request's branch \
5926            for you; do not push, merge, or close anything yourself.\n\
5927         5. Never name yourself, your vendor, or your model, anywhere.\n\n\
5928         # Output\n\n\
5929         Say what you changed and why, and what you declined and why.",
5930    );
5931
5932    let language = &state.config.graph.language;
5933    if !(language.trim().is_empty() || language.eq_ignore_ascii_case("en")) {
5934        let _ = write!(s, "\n\nWrite all prose in {language}.");
5935    }
5936    // After the language line, so the exception is the last word on it.
5937    s.push_str(&crate::prompt::github_rule(
5938        language,
5939        &state.config.graph.github_language,
5940    ));
5941    if let Some(overlay) = state.config.prompts.overlay("fix") {
5942        let _ = write!(s, "\n\n{overlay}");
5943    }
5944    s.push('\n');
5945    s.push_str(crate::prompt::child_run_ownership());
5946    s
5947}
5948
5949/// Failing log tails, the way the operator collects them by hand:
5950/// `gh run view --log-failed`.
5951async fn failing_logs(repo: &Path, failing: &[(String, String)]) -> String {
5952    let mut out = String::new();
5953    for (name, url) in failing.iter().take(MAX_LOGS) {
5954        let args = match (job_of(url), run_of(url)) {
5955            (Some(job), _) => vec![
5956                "run".to_owned(),
5957                "view".to_owned(),
5958                "--log-failed".to_owned(),
5959                "--job".to_owned(),
5960                job,
5961            ],
5962            (None, Some(run)) => vec![
5963                "run".to_owned(),
5964                "view".to_owned(),
5965                run,
5966                "--log-failed".to_owned(),
5967            ],
5968            // Not a GitHub Actions check - an external status has no log here.
5969            (None, None) => continue,
5970        };
5971        let (ok, body) = match gh(repo, &args).await {
5972            Ok(v) => v,
5973            Err(e) => (false, format!("{e:#}")),
5974        };
5975        if !ok && body.trim().is_empty() {
5976            continue;
5977        }
5978        let _ = write!(out, "### {name}\n\n```\n{}\n```\n\n", tail(&body, LOG_TAIL));
5979    }
5980    out
5981}
5982
5983/// Job id out of a check's `detailsUrl`
5984/// (`https://github.com/o/r/actions/runs/<run>/job/<job>`).
5985fn job_of(details_url: &str) -> Option<String> {
5986    let after = details_url.split("/job/").nth(1)?;
5987    let id: String = after.chars().take_while(char::is_ascii_digit).collect();
5988    (!id.is_empty()).then_some(id)
5989}
5990
5991/// Workflow run id out of a check's `detailsUrl`.
5992pub(crate) fn run_of(details_url: &str) -> Option<String> {
5993    let after = details_url.split("/actions/runs/").nth(1)?;
5994    let id: String = after.chars().take_while(char::is_ascii_digit).collect();
5995    (!id.is_empty()).then_some(id)
5996}
5997
5998/// The comment `stop` posts. Fixed English, whatever `[graph] language` says:
5999/// it lands on GitHub, not in front of the operator. Pure so a test can hold
6000/// it to that.
6001fn stop_comment(run_id: &str, why: &str) -> String {
6002    format!(
6003        "{MARKER}\nmagi stopped landing this pull request: {why}\n\n\
6004         The branch is untouched and the run is `{run_id}`. Nothing was merged."
6005    )
6006}
6007
6008/// Leave the pull request open, say why on it, and mark the run blocked.
6009///
6010/// The comment is what makes an unattended stop actionable: the operator wakes
6011/// up to a pull request that explains itself rather than to a silent queue.
6012async fn stop(state: &mut RunState, repo: &Path, pr: &PrState, why: &str) -> Result<()> {
6013    let body = stop_comment(&state.id, why);
6014    let (_, mut body) = crate::github_text::prepare(state, "", &body);
6015    if !body.contains(MARKER) {
6016        body = format!("{MARKER}\n{body}");
6017    }
6018    let posted = gh(
6019        repo,
6020        &[
6021            "pr".to_owned(),
6022            "comment".to_owned(),
6023            pr.number.to_string(),
6024            "--body".to_owned(),
6025            body,
6026        ],
6027    )
6028    .await;
6029    match posted {
6030        Ok((true, _)) => {}
6031        Ok((false, out)) => tracing::warn!("could not comment on {}: {out}", pr.url),
6032        Err(e) => tracing::warn!("could not comment on {}: {e:#}", pr.url),
6033    }
6034    state.status = RunStatus::Blocked;
6035    state.merge = Some(MergeOutcome {
6036        mode: MergeMode::Pr,
6037        ok: false,
6038        detail: why.to_owned(),
6039        empty: false,
6040    });
6041    state.event("land", format!("stopped: {why}"));
6042    state.save()?;
6043    Ok(())
6044}
6045
6046/// Run `gh` in `repo`, returning success and the combined output.
6047///
6048/// Combined because `gh` reports a refused merge on stderr and the pull request
6049/// json on stdout, and both are evidence.
6050///
6051/// `GH_REPO` is stripped from the child's environment: every call site here
6052/// passes an explicit `cwd` (or a full pull request URL) meaning to operate
6053/// on *that* checkout's own remote, and `gh` prefers `GH_REPO` over the
6054/// checkout it is sitting in when no `--repo` flag is given. Left unset, a
6055/// `GH_REPO` the operator happens to have exported for an unrelated script
6056/// would silently redirect [`repo_slug`] (and every other cwd-scoped call
6057/// below) to a different repository than the one actually on disk - which
6058/// for the same-repo guard in [`correct_manual_merge`] would mean the check
6059/// could be made to agree with whatever repository a forged `--merged` URL
6060/// claims, defeating it entirely.
6061pub(crate) async fn gh(cwd: &Path, args: &[String]) -> Result<(bool, String)> {
6062    let out = tokio::process::Command::new("gh")
6063        .args(args)
6064        .current_dir(cwd)
6065        .env_remove("GH_REPO")
6066        .quiet()
6067        .stdin(std::process::Stdio::null())
6068        .output()
6069        .await
6070        .with_context(|| format!("spawn gh {}", args.join(" ")))?;
6071    let mut body = String::from_utf8_lossy(&out.stdout).into_owned();
6072    let err = String::from_utf8_lossy(&out.stderr);
6073    if body.trim().is_empty() {
6074        body = err.into_owned();
6075    } else if !err.trim().is_empty() {
6076        body.push_str(&err);
6077    }
6078    Ok((out.status.success(), body.trim().to_owned()))
6079}
6080
6081/// Verdict of one entry in the status rollup.
6082#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6083pub(crate) enum Verdict {
6084    Pass,
6085    Fail,
6086    Pending,
6087    Unknown,
6088}
6089
6090impl Verdict {
6091    /// Short operator-facing check result.
6092    pub(crate) fn label(self) -> &'static str {
6093        match self {
6094            Self::Pass => "passed",
6095            Self::Fail => "failed",
6096            Self::Pending => "pending",
6097            Self::Unknown => "unknown",
6098        }
6099    }
6100}
6101
6102#[derive(Debug, Deserialize)]
6103#[serde(rename_all = "camelCase")]
6104struct GhPr {
6105    #[serde(default)]
6106    url: String,
6107    #[serde(default)]
6108    number: u64,
6109    #[serde(default)]
6110    state: String,
6111    #[serde(default)]
6112    title: String,
6113    #[serde(default)]
6114    status_check_rollup: Vec<GhCheck>,
6115    /// GitHub's own verdict on whether the pull request can be merged.
6116    ///
6117    /// Worth asking for because it is the only place the *required* check set
6118    /// is applied: the rollup lists every check equally, so a repository that
6119    /// deliberately does not require `coverage` still looks red here. See
6120    /// [`Blocking`].
6121    #[serde(default)]
6122    merge_state_status: String,
6123    /// The commit the pull request currently points at. Compared with the
6124    /// commit a fix round pushed, it is how the loop knows the forge has moved
6125    /// on and the rollup belongs to the new head.
6126    #[serde(default)]
6127    head_ref_oid: String,
6128    #[serde(default)]
6129    base_ref_name: String,
6130    #[serde(default)]
6131    reviews: Vec<GhReview>,
6132    #[serde(default)]
6133    comments: Vec<GhComment>,
6134}
6135
6136/// One rollup entry. `gh` mixes two GraphQL types in this array: a `CheckRun`
6137/// has `name`/`status`/`conclusion`, while a `StatusContext` - the old commit
6138/// status API, which is how CodeRabbit reports - has `context`/`state` and no
6139/// conclusion at all.
6140#[derive(Debug, Deserialize)]
6141#[serde(rename_all = "camelCase")]
6142struct GhCheck {
6143    #[serde(default)]
6144    name: Option<String>,
6145    #[serde(default)]
6146    context: Option<String>,
6147    #[serde(default)]
6148    status: Option<String>,
6149    #[serde(default)]
6150    conclusion: Option<String>,
6151    #[serde(default)]
6152    state: Option<String>,
6153    #[serde(default)]
6154    details_url: Option<String>,
6155    #[serde(default)]
6156    target_url: Option<String>,
6157    /// Whether the base branch requires this check. Only the GraphQL node
6158    /// carries it; `None` is "not read", never "not required".
6159    #[serde(default)]
6160    is_required: Option<bool>,
6161}
6162
6163impl GhCheck {
6164    /// Name to show a human and hand to the fixer.
6165    fn label(&self) -> String {
6166        self.name
6167            .clone()
6168            .or_else(|| self.context.clone())
6169            .unwrap_or_else(|| "(unnamed check)".to_owned())
6170    }
6171
6172    /// Where this check's logs live, when it has any.
6173    fn url(&self) -> Option<&str> {
6174        self.details_url
6175            .as_deref()
6176            .or(self.target_url.as_deref())
6177            .filter(|u| !u.is_empty())
6178    }
6179
6180    /// Did it pass?
6181    ///
6182    /// `SKIPPED` and `NEUTRAL` count as passed: the Claude review workflow
6183    /// skips release and bot pull requests by design, and a skip that blocked
6184    /// landing would block exactly the pull requests that need no review.
6185    /// `CANCELLED` counts as failed - a cancelled check did not pass, and
6186    /// merging over one is merging over a check that never ran.
6187    fn verdict(&self) -> Verdict {
6188        if let Some(status) = self.status.as_deref() {
6189            if !status.eq_ignore_ascii_case("COMPLETED") {
6190                return Verdict::Pending;
6191            }
6192        }
6193        let outcome = self
6194            .conclusion
6195            .as_deref()
6196            .or(self.state.as_deref())
6197            .unwrap_or("");
6198        match outcome.to_ascii_uppercase().as_str() {
6199            "SUCCESS" | "SKIPPED" | "NEUTRAL" => Verdict::Pass,
6200            "FAILURE" | "ERROR" | "TIMED_OUT" | "CANCELLED" | "STARTUP_FAILURE"
6201            | "ACTION_REQUIRED" => Verdict::Fail,
6202            "PENDING" | "EXPECTED" | "QUEUED" | "IN_PROGRESS" | "WAITING" | "REQUESTED" => {
6203                Verdict::Pending
6204            }
6205            _ => Verdict::Unknown,
6206        }
6207    }
6208}
6209
6210#[derive(Debug, Deserialize)]
6211struct GhAuthor {
6212    #[serde(default)]
6213    login: String,
6214}
6215
6216#[derive(Debug, Deserialize)]
6217struct GhReview {
6218    #[serde(default)]
6219    author: GhAuthor,
6220    #[serde(default)]
6221    body: String,
6222}
6223
6224#[derive(Debug, Deserialize)]
6225struct GhComment {
6226    #[serde(default)]
6227    author: GhAuthor,
6228    #[serde(default)]
6229    body: String,
6230}
6231
6232#[derive(Debug, Deserialize)]
6233struct GhUser {
6234    #[serde(default)]
6235    login: String,
6236}
6237
6238#[derive(Debug, Deserialize)]
6239struct GhInline {
6240    #[serde(default)]
6241    user: GhUser,
6242    #[serde(default)]
6243    path: Option<String>,
6244    #[serde(default)]
6245    line: Option<u64>,
6246    #[serde(default)]
6247    body: String,
6248}
6249
6250impl Default for GhAuthor {
6251    fn default() -> Self {
6252        Self {
6253            login: "(unknown)".to_owned(),
6254        }
6255    }
6256}
6257
6258impl Default for GhUser {
6259    fn default() -> Self {
6260        Self {
6261            login: "(unknown)".to_owned(),
6262        }
6263    }
6264}
6265
6266#[cfg(test)]
6267pub(crate) mod tests {
6268    use super::*;
6269    use crate::run::{Candidate, ReviewRecord, ReviewRound, Tally};
6270
6271    fn head_json(head: &str, base: &str, state: &str, cross: bool) -> String {
6272        format!(
6273            r#"{{"headRefName":"{head}","headRefOid":"aaa","baseRefName":"{base}","state":"{state}","isCrossRepository":{cross}}}"#
6274        )
6275    }
6276
6277    #[test]
6278    fn a_pull_request_is_closed_only_when_its_head_is_exactly_the_runs_branch() {
6279        let ok = head_json("magi/27b2/A", "main", "OPEN", false);
6280        assert_eq!(
6281            closable(&ok, "magi/27b2/A", "main", &["aaa".to_owned()]),
6282            Ok(())
6283        );
6284        for (json, why) in [
6285            (head_json("magi/27b2/B", "main", "OPEN", false), "head"),
6286            (head_json("magi/27b2/A-2", "main", "OPEN", false), "head"),
6287            (head_json("magi/27b2/A", "main", "OPEN", true), "fork"),
6288            (head_json("magi/27b2/A", "dev", "OPEN", false), "targets"),
6289            (head_json("magi/27b2/A", "main", "MERGED", false), "already"),
6290            (head_json("magi/27b2/A", "main", "CLOSED", false), "already"),
6291        ] {
6292            let err = closable(&json, "magi/27b2/A", "main", &["aaa".to_owned()])
6293                .unwrap_err()
6294                .why;
6295            assert!(err.contains(why), "{json}: {err}");
6296        }
6297        // A head that moved on past what was verified is left alone.
6298        let moved = head_json("magi/27b2/A", "main", "OPEN", false);
6299        let err = closable(&moved, "magi/27b2/A", "main", &["bbb".to_owned()]).unwrap_err();
6300        assert!(err.retry && err.why.contains("not a commit"), "{err:?}");
6301        assert!(
6302            !closable(
6303                &head_json("x", "main", "OPEN", false),
6304                "magi/27b2/A",
6305                "main",
6306                &[]
6307            )
6308            .unwrap_err()
6309            .retry
6310        );
6311        assert!(is_forge_url("https://github.com/o/r.git"));
6312        assert!(is_forge_url("git@github.com:o/r.git"));
6313        assert!(!is_forge_url("/tmp/origin.git"));
6314        assert!(!is_forge_url("C:\\work\\origin.git"));
6315        assert!(!is_forge_url("file:///tmp/origin.git"));
6316        assert!(forge_unavailable(
6317            "gh pr list failed: none of the git remotes configured for this repository point to a known GitHub host."
6318        ));
6319        assert!(!forge_unavailable(
6320            "gh pr list failed: error connecting to api.github.com"
6321        ));
6322        assert!(closable("not json", "magi/27b2/A", "main", &[]).is_err());
6323        // A record that does not say whether it is a fork is not trusted.
6324        assert!(
6325            closable(
6326                r#"{"headRefName":"b","headRefOid":"aaa","baseRefName":"main","state":"OPEN"}"#,
6327                "b",
6328                "main",
6329                &["aaa".to_owned()]
6330            )
6331            .is_err()
6332        );
6333    }
6334
6335    #[test]
6336    fn the_close_comment_names_the_commit_on_the_base() {
6337        let e = crate::already::Evidence {
6338            proof: crate::already::Proof::PatchId,
6339            tip: "1234567890".to_owned(),
6340            commits: vec!["0e368de0000".to_owned()],
6341        };
6342        let c = superseded_comment("main", &e);
6343        assert!(c.contains("0e368de") && c.contains("`main`"), "{c}");
6344    }
6345
6346    /// Real `gh pr view` output for the open pull request #10 (Renovate's apm bump), trimmed to four checks and its one comment. Every check passed or was skipped by the review workflow, and the only comment is CodeRabbit's trigger notice.
6347    const GREEN_OPEN: &str = r####"{
6348  "url": "https://github.com/yukimemi/magi/pull/10",
6349  "number": 10,
6350  "state": "OPEN",
6351  "mergeStateStatus": "CLEAN",
6352  "statusCheckRollup": [
6353    {
6354      "__typename": "CheckRun",
6355      "conclusion": "SKIPPED",
6356      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278334/job/99378963755",
6357      "name": "review",
6358      "status": "COMPLETED",
6359      "workflowName": "claude-review"
6360    },
6361    {
6362      "__typename": "CheckRun",
6363      "conclusion": "SUCCESS",
6364      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278338/job/99378963144",
6365      "name": "check (ubuntu-latest)",
6366      "status": "COMPLETED",
6367      "workflowName": "CI"
6368    },
6369    {
6370      "__typename": "CheckRun",
6371      "conclusion": "SUCCESS",
6372      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278338/job/99378963095",
6373      "name": "rustfmt",
6374      "status": "COMPLETED",
6375      "workflowName": "CI"
6376    },
6377    {
6378      "__typename": "StatusContext",
6379      "context": "CodeRabbit",
6380      "state": "SUCCESS",
6381      "targetUrl": ""
6382    }
6383  ],
6384  "reviews": [],
6385  "comments": [
6386    {
6387      "author": {
6388        "login": "coderabbitai"
6389      },
6390      "authorAssociation": "NONE",
6391      "body": "<!-- This is an auto-generated comment: summarize by coderabbit.ai -->\n<!-- This is an auto-generated comment: skip review by coderabbit.ai -->\n\n> [!IMPORTANT]\n> - [ ] <!-- {\"checkboxId\":\"e9bb8d72-00e8-4f67-9cb2-caf3b22574fe\"} --> 🔍 Trigger review\n> \n> This repository does not receive automatic reviews because it has fewer than 10 stars.\n> \n> <details>\n> <summary>⚙️ Run configuration</summary>\n> \n> **Configuration used**: defaults\n> \n> **Review profile**: CHILL\n> \n> **Plan**: Pro Plus\n> \n> **Run ID**: `78e70bf3-c5a0-4269-a96c-2afb2dba7eff`\n> \n> </details>\n\n<!-- end of auto-generated comment: skip review by coderabbit.ai -->\n\n<!-- tips_start -->\n\n---\n\nThanks for using [CodeRabbit](https://coderabbit.ai?utm_source=oss&utm_medium=github&utm_campaign=yukimemi/magi&utm_content=10)! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.\n\n<details>\n<summary>❤️ Share</summary>\n\n- [X](https://twitter.com/intent/tweet?text=I%20just%20used%20%40coderabbitai%20for%20my%20code%20review%2C%20and%20it%27s%20fantastic%21%20It%27s%20free%20for%20OSS%20and%2"
6392    }
6393  ]
6394}"####;
6395
6396    /// Real output for the open pull request #9 (the daily kata-apply), whose `editorconfig` check failed while everything else passed.
6397    const RED_OPEN: &str = r####"{
6398  "url": "https://github.com/yukimemi/magi/pull/9",
6399  "number": 9,
6400  "state": "OPEN",
6401  "mergeStateStatus": "UNSTABLE",
6402  "statusCheckRollup": [
6403    {
6404      "__typename": "CheckRun",
6405      "conclusion": "SUCCESS",
6406      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323744",
6407      "name": "check (ubuntu-latest)",
6408      "status": "COMPLETED",
6409      "workflowName": "CI"
6410    },
6411    {
6412      "__typename": "CheckRun",
6413      "conclusion": "SUCCESS",
6414      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323811",
6415      "name": "rustfmt",
6416      "status": "COMPLETED",
6417      "workflowName": "CI"
6418    },
6419    {
6420      "__typename": "CheckRun",
6421      "conclusion": "FAILURE",
6422      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572",
6423      "name": "editorconfig",
6424      "status": "COMPLETED",
6425      "workflowName": "CI"
6426    },
6427    {
6428      "__typename": "StatusContext",
6429      "context": "CodeRabbit",
6430      "state": "SUCCESS",
6431      "targetUrl": ""
6432    }
6433  ],
6434  "reviews": [],
6435  "comments": [
6436    {
6437      "author": {
6438        "login": "coderabbitai"
6439      },
6440      "authorAssociation": "NONE",
6441      "body": "<!-- This is an auto-generated comment: summarize by coderabbit.ai -->\n<!-- This is an auto-generated comment: skip review by coderabbit.ai -->\n\n> [!IMPORTANT]\n> - [ ] <!-- {\"checkboxId\":\"e9bb8d72-00e8-4f67-9cb2-caf3b22574fe\"} --> 🔍 Trigger review\n> \n> This repository does not receive automatic reviews because it has fewer than 10 stars.\n> \n> <details>\n> <summary>⚙️ Run configuration</summary>\n> \n> **Configuration used**: defaults\n> \n> **Review profile**: CHILL\n> \n> **Plan**: Team\n> \n> **Run ID**: `91e0dc24-6040-4c3d-92c6-f7d2b542523d`\n> \n> </details>\n\n<!-- end of auto-generated comment: skip review by coderabbit.ai -->\n\n<!-- tips_start -->\n\n---\n\nThanks for using [CodeRabbit](https://coderab"
6442    }
6443  ]
6444}"####;
6445
6446    /// Pull request #9's real payload with its `editorconfig` check rewound to the `IN_PROGRESS` / `conclusion: null` pair `gh` reports while a job is still in flight.
6447    const PENDING_OPEN: &str = r####"{
6448  "url": "https://github.com/yukimemi/magi/pull/9",
6449  "number": 9,
6450  "state": "OPEN",
6451  "statusCheckRollup": [
6452    {
6453      "__typename": "CheckRun",
6454      "conclusion": "SUCCESS",
6455      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323744",
6456      "name": "check (ubuntu-latest)",
6457      "status": "COMPLETED",
6458      "workflowName": "CI"
6459    },
6460    {
6461      "__typename": "CheckRun",
6462      "conclusion": "SUCCESS",
6463      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323811",
6464      "name": "rustfmt",
6465      "status": "COMPLETED",
6466      "workflowName": "CI"
6467    },
6468    {
6469      "__typename": "CheckRun",
6470      "conclusion": null,
6471      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572",
6472      "name": "editorconfig",
6473      "status": "IN_PROGRESS",
6474      "workflowName": "CI"
6475    },
6476    {
6477      "__typename": "StatusContext",
6478      "context": "CodeRabbit",
6479      "state": "SUCCESS",
6480      "targetUrl": ""
6481    }
6482  ],
6483  "reviews": [],
6484  "comments": []
6485}"####;
6486
6487    /// Real output for pull request #16 after it was merged - the shape landing sees when a person merged underneath it.
6488    const MERGED: &str = r####"{
6489  "url": "https://github.com/yukimemi/magi/pull/16",
6490  "number": 16,
6491  "state": "MERGED",
6492  "statusCheckRollup": [
6493    {
6494      "__typename": "CheckRun",
6495      "conclusion": "SUCCESS",
6496      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33636587933/job/100268878095",
6497      "name": "check (ubuntu-latest)",
6498      "status": "COMPLETED",
6499      "workflowName": "CI"
6500    },
6501    {
6502      "__typename": "CheckRun",
6503      "conclusion": "SUCCESS",
6504      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33636587918/job/100268876427",
6505      "name": "review",
6506      "status": "COMPLETED",
6507      "workflowName": "claude-review"
6508    }
6509  ],
6510  "reviews": [],
6511  "comments": []
6512}"####;
6513
6514    /// Pull request #12's real payload - a green pull request carrying CodeRabbit's walkthrough and a Claude review that found a real bug - rewound to the `OPEN` state it was in when that review was posted.
6515    const REVIEWED_OPEN: &str = r####"{
6516  "url": "https://github.com/yukimemi/magi/pull/12",
6517  "number": 12,
6518  "state": "OPEN",
6519  "statusCheckRollup": [
6520    {
6521      "__typename": "CheckRun",
6522      "conclusion": "SUCCESS",
6523      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33571212506/job/100065355258",
6524      "name": "check (ubuntu-latest)",
6525      "status": "COMPLETED",
6526      "workflowName": "CI"
6527    },
6528    {
6529      "__typename": "CheckRun",
6530      "conclusion": "SUCCESS",
6531      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33571212566/job/100065355810",
6532      "name": "review",
6533      "status": "COMPLETED",
6534      "workflowName": "claude-review"
6535    }
6536  ],
6537  "reviews": [
6538    {
6539      "author": {
6540        "login": "claude"
6541      },
6542      "state": "COMMENTED",
6543      "body": ""
6544    }
6545  ],
6546  "comments": [
6547    {
6548      "author": {
6549        "login": "coderabbitai"
6550      },
6551      "authorAssociation": "NONE",
6552      "body": "<!-- This is an auto-generated comment: summarize by coderabbit.ai -->\n<!-- This is an auto-generated comment: skip review by coderabbit.ai -->\n\n> [!IMPORTANT]\n> - [ ] <!-- {\"checkboxId\":\"e9bb8d72-00e8-4f67-9cb2-caf3b22574fe\"} --> 🔍 Trigger review\n> \n> This repository does not receive automatic reviews because it has fewer than 10 stars.\n> \n> <details>\n> <summary>⚙️ Run configuration</summary>\n> \n> **Configuration used**: defaults\n> \n> **Review profile**: CHILL\n> \n> **Plan**: Team\n> \n> **Run ID**: `72058bf3-b7df-41d9-8e4d-a06a31be4a26`\n> \n> </details>\n\n<!-- end of auto-generated comment: skip review by coderabbit.ai -->\n\n<!-- tips_start -->\n\n---\n\nThanks for using [CodeRabbit](https://coderabbit.ai?utm_source=oss&utm_medium=github&utm_campaign=yukimemi/magi&utm_content=12)! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.\n\n<details>\n<summa"
6553    },
6554    {
6555      "author": {
6556        "login": "claude"
6557      },
6558      "authorAssociation": "NONE",
6559      "body": "**Claude finished @yukimemi's task in 3m 52s** —— [View job](https://github.com/yukimemi/magi/actions/runs/33571212566)\n\n---\n### Review: `magi review <branch>` — cheap-half-only graph\n\nRead through `src/graph.rs`, `src/main.rs`, `src/prompt.rs`, and the new/edited tests, and traced the claimed degeneration (`prep` short-circuits on a non-empty candidate list, `implement` skips because `commits != 0`, `judge`/`vote` skip on `viable().len() == 1`, `tally` skips because it's pre-set, `fold_losers` has no losers) against the actual code — it holds up. CI (`cargo make check`) is green on this PR.\n\n**Correctness**\n\n- One real bug, flagged inline on `src/graph.rs:1255`: the fixer-agent fallback (`self.roles.implementers[winner.index].clone()`) is unreachable in the normal graph (a real candidate's `winner.agent` always resolves via `config.agent(...)`), but a review-only run's `winner.agent` is always the `\"(existing branch)\"` sentinel, so this fallback now runs on *every* review-only fix that has no dedicated `[roles] fixer`. `graph.candidates` has no lower-bound validation, so a `magi.toml` tuned for review-only use (`candidates = 0`, plausible given this PR's own cost rationale) would panic with an out-of-bounds index the first time a"
6560    }
6561  ]
6562}"####;
6563
6564    /// Real `gh api repos/{owner}/{repo}/pulls/12/comments` output: one inline finding with its file and line.
6565    const INLINE: &str = r####"[
6566  {
6567    "user": {
6568      "login": "claude[bot]"
6569    },
6570    "path": "src/graph.rs",
6571    "line": 231,
6572    "body": "Minor edge case: unlike `implement()` (which sets `c.empty = commits == 0 || patch.trim().is_empty()`, `src/graph.rs:472`), the seeded review-only candidate always sets `empty: false` once `commits > 0` is confirmed, without checking whether the diff itself is actually empty (e.g. a commit immediately followed by a revert nets zero file changes). Such a branch would pass `Runner::review`'s validation and proceed into a review round with an empty patch, where `implement()`'s equivalent path would"
6573  }
6574]"####;
6575
6576    /// CodeRabbit's real trigger notice: a checkbox, a `<details>` block, and its own "skip review" marker.
6577    const CODERABBIT_TRIGGER: &str = r####"<!-- This is an auto-generated comment: summarize by coderabbit.ai -->
6578<!-- This is an auto-generated comment: skip review by coderabbit.ai -->
6579
6580> [!IMPORTANT]
6581> - [ ] <!-- {"checkboxId":"e9bb8d72-00e8-4f67-9cb2-caf3b22574fe"} --> 🔍 Trigger review
6582> 
6583> This repository does not receive automatic reviews because it has fewer than 10 stars.
6584> 
6585> <details>
6586> <summary>⚙️ Run configuration</summary>
6587> 
6588> **Configuration used**: defaults
6589> 
6590> **Review profile**: CHILL
6591> 
6592> **Plan**: Team
6593> 
6594> **Run ID**: `c1e2a68f-87fc-4b35-9ec4-e75c7854966a`
6595> 
6596> </details>
6597
6598<!-- end of auto-generated comment: skip review by coderabbit.ai -->
6599
6600<!-- tips_start -->
6601
6602---
6603
6604Thanks for using [CodeRabbit](https://coderabbit.ai?utm_source=oss&utm_medium=github&utm_campaign=yukimemi/magi&utm_content=16)! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.
6605
6606<details>
6607<summary>❤️ Share</summary>
6608
6609- [X](https://twitter.com/intent/tweet?text=I%20just%20used%20%40coderabbitai%20for%20my%20code%20review%2C%20and%20it%27s%20fantastic%21%20It%27s%20free%20for%20OSS%20and%20off"####;
6610
6611    /// The Claude review job's real comment while it is still working: a heading and a task list, and nothing that asks for a change.
6612    const CLAUDE_CHECKLIST: &str = r####"**Claude finished @yukimemi's task in 4m 14s** —— [View job](https://github.com/yukimemi/magi/actions/runs/33636587918)
6613
6614---
6615### Reviewing PR #16
6616
6617- [x] Read AGENTS.md conventions
6618- [x] Review `src/daemon.rs` changes
6619- [x] Review `src/main.rs` changes (new `doctor` reporting)
6620- [x] Review `src/web.rs` changes (reuse of unreadable-run count)
6621- [x] Check test coverage for new behavior
6622- [x] Run verification commands (blocked — see note)
6623- [x] Post findings"####;
6624
6625    /// The same job's real comment on pull request #12 once it had something to say.
6626    const CLAUDE_FINDING: &str = r####"**Claude finished @yukimemi's task in 3m 52s** —— [View job](https://github.com/yukimemi/magi/actions/runs/33571212566)
6627
6628---
6629### Review: `magi review <branch>` — cheap-half-only graph
6630
6631Read through `src/graph.rs`, `src/main.rs`, `src/prompt.rs`, and the new/edited tests, and traced the claimed degeneration (`prep` short-circuits on a non-empty candidate list, `implement` skips because `commits != 0`, `judge`/`vote` skip on `viable().len() == 1`, `tally` skips because it's pre-set, `fold_losers` has no losers) against the actual code — it holds up. CI (`cargo make check`) is green on this PR.
6632
6633**Correctness**
6634
6635- One real bug, flagged inline on `src/graph.rs:1255`: the fixer-agent fallback (`self.roles.implementers[winner.index].clone()`) is unreachable in the normal graph (a real candidate's `winner.agent` always resolves via `config.agent(...)`), but a review-only run's `winner.agent` is always the `"(existing branch)"` sentinel, so this fallback now runs on *every* review-only fix that has no dedicated `[roles] fixer`. `graph.candidates` has no lower-bound validation, so a `magi.toml` tuned for review-only use (`candidates = 0`, plausible given this PR's own cost rationale) would panic with an out-of-bounds index the first time a"####;
6636
6637    fn pr(checks: Checks, failing: &[&str], comments: usize) -> PrState {
6638        PrState {
6639            url: "https://github.com/yukimemi/magi/pull/16".to_owned(),
6640            number: 16,
6641            state: PrLifecycle::Open,
6642            checks,
6643            // These tests are about red-means-fix, so a red here is one the
6644            // forge gates on. Without saying so they would assert the new
6645            // "merge past a check nobody requires" path by accident.
6646            blocking: if matches!(checks, Checks::Red) {
6647                Blocking::Yes
6648            } else {
6649                Blocking::No
6650            },
6651            failing: failing.iter().map(|s| (*s).to_owned()).collect(),
6652            review_comments: (0..comments)
6653                .map(|i| ReviewComment {
6654                    author: "coderabbitai".to_owned(),
6655                    path: Some("src/graph.rs".to_owned()),
6656                    line: Some(231),
6657                    body: format!("finding {i}"),
6658                })
6659                .collect(),
6660        }
6661    }
6662
6663    #[test]
6664    fn expected_ci_is_exactly_decide_and_absent_ci_never_waits_for_checks() {
6665        use CiExpectation::{Absent, Expected};
6666        for checks in [Checks::Pending, Checks::Unknown, Checks::Green, Checks::Red] {
6667            let p = pr(checks, &["x"], 0);
6668            for waited in [Duration::ZERO, CHECKS_GRACE] {
6669                assert_eq!(
6670                    decide_with(&p, 0, 4, waited, Expected),
6671                    decide(&p, 0, 4, waited)
6672                );
6673            }
6674        }
6675        // Nothing will ever report: no wait, no give-up, no fix round.
6676        for checks in [Checks::Pending, Checks::Unknown, Checks::Red] {
6677            let p = pr(checks, &["x"], 0);
6678            assert_eq!(decide_with(&p, 0, 4, Duration::ZERO, Absent), Step::Merge);
6679            assert_eq!(decide_with(&p, 4, 4, CHECKS_GRACE, Absent), Step::Merge);
6680        }
6681        // Third-party statuses never change the review decision, even at budget.
6682        for comments in [0, 1] {
6683            for round in [0, 4] {
6684                let absent = decide_with(
6685                    &pr(Checks::Unknown, &[], comments),
6686                    round,
6687                    4,
6688                    CHECKS_GRACE,
6689                    Absent,
6690                );
6691                for checks in [Checks::Green, Checks::Red, Checks::Pending] {
6692                    assert_eq!(
6693                        decide_with(
6694                            &pr(checks, &["third-party"], comments),
6695                            round,
6696                            4,
6697                            Duration::ZERO,
6698                            Absent
6699                        ),
6700                        absent
6701                    );
6702                }
6703                if comments != 0 {
6704                    assert!(matches!(absent, Step::Fix { .. } | Step::GiveUp { .. }));
6705                    assert_eq!(matches!(absent, Step::GiveUp { .. }), round == 4);
6706                }
6707            }
6708        }
6709        let empty = pr(Checks::Unknown, &[], 0);
6710        for waited in [Duration::ZERO, CHECKS_GRACE + POLL] {
6711            assert_eq!(decide_with(&empty, 0, 4, waited, Absent), Step::Merge);
6712        }
6713        assert_eq!(
6714            decide_with(&empty, 0, 4, Duration::ZERO, Expected),
6715            Step::Wait
6716        );
6717        assert_eq!(
6718            decide_with(&empty, 0, 4, CHECKS_GRACE, Expected),
6719            Step::GiveUp { reason: "no check status is readable on the pull request after 3 minute(s); refusing to merge on a guess".to_owned() }
6720        );
6721        // A conflict is not a check: it still wants the rebase.
6722        let mut p = pr(Checks::Unknown, &[], 0);
6723        p.blocking = Blocking::Conflict;
6724        assert_eq!(decide_with(&p, 0, 4, Duration::ZERO, Absent), Step::Rebase);
6725        // And a pull request that left our hands is still done.
6726        p.state = PrLifecycle::Merged;
6727        assert_eq!(
6728            decide_with(&p, 0, 4, Duration::ZERO, Absent),
6729            Step::Done { merged: true }
6730        );
6731    }
6732
6733    #[test]
6734    fn a_green_pull_request_with_nothing_outstanding_parses_as_ready_to_merge() {
6735        let state = parse_pr(GREEN_OPEN).expect("green fixture parses");
6736        assert_eq!(state.number, 10);
6737        assert_eq!(state.state, PrLifecycle::Open);
6738        assert_eq!(state.checks, Checks::Green);
6739        assert!(state.failing.is_empty());
6740        assert!(
6741            state.review_comments.is_empty(),
6742            "the only comment is CodeRabbit's trigger notice: {:?}",
6743            state.review_comments
6744        );
6745        assert_eq!(decide(&state, 0, 4, Duration::ZERO), Step::Merge);
6746    }
6747
6748    #[test]
6749    fn a_failing_check_parses_as_red_and_is_named() {
6750        let state = parse_pr(RED_OPEN).expect("red fixture parses");
6751        assert_eq!(state.checks, Checks::Red);
6752        assert_eq!(state.failing, vec!["editorconfig".to_owned()]);
6753        // The captured payload says `UNSTABLE` - mergeable, with a check
6754        // nobody requires red - which is exactly the shape that had to be
6755        // merged by hand. Asserted separately, in
6756        // `a_red_check_nobody_requires_does_not_buy_a_fix_round`. What this
6757        // test is about is that a red check is *named*, so the reason a fixer
6758        // is handed says which one; so it asks the blocking question here.
6759        let mut blocking = state.clone();
6760        blocking.blocking = Blocking::Yes;
6761        match decide(&blocking, 0, 4, Duration::ZERO) {
6762            Step::Fix { reason } => {
6763                assert!(reason.contains("editorconfig"), "reason: {reason}");
6764                assert!(reason.contains("failing"), "reason: {reason}");
6765            }
6766            other => panic!("expected a fix round, got {other:?}"),
6767        }
6768    }
6769
6770    #[test]
6771    fn a_check_still_running_parses_as_pending_and_is_waited_for() {
6772        let state = parse_pr(PENDING_OPEN).expect("pending fixture parses");
6773        assert_eq!(state.checks, Checks::Pending);
6774        assert_eq!(decide(&state, 0, 4, Duration::ZERO), Step::Wait);
6775    }
6776
6777    #[test]
6778    fn a_pull_request_merged_underneath_us_is_done_rather_than_a_failure() {
6779        let state = parse_pr(MERGED).expect("merged fixture parses");
6780        assert_eq!(state.state, PrLifecycle::Merged);
6781        assert_eq!(
6782            decide(&state, 0, 4, Duration::ZERO),
6783            Step::Done { merged: true }
6784        );
6785    }
6786
6787    #[test]
6788    fn a_review_that_found_something_is_outstanding_and_holds_the_merge() {
6789        let state = parse_pr(REVIEWED_OPEN).expect("reviewed fixture parses");
6790        assert_eq!(state.checks, Checks::Green);
6791        let authors: Vec<&str> = state
6792            .review_comments
6793            .iter()
6794            .map(|c| c.author.as_str())
6795            .collect();
6796        assert_eq!(
6797            authors,
6798            vec!["claude"],
6799            "CodeRabbit's walkthrough is machinery; Claude's review is a finding"
6800        );
6801        match decide(&state, 0, 4, Duration::ZERO) {
6802            Step::Fix { reason } => assert!(reason.contains("unresolved"), "reason: {reason}"),
6803            other => panic!("expected a fix round, got {other:?}"),
6804        }
6805    }
6806
6807    #[test]
6808    fn inline_review_comments_keep_their_file_and_line() {
6809        let comments = parse_inline_comments(INLINE).expect("inline fixture parses");
6810        assert_eq!(comments.len(), 1);
6811        assert_eq!(comments[0].author, "claude[bot]");
6812        assert_eq!(comments[0].path.as_deref(), Some("src/graph.rs"));
6813        assert_eq!(comments[0].line, Some(231));
6814        assert!(comments[0].body.contains("empty"), "{}", comments[0].body);
6815    }
6816
6817    #[test]
6818    fn a_status_only_bot_comment_does_not_trigger_a_fix_round() {
6819        assert!(
6820            is_noise(CODERABBIT_TRIGGER),
6821            "CodeRabbit's trigger notice declares itself not a review"
6822        );
6823        assert!(
6824            is_noise(CLAUDE_CHECKLIST),
6825            "a progress checklist asks for nothing"
6826        );
6827        assert!(
6828            !is_noise(CLAUDE_FINDING),
6829            "a review that names a bug is input, not noise"
6830        );
6831
6832        let mut clean = pr(Checks::Green, &[], 0);
6833        clean.review_comments.push(ReviewComment {
6834            author: "coderabbitai".to_owned(),
6835            path: None,
6836            line: None,
6837            body: CODERABBIT_TRIGGER.to_owned(),
6838        });
6839        clean.review_comments.retain(|c| !is_noise(&c.body));
6840        assert_eq!(decide(&clean, 0, 4, Duration::ZERO), Step::Merge);
6841
6842        let mut found = pr(Checks::Green, &[], 0);
6843        found.review_comments.push(ReviewComment {
6844            author: "claude".to_owned(),
6845            path: None,
6846            line: None,
6847            body: CLAUDE_FINDING.to_owned(),
6848        });
6849        found.review_comments.retain(|c| !is_noise(&c.body));
6850        assert!(matches!(
6851            decide(&found, 0, 4, Duration::ZERO),
6852            Step::Fix { .. }
6853        ));
6854    }
6855
6856    #[test]
6857    fn the_policy_table_holds_for_every_combination_that_matters() {
6858        let cases: Vec<(&str, PrState, usize, usize, Duration, Step)> = vec![
6859            (
6860                "pending checks are waited for, even on the last round",
6861                pr(Checks::Pending, &[], 0),
6862                4,
6863                4,
6864                Duration::ZERO,
6865                Step::Wait,
6866            ),
6867            (
6868                "red checks are fixed",
6869                pr(Checks::Red, &["editorconfig"], 0),
6870                0,
6871                4,
6872                Duration::ZERO,
6873                Step::Fix {
6874                    reason: "1 check(s) failing: editorconfig".to_owned(),
6875                },
6876            ),
6877            (
6878                "green with comments is fixed, not merged",
6879                pr(Checks::Green, &[], 2),
6880                1,
6881                4,
6882                Duration::ZERO,
6883                Step::Fix {
6884                    reason: "checks are green but 2 review comment(s) are unresolved: coderabbitai"
6885                        .to_owned(),
6886                },
6887            ),
6888            (
6889                "green and clean merges",
6890                pr(Checks::Green, &[], 0),
6891                3,
6892                4,
6893                Duration::ZERO,
6894                Step::Merge,
6895            ),
6896            (
6897                "an unreadable rollup is waited on while the grace lasts",
6898                pr(Checks::Unknown, &[], 0),
6899                0,
6900                4,
6901                Duration::ZERO,
6902                Step::Wait,
6903            ),
6904            (
6905                "an unreadable rollup is never merged once the grace is spent",
6906                pr(Checks::Unknown, &[], 0),
6907                0,
6908                4,
6909                CHECKS_GRACE,
6910                Step::GiveUp {
6911                    reason: "no check status is readable on the pull request after 3 minute(s); \
6912                             refusing to merge on a guess"
6913                        .to_owned(),
6914                },
6915            ),
6916        ];
6917        for (what, state, round, budget, waited, want) in cases {
6918            assert_eq!(decide(&state, round, budget, waited), want, "{what}");
6919        }
6920    }
6921
6922    #[test]
6923    fn the_forge_verdict_survives_the_round_trip_from_gh() {
6924        // Read off `gh pr view --json ...,mergeStateStatus`, because a field
6925        // requested but never parsed is the kind of thing that looks wired up
6926        // and answers `Unsaid` forever.
6927        let green = parse_pr(GREEN_OPEN).expect("parse");
6928        assert_eq!(green.blocking, Blocking::No);
6929        let red = parse_pr(RED_OPEN).expect("parse");
6930        assert_eq!(
6931            red.blocking,
6932            Blocking::No,
6933            "`UNSTABLE` is mergeable: the red check is one nobody requires"
6934        );
6935        assert_eq!(red.checks, Checks::Red, "and it is still reported as red");
6936        // A payload from an older `gh` has no such field at all.
6937        let quiet =
6938            parse_pr(&GREEN_OPEN.replace("\"mergeStateStatus\": \"CLEAN\",", "")).expect("parse");
6939        assert_eq!(quiet.blocking, Blocking::Unsaid);
6940    }
6941
6942    #[test]
6943    fn a_red_check_nobody_requires_does_not_buy_a_fix_round() {
6944        // Pull request 37's only red check was `editorconfig`, failing
6945        // because the action could not fetch its own binary after
6946        // editorconfig-checker v4 renamed its release assets. The repository
6947        // does not require it. magi answered by asking a fixer to repair a
6948        // change that was fine, and the pull request had to be merged by hand.
6949        let mut nonblocking = pr(Checks::Red, &["editorconfig", "coverage"], 0);
6950        nonblocking.blocking = Blocking::No;
6951        assert_eq!(
6952            decide(&nonblocking, 0, 4, Duration::ZERO),
6953            Step::Merge,
6954            "the forge says nothing is in the way, so nothing is"
6955        );
6956
6957        // The same red, gated on: that is a fix round, as before.
6958        let mut blocking = pr(Checks::Red, &["test (ubuntu-latest)"], 0);
6959        blocking.blocking = Blocking::Yes;
6960        assert!(matches!(
6961            decide(&blocking, 0, 4, Duration::ZERO),
6962            Step::Fix { .. }
6963        ));
6964
6965        // A review comment still outranks green-enough: a non-required red
6966        // must not become a way to merge past an unanswered reviewer.
6967        let mut commented = pr(Checks::Red, &["coverage"], 1);
6968        commented.blocking = Blocking::No;
6969        assert!(matches!(
6970            decide(&commented, 0, 4, Duration::ZERO),
6971            Step::Fix { .. }
6972        ));
6973
6974        // And silence from the forge is not consent.
6975        let mut unsaid = pr(Checks::Red, &["coverage"], 0);
6976        unsaid.blocking = Blocking::Unsaid;
6977        assert_eq!(decide(&unsaid, 0, 4, Duration::ZERO), Step::Wait);
6978        assert!(matches!(
6979            decide(&unsaid, 0, 4, CHECKS_GRACE),
6980            Step::Fix { .. }
6981        ));
6982    }
6983
6984    #[test]
6985    fn a_red_merge_is_announced_with_every_failing_check_and_a_green_one_is_not() {
6986        let mut red = pr(Checks::Red, &["test (windows-latest)", "coverage"], 0);
6987        red.blocking = Blocking::No;
6988        assert_eq!(
6989            decide(&red, 0, 4, Duration::ZERO),
6990            Step::Merge,
6991            "announcing must not change the decision"
6992        );
6993        let said = red_merge_summary("yukimemi/magi", &red).expect("red merge is announced");
6994        assert!(said.contains("yukimemi/magi"), "{said}");
6995        assert!(said.contains("#16"), "{said}");
6996        assert!(
6997            said.contains("https://github.com/yukimemi/magi/pull/16"),
6998            "{said}"
6999        );
7000        assert!(
7001            said.contains("test (windows-latest)") && said.contains("coverage"),
7002            "{said}"
7003        );
7004
7005        // `failing` can be left over on a green observation; only `checks` counts.
7006        let green = pr(Checks::Green, &["stale"], 0);
7007        assert_eq!(red_merge_summary("yukimemi/magi", &green), None);
7008    }
7009
7010    #[test]
7011    fn red_merge_notices_omit_empty_check_details() {
7012        for checks in [vec![], vec!["", "  "]] {
7013            let red = pr(Checks::Red, &checks, 0);
7014            let summary = red_merge_summary("owner/repo", &red).unwrap();
7015            let notice = crate::notices::merged_red("run-1", &summary);
7016            assert_eq!(
7017                notice.message,
7018                format!("Merged owner/repo PR #16 with red checks ({})", red.url)
7019            );
7020            assert_eq!(notice.severity, crate::notices::Severity::Warn);
7021        }
7022        let red = pr(Checks::Red, &["", " test ", " "], 0);
7023        let summary = red_merge_summary("owner/repo", &red).unwrap();
7024        assert!(summary.contains("with red checks: test ("), "{summary}");
7025    }
7026
7027    #[test]
7028    fn the_repo_label_comes_from_the_pull_request_url() {
7029        let p = Path::new("/tmp/checkout");
7030        assert_eq!(
7031            repo_label(p, "https://github.com/yukimemi/magi/pull/16"),
7032            "yukimemi/magi"
7033        );
7034        assert_eq!(repo_label(p, "not a url"), "checkout");
7035    }
7036
7037    #[test]
7038    fn a_branch_the_base_moved_under_is_rebased_not_fixed() {
7039        // Pull requests 35 and 37 were both rebased by hand: a competition
7040        // that runs for two hours against a repository merging pull requests
7041        // all day conflicts on the way in, and that is arithmetic rather
7042        // than a defect in the change.
7043        let mut conflicted = pr(Checks::Green, &[], 0);
7044        conflicted.blocking = Blocking::Conflict;
7045        assert_eq!(decide(&conflicted, 0, 4, Duration::ZERO), Step::Rebase);
7046
7047        // Decided before the checks, and even with the rounds spent: every
7048        // check on a branch that cannot land is an answer about a state that
7049        // cannot land, and a conflict is not the change's fault.
7050        let mut red = pr(Checks::Red, &["test (ubuntu-latest)"], 2);
7051        red.blocking = Blocking::Conflict;
7052        assert_eq!(decide(&red, 4, 4, Duration::ZERO), Step::Rebase);
7053
7054        // The lifecycle still wins over everything, conflict included.
7055        let mut merged = pr(Checks::Red, &[], 0);
7056        merged.blocking = Blocking::Conflict;
7057        merged.state = PrLifecycle::Merged;
7058        assert_eq!(
7059            decide(&merged, 0, 4, Duration::ZERO),
7060            Step::Done { merged: true }
7061        );
7062    }
7063
7064    #[test]
7065    fn the_forge_verdict_is_read_off_merge_state_status() {
7066        // The spellings that mean "mergeable". `UNSTABLE` is the one that
7067        // matters: mergeable, with a non-required check red or still running.
7068        for ok in ["CLEAN", "UNSTABLE", "unstable", "HAS_HOOKS"] {
7069            assert_eq!(Blocking::of(ok), Blocking::No, "{ok}");
7070            assert!(!Blocking::of(ok).stops_a_merge(), "{ok}");
7071        }
7072        assert_eq!(Blocking::of("DIRTY"), Blocking::Conflict);
7073        assert_eq!(Blocking::of("BLOCKED"), Blocking::Yes);
7074        assert_eq!(Blocking::of("BEHIND"), Blocking::Behind);
7075        // An older `gh`, or a token without the scope, says nothing - and
7076        // refusing to guess is the rule everywhere else in this module.
7077        for quiet in ["", "UNKNOWN"] {
7078            assert_eq!(Blocking::of(quiet), Blocking::Unsaid);
7079            assert!(Blocking::of(quiet).stops_a_merge());
7080        }
7081    }
7082
7083    #[test]
7084    fn a_merge_command_that_failed_after_merging_is_still_a_merge() {
7085        let argv = merge_argv(28, "fix: retry uploads on transient network errors");
7086        // The exact stderr from run ec12, in a jj-colocated repository.
7087        let jj = "could not determine current branch: failed to run git: not on any branch";
7088
7089        let landed = merged_after_all(&argv, jj, Some(PrLifecycle::Merged))
7090            .expect("the forge says merged, so it merged");
7091        assert!(landed.ok);
7092        assert!(
7093            landed.detail.contains("but the pull request is merged"),
7094            "the record must not read as a clean success: {}",
7095            landed.detail
7096        );
7097        assert!(
7098            landed.detail.contains("not on any branch"),
7099            "and it must keep what the command actually said: {}",
7100            landed.detail
7101        );
7102
7103        // A pull request still open means the merge really failed.
7104        assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Open)).is_none());
7105        assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Closed)).is_none());
7106        // And an unreadable answer is not evidence of success.
7107        assert!(merged_after_all(&argv, jj, None).is_none());
7108    }
7109
7110    #[test]
7111    fn a_pull_request_closed_underneath_us_is_done_and_not_merged() {
7112        let mut state = pr(Checks::Red, &["editorconfig"], 3);
7113        state.state = PrLifecycle::Closed;
7114        assert_eq!(
7115            decide(&state, 0, 4, Duration::ZERO),
7116            Step::Done { merged: false },
7117            "a human closing the pull request ends the loop, whatever CI says"
7118        );
7119    }
7120
7121    #[test]
7122    fn the_last_round_gives_up_with_a_reason_naming_what_is_still_failing() {
7123        let red = decide(
7124            &pr(Checks::Red, &["editorconfig", "test (macos)"], 0),
7125            4,
7126            4,
7127            Duration::ZERO,
7128        );
7129        match red {
7130            Step::GiveUp { reason } => {
7131                assert!(reason.contains("editorconfig"), "reason: {reason}");
7132                assert!(reason.contains("test (macos)"), "reason: {reason}");
7133                assert!(reason.contains("4 fix round(s)"), "reason: {reason}");
7134            }
7135            other => panic!("expected a give-up, got {other:?}"),
7136        }
7137
7138        let commented = decide(&pr(Checks::Green, &[], 1), 2, 2, Duration::ZERO);
7139        match commented {
7140            Step::GiveUp { reason } => {
7141                assert!(reason.contains("unresolved"), "reason: {reason}");
7142                assert!(reason.contains("2 fix round(s)"), "reason: {reason}");
7143            }
7144            other => panic!("expected a give-up, got {other:?}"),
7145        }
7146    }
7147
7148    #[test]
7149    fn the_merge_command_squashes_deletes_the_branch_and_sets_its_own_subject() {
7150        let candidate_commit = "magi: candidate A (uncommitted work)";
7151        let subject = merge_subject(candidate_commit, "add retries to the uploader");
7152        let argv = merge_argv(16, &subject);
7153
7154        assert!(argv.contains(&"--squash".to_owned()));
7155        assert!(argv.contains(&"--delete-branch".to_owned()));
7156        assert!(argv.contains(&"--subject".to_owned()));
7157        assert_eq!(
7158            argv.last().map(String::as_str),
7159            Some("add retries to the uploader"),
7160            "the subject must not be the candidate commit message"
7161        );
7162        assert_ne!(subject, candidate_commit);
7163    }
7164
7165    #[test]
7166    fn a_real_pull_request_title_is_used_as_the_squash_subject_verbatim() {
7167        assert_eq!(
7168            merge_subject("feat: a queue, an unattended loop, and a phone UI", "task"),
7169            "feat: a queue, an unattended loop, and a phone UI"
7170        );
7171        assert_eq!(
7172            merge_subject("", "# port the retry logic\n\ndetails"),
7173            "port the retry logic",
7174            "an empty title falls back to the task's first line, heading marks stripped"
7175        );
7176    }
7177
7178    #[test]
7179    fn a_failing_checks_details_url_yields_the_job_to_read_logs_from() {
7180        let url = "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572";
7181        assert_eq!(job_of(url).as_deref(), Some("100114323572"));
7182        assert_eq!(run_of(url).as_deref(), Some("33587406996"));
7183        assert_eq!(job_of("https://coderabbit.ai/status"), None);
7184        assert_eq!(run_of(""), None);
7185    }
7186
7187    #[test]
7188    fn magis_own_stop_comment_is_never_read_back_as_a_finding() {
7189        let mut out = Vec::new();
7190        push_if_outstanding(
7191            &mut out,
7192            ReviewComment {
7193                author: "yukimemi".to_owned(),
7194                path: None,
7195                line: None,
7196                body: format!("{MARKER}\nmagi stopped landing this pull request: 1 check failing"),
7197            },
7198        );
7199        assert!(out.is_empty());
7200    }
7201
7202    /// A run with no tally, so [`RunState::winner`] is `None` and the panel
7203    /// falls back to the repository - which keeps these tests free of a
7204    /// worktree, a `git` invocation and a network.
7205    fn run_state() -> RunState {
7206        let mut state = RunState::new(
7207            std::path::PathBuf::from("/repo/magi"),
7208            "main".to_owned(),
7209            "abcdef1234".to_owned(),
7210            "add retries to the uploader".to_owned(),
7211            crate::config::Config::default(),
7212        );
7213        // These fixtures test execution flow, independent of host disk capacity.
7214        state.config.disk.min_free_bytes = 0;
7215        // Tests run in parallel against one persistent home and the ids
7216        // `RunState::new` draws from the clock can repeat, so two tests would
7217        // share a run's questions. The home also outlives the process, so the
7218        // counter alone would reuse an earlier run's ids.
7219        static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
7220        let nanos = std::time::SystemTime::now()
7221            .duration_since(std::time::UNIX_EPOCH)
7222            .map_or(0, |d| d.subsec_nanos() % 1_000_000);
7223        state.id = format!(
7224            "20261004-{nanos:06}-{:04x}",
7225            NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
7226        );
7227        state
7228    }
7229
7230    fn green_pr() -> PrState {
7231        PrState {
7232            url: "https://github.com/yukimemi/magi/pull/42".to_owned(),
7233            number: 42,
7234            state: PrLifecycle::Open,
7235            checks: Checks::Green,
7236            // The forge sees nothing in the way unless a test says otherwise.
7237            blocking: Blocking::No,
7238            failing: Vec::new(),
7239            review_comments: vec![ReviewComment {
7240                author: "coderabbitai".to_owned(),
7241                path: Some("src/land.rs".to_owned()),
7242                line: Some(212),
7243                body: "this branch never checks the exit code".to_owned(),
7244            }],
7245        }
7246    }
7247
7248    #[test]
7249    fn land_fixer_defers_review_and_verification_without_a_cache() {
7250        let state = run_state();
7251        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7252        assert!(p.contains(crate::prompt::child_run_ownership()), "{p}");
7253        assert!(p.contains("Commit in this worktree"), "{p}");
7254    }
7255
7256    #[test]
7257    fn github_facing_land_text_is_english_whatever_the_language() {
7258        let mut state = run_state();
7259        state.config.graph.language = "ja".to_owned();
7260        let comment = stop_comment(&state.id, "checks are still red");
7261        assert!(crate::github_text::check("", &comment).is_empty());
7262        assert!(comment.is_ascii(), "{comment}");
7263        assert!(comment.starts_with(MARKER));
7264
7265        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7266        let ja_at = p.find("Write all prose in ja").unwrap();
7267        let rule_at = p.find(crate::prompt::GITHUB_ENGLISH_HEADING).unwrap();
7268        assert!(ja_at < rule_at, "{p}");
7269        assert!(p.contains("stays in Japanese"), "{p}");
7270
7271        state.config.graph.language = "en".to_owned();
7272        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7273        assert!(p.contains(crate::prompt::GITHUB_ENGLISH_HEADING), "{p}");
7274        assert!(!p.contains("does not apply"), "{p}");
7275    }
7276
7277    const NUMSTAT: &str = "12\t3\tsrc/land.rs\n40\t1\tsrc/web.rs\n-\t-\tassets/logo.png";
7278
7279    fn panel() -> String {
7280        approval_panel(
7281            &run_state(),
7282            &green_pr(),
7283            NUMSTAT,
7284            "diff --git a/src/land.rs b/src/land.rs\n@@ -1,2 +1,2 @@\n-old line\n+new line\n context",
7285            &[
7286                "land: ask before merging".to_owned(),
7287                "land: colour the diff".to_owned(),
7288            ],
7289            "feat: merge approval from the phone",
7290        )
7291    }
7292
7293    #[test]
7294    fn the_approval_panel_carries_the_whole_case_for_the_merge() {
7295        let html = panel();
7296        for needle in [
7297            "42",
7298            "main",
7299            "src/land.rs",
7300            "src/web.rs",
7301            "assets/logo.png",
7302            "feat: merge approval from the phone",
7303            "land: ask before merging",
7304            "land: colour the diff",
7305            "coderabbitai",
7306            "this branch never checks the exit code",
7307            "green",
7308        ] {
7309            assert!(html.contains(needle), "the panel must state `{needle}`");
7310        }
7311    }
7312
7313    async fn landing_git_fixture() -> (tempfile::TempDir, RunState, String) {
7314        crate::run::pin_test_home();
7315        let tmp = tempfile::tempdir().unwrap();
7316        let repo = tmp.path().join("repo");
7317        let remote = tmp.path().join("remote.git");
7318        std::fs::create_dir(&repo).unwrap();
7319        git::git(tmp.path(), &["init", "--bare", remote.to_str().unwrap()])
7320            .await
7321            .unwrap();
7322        git::git(&repo, &["init", "-b", "main"]).await.unwrap();
7323        git::git(&repo, &["config", "user.name", "Test"])
7324            .await
7325            .unwrap();
7326        git::git(&repo, &["config", "user.email", "test@example.test"])
7327            .await
7328            .unwrap();
7329        std::fs::write(repo.join("base"), "base").unwrap();
7330        git::git(&repo, &["add", "."]).await.unwrap();
7331        git::git(&repo, &["commit", "-m", "base"]).await.unwrap();
7332        git::git(
7333            &repo,
7334            &["remote", "add", "origin", remote.to_str().unwrap()],
7335        )
7336        .await
7337        .unwrap();
7338        git::git(&repo, &["push", "origin", "main"]).await.unwrap();
7339        git::git(&repo, &["checkout", "-b", "winner"])
7340            .await
7341            .unwrap();
7342        std::fs::write(repo.join("change"), "change").unwrap();
7343        git::git(&repo, &["add", "."]).await.unwrap();
7344        git::git(&repo, &["commit", "-m", "change"]).await.unwrap();
7345        let head = git::rev_parse(&repo, "HEAD").await.unwrap();
7346        git::git(&repo, &["push", "origin", "HEAD:refs/heads/task-head"])
7347            .await
7348            .unwrap();
7349        let mut state = run_state();
7350        state.repo = repo.clone();
7351        state.base_commit = git::rev_parse(&repo, "origin/main").await.unwrap();
7352        state.config.graph.land = true;
7353        state.config.graph.land_approval = true;
7354        state.pr_head = Some("task-head".into());
7355        state.pr_pushed_head = Some(head.clone());
7356        state.candidates = vec![winning_candidate("change")];
7357        state.candidates[0].worktree = repo;
7358        state.candidates[0].branch = "winner".into();
7359        state.tally = Some(uncontested_tally());
7360        state.gate_ran = true;
7361        state.gate_head = Some(head.clone());
7362        state.land_sync_pending = true;
7363        state.save().unwrap();
7364        (tmp, state, head)
7365    }
7366
7367    async fn resume_observed_head(state: &mut RunState, head: &str) -> Result<String> {
7368        let forge = Scripted::new(vec![seen(head, Checks::Green, "CLEAN", false)], vec![]);
7369        resume_landing_head(state, head, &green_pr().url, &forge, None).await
7370    }
7371
7372    async fn advance_landing_base(state: &RunState) {
7373        git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7374        std::fs::write(state.repo.join("advance"), "advance").unwrap();
7375        git::git(&state.repo, &["add", "."]).await.unwrap();
7376        git::git(&state.repo, &["commit", "-m", "advance base"])
7377            .await
7378            .unwrap();
7379        git::git(&state.repo, &["push", "origin", "main"])
7380            .await
7381            .unwrap();
7382        git::git(&state.repo, &["checkout", "winner"])
7383            .await
7384            .unwrap();
7385    }
7386
7387    #[tokio::test]
7388    async fn rebase_preparation_failure_preserves_landing_budget_and_resumes() {
7389        let (_tmp, mut state, head) = landing_git_fixture().await;
7390        advance_landing_base(&state).await;
7391        let scratch = state.dir().join("rebase");
7392        std::fs::create_dir_all(&scratch).unwrap();
7393        std::fs::write(scratch.join("obstruction"), "keep").unwrap();
7394        let attempts = state.land_sync_attempts;
7395        let error = rebase_landing_worktree(&mut state, "origin/main")
7396            .await
7397            .unwrap_err();
7398        assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
7399        assert_eq!(state.land_sync_attempts, attempts);
7400        assert!(state.land_sync_target.is_none());
7401        assert!(state.rebase_fixes.is_empty());
7402        assert!(
7403            state
7404                .base_sync
7405                .as_ref()
7406                .is_none_or(|sync| sync.conflict.is_none())
7407        );
7408        assert!(
7409            state
7410                .resource_block
7411                .as_ref()
7412                .unwrap()
7413                .detail
7414                .contains("worktree add")
7415        );
7416        assert_eq!(git::rev_parse(&state.repo, "winner").await.unwrap(), head);
7417        std::fs::remove_dir_all(&scratch).unwrap();
7418        state.resource_block = None;
7419        assert_eq!(
7420            rebase_landing_worktree(&mut state, "origin/main")
7421                .await
7422                .unwrap(),
7423            crate::rebase::Rebased::Applied
7424        );
7425        assert_eq!(state.land_sync_attempts, attempts + 1);
7426        assert!(git::is_ancestor(&state.repo, "origin/main", "winner").await);
7427        assert!(git::is_clean(&state.repo).await.unwrap());
7428        assert!(state.rebase_fixes.is_empty());
7429    }
7430
7431    async fn foreign_landing_fixture() -> (tempfile::TempDir, RunState, String, std::path::PathBuf)
7432    {
7433        let (tmp, mut state, old) = landing_git_fixture().await;
7434        let path = tmp.path().join("foreign");
7435        git::worktree_add_branch(&state.repo, &path, "task-head", &old)
7436            .await
7437            .unwrap();
7438        state.foreign_checkout = Some(
7439            crate::foreign_checkout::inspect(&state.repo, "task-head", &path)
7440                .await
7441                .unwrap(),
7442        );
7443        state.config.merge.mode = crate::config::MergeMode::Pr;
7444        state.save().unwrap();
7445        (tmp, state, old, path)
7446    }
7447
7448    #[tokio::test]
7449    async fn foreign_landing_sync_and_interrupted_resumes_preserve_delivery_ancestry() {
7450        for phase in 0..4 {
7451            let (_tmp, mut state, old, path) = foreign_landing_fixture().await;
7452            advance_landing_base(&state).await;
7453            state.config.verify.gate = vec!["test -f advance && test -f change".into()];
7454            if phase == 0 {
7455                // The live Step::Rebase path uses this same synchronization
7456                // and publication pair, without going through resume.
7457                assert_eq!(
7458                    rebase_landing_worktree(&mut state, "origin/main")
7459                        .await
7460                        .unwrap(),
7461                    crate::rebase::Rebased::Applied
7462                );
7463            } else {
7464                interrupt_landing_rebase(&mut state).await;
7465                let repaired_tree = git::tree_of(&state.repo, "HEAD").await.unwrap();
7466                if phase == 2 {
7467                    git::sync_to_head(&state.repo).await.unwrap();
7468                } else if phase == 3 {
7469                    // Crash after joining history, before clearing its saved
7470                    // start. Repeating restoration must not add another merge.
7471                    restore_landing_worktree(&mut state).await.unwrap();
7472                    let joined = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7473                    state.land_rebase_from = Some(old.clone());
7474                    state.save().unwrap();
7475                    restore_landing_worktree(&mut state).await.unwrap();
7476                    assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), joined);
7477                }
7478                state.save().unwrap();
7479                state = RunState::load(&state.id).unwrap();
7480                restore_landing_worktree(&mut state).await.unwrap();
7481                assert_eq!(
7482                    git::tree_of(&state.repo, "HEAD").await.unwrap(),
7483                    repaired_tree
7484                );
7485            }
7486            let head = if phase == 0 {
7487                let forge = Scripted::new(vec![seen(&old, Checks::Green, "CLEAN", false)], vec![]);
7488                publish_landing_head(&mut state, &old, &green_pr().url, &forge)
7489                    .await
7490                    .unwrap()
7491            } else {
7492                resume_observed_head(&mut state, &old).await.unwrap()
7493            };
7494            assert!(git::is_ancestor(&state.repo, &old, &head).await);
7495            assert!(git::is_ancestor(&state.repo, "origin/main", &head).await);
7496            assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), head);
7497            assert_eq!(
7498                git::remote_head(&state.repo, "origin", "task-head")
7499                    .await
7500                    .unwrap(),
7501                Some(head.clone())
7502            );
7503            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7504            assert_eq!(state.foreign_checkout.as_ref().unwrap().synced_head, head);
7505            assert!(state.gate_allows_progress());
7506            assert!(state.land_rebase_from.is_none());
7507            assert!(!state.land_sync_pending);
7508            assert!(git::is_clean(&path).await.unwrap());
7509        }
7510    }
7511
7512    #[tokio::test]
7513    async fn foreign_landing_conflict_repair_can_resume_and_publish_without_losing_ancestry() {
7514        let (_tmp, mut state, old, path) = foreign_landing_fixture().await;
7515        git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7516        std::fs::write(state.repo.join("change"), "conflicting base change").unwrap();
7517        git::commit_all(&state.repo, "conflicting base")
7518            .await
7519            .unwrap();
7520        git::git(&state.repo, &["push", "origin", "main"])
7521            .await
7522            .unwrap();
7523        git::git(&state.repo, &["checkout", "winner"])
7524            .await
7525            .unwrap();
7526        landing_gate_fixer(
7527            &mut state,
7528            "cat >/dev/null; printf resolved > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"resolved\"}'",
7529        );
7530        state.config.graph.gate_fix_rounds = 0;
7531        state.config.verify.gate = vec!["exit 1".into()];
7532        assert!(resume_observed_head(&mut state, &old).await.is_err());
7533        assert!(state.rebase_fixes.iter().any(|fix| fix.finished));
7534        let repaired = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7535        assert!(git::is_ancestor(&state.repo, &old, &repaired).await);
7536        assert_eq!(
7537            std::fs::read_to_string(state.repo.join("change")).unwrap(),
7538            "resolved"
7539        );
7540        // A red gate must neither deliver nor publish the repaired tree.
7541        assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), old);
7542        assert_eq!(
7543            git::remote_head(&state.repo, "origin", "task-head")
7544                .await
7545                .unwrap(),
7546            Some(old.clone())
7547        );
7548        state = RunState::load(&state.id).unwrap();
7549        state.config.verify.gate = vec!["grep -q resolved change".into()];
7550        let head = resume_observed_head(&mut state, &old).await.unwrap();
7551        assert_eq!(head, repaired);
7552        assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), head);
7553        assert_eq!(
7554            std::fs::read_to_string(path.join("change")).unwrap(),
7555            "resolved"
7556        );
7557        assert_eq!(
7558            git::remote_head(&state.repo, "origin", "task-head")
7559                .await
7560                .unwrap(),
7561            Some(head.clone())
7562        );
7563        assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7564        assert!(git::is_ancestor(&state.repo, "origin/main", &head).await);
7565        assert!(git::is_clean(&path).await.unwrap());
7566    }
7567
7568    #[tokio::test]
7569    async fn landing_resume_completes_the_last_charged_sync_attempt() {
7570        for (scratch_started, saved_target) in [(false, true), (true, true), (true, false)] {
7571            let (_tmp, mut state, old) = landing_git_fixture().await;
7572            git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7573            std::fs::write(state.repo.join("change"), "conflicting base change").unwrap();
7574            git::commit_all(&state.repo, "conflicting base")
7575                .await
7576                .unwrap();
7577            git::git(&state.repo, &["push", "origin", "main"])
7578                .await
7579                .unwrap();
7580            git::git(&state.repo, &["checkout", "winner"])
7581                .await
7582                .unwrap();
7583            let target = git::rev_parse(&state.repo, "origin/main").await.unwrap();
7584            state.config.graph.land_rounds = 1;
7585            state.land_sync_attempts = 1;
7586            state.land_sync_target = saved_target.then(|| target.clone());
7587            state.land_rebase_from = Some(old.clone());
7588            landing_gate_fixer(
7589                &mut state,
7590                "cat >/dev/null; printf resolved > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"resolved\"}'",
7591            );
7592            state.config.verify.gate = vec!["grep -q resolved change".into()];
7593            state.save().unwrap();
7594            // Simulate interruption before the scratch start and at a conflict.
7595            if scratch_started {
7596                assert!(matches!(
7597                    git::rebase_start(&state.repo, &state.dir().join("rebase"), "winner", &target)
7598                        .await
7599                        .unwrap(),
7600                    git::RebaseStart::Conflicted(_)
7601                ));
7602            }
7603            state = RunState::load(&state.id).unwrap();
7604            let head = resume_observed_head(&mut state, &old).await.unwrap();
7605            assert_ne!(head, old);
7606            assert_eq!(state.land_sync_attempts, 1);
7607            assert!(state.land_sync_target.is_none());
7608            assert!(state.land_rebase_from.is_none());
7609            assert!(!state.land_sync_pending);
7610            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7611            assert!(state.gate_allows_progress());
7612            assert_eq!(
7613                git::remote_head(&state.repo, "origin", "task-head")
7614                    .await
7615                    .unwrap(),
7616                Some(head)
7617            );
7618            assert!(
7619                rebase_landing_worktree(&mut state, "origin/main")
7620                    .await
7621                    .unwrap_err()
7622                    .to_string()
7623                    .contains("budget exhausted")
7624            );
7625        }
7626    }
7627
7628    #[tokio::test]
7629    async fn landing_resume_gates_rebased_sha_and_publishes_it_to_the_existing_head() {
7630        let (_tmp, mut state, old) = landing_git_fixture().await;
7631        advance_landing_base(&state).await;
7632        state.config.verify.gate = vec!["test -f advance".into()];
7633        let head = resume_observed_head(&mut state, &old).await.unwrap();
7634        assert_ne!(head, old);
7635        assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7636        assert!(state.gate_allows_progress());
7637        assert_eq!(
7638            git::remote_head(&state.repo, "origin", "task-head")
7639                .await
7640                .unwrap(),
7641            Some(head.clone())
7642        );
7643        assert_eq!(state.pr_pushed_head, Some(head));
7644        assert!(!state.land_sync_pending);
7645        assert!(state.config.graph.land_approval);
7646    }
7647
7648    fn landing_gate_fixer(state: &mut RunState, script: &str) {
7649        state.config.disk.min_free_bytes = 0;
7650        state.config.graph.gate_fix_rounds = 1;
7651        state.config.agents = vec![crate::config::AgentSpec {
7652            id: "mock".into(),
7653            kind: crate::config::AgentKind::Command,
7654            model: None,
7655            command: vec!["sh".into(), "-c".into(), script.into()],
7656            extra_args: Vec::new(),
7657            env: Default::default(),
7658            prompt_delivery: None,
7659            max_turn_secs: None,
7660        }];
7661        state.candidates[0].agent = "mock".into();
7662    }
7663
7664    #[tokio::test]
7665    async fn landing_resume_revalidates_an_operator_published_winner_extension() {
7666        let (_tmp, mut state, old) = landing_git_fixture().await;
7667        std::fs::write(state.repo.join("change"), "operator update").unwrap();
7668        git::commit_all(&state.repo, "extend winner").await.unwrap();
7669        let updated = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7670        git::git(
7671            &state.repo,
7672            &["push", "origin", "HEAD:refs/heads/task-head"],
7673        )
7674        .await
7675        .unwrap();
7676        state.config.verify.gate = vec!["exit 1".into()];
7677        state.config.graph.gate_fix_rounds = 0;
7678        assert!(resume_observed_head(&mut state, &updated).await.is_err());
7679        assert_ne!(old, updated);
7680        assert_eq!(state.gate_head.as_ref(), Some(&updated));
7681        assert!(!state.gate_allows_progress());
7682        assert!(state.land_sync_pending);
7683        state.config.verify.gate = vec!["grep -q 'operator update' change".into()];
7684        let head = resume_observed_head(&mut state, &updated).await.unwrap();
7685        assert_eq!(head, updated);
7686        assert!(state.gate_allows_progress());
7687        assert!(!state.land_sync_pending);
7688        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7689        land_with(&mut state, &green_pr().url, &forge)
7690            .await
7691            .unwrap();
7692        assert!(state.parked);
7693        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7694        assert!(forge.argvs().is_empty());
7695    }
7696
7697    #[tokio::test]
7698    async fn landing_resume_refuses_remote_only_and_divergent_operator_updates() {
7699        for divergent in [false, true] {
7700            let (_tmp, mut state, old) = landing_git_fixture().await;
7701            if divergent {
7702                git::git(&state.repo, &["reset", "--hard", "origin/main"])
7703                    .await
7704                    .unwrap();
7705            }
7706            std::fs::write(state.repo.join("external"), "external").unwrap();
7707            git::commit_all(&state.repo, "external update")
7708                .await
7709                .unwrap();
7710            let external = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7711            git::git(
7712                &state.repo,
7713                &["push", "--force", "origin", "HEAD:refs/heads/task-head"],
7714            )
7715            .await
7716            .unwrap();
7717            if !divergent {
7718                git::git(&state.repo, &["reset", "--hard", &old])
7719                    .await
7720                    .unwrap();
7721            }
7722            let error = resume_observed_head(&mut state, &external)
7723                .await
7724                .unwrap_err();
7725            assert!(
7726                error
7727                    .to_string()
7728                    .contains("public head moved outside this run")
7729            );
7730            assert_eq!(state.pr_pushed_head.as_ref(), Some(&old));
7731            assert_eq!(
7732                git::remote_head(&state.repo, "origin", "task-head")
7733                    .await
7734                    .unwrap(),
7735                Some(external)
7736            );
7737        }
7738    }
7739
7740    #[tokio::test]
7741    async fn landing_resume_repairs_a_failed_rebased_gate_before_publication() {
7742        let (_tmp, mut state, old) = landing_git_fixture().await;
7743        advance_landing_base(&state).await;
7744        landing_gate_fixer(
7745            &mut state,
7746            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7747        );
7748        state.config.verify.gate =
7749            vec!["grep -q fixed change || { echo 'change needs repair'; exit 1; }".into()];
7750        state.config.verify.e2e = vec!["test -f advance".into()];
7751        // First save a red gate without spending a fixer round. Resume must
7752        // still offer the remaining budget for this exact same failed head.
7753        state.config.graph.gate_fix_rounds = 0;
7754        assert!(resume_observed_head(&mut state, &old).await.is_err());
7755        assert_eq!(
7756            git::remote_head(&state.repo, "origin", "task-head")
7757                .await
7758                .unwrap(),
7759            Some(old.clone())
7760        );
7761        state.config.graph.gate_fix_rounds = 1;
7762        let head = resume_observed_head(&mut state, &old).await.unwrap();
7763        assert_eq!(state.gate_fixes.len(), 1);
7764        assert!(state.gate_fixes[0].committed);
7765        assert!(state.gate_allows_progress());
7766        assert_eq!(state.gate_head.as_ref(), Some(&head));
7767        assert_eq!(
7768            git::remote_head(&state.repo, "origin", "task-head")
7769                .await
7770                .unwrap(),
7771            Some(head.clone())
7772        );
7773        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7774        land_with(&mut state, &green_pr().url, &forge)
7775            .await
7776            .unwrap();
7777        assert!(state.parked);
7778        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7779        assert!(forge.argvs().is_empty());
7780    }
7781
7782    #[tokio::test]
7783    async fn landing_gate_repairs_stop_at_the_saved_budget_without_publishing() {
7784        let (_tmp, mut state, old) = landing_git_fixture().await;
7785        advance_landing_base(&state).await;
7786        landing_gate_fixer(
7787            &mut state,
7788            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7789        );
7790        state.config.verify.gate = vec!["echo still red; exit 1".into()];
7791        for _ in 0..2 {
7792            assert!(resume_observed_head(&mut state, &old).await.is_err());
7793            assert_eq!(state.gate_fixes.len(), 1);
7794            assert_eq!(
7795                git::remote_head(&state.repo, "origin", "task-head")
7796                    .await
7797                    .unwrap(),
7798                Some(old.clone())
7799            );
7800        }
7801    }
7802
7803    #[tokio::test]
7804    async fn landing_gate_repair_cannot_publish_failed_e2e_on_repeated_resumes() {
7805        let (_tmp, mut state, old) = landing_git_fixture().await;
7806        advance_landing_base(&state).await;
7807        landing_gate_fixer(
7808            &mut state,
7809            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7810        );
7811        state.config.verify.gate =
7812            vec!["grep -q fixed change || { echo 'change needs repair'; exit 1; }".into()];
7813        // The repair makes the gate green while breaking an e2e invariant.
7814        state.config.verify.e2e = vec!["grep -q '^change$' change".into()];
7815        for resume in 0..3 {
7816            assert!(resume_observed_head(&mut state, &old).await.is_err());
7817            state = RunState::load(&state.id).unwrap();
7818            let evidence = state.gate_repair_e2e.as_ref().unwrap();
7819            let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7820            assert_eq!(evidence.head, head);
7821            assert!(!evidence.passed);
7822            assert!(evidence.outcomes.iter().any(|o| !o.ok()));
7823            assert_eq!(state.gate_fixes.len(), 1);
7824            assert_eq!(
7825                git::remote_head(&state.repo, "origin", "task-head")
7826                    .await
7827                    .unwrap(),
7828                Some(old.clone())
7829            );
7830            if resume > 0 {
7831                assert!(
7832                    state.gate_allows_progress(),
7833                    "a green gate must not bypass red e2e"
7834                );
7835            }
7836        }
7837        // Once e2e genuinely succeeds on the same SHA, the saved requirement
7838        // can be satisfied without another fixer or approval bypass.
7839        state.config.verify.e2e = vec!["grep -q fixed change".into()];
7840        let head = resume_observed_head(&mut state, &old).await.unwrap();
7841        assert!(state.gate_repair_e2e.as_ref().unwrap().passed);
7842        assert_eq!(state.gate_repair_e2e.as_ref().unwrap().head, head);
7843        assert_eq!(state.gate_fixes.len(), 1);
7844        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7845        land_with(&mut state, &green_pr().url, &forge)
7846            .await
7847            .unwrap();
7848        assert!(state.parked);
7849        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7850        assert!(forge.argvs().is_empty());
7851    }
7852
7853    #[tokio::test]
7854    async fn landing_resumes_recheck_pending_deferred_and_stale_repair_e2e() {
7855        for phase in 0..3 {
7856            let (_tmp, mut state, old) = landing_git_fixture().await;
7857            advance_landing_base(&state).await;
7858            let head = resume_observed_head(&mut state, &old).await.unwrap();
7859            // Persist the shapes left by interruption, resource deferral,
7860            // and a successful check for a different (older) SHA.
7861            state.land_sync_pending = true;
7862            state.config.verify.e2e = vec!["echo e2e is red; exit 1".into()];
7863            state.gate_repair_e2e = Some(crate::run::GateRepairE2e {
7864                head: if phase == 2 {
7865                    old.clone()
7866                } else {
7867                    head.clone()
7868                },
7869                passed: phase == 2,
7870                outcomes: if phase == 1 {
7871                    vec![crate::run::CommandOutcome {
7872                        command: state.config.verify.e2e[0].clone(),
7873                        code: None,
7874                        output_tail: "verification resource unavailable".into(),
7875                        duration_ms: 0,
7876                        resource_blocked: true,
7877                    }]
7878                } else {
7879                    Vec::new()
7880                },
7881            });
7882            state.save().unwrap();
7883            for _ in 0..2 {
7884                state = RunState::load(&state.id).unwrap();
7885                assert!(resume_observed_head(&mut state, &head).await.is_err());
7886                let evidence = state.gate_repair_e2e.as_ref().unwrap();
7887                assert_eq!(evidence.head, head);
7888                assert!(!evidence.passed);
7889                assert!(!evidence.outcomes.is_empty());
7890                assert_eq!(
7891                    git::remote_head(&state.repo, "origin", "task-head")
7892                        .await
7893                        .unwrap(),
7894                    Some(head.clone())
7895                );
7896                assert!(state.land_sync_pending);
7897            }
7898        }
7899    }
7900
7901    async fn interrupt_landing_rebase(state: &mut RunState) {
7902        state.land_rebase_from = Some(git::rev_parse(&state.repo, "HEAD").await.unwrap());
7903        state.save().unwrap();
7904        let scratch = state.dir().join("rebase");
7905        assert_eq!(
7906            crate::rebase::rebase_with_fixer(state, &scratch, "winner", "origin/main")
7907                .await
7908                .unwrap(),
7909            crate::rebase::Rebased::Applied
7910        );
7911        assert!(!git::is_clean(&state.repo).await.unwrap());
7912    }
7913
7914    async fn landing_setup(state: &mut RunState) {
7915        git::git(
7916            &state.repo,
7917            &["config", "extensions.worktreeConfig", "true"],
7918        )
7919        .await
7920        .unwrap();
7921        state.config.worktree.setup =
7922            vec![toml::from_str("run = \"printf secret > .env\"").unwrap()];
7923        crate::worktree_setup::prepare(&state.config, &state.repo, &state.repo)
7924            .await
7925            .unwrap();
7926        state.config.verify.gate = vec!["test -f advance && test -f .env".into()];
7927    }
7928
7929    #[tokio::test]
7930    async fn landing_resume_restores_setup_after_both_fresh_and_interrupted_rebases() {
7931        for phase in 0..3 {
7932            let (_tmp, mut state, old) = landing_git_fixture().await;
7933            advance_landing_base(&state).await;
7934            landing_setup(&mut state).await;
7935            if phase > 0 {
7936                interrupt_landing_rebase(&mut state).await;
7937                if phase == 2 {
7938                    // Crash after clean removed setup products, before setup.
7939                    git::sync_to_head(&state.repo).await.unwrap();
7940                    assert!(!state.repo.join(".env").exists());
7941                }
7942                state = RunState::load(&state.id).unwrap();
7943            }
7944            let head = resume_observed_head(&mut state, &old).await.unwrap();
7945            assert_ne!(head, old);
7946            assert!(state.gate_allows_progress());
7947            assert!(state.land_rebase_from.is_none());
7948            assert_eq!(
7949                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
7950                "secret"
7951            );
7952            assert!(git::is_clean(&state.repo).await.unwrap());
7953            assert!(
7954                !git::git(&state.repo, &["ls-tree", "--name-only", "HEAD"])
7955                    .await
7956                    .unwrap()
7957                    .contains(".env")
7958            );
7959        }
7960    }
7961
7962    #[tokio::test]
7963    async fn landing_restoration_protects_ignored_files_outside_setup_products() {
7964        let (_tmp, mut state, _) = landing_git_fixture().await;
7965        advance_landing_base(&state).await;
7966        landing_setup(&mut state).await;
7967        interrupt_landing_rebase(&mut state).await;
7968        // Exercise unusual names without asking Windows to create an invalid
7969        // control-character filename. Unix also covers embedded newlines.
7970        let locals = [
7971            "local notes",
7972            #[cfg(unix)]
7973            "local\nnotes",
7974        ];
7975        let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
7976            .await
7977            .unwrap();
7978        std::fs::write(state.repo.join(excludes), "local*\n").unwrap();
7979        for local in locals {
7980            std::fs::write(state.repo.join(local), "keep these notes").unwrap();
7981            assert!(
7982                git::git_raw(&state.repo, &["check-ignore", "--quiet", local])
7983                    .await
7984                    .unwrap()
7985                    .ok()
7986            );
7987        }
7988        restore_landing_worktree(&mut state).await.unwrap();
7989        for local in locals {
7990            assert_eq!(
7991                std::fs::read_to_string(state.repo.join(local)).unwrap(),
7992                "keep these notes"
7993            );
7994        }
7995        assert_eq!(
7996            std::fs::read_to_string(state.repo.join(".env")).unwrap(),
7997            "secret"
7998        );
7999        assert!(git::is_clean(&state.repo).await.unwrap());
8000        assert!(state.land_rebase_from.is_none());
8001    }
8002
8003    #[tokio::test]
8004    async fn landing_restoration_rejects_ignored_paths_conflicting_with_the_new_tree() {
8005        for local in ["advance", "advance/notes", "new-directory"] {
8006            let (_tmp, mut state, _) = landing_git_fixture().await;
8007            advance_landing_base(&state).await;
8008            // Also cover a local file blocking a new tracked directory.
8009            git::git(&state.repo, &["checkout", "main"]).await.unwrap();
8010            std::fs::create_dir(state.repo.join("new-directory")).unwrap();
8011            std::fs::write(state.repo.join("new-directory/tracked"), "new").unwrap();
8012            git::git(&state.repo, &["add", "."]).await.unwrap();
8013            git::git(&state.repo, &["commit", "-m", "add directory"])
8014                .await
8015                .unwrap();
8016            git::git(&state.repo, &["push", "origin", "main"])
8017                .await
8018                .unwrap();
8019            git::git(&state.repo, &["checkout", "winner"])
8020                .await
8021                .unwrap();
8022            let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
8023                .await
8024                .unwrap();
8025            std::fs::write(state.repo.join(excludes), "advance\nnew-directory\n").unwrap();
8026            let path = state.repo.join(local);
8027            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
8028            std::fs::write(&path, "local notes").unwrap();
8029            interrupt_landing_rebase(&mut state).await;
8030            let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
8031            let checkpoint = state.land_rebase_from.clone();
8032            let error = restore_landing_worktree(&mut state).await.unwrap_err();
8033            assert!(
8034                error.to_string().contains("conflicting with HEAD"),
8035                "{error:#}"
8036            );
8037            assert_eq!(std::fs::read_to_string(&path).unwrap(), "local notes");
8038            assert_eq!(
8039                git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
8040                before
8041            );
8042            assert_eq!(state.land_rebase_from, checkpoint);
8043        }
8044    }
8045
8046    #[tokio::test]
8047    async fn landing_resume_preserves_ignored_gate_artifacts_without_setup() {
8048        for interrupted in [false, true] {
8049            let (_tmp, mut state, old) = landing_git_fixture().await;
8050            assert!(state.config.worktree.setup.is_empty());
8051            // A gate product exists before the base moves, without setup metadata.
8052            let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
8053                .await
8054                .unwrap();
8055            std::fs::write(state.repo.join(excludes), "target/\n").unwrap();
8056            state.config.verify.gate =
8057                vec!["mkdir -p target && printf artifact > target/probe".into()];
8058            state.gate_ran = false;
8059            resume_observed_head(&mut state, &old).await.unwrap();
8060            assert_eq!(
8061                std::fs::read_to_string(state.repo.join("target/probe")).unwrap(),
8062                "artifact"
8063            );
8064            advance_landing_base(&state).await;
8065            if interrupted {
8066                interrupt_landing_rebase(&mut state).await;
8067                state = RunState::load(&state.id).unwrap();
8068            }
8069            state.config.verify.gate =
8070                vec!["test -f advance && test \"$(cat target/probe)\" = artifact".into()];
8071            let head = resume_observed_head(&mut state, &old).await.unwrap();
8072            assert_ne!(head, old);
8073            assert!(state.gate_allows_progress());
8074            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
8075            assert_eq!(
8076                std::fs::read_to_string(state.repo.join("target/probe")).unwrap(),
8077                "artifact"
8078            );
8079            assert!(state.land_rebase_from.is_none());
8080            assert_eq!(
8081                git::remote_head(&state.repo, "origin", "task-head")
8082                    .await
8083                    .unwrap(),
8084                Some(head.clone())
8085            );
8086            let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8087            land_with(&mut state, &green_pr().url, &forge)
8088                .await
8089                .unwrap();
8090            assert!(state.parked);
8091            assert_eq!(state.land_approval.as_ref().unwrap().head, head);
8092            assert!(forge.argvs().is_empty());
8093        }
8094    }
8095
8096    #[tokio::test]
8097    #[cfg(unix)]
8098    async fn landing_restoration_waits_for_external_coordination_before_changing_files() {
8099        use std::os::fd::AsRawFd as _;
8100
8101        for interrupted in [false, true] {
8102            let (_tmp, mut state, _) = landing_git_fixture().await;
8103            advance_landing_base(&state).await;
8104            landing_setup(&mut state).await;
8105            if interrupted {
8106                interrupt_landing_rebase(&mut state).await;
8107            }
8108            state.config.worktree.setup =
8109                vec![toml::from_str("run = \"printf restored > .env\"").unwrap()];
8110            let common = crate::repo_lock::common_dir(&state.repo)
8111                .await
8112                .unwrap()
8113                .unwrap();
8114            std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8115            state.config.coordination = crate::config::test_coordination();
8116            state.config.graph.timeout_resource_wait = 0;
8117            let external = std::fs::OpenOptions::new()
8118                .read(true)
8119                .write(true)
8120                .create(true)
8121                .truncate(false)
8122                .open(common.join("updater.lock"))
8123                .unwrap();
8124            // SAFETY: the descriptor belongs to `external` and remains open.
8125            let locked =
8126                unsafe { libc::flock(external.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
8127            assert_eq!(locked, 0);
8128            let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
8129            let checkpoint = state.land_rebase_from.clone();
8130            let error = restore_landing_worktree(&mut state).await.unwrap_err();
8131            assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8132            assert_eq!(
8133                git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
8134                before
8135            );
8136            assert_eq!(state.land_rebase_from, checkpoint);
8137            assert_eq!(
8138                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8139                "secret"
8140            );
8141
8142            drop(external);
8143            state.config.graph.timeout_resource_wait = 2;
8144            restore_landing_worktree(&mut state).await.unwrap();
8145            assert!(git::is_clean(&state.repo).await.unwrap());
8146            assert!(state.land_rebase_from.is_none());
8147            assert_eq!(
8148                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8149                "restored"
8150            );
8151        }
8152    }
8153
8154    #[tokio::test]
8155    #[cfg(unix)]
8156    async fn landing_restoration_inherits_cancellation_while_waiting_for_a_local_seat() {
8157        use std::sync::atomic::{AtomicBool, Ordering};
8158
8159        let (_tmp, mut state, _) = landing_git_fixture().await;
8160        advance_landing_base(&state).await;
8161        landing_setup(&mut state).await;
8162        interrupt_landing_rebase(&mut state).await;
8163        let common = crate::repo_lock::common_dir(&state.repo)
8164            .await
8165            .unwrap()
8166            .unwrap();
8167        std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8168        state.config.coordination = crate::config::test_coordination();
8169        let holder = crate::repo_lock::SeatLease::for_checkout(
8170            &state.repo,
8171            true,
8172            state.config.coordination.as_ref(),
8173        )
8174        .await
8175        .unwrap();
8176        assert!(holder.is_some());
8177        let cancelled = Arc::new(AtomicBool::new(false));
8178        let signal = cancelled.clone();
8179        let wait = crate::repo_lock::WaitPolicy::new(Duration::from_secs(30), move || {
8180            signal.load(Ordering::SeqCst)
8181        });
8182        let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
8183        let checkpoint = state.land_rebase_from.clone();
8184        let (result, ()) = tokio::join!(
8185            tokio::time::timeout(
8186                Duration::from_secs(2),
8187                wait.scope(restore_landing_worktree(&mut state)),
8188            ),
8189            async {
8190                tokio::time::sleep(Duration::from_millis(100)).await;
8191                cancelled.store(true, Ordering::SeqCst);
8192            }
8193        );
8194        let error = result
8195            .expect("cancellation must release the waiting driver")
8196            .unwrap_err();
8197        assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8198        assert_eq!(
8199            git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
8200            before
8201        );
8202        assert_eq!(state.land_rebase_from, checkpoint);
8203        assert_eq!(
8204            std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8205            "secret"
8206        );
8207        drop(holder);
8208        restore_landing_worktree(&mut state).await.unwrap();
8209        assert!(state.land_rebase_from.is_none());
8210        assert!(git::is_clean(&state.repo).await.unwrap());
8211    }
8212
8213    #[tokio::test]
8214    #[cfg(unix)]
8215    async fn landing_verification_inherits_cancellation_while_waiting_for_a_local_seat() {
8216        use std::sync::atomic::{AtomicBool, Ordering};
8217
8218        for e2e in [false, true] {
8219            let (_tmp, mut state, head) = landing_git_fixture().await;
8220            let common = crate::repo_lock::common_dir(&state.repo)
8221                .await
8222                .unwrap()
8223                .unwrap();
8224            std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8225            state.config.coordination = crate::config::test_coordination();
8226            if e2e {
8227                state.config.verify.e2e = vec!["true".into()];
8228                state.gate_repair_e2e = Some(crate::run::GateRepairE2e {
8229                    head: head.clone(),
8230                    passed: false,
8231                    outcomes: Vec::new(),
8232                });
8233            } else {
8234                state.config.verify.gate = vec!["true".into()];
8235                state.gate_ran = false;
8236            }
8237            let holder = crate::repo_lock::SeatLease::for_checkout(
8238                &state.repo,
8239                true,
8240                state.config.coordination.as_ref(),
8241            )
8242            .await
8243            .unwrap();
8244            assert!(holder.is_some());
8245            let cancelled = Arc::new(AtomicBool::new(false));
8246            let signal = cancelled.clone();
8247            let waiting = Arc::new(tokio::sync::Notify::new());
8248            let observed = waiting.clone();
8249            let wait = crate::repo_lock::WaitPolicy::new(Duration::from_secs(30), move || {
8250                observed.notify_one();
8251                signal.load(Ordering::SeqCst)
8252            });
8253            let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8254            let url = green_pr().url;
8255            let result = {
8256                let mut publishing =
8257                    Box::pin(wait.scope(publish_landing_head(&mut state, &head, &url, &forge)));
8258                // Git and fixture I/O precede local coordination. Start the
8259                // cancellation deadline only once the inherited wait policy
8260                // is polled, rather than timing those unrelated subprocesses.
8261                tokio::time::timeout(Duration::from_secs(30), async {
8262                    tokio::select! {
8263                        result = &mut publishing => panic!(
8264                            "verification must wait behind the held seat: {result:?}"
8265                        ),
8266                        () = waiting.notified() => {}
8267                    }
8268                })
8269                .await
8270                .expect("verification must reach the inherited coordination wait");
8271                cancelled.store(true, Ordering::SeqCst);
8272                tokio::time::timeout(Duration::from_secs(2), publishing).await
8273            };
8274            let error = result
8275                .expect("cancellation must release the verification waiter")
8276                .unwrap_err();
8277            assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8278            assert!(error.to_string().contains("cancelled"), "{error:#}");
8279            assert!(forge.argvs().is_empty());
8280            assert_eq!(
8281                git::remote_head(&state.repo, "origin", "task-head")
8282                    .await
8283                    .unwrap(),
8284                Some(head.clone())
8285            );
8286            drop(holder);
8287            // Cancellation must release its reservation so another attempt can verify.
8288            assert_eq!(
8289                publish_landing_head(&mut state, &head, &url, &forge)
8290                    .await
8291                    .unwrap(),
8292                head
8293            );
8294        }
8295    }
8296
8297    #[tokio::test]
8298    async fn landing_resume_preserves_user_edits_after_an_interrupted_rebase() {
8299        for staged in [false, true] {
8300            let (_tmp, mut state, old) = landing_git_fixture().await;
8301            advance_landing_base(&state).await;
8302            interrupt_landing_rebase(&mut state).await;
8303            std::fs::write(state.repo.join("change"), "user edit").unwrap();
8304            if staged {
8305                git::git(&state.repo, &["add", "change"]).await.unwrap();
8306            }
8307            assert!(resume_observed_head(&mut state, &old).await.is_err());
8308            assert_eq!(
8309                std::fs::read_to_string(state.repo.join("change")).unwrap(),
8310                "user edit"
8311            );
8312            assert_eq!(
8313                git::remote_head(&state.repo, "origin", "task-head")
8314                    .await
8315                    .unwrap(),
8316                Some(old)
8317            );
8318        }
8319    }
8320
8321    #[tokio::test]
8322    async fn landing_resume_returns_to_approval_wait_and_closed_pr_skips_sync() {
8323        let (_tmp, mut state, head) = landing_git_fixture().await;
8324        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8325        let id = state.id.clone();
8326        let pr = land_with(&mut state, &green_pr().url, &forge)
8327            .await
8328            .unwrap();
8329        assert_eq!(pr.state, PrLifecycle::Open);
8330        assert_eq!(state.id, id);
8331        assert!(state.parked);
8332        assert_eq!(state.status, RunStatus::Landing);
8333        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
8334        assert!(forge.argvs().is_empty());
8335
8336        state.land_sync_pending = true;
8337        std::fs::write(state.repo.join("dirty"), "do not touch").unwrap();
8338        let mut closed = seen("foreign", Checks::Green, "CLEAN", false);
8339        closed.pr.state = PrLifecycle::Closed;
8340        let forge = Scripted::new(vec![closed], vec![]);
8341        assert_eq!(
8342            land_with(&mut state, &green_pr().url, &forge)
8343                .await
8344                .unwrap()
8345                .state,
8346            PrLifecycle::Closed
8347        );
8348        assert_eq!(
8349            std::fs::read_to_string(state.repo.join("dirty")).unwrap(),
8350            "do not touch"
8351        );
8352        assert!(forge.argvs().is_empty());
8353    }
8354
8355    #[tokio::test]
8356    async fn landing_resume_does_not_publish_a_failed_rebased_gate() {
8357        let (_tmp, mut state, old) = landing_git_fixture().await;
8358        advance_landing_base(&state).await;
8359        state.config.verify.gate = vec!["exit 1".into()];
8360        assert!(resume_observed_head(&mut state, &old).await.is_err());
8361        assert_ne!(state.gate_head.as_deref(), Some(old.as_str()));
8362        assert!(!state.gate_allows_progress());
8363        assert_eq!(
8364            git::remote_head(&state.repo, "origin", "task-head")
8365                .await
8366                .unwrap(),
8367            Some(old)
8368        );
8369        assert!(state.land_sync_pending);
8370    }
8371
8372    #[tokio::test]
8373    async fn landing_publication_recovers_a_push_before_save_and_refuses_a_lease_conflict() {
8374        let (_tmp, mut state, old) = landing_git_fixture().await;
8375        advance_landing_base(&state).await;
8376        let pushed = resume_observed_head(&mut state, &old).await.unwrap();
8377        // Model a crash after the push but before saving its published SHA.
8378        state.pr_pushed_head = Some(old.clone());
8379        state.land_sync_pending = true;
8380        assert_eq!(
8381            resume_observed_head(&mut state, &pushed).await.unwrap(),
8382            pushed
8383        );
8384        // A writer races the observed PR snapshot: the explicit remote lease
8385        // must reject the push even though preflight saw our expected head.
8386        git::git(
8387            &state.repo,
8388            &["push", "--force", "origin", "main:refs/heads/task-head"],
8389        )
8390        .await
8391        .unwrap();
8392        assert!(
8393            publish_landing_head(
8394                &mut state,
8395                &pushed,
8396                &green_pr().url,
8397                &Scripted::new(vec![seen(&pushed, Checks::Green, "CLEAN", false)], vec![])
8398            )
8399            .await
8400            .unwrap_err()
8401            .to_string()
8402            .contains("publishing gated")
8403        );
8404        assert!(
8405            resume_observed_head(&mut state, "foreign-head")
8406                .await
8407                .is_err()
8408        );
8409    }
8410    #[tokio::test]
8411    async fn landing_publication_refuses_a_pr_closed_during_gate() {
8412        let (_tmp, mut state, head) = landing_git_fixture().await;
8413        let mut closed = seen(&head, Checks::Green, "CLEAN", false);
8414        closed.pr.state = PrLifecycle::Closed;
8415        let forge = Scripted::new(vec![closed], vec![]);
8416        assert!(
8417            publish_landing_head(&mut state, &head, &green_pr().url, &forge)
8418                .await
8419                .unwrap_err()
8420                .to_string()
8421                .contains("PR closed or merged")
8422        );
8423    }
8424
8425    /// A candidate selected by the uncontested tally.
8426    fn winning_candidate(summary: &str) -> Candidate {
8427        Candidate {
8428            index: 0,
8429            label: 'A',
8430            agent: "opus".to_owned(),
8431            branch: "magi/x/A".to_owned(),
8432            worktree: PathBuf::from("/wt/A"),
8433            summary: summary.to_owned(),
8434            stat: String::new(),
8435            files: 1,
8436            commits: 1,
8437            empty: false,
8438            failed: None,
8439            verified_noop: None,
8440            duration_ms: 0,
8441            folded: false,
8442        }
8443    }
8444
8445    fn uncontested_tally() -> Tally {
8446        Tally {
8447            first_choice: BTreeMap::from([('A', 1)]),
8448            borda: BTreeMap::new(),
8449            winner: 'A',
8450            rankings: 1,
8451            unanimous_initial: true,
8452            deliberated: false,
8453            changed_votes: 0,
8454            unanimous_final: true,
8455            tie_break: None,
8456            judges: 1,
8457            present: 1,
8458            quorum: 1,
8459            met_quorum: true,
8460            uncontested: None,
8461        }
8462    }
8463
8464    fn review_record(reviewer: usize, agent: &str, summary: &str) -> ReviewRecord {
8465        ReviewRecord {
8466            attempts: 0,
8467            reviewer,
8468            agent: agent.to_owned(),
8469            summary: summary.to_owned(),
8470            findings: Vec::new(),
8471            vote: None,
8472            failed: None,
8473            duration_ms: 0,
8474        }
8475    }
8476
8477    fn review_round(round: usize, reviews: Vec<ReviewRecord>) -> ReviewRound {
8478        let answered = reviews.len();
8479        ReviewRound {
8480            round,
8481            head: "abc1234".to_owned(),
8482            verified_head: None,
8483            verified_at: None,
8484            reviews,
8485            e2e: Vec::new(),
8486            verify_retried: false,
8487            e2e_deferred: false,
8488            e2e_defer_reason: None,
8489            fix: None,
8490            blocking: 0,
8491            answered,
8492            expected: answered,
8493            clean: true,
8494            progressed: false,
8495            vote_split: false,
8496            reconsideration: Vec::new(),
8497            verdict: None,
8498        }
8499    }
8500
8501    #[test]
8502    fn the_approval_panel_states_the_task_verbatim_in_either_language() {
8503        let en = panel();
8504        assert!(en.contains("Task"), "{en}");
8505        assert!(en.contains("add retries to the uploader"), "{en}");
8506
8507        let mut state = run_state();
8508        state.config.graph.language = "ja".to_owned();
8509        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8510        assert!(ja.contains("タスク"), "{ja}");
8511        assert!(
8512            ja.contains("add retries to the uploader"),
8513            "the task itself is not translated: {ja}"
8514        );
8515    }
8516
8517    #[test]
8518    fn the_approval_panel_omits_what_changed_and_review_verdict_with_no_data() {
8519        // `run_state()` has no candidates, no tally and no reviews - exactly
8520        // the shape a run has before anything has judged or reviewed it, and
8521        // the panel must not print an empty box for either.
8522        let html = panel();
8523        assert!(!html.contains("What changed"), "{html}");
8524        assert!(!html.contains("Review verdict"), "{html}");
8525    }
8526
8527    #[test]
8528    fn the_approval_panel_omits_what_changed_when_the_winners_summary_is_empty() {
8529        let mut state = run_state();
8530        state.candidates = vec![winning_candidate("")];
8531        state.tally = Some(uncontested_tally());
8532        let html = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8533        assert!(
8534            !html.contains("What changed"),
8535            "an empty summary must not render an empty box: {html}"
8536        );
8537    }
8538
8539    #[test]
8540    fn the_approval_panel_shows_the_winners_own_account_in_either_language() {
8541        let mut state = run_state();
8542        state.candidates = vec![winning_candidate(
8543            "Added a retry loop around the uploader PUT call.",
8544        )];
8545        state.tally = Some(uncontested_tally());
8546        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8547        assert!(en.contains("What changed"), "{en}");
8548        assert!(
8549            en.contains("Added a retry loop around the uploader PUT call."),
8550            "{en}"
8551        );
8552
8553        state.config.graph.language = "ja".to_owned();
8554        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8555        assert!(ja.contains("変更内容"), "{ja}");
8556        assert!(
8557            ja.contains("Added a retry loop around the uploader PUT call."),
8558            "{ja}"
8559        );
8560    }
8561
8562    #[test]
8563    fn the_approval_panel_shows_only_the_last_review_rounds_verdict() {
8564        let mut state = run_state();
8565        state.reviews = vec![
8566            review_round(
8567                1,
8568                vec![review_record(1, "alpha", "found a race, sent back")],
8569            ),
8570            review_round(2, vec![review_record(1, "alpha", "race is fixed, clean")]),
8571        ];
8572        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8573        assert!(en.contains("Review verdict"), "{en}");
8574        assert!(en.contains("race is fixed, clean"), "{en}");
8575        assert!(
8576            !en.contains("found a race, sent back"),
8577            "only the round that actually cleared the merge should show: {en}"
8578        );
8579
8580        state.config.graph.language = "ja".to_owned();
8581        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8582        assert!(ja.contains("レビューの結論"), "{ja}");
8583        assert!(ja.contains("レビュアー"), "{ja}");
8584        assert!(ja.contains("race is fixed, clean"), "{ja}");
8585    }
8586
8587    /// The `incomplete_review = "warn"` policy (see
8588    /// `graph::Runner::review_loop`) can push a `clean` round to
8589    /// `state.reviews` while one seat's own record still has `failed: Some`
8590    /// and an empty `summary` - a seat that never answered, not one that
8591    /// answered with nothing to say.
8592    fn unanswered_review_record(reviewer: usize, agent: &str, reason: &str) -> ReviewRecord {
8593        ReviewRecord {
8594            attempts: 0,
8595            reviewer,
8596            agent: agent.to_owned(),
8597            summary: String::new(),
8598            findings: Vec::new(),
8599            vote: None,
8600            failed: Some(reason.to_owned()),
8601            duration_ms: 0,
8602        }
8603    }
8604
8605    #[test]
8606    fn the_approval_panel_never_shows_an_unanswered_seat_as_a_blank_verdict() {
8607        let mut state = run_state();
8608        state.reviews = vec![review_round(
8609            1,
8610            vec![
8611                review_record(1, "alpha", "clean, nothing to add"),
8612                unanswered_review_record(2, "beta", "timed out"),
8613            ],
8614        )];
8615        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8616        assert!(en.contains("clean, nothing to add"), "{en}");
8617        assert!(
8618            en.contains("produced no answer: timed out"),
8619            "a seat that never answered must say so, not render a blank box: {en}"
8620        );
8621        assert!(
8622            !en.contains("<div style=\"white-space:pre-wrap;font-size:13px\"></div>"),
8623            "no reviewer box may be left empty: {en}"
8624        );
8625
8626        state.config.graph.language = "ja".to_owned();
8627        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8628        assert!(ja.contains("回答なし: timed out"), "{ja}");
8629    }
8630
8631    #[test]
8632    fn the_approval_panel_contains_nothing_the_frames_policy_would_block() {
8633        let html = panel();
8634        assert!(!html.contains("<script"), "no script survives the csp");
8635        assert!(!html.contains("<form"), "form-action is 'none'");
8636        let pr = green_pr();
8637        assert_eq!(
8638            html.matches("http").count(),
8639            html.matches(pr.url.as_str()).count(),
8640            "the only http url in the panel is the pull request's own link"
8641        );
8642        assert!(
8643            html.contains("target=\"_blank\""),
8644            "the PR link must open in a new tab so it escapes the iframe"
8645        );
8646        assert!(
8647            html.contains("rel=\"noopener noreferrer\""),
8648            "external links opening in new tabs must carry noopener noreferrer"
8649        );
8650    }
8651
8652    #[test]
8653    fn added_and_removed_diff_lines_are_distinguishable_without_colour() {
8654        let html = panel();
8655        assert!(
8656            html.contains(">+</span>"),
8657            "an added line carries a `+` in the gutter, not only a background"
8658        );
8659        assert!(
8660            html.contains(">-</span>"),
8661            "a removed line carries a `-` in the gutter, not only a background"
8662        );
8663        assert!(
8664            html.contains(">new line</span>"),
8665            "the marker is moved to the gutter, so the body is printed once without it"
8666        );
8667    }
8668
8669    #[test]
8670    fn a_diff_past_the_threshold_is_cut_with_an_honest_count() {
8671        let total = DIFF_MAX_LINES + 100;
8672        let diff: String = (0..total).map(|i| format!("+line {i}\n")).collect();
8673        let html = approval_panel(
8674            &run_state(),
8675            &green_pr(),
8676            NUMSTAT,
8677            &diff,
8678            &[],
8679            "feat: something long",
8680        );
8681        assert!(
8682            html.contains(&format!("100 of {total} diff lines omitted")),
8683            "the note must say exactly how much was cut"
8684        );
8685        assert!(html.contains(&format!("line {}", DIFF_MAX_LINES - 1)));
8686        assert!(
8687            !html.contains(&format!("line {DIFF_MAX_LINES}")),
8688            "nothing past the threshold is rendered"
8689        );
8690        assert!(
8691            html.contains("/repo/magi"),
8692            "the note says where the rest is"
8693        );
8694    }
8695
8696    #[test]
8697    fn a_path_with_html_metacharacters_is_escaped_rather_than_rendered() {
8698        let html = approval_panel(
8699            &run_state(),
8700            &green_pr(),
8701            "1\t2\tsrc/<b>&\"x\"'.rs",
8702            "",
8703            &[],
8704            "subject",
8705        );
8706        assert!(html.contains("src/&lt;b&gt;&amp;&quot;x&quot;&#39;.rs"));
8707        assert!(
8708            !html.contains("<b>"),
8709            "an agent-influenced path must never become markup"
8710        );
8711    }
8712
8713    #[tokio::test]
8714    async fn the_merge_lock_serialises_one_repository_but_never_a_different_one() {
8715        let a = std::path::PathBuf::from("/repo/a");
8716        let b = std::path::PathBuf::from("/repo/b");
8717
8718        let held = repo_merge_lock(&a).lock_owned().await;
8719
8720        // A second, concurrent land run against the *same* repository must
8721        // wait - `try_lock` fails while `held` is alive.
8722        assert!(
8723            repo_merge_lock(&a).try_lock().is_err(),
8724            "a second merge into the same repository must not proceed concurrently"
8725        );
8726
8727        // A run against a *different* repository must not be blocked by it -
8728        // this is what keeps a slow rebase or `gh pr merge` in one
8729        // repository from also stalling a land-approval resume in another.
8730        assert!(
8731            repo_merge_lock(&b).try_lock().is_ok(),
8732            "a different repository's merge lock must be independent"
8733        );
8734
8735        drop(held);
8736        assert!(
8737            repo_merge_lock(&a).try_lock().is_ok(),
8738            "the lock is released once the holder is done"
8739        );
8740    }
8741
8742    pub(crate) fn repair_state(major: bool, reject: bool) -> RunState {
8743        let mut state = landing_state();
8744        let mut rec = review_record(1, "alpha", "precise rejection reason");
8745        rec.vote = Some(if reject {
8746            crate::verdict::ReviewVote::Reject
8747        } else {
8748            crate::verdict::ReviewVote::Approve
8749        });
8750        if major {
8751            rec.findings = contested().findings;
8752        }
8753        let mut round = review_round(1, vec![rec]);
8754        round.clean = false;
8755        round.blocking = usize::from(major);
8756        state.reviews.push(round);
8757        state.config.graph.review_rounds = 1;
8758        state
8759    }
8760
8761    #[test]
8762    fn approval_policy_controls_are_independent_and_keep_all_reasons() {
8763        for every in [false, true] {
8764            for contested in [false, true] {
8765                for major in [false, true] {
8766                    for reject in [false, true] {
8767                        let mut state = repair_state(major, reject);
8768                        state.config.graph.land_approval = every;
8769                        state.config.graph.hold_contested_merge = contested;
8770                        let reasons = approval_reasons(&state);
8771                        assert_eq!(reasons.contains(&ApprovalReason::EveryMerge), every);
8772                        assert_eq!(
8773                            reasons.contains(&ApprovalReason::OpenBlockingFindings),
8774                            contested && major
8775                        );
8776                        assert_eq!(
8777                            reasons.contains(&ApprovalReason::FinalReject),
8778                            contested && reject
8779                        );
8780                        assert_eq!(
8781                            reasons.len(),
8782                            usize::from(every)
8783                                + usize::from(contested && major)
8784                                + usize::from(contested && reject)
8785                        );
8786                    }
8787                }
8788            }
8789        }
8790    }
8791
8792    #[test]
8793    fn approval_policy_and_rendering_follow_reconsideration_in_both_directions() {
8794        use crate::verdict::ReviewVote::{Approve, Reject};
8795        for (initial_reject, final_vote) in [(true, Approve), (false, Reject)] {
8796            let mut state = repair_state(false, initial_reject);
8797            state.reviews[0]
8798                .reconsideration
8799                .push(crate::run::ReviewRevoteRecord {
8800                    reviewer: 1,
8801                    agent: "alpha".into(),
8802                    vote: Some(final_vote),
8803                    reason: "changed after reading the panel <evidence>".into(),
8804                    failed: None,
8805                });
8806            assert_eq!(
8807                approval_reasons(&state).contains(&ApprovalReason::FinalReject),
8808                final_vote == Reject
8809            );
8810            for language in ["en", "ja"] {
8811                state.config.graph.language = language.into();
8812                let evidence = approval_evidence(&state);
8813                assert!(evidence.contains(&format!("→ {}", final_vote.label())));
8814                assert!(evidence.contains("changed after reading the panel <evidence>"));
8815                let html = approval_panel(&state, &green_pr(), "", "", &[], "subject");
8816                assert!(html.contains("changed after reading the panel &lt;evidence&gt;"));
8817                assert!(!html.contains("<evidence>"));
8818            }
8819            state.reviews[0].reconsideration[0].vote = None;
8820            state.reviews[0].reconsideration[0].failed = Some("timed out".into());
8821            assert_eq!(
8822                approval_reasons(&state).contains(&ApprovalReason::FinalReject),
8823                initial_reject
8824            );
8825            assert!(approval_evidence(&state).contains("timed out"));
8826        }
8827    }
8828
8829    #[tokio::test]
8830    async fn approval_merge_paths_apply_controls_to_major_and_reject_independently() {
8831        for every in [false, true] {
8832            for contested in [false, true] {
8833                for (major, reject) in [(false, false), (false, true), (true, false), (true, true)]
8834                {
8835                    let mut state = repair_state(major, reject);
8836                    state.config.graph.land_approval = every;
8837                    state.config.graph.hold_contested_merge = contested;
8838                    let forge = Scripted::new(
8839                        vec![seen("abc", Checks::Green, "CLEAN", false)],
8840                        vec![(true, "")],
8841                    );
8842                    land_with(&mut state, URL, &forge).await.unwrap();
8843                    let expected = every || (contested && (major || reject));
8844                    assert_eq!(state.land_approval.is_some(), expected);
8845                    assert_eq!(forge.calls().contains(&"merge"), !expected);
8846                    if expected {
8847                        assert!(state.parked);
8848                    }
8849                }
8850            }
8851        }
8852    }
8853
8854    #[tokio::test]
8855    async fn reviewed_branch_hold_is_read_before_landing_decision() {
8856        for (base, control) in [
8857            (false, "land_approval"),
8858            (true, "land_approval"),
8859            (false, "hold_contested_merge"),
8860        ] {
8861            let (_tmp, mut state, _) = landing_git_fixture().await;
8862            state.config.graph.land_approval = base;
8863            state.config.graph.hold_contested_merge = false;
8864            state.reviewed_commits = Some(Vec::new());
8865            if control == "hold_contested_merge" {
8866                state.reviews = repair_state(false, true).reviews;
8867            }
8868            std::fs::write(
8869                state.repo.join("magi.toml"),
8870                format!("[graph]\n{control} = {}\n", !base),
8871            )
8872            .unwrap();
8873            git::git(&state.repo, &["add", "magi.toml"]).await.unwrap();
8874            git::git(&state.repo, &["commit", "-m", "approval policy"])
8875                .await
8876                .unwrap();
8877            let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8878            state.land_sync_pending = false;
8879            state.pr_pushed_head = Some(head.clone());
8880            state.gate_head = Some(head.clone());
8881            let forge = Scripted::new(
8882                vec![seen(&head, Checks::Green, "CLEAN", false)],
8883                vec![(true, "")],
8884            );
8885            land_with(&mut state, URL, &forge).await.unwrap();
8886            assert!(
8887                state.land_approval.is_some(),
8888                "base={base}, control={control}"
8889            );
8890            assert!(!forge.calls().contains(&"merge"));
8891            if !base {
8892                let question = ask::Questions::open()
8893                    .get(&state.land_approval.as_ref().unwrap().question)
8894                    .unwrap();
8895                assert!(question.detail.contains(&format!(
8896                    "{control}=true from the reviewed branch's magi.toml"
8897                )));
8898            }
8899        }
8900    }
8901
8902    #[tokio::test]
8903    async fn reviewed_branch_hold_asks_and_survives_removal_and_resume() {
8904        for file in ["magi.toml", ".magi/config.toml"] {
8905            for control in crate::config::OwnerHold::ALL {
8906                let (_tmp, mut state, _) = landing_git_fixture().await;
8907                state.config.graph.land_approval = false;
8908                state.config.graph.hold_contested_merge = false;
8909                state.reviewed_commits = Some(Vec::new());
8910                if control == crate::config::OwnerHold::HoldContestedMerge {
8911                    state.reviews = repair_state(false, true).reviews;
8912                }
8913                let config = state.repo.join(file);
8914                std::fs::create_dir_all(config.parent().unwrap()).unwrap();
8915                std::fs::write(
8916                    &config,
8917                    format!(
8918                        "[graph]\n{} = true\n[verify]\ngate = ['untrusted']\n",
8919                        control.key()
8920                    ),
8921                )
8922                .unwrap();
8923                git::git(&state.repo, &["add", file]).await.unwrap();
8924                git::git(&state.repo, &["commit", "-m", "require approval"])
8925                    .await
8926                    .unwrap();
8927                let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8928                let gate = state.config.verify.gate.clone();
8929                state.observe_branch_owner_holds(&head).await;
8930                assert_eq!(state.config.verify.gate, gate);
8931                assert!(state.owner_hold(control));
8932                let holds = state.branch_owner_holds.clone();
8933                git::git(&state.repo, &["rm", file]).await.unwrap();
8934                git::git(&state.repo, &["commit", "-m", "remove config"])
8935                    .await
8936                    .unwrap();
8937                let later = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8938                state.save().unwrap();
8939                state = RunState::load(&state.id).unwrap();
8940                state.observe_branch_owner_holds(&later).await;
8941                assert_eq!(state.branch_owner_holds, holds);
8942                assert_eq!(state.branch_owner_holds[0].head, head);
8943                state.land_sync_pending = false;
8944                state.pr_pushed_head = Some(later.clone());
8945                state.gate_head = Some(later.clone());
8946                let forge = Scripted::new(
8947                    vec![seen(&later, Checks::Green, "CLEAN", false)],
8948                    vec![(true, "")],
8949                );
8950                land_with(&mut state, URL, &forge).await.unwrap();
8951                assert!(!forge.calls().contains(&"merge"));
8952                assert!(state.parked);
8953                let question = ask::Questions::open()
8954                    .get(&state.land_approval.as_ref().unwrap().question)
8955                    .unwrap();
8956                assert!(question.detail.contains("Approval required because:"));
8957                assert!(question.detail.contains(&format!(
8958                    "{}=true from the reviewed branch's {file}",
8959                    control.key()
8960                )));
8961                assert_eq!(state.branch_owner_holds, holds);
8962                state.save().unwrap();
8963                let resumed = RunState::load(&state.id).unwrap();
8964                assert!(resumed.owner_hold(control));
8965                assert_eq!(resumed.branch_owner_holds, holds);
8966                assert_eq!(
8967                    resumed.land_approval.unwrap().question,
8968                    state.land_approval.unwrap().question
8969                );
8970            }
8971        }
8972    }
8973
8974    #[tokio::test]
8975    async fn approval_snapshot_exposes_minor_findings_and_survives_disabled_controls() {
8976        let mut state = repair_state(false, true);
8977        state.reviews[0].clean = true;
8978        let mut finding = contested().findings.remove(0);
8979        finding.severity = crate::verdict::Severity::Minor;
8980        state.reviews[0].reviews[0].findings.push(finding);
8981        assert!(state.open_findings().is_empty());
8982        let mut pr = green_pr();
8983        pr.review_comments.clear();
8984        for language in ["en", "ja"] {
8985            state.config.graph.language = language.into();
8986            let html = approval_panel(&state, &pr, "", "", &[], "subject");
8987            assert!(html.contains("[R3-1-1] minor"));
8988            assert!(html.contains(if language == "ja" {
8989                "内部指摘の解決を意味するものではありません"
8990            } else {
8991                "This does not mean internal findings are resolved"
8992            }));
8993            assert!(
8994                html.find(if language == "ja" {
8995                    "承認が必要な理由:"
8996                } else {
8997                    "Approval required because:"
8998                })
8999                .unwrap()
9000                    < html.find("[R3-1-1]").unwrap()
9001            );
9002        }
9003        state.config.graph.language = "en".into();
9004        let observed = seen("abc", Checks::Green, "CLEAN", false);
9005        assert_eq!(
9006            approval_gate(&mut state, &observed.pr, "subject", None, "abc")
9007                .await
9008                .unwrap(),
9009            ApprovalGate::Pending
9010        );
9011        let id = state.land_approval.as_ref().unwrap().question.clone();
9012        let q = ask::Questions::open().get(&id).unwrap();
9013        assert!(q.detail.starts_with("Approval required because:"));
9014        assert!(q.detail.contains("final reviewer reject"));
9015        assert!(q.detail.contains("[R3-1-1] minor"));
9016        assert!(
9017            q.detail
9018                .contains("No adoption or resolution evidence recorded")
9019        );
9020        state.config.graph.land_approval = false;
9021        state.config.graph.hold_contested_merge = false;
9022        state.reviews.clear();
9023        assert_eq!(approval_reasons(&state), [ApprovalReason::ExistingDecision]);
9024        assert!(deputy_brief(&q, Some(&state)).contains("final reviewer reject"));
9025        assert!(deputy_brief(&q, None).contains("[R3-1-1] minor"));
9026        let forge = Scripted::new(vec![observed], vec![]);
9027        land_with(&mut state, URL, &forge).await.unwrap();
9028        assert!(!forge.calls().contains(&"merge"));
9029        assert_eq!(state.land_approval.as_ref().unwrap().question, id);
9030        assert_eq!(ask::Questions::open().get(&id).unwrap().detail, q.detail);
9031    }
9032
9033    #[tokio::test]
9034    async fn approval_evidence_keeps_all_findings_and_bounds_unicode_prose() {
9035        let mut state = repair_state(false, true);
9036        state.config.graph.land_approval = false;
9037        let long_reason = format!("{}REASON_TAIL", "拒否🦀".repeat(200));
9038        let long_detail = format!("{}DETAIL_TAIL", "詳細🦀".repeat(200));
9039        let long_title = format!("{}TITLE_TAIL", "題🦀".repeat(100));
9040        state.reviews[0].reviews[0].summary = long_reason.clone();
9041        for i in 1..=10 {
9042            let mut finding = contested().findings.remove(0);
9043            finding.id = format!("R1-1-{i}");
9044            finding.severity = if i == 9 {
9045                crate::verdict::Severity::Major
9046            } else {
9047                crate::verdict::Severity::Minor
9048            };
9049            finding.title = long_title.clone();
9050            finding.detail = long_detail.clone();
9051            state.reviews[0].reviews[0].findings.push(finding);
9052        }
9053        state.reviews[0].fix = Some(crate::run::FixRecord {
9054            agent: "fixer".into(),
9055            addressed: vec!["R1-1-9".into()],
9056            rejected: vec![crate::verdict::Rejection {
9057                id: "R1-1-10".into(),
9058                why: long_reason.clone(),
9059            }],
9060            notes: long_detail.clone(),
9061            committed: false,
9062            failed: None,
9063            duration_ms: 0,
9064            continuation: None,
9065        });
9066        assert_eq!(
9067            approval_reasons(&state),
9068            [
9069                ApprovalReason::OpenBlockingFindings,
9070                ApprovalReason::FinalReject
9071            ]
9072        );
9073        let excerpt = approval_excerpt(&long_reason, 300);
9074        assert_eq!(excerpt.chars().count(), 300);
9075        assert!(excerpt.ends_with('…'));
9076        let boundary = "拒".repeat(300);
9077        assert_eq!(approval_excerpt(&boundary, 300), boundary);
9078        for language in ["en", "ja"] {
9079            state.config.graph.language = language.into();
9080            for revote in [
9081                None,
9082                Some(crate::verdict::ReviewVote::Reject),
9083                Some(crate::verdict::ReviewVote::Approve),
9084            ] {
9085                state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Reject);
9086                state.reviews[0].reconsideration.clear();
9087                if let Some(vote) = revote {
9088                    state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Approve);
9089                    state.reviews[0]
9090                        .reconsideration
9091                        .push(crate::run::ReviewRevoteRecord {
9092                            reviewer: 1,
9093                            agent: "alpha".into(),
9094                            vote: Some(vote),
9095                            reason: long_reason.clone(),
9096                            failed: None,
9097                        });
9098                }
9099                let evidence = approval_evidence(&state);
9100                let final_vote = revote.unwrap_or(crate::verdict::ReviewVote::Reject);
9101                assert!(evidence.contains(&format!("#1 (alpha): {}", final_vote.label())));
9102                assert!(approval_reasons(&state).contains(&ApprovalReason::OpenBlockingFindings));
9103                assert_eq!(
9104                    approval_reasons(&state).contains(&ApprovalReason::FinalReject),
9105                    final_vote == crate::verdict::ReviewVote::Reject
9106                );
9107                assert!(evidence.contains(&excerpt));
9108                assert!(evidence.contains("[R1-1-8] minor"));
9109                assert!(evidence.contains("[R1-1-9] major"));
9110                assert!(evidence.contains("[R1-1-10] minor"));
9111                for tail in ["REASON_TAIL", "DETAIL_TAIL", "TITLE_TAIL"] {
9112                    assert!(!evidence.contains(tail));
9113                }
9114                assert!(evidence.contains(if language == "ja" {
9115                    "採用申告(解決未確認)"
9116                } else {
9117                    "claimed addressed (resolution unconfirmed)"
9118                }));
9119                assert!(evidence.contains(if language == "ja" {
9120                    "不採用理由"
9121                } else {
9122                    "declined"
9123                }));
9124                let major_evidence = evidence
9125                    .split("[R1-1-9] major")
9126                    .nth(1)
9127                    .unwrap()
9128                    .split("[R1-1-10]")
9129                    .next()
9130                    .unwrap();
9131                assert!(major_evidence.contains(if language == "ja" {
9132                    "採用申告(解決未確認)"
9133                } else {
9134                    "claimed addressed (resolution unconfirmed)"
9135                }));
9136                let last_evidence = evidence.split("[R1-1-10] minor").nth(1).unwrap();
9137                assert!(last_evidence.contains(if language == "ja" {
9138                    "不採用理由"
9139                } else {
9140                    "declined"
9141                }));
9142                let html = approval_panel(&state, &green_pr(), "", "", &[], "subject");
9143                assert!(html.contains(&esc(&evidence)));
9144                assert_eq!(
9145                    approval_gate(&mut state, &green_pr(), "subject", None, "abc")
9146                        .await
9147                        .unwrap(),
9148                    ApprovalGate::Pending
9149                );
9150                let id = &state.land_approval.take().unwrap().question;
9151                let q = ask::Questions::open().get(id).unwrap();
9152                assert!(q.detail.starts_with(&evidence));
9153            }
9154            state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Reject);
9155        }
9156    }
9157
9158    #[test]
9159    fn merge_repair_choice_covers_major_only_and_reject_only_without_contested_and() {
9160        for (major, reject) in [(true, false), (false, true), (true, true)] {
9161            let state = repair_state(major, reject);
9162            assert!(repair_available(&state));
9163            assert_eq!(&approval_choices(&state)[..3], [APPROVE, HOLD, REPAIR]);
9164        }
9165        assert!(!repair_available(&repair_state(false, false)));
9166        let mut clean = repair_state(true, false);
9167        clean.reviews[0].clean = true;
9168        assert_eq!(&approval_choices(&clean)[..3], [APPROVE, HOLD, REPAIR]);
9169        assert_eq!(approval(Some(REPAIR)), Approval::Repair);
9170    }
9171
9172    #[tokio::test]
9173    async fn merge_repair_upgrades_legacy_questions_and_snapshots_exact_evidence_once() {
9174        let mut state = repair_state(true, false);
9175        let pr = green_pr();
9176        approval_gate(&mut state, &pr, "feat: x", None, "abc")
9177            .await
9178            .unwrap();
9179        let store = ask::Questions::open();
9180        let id = state.land_approval.as_ref().unwrap().question.clone();
9181        // Simulate an unanswered two-choice question created by an older build.
9182        store
9183            .update(&id, |q| {
9184                q.choices = vec![APPROVE.into(), HOLD.into()];
9185                Ok(())
9186            })
9187            .unwrap();
9188        let upgraded = store.get(&id).unwrap();
9189        assert_eq!(upgraded.choices, approval_choices(&state));
9190        assert!(!upgraded.actions.contains_key(HOLD));
9191        assert_eq!(store.get(&id).unwrap().choices, upgraded.choices);
9192        assert!(
9193            store
9194                .list()
9195                .iter()
9196                .any(|q| q.id == id && q.choices == upgraded.choices)
9197        );
9198        assert!(
9199            crate::prompt::chat_consult(&upgraded).contains("--reply 'fix findings and re-review'")
9200        );
9201        assert!(deputy_brief(&upgraded, Some(&state)).contains("never approves a merge"));
9202        store
9203            .update(&id, |q| q.answer(ask::Answer::Choice(REPAIR.into())))
9204            .unwrap();
9205        // An earlier build may have recorded the repair answer and stopped
9206        // before any driver consumed it. Reconcile that durable decision too.
9207        store
9208            .update(&id, |q| {
9209                q.actions.clear();
9210                Ok(())
9211            })
9212            .unwrap();
9213        assert_eq!(
9214            store.get(&id).unwrap().chosen_action(),
9215            Some(&ask::ChoiceAction::Resume {
9216                run: state.id.clone()
9217            })
9218        );
9219        let binding = state.land_approval.clone();
9220        assert_eq!(
9221            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9222                .await
9223                .unwrap(),
9224            ApprovalGate::Repair
9225        );
9226        assert!(state.land_approval.is_none());
9227        assert_eq!(state.merge_repairs.len(), 1);
9228        let request = &state.merge_repairs[0];
9229        assert_eq!(request.question, id);
9230        assert_eq!(request.head, "abc");
9231        assert_eq!(request.pr, pr.url);
9232        assert_eq!(
9233            request.reviews[0].reviews[0].summary,
9234            "precise rejection reason"
9235        );
9236        assert_eq!(request.reviews[0].reviews[0].findings[0].id, "R3-1-1");
9237        assert_eq!(
9238            request.reviews[0].reviews[0].findings[0].detail,
9239            state.reviews[0].reviews[0].findings[0].detail
9240        );
9241        // A repeated consumption of the same answer never dispatches another repair.
9242        state.land_approval = binding;
9243        assert_eq!(
9244            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9245                .await
9246                .unwrap(),
9247            ApprovalGate::Repair
9248        );
9249        assert_eq!(state.merge_repairs.len(), 1);
9250        state.land_approval = None;
9251        state.config.graph.land_approval = false;
9252        state.config.graph.hold_contested_merge = false;
9253        state.reviews.clear();
9254        assert_eq!(approval_reasons(&state), [ApprovalReason::AfterRepair]);
9255        assert_eq!(
9256            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9257                .await
9258                .unwrap(),
9259            ApprovalGate::Pending
9260        );
9261        let fresh_id = &state.land_approval.as_ref().unwrap().question;
9262        assert_ne!(fresh_id, &id);
9263        let fresh = store.get(fresh_id).unwrap();
9264        assert!(
9265            fresh
9266                .detail
9267                .contains("fresh owner approval after merge repair")
9268        );
9269        assert!(fresh.detail.contains("No review recorded"));
9270        assert!(!fresh.detail.contains("precise rejection reason"));
9271    }
9272
9273    #[tokio::test]
9274    async fn merge_repair_answer_never_merges_and_hold_never_requests_repair() {
9275        for choice in [REPAIR, HOLD] {
9276            let mut state = repair_state(false, true);
9277            let observed = seen("abc", Checks::Green, "CLEAN", false);
9278            approval_gate(&mut state, &observed.pr, "feat: x", None, "abc")
9279                .await
9280                .unwrap();
9281            let id = state.land_approval.as_ref().unwrap().question.clone();
9282            ask::Questions::open()
9283                .update(&id, |q| q.answer(ask::Answer::Choice(choice.into())))
9284                .unwrap();
9285            let forge = Scripted::new(vec![observed], vec![(true, "")]);
9286            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
9287                .await
9288                .unwrap();
9289            assert!(
9290                forge
9291                    .argvs()
9292                    .iter()
9293                    .all(|a| a.iter().any(|s| s == "--disable-auto"))
9294            );
9295            assert!(!forge.calls().contains(&"fix"));
9296            assert_eq!(state.merge_repairs.len(), usize::from(choice == REPAIR));
9297            assert_ne!(state.status, RunStatus::Merged);
9298        }
9299    }
9300
9301    #[test]
9302    fn only_the_merge_choice_merges_and_silence_holds() {
9303        let table = [
9304            (None, Approval::Hold),
9305            (Some("merge"), Approval::Merge),
9306            (Some(" merge\n"), Approval::Merge),
9307            (Some("hold"), Approval::Hold),
9308            (Some(""), Approval::Hold),
9309            (Some("yes"), Approval::Hold),
9310        ];
9311        for (answer, want) in table {
9312            assert_eq!(
9313                approval(answer),
9314                want,
9315                "answer {answer:?} must resolve to {want:?}"
9316            );
9317        }
9318    }
9319
9320    #[tokio::test]
9321    async fn a_first_visit_to_the_merge_gate_files_a_question_and_returns_pending_at_once() {
9322        let mut state = landing_state();
9323        state.config.graph.land_approval = true;
9324        let pr = green_pr();
9325
9326        let gate = approval_gate(&mut state, &pr, "feat: x", None, "abc")
9327            .await
9328            .unwrap();
9329        assert_eq!(gate, ApprovalGate::Pending, "nobody has answered yet");
9330        assert!(
9331            !state.parked,
9332            "approval_gate itself never sets `parked`; only its caller does"
9333        );
9334
9335        let store = ask::Questions::open();
9336        let filed: Vec<_> = store
9337            .list()
9338            .into_iter()
9339            .filter(|q| q.run == state.id)
9340            .collect();
9341        assert_eq!(filed.len(), 1, "exactly one question is filed");
9342        assert_eq!(filed[0].node, APPROVAL_NODE);
9343        assert_eq!(filed[0].choices, approval_choices(&state));
9344        assert!(filed[0].status.open());
9345
9346        // A second visit - standing in for a resumed run whose slot the
9347        // daemon handed to something else while nobody had answered - must
9348        // find the same question rather than filing a second one.
9349        let again = approval_gate(&mut state, &pr, "feat: x", None, "abc")
9350            .await
9351            .unwrap();
9352        assert_eq!(again, ApprovalGate::Pending);
9353        let still_one = store
9354            .list()
9355            .into_iter()
9356            .filter(|q| q.run == state.id)
9357            .count();
9358        assert_eq!(
9359            still_one, 1,
9360            "asking twice must not double-file the question"
9361        );
9362    }
9363
9364    #[tokio::test]
9365    async fn approving_the_existing_question_is_read_back_as_approved() {
9366        crate::run::pin_test_home();
9367        let mut state = run_state();
9368        state.config.graph.land_approval = true;
9369        let pr = green_pr();
9370        assert_eq!(
9371            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9372                .await
9373                .unwrap(),
9374            ApprovalGate::Pending
9375        );
9376
9377        let store = ask::Questions::open();
9378        let mut q = store
9379            .list()
9380            .into_iter()
9381            .find(|q| q.run == state.id)
9382            .expect("filed above");
9383        let talks = crate::talk::Talks::open();
9384        let cfg = crate::config::Config {
9385            agents: vec![crate::config::AgentSpec {
9386                id: "mock".into(),
9387                kind: crate::config::AgentKind::Command,
9388                model: None,
9389                command: vec!["true".into()],
9390                extra_args: Vec::new(),
9391                env: Default::default(),
9392                prompt_delivery: None,
9393                max_turn_secs: None,
9394            }],
9395            ..crate::config::Config::default()
9396        };
9397        let mut talk = crate::talk::begin(&talks, &cfg, state.repo.clone(), Some("mock")).unwrap();
9398        crate::consult::begin(&store, &talks, &q, &talk).unwrap();
9399        crate::talk::drain(&mut talk, &talks).unwrap();
9400        assert_eq!(
9401            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9402                .await
9403                .unwrap(),
9404            ApprovalGate::Pending,
9405            "consultation cannot approve or hold the merge"
9406        );
9407        q = store.get(&q.id).unwrap();
9408        assert!(q.answer.is_none());
9409        // The owner's merge answer (from the chat or the card) is the approval.
9410        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
9411        store.put(&mut q).unwrap();
9412
9413        assert_eq!(
9414            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9415                .await
9416                .unwrap(),
9417            ApprovalGate::Approved
9418        );
9419    }
9420
9421    #[tokio::test]
9422    async fn legacy_hold_actions_are_removed_on_get_and_list_before_answering() {
9423        crate::run::pin_test_home();
9424        let store = ask::Questions::open();
9425        for via_list in [false, true] {
9426            let mut state = repair_state(false, true);
9427            let pr = green_pr();
9428            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9429                .await
9430                .unwrap();
9431            let id = state.land_approval.as_ref().unwrap().question.clone();
9432            store
9433                .update(&id, |q| {
9434                    q.actions.insert(
9435                        HOLD.to_owned(),
9436                        ask::ChoiceAction::Resume {
9437                            run: state.id.clone(),
9438                        },
9439                    );
9440                    Ok(())
9441                })
9442                .unwrap();
9443            let q = if via_list {
9444                store.list().into_iter().find(|q| q.id == id).unwrap()
9445            } else {
9446                store.get(&id).unwrap()
9447            };
9448            assert!(!q.actions.contains_key(HOLD));
9449            store
9450                .update(&id, |q| {
9451                    // Check the persisted migration, without another read upgrade.
9452                    assert!(!q.actions.contains_key(HOLD));
9453                    assert!(!upgrade_repair_choice(q, &state));
9454                    q.answer(ask::Answer::Choice(HOLD.to_owned()))
9455                })
9456                .unwrap();
9457            assert!(store.get(&id).unwrap().chosen_action().is_none());
9458            assert_eq!(
9459                approval_gate(&mut state, &pr, "feat: x", None, "abc")
9460                    .await
9461                    .unwrap(),
9462                ApprovalGate::Held
9463            );
9464        }
9465    }
9466
9467    #[tokio::test]
9468    async fn explicit_hold_stays_held_but_expired_approval_is_reasked() {
9469        crate::run::pin_test_home();
9470        let store = ask::Questions::open();
9471
9472        let mut held_state = run_state();
9473        held_state.config.graph.land_approval = true;
9474        let pr = green_pr();
9475        approval_gate(&mut held_state, &pr, "feat: x", None, "abc")
9476            .await
9477            .unwrap();
9478        let mut q = store
9479            .list()
9480            .into_iter()
9481            .find(|q| q.run == held_state.id)
9482            .expect("filed above");
9483        q.answer(ask::Answer::Choice(HOLD.to_owned())).unwrap();
9484        store.put(&mut q).unwrap();
9485        assert_eq!(
9486            approval_gate(&mut held_state, &pr, "feat: x", None, "abc")
9487                .await
9488                .unwrap(),
9489            ApprovalGate::Held
9490        );
9491
9492        let mut abandoned_state = run_state();
9493        abandoned_state.config.graph.land_approval = true;
9494        approval_gate(&mut abandoned_state, &pr, "feat: x", None, "abc")
9495            .await
9496            .unwrap();
9497        let mut q = store
9498            .list()
9499            .into_iter()
9500            .find(|q| q.run == abandoned_state.id)
9501            .expect("filed above");
9502        q.abandon("no answer within the timeout");
9503        store.put(&mut q).unwrap();
9504        assert_eq!(
9505            approval_gate(&mut abandoned_state, &pr, "feat: x", None, "abc")
9506                .await
9507                .unwrap(),
9508            ApprovalGate::Pending,
9509            "an expired approval must ask again without merging"
9510        );
9511        assert_eq!(
9512            store.get(&q.id).unwrap().status,
9513            ask::QuestionStatus::Abandoned
9514        );
9515        assert_ne!(
9516            abandoned_state.land_approval.as_ref().unwrap().question,
9517            q.id
9518        );
9519    }
9520
9521    fn contested() -> ContestedHandoff {
9522        let finding = |id: &str, n: u32| crate::verdict::Finding {
9523            id: id.to_owned(),
9524            severity: crate::verdict::Severity::Major,
9525            file: Some("src/a.rs".to_owned()),
9526            line: Some(n),
9527            title: format!("problem {id}"),
9528            detail: String::new(),
9529        };
9530        ContestedHandoff {
9531            findings: (1..=7).map(|n| finding(&format!("R3-1-{n}"), n)).collect(),
9532            rejecters: vec![(1, "alpha".to_owned())],
9533        }
9534    }
9535
9536    #[test]
9537    fn the_contested_record_is_asked_about_unless_the_switch_is_off() {
9538        let mut state = run_state();
9539        assert!(contested_to_ask(&state).is_none(), "nothing recorded");
9540        state.contested_handoff = Some(contested());
9541        assert!(contested_to_ask(&state).is_some());
9542        state.config.graph.hold_contested_merge = false;
9543        assert!(
9544            contested_to_ask(&state).is_none(),
9545            "the switch restores today"
9546        );
9547    }
9548
9549    #[test]
9550    fn the_deputy_brief_carries_the_pr_the_findings_and_names_what_is_missing() {
9551        let q = ask::Question::new(
9552            "run-1".to_owned(),
9553            APPROVAL_NODE.to_owned(),
9554            "land".to_owned(),
9555            "Merge?".to_owned(),
9556            String::new(),
9557            vec![APPROVE.to_owned(), HOLD.to_owned()],
9558        );
9559        let none = deputy_brief(&q, None);
9560        assert!(none.contains("could not be read"), "{none}");
9561        assert!(none.contains("Silence is a hold"), "{none}");
9562
9563        let mut state = run_state();
9564        state.pr = Some(crate::run::PrRecord {
9565            url: "https://example.test/pull/7".to_owned(),
9566            number: 7,
9567            state: "open".to_owned(),
9568            checks: "green".to_owned(),
9569            round: 0,
9570            rounds: 3,
9571            red_at_merge: Vec::new(),
9572        });
9573        state.contested_handoff = Some(contested());
9574        let b = deputy_brief(&q, Some(&state));
9575        assert!(b.contains("https://example.test/pull/7"), "{b}");
9576        assert!(b.contains("not recorded in this legacy question"), "{b}");
9577        assert!(!b.contains("This question was filed although"));
9578        state.contested_handoff = None;
9579        assert!(deputy_brief(&q, Some(&state)).contains("not recorded in this legacy question"));
9580    }
9581
9582    #[test]
9583    fn the_contested_question_names_the_pr_the_findings_and_the_rejecter() {
9584        for lang in ["en", "ja"] {
9585            let mut cfg = crate::config::Config::default();
9586            cfg.graph.language = lang.to_owned();
9587            let w = words(&cfg.graph.language);
9588            let text = w.approval_detail(
9589                "https://github.com/yukimemi/magi/pull/42",
9590                "main",
9591                "feat: x",
9592                Some(&contested()),
9593            );
9594            assert!(text.contains("pull/42"), "{text}");
9595            assert!(
9596                text.contains("R3-1-1 major src/a.rs:1: problem R3-1-1"),
9597                "{text}"
9598            );
9599            assert!(text.contains("R3-1-5"), "{text}");
9600            assert!(!text.contains("R3-1-6"), "the list is capped: {text}");
9601            assert!(text.contains("2"), "the rest are counted: {text}");
9602            assert!(text.contains("#1 (alpha)"), "{text}");
9603        }
9604        let plain = words("en").approval_detail("u", "main", "s", None);
9605        assert!(!plain.contains("reject"), "{plain}");
9606    }
9607
9608    #[tokio::test]
9609    async fn a_contested_question_is_filed_once_and_a_resume_finds_the_same_one() {
9610        crate::run::pin_test_home();
9611        let mut state = run_state();
9612        state.config.graph.land_approval = false;
9613        state.contested_handoff = Some(contested());
9614        let pr = green_pr();
9615        let c = contested_to_ask(&state);
9616        assert_eq!(
9617            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9618                .await
9619                .unwrap(),
9620            ApprovalGate::Pending,
9621            "silence is a hold"
9622        );
9623        let store = ask::Questions::open();
9624        let filed: Vec<_> = store
9625            .list()
9626            .into_iter()
9627            .filter(|q| q.run == state.id)
9628            .collect();
9629        assert_eq!(filed.len(), 1);
9630        assert!(filed[0].detail.contains("R3-1-1"), "{}", filed[0].detail);
9631
9632        assert_eq!(
9633            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9634                .await
9635                .unwrap(),
9636            ApprovalGate::Pending
9637        );
9638        let mut q = store
9639            .list()
9640            .into_iter()
9641            .find(|q| q.run == state.id)
9642            .unwrap();
9643        assert_eq!(q.id, filed[0].id, "the same question after a resume");
9644        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
9645        store.put(&mut q).unwrap();
9646        assert_eq!(
9647            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9648                .await
9649                .unwrap(),
9650            ApprovalGate::Approved
9651        );
9652    }
9653
9654    #[test]
9655    fn the_diffstat_table_is_ordered_by_churn_with_binaries_last() {
9656        let rows = parse_numstat(NUMSTAT);
9657        assert_eq!(
9658            rows.iter().map(|r| r.path.as_str()).collect::<Vec<_>>(),
9659            ["src/web.rs", "src/land.rs", "assets/logo.png"]
9660        );
9661        assert_eq!(rows[2].added, None, "a binary file has no line counts");
9662    }
9663    #[test]
9664    fn the_approval_speaks_the_language_the_repository_is_configured_for() {
9665        // Reported from a real run: the merge question arrived in English on a
9666        // repository with `language = "ja"`. magi's own strings have to follow
9667        // that setting too - "it is a literal in Rust" is not an answer.
9668        let mut state = run_state();
9669        state.config.graph.language = "ja".to_owned();
9670        let pr = green_pr();
9671        let commits = ["c1".to_owned()];
9672
9673        let ja = approval_panel(&state, &pr, "3\t1\tsrc/a.rs", "+ x", &commits, "feat: x");
9674        assert!(ja.contains("lang=\"ja\""), "the document must declare it");
9675        assert!(ja.contains("squash されるコミット"), "{ja}");
9676        assert!(ja.contains("レビューコメント"), "{ja}");
9677        assert!(ja.contains("差分"), "{ja}");
9678        assert!(
9679            !ja.contains("Commits being squashed"),
9680            "no English left over"
9681        );
9682
9683        let w = words("ja");
9684        assert!(w.approval_summary(17, "feat: x").contains("マージ"));
9685        assert!(
9686            w.approval_detail("http://x/1", "main", "feat: x", None)
9687                .contains("パネル")
9688        );
9689
9690        // The evidence itself is language-neutral and must survive either way.
9691        assert!(ja.contains("src/a.rs"), "the diffstat is not prose");
9692        assert!(ja.contains("feat: x"), "nor is the merge subject");
9693
9694        // English stays the default, and a language magi cannot check falls
9695        // back to it rather than shipping a guess.
9696        state.config.graph.language = "en".to_owned();
9697        let en = approval_panel(&state, &pr, "3\t1\tsrc/a.rs", "+ x", &commits, "feat: x");
9698        assert!(en.contains("Commits being squashed"), "{en}");
9699        assert_eq!(words("Klingon").html_lang, "en");
9700    }
9701
9702    /// A `gh pr list` result naming exactly one pull request whose base and
9703    /// merge time both fit the run is exactly the case
9704    /// [`find_external_merge`] exists to act on.
9705    #[test]
9706    fn pick_open_pr_classifies_by_count_and_base() {
9707        let one = r#"[{"number":58,"url":"https://x/pull/58","title":"t","baseRefName":"main"}]"#;
9708        assert_eq!(
9709            pick_open_pr(one, "main").unwrap(),
9710            OpenPr::One {
9711                url: "https://x/pull/58".into(),
9712                title: "t".into()
9713            }
9714        );
9715        assert_eq!(pick_open_pr("[]", "main").unwrap(), OpenPr::None);
9716        assert_eq!(pick_open_pr(one, "dev").unwrap(), OpenPr::None);
9717        let two = r#"[{"number":1,"url":"u1","title":"","baseRefName":"main"},
9718                     {"number":2,"url":"u2","title":"","baseRefName":"main"}]"#;
9719        assert_eq!(
9720            pick_open_pr(two, "main").unwrap(),
9721            OpenPr::Many(vec!["u1".into(), "u2".into()])
9722        );
9723        // A fork's same-named branch is not a pull request for this head.
9724        let fork = r#"[{"url":"f","baseRefName":"main","isCrossRepository":true}]"#;
9725        assert_eq!(pick_open_pr(fork, "main").unwrap(), OpenPr::None);
9726        assert!(pick_open_pr("not json", "main").is_err());
9727        // An incomplete record is an error, never "nothing open".
9728        assert!(pick_open_pr(r#"[{"url":"u","title":"t"}]"#, "main").is_err());
9729        assert!(pick_open_pr(r#"[{"title":"t","baseRefName":"main"}]"#, "main").is_err());
9730    }
9731
9732    #[test]
9733    fn pick_merged_pr_picks_the_unique_match() {
9734        let json = r#"[
9735            {"url": "https://github.com/o/r/pull/42", "number": 42,
9736             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "main"}
9737        ]"#;
9738        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9739        let found = pick_merged_pr(json, "main", created_at)
9740            .expect("valid json")
9741            .expect("one unambiguous match");
9742        assert_eq!(found.url, "https://github.com/o/r/pull/42");
9743        assert_eq!(found.number, 42);
9744    }
9745
9746    /// Two candidates surviving the filter is exactly as uninformative as
9747    /// zero — a branch name can be reused across runs — so neither is
9748    /// preferred over the other and nothing is recorded automatically.
9749    #[test]
9750    fn pick_merged_pr_refuses_when_more_than_one_candidate_survives() {
9751        let json = r#"[
9752            {"url": "https://github.com/o/r/pull/42", "number": 42,
9753             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "main"},
9754            {"url": "https://github.com/o/r/pull/43", "number": 43,
9755             "mergedAt": "2026-09-21T10:00:00Z", "baseRefName": "main"}
9756        ]"#;
9757        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9758        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9759    }
9760
9761    /// A pull request that targets a different base branch cannot be this
9762    /// run's, whatever its head branch is named — a reused branch name from
9763    /// an unrelated task must not be recorded as this run's merge.
9764    #[test]
9765    fn pick_merged_pr_ignores_a_different_base_branch() {
9766        let json = r#"[
9767            {"url": "https://github.com/o/r/pull/42", "number": 42,
9768             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "release"}
9769        ]"#;
9770        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9771        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9772    }
9773
9774    /// A pull request merged before this run was even created cannot be this
9775    /// run's winner, no matter how its head branch is spelled.
9776    #[test]
9777    fn pick_merged_pr_ignores_a_merge_that_predates_the_run() {
9778        let json = r#"[
9779            {"url": "https://github.com/o/r/pull/42", "number": 42,
9780             "mergedAt": "2026-09-18T10:00:00Z", "baseRefName": "main"}
9781        ]"#;
9782        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9783        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9784    }
9785
9786    #[test]
9787    fn slug_of_pr_url_reads_host_owner_and_repo() {
9788        assert_eq!(
9789            slug_of_pr_url("https://github.com/yukimemi/shun/pull/272").as_deref(),
9790            Some("github.com/yukimemi/shun")
9791        );
9792    }
9793
9794    #[test]
9795    fn slug_of_pr_url_refuses_a_url_with_no_pull_segment() {
9796        assert_eq!(slug_of_pr_url("https://github.com/yukimemi/shun"), None);
9797        assert_eq!(slug_of_pr_url("not a url at all"), None);
9798        assert_eq!(slug_of_pr_url("https://github.com"), None);
9799    }
9800
9801    #[test]
9802    fn slug_of_repo_url_reads_host_owner_and_repo() {
9803        assert_eq!(
9804            slug_of_repo_url("https://github.com/yukimemi/magi").as_deref(),
9805            Some("github.com/yukimemi/magi")
9806        );
9807        assert_eq!(slug_of_repo_url("https://github.com"), None);
9808    }
9809
9810    #[test]
9811    fn ensure_same_repo_accepts_a_matching_slug_regardless_of_case() {
9812        ensure_same_repo("github.com/yukimemi/magi", "GitHub.Com/YukiMemi/Magi")
9813            .expect("same repo, different case");
9814    }
9815
9816    /// The shun/8c75 incident: an id-less `--merged` picked this repository's
9817    /// own in-progress run and rewrote its status from a pull request in a
9818    /// completely different repository. This is the guard that must catch
9819    /// that even when an explicit (but wrong) id is given.
9820    #[test]
9821    fn ensure_same_repo_refuses_a_different_repo() {
9822        let err =
9823            ensure_same_repo("github.com/yukimemi/magi", "github.com/yukimemi/shun").unwrap_err();
9824        let msg = format!("{err:#}");
9825        assert!(msg.contains("github.com/yukimemi/magi"), "{msg}");
9826        assert!(msg.contains("github.com/yukimemi/shun"), "{msg}");
9827    }
9828
9829    /// Same owner/repo on two different forge hosts (a GitHub Enterprise
9830    /// instance mirroring a `github.com` repository's name, say) must not be
9831    /// treated as the same repository just because the trailing path
9832    /// matches.
9833    #[test]
9834    fn ensure_same_repo_refuses_the_same_slug_on_a_different_host() {
9835        let err = ensure_same_repo(
9836            "github.com/yukimemi/magi",
9837            "github.example.com/yukimemi/magi",
9838        )
9839        .unwrap_err();
9840        let msg = format!("{err:#}");
9841        assert!(msg.contains("github.com/yukimemi/magi"), "{msg}");
9842        assert!(msg.contains("github.example.com/yukimemi/magi"), "{msg}");
9843    }
9844
9845    /// No winner decided yet means there is no branch to ask GitHub about at
9846    /// all — `find_external_merge` must return `None` without ever spawning
9847    /// `gh`, which this proves by never providing a real repository to spawn
9848    /// it in.
9849    #[tokio::test]
9850    async fn find_external_merge_returns_none_without_a_winner() {
9851        let state = RunState::new(
9852            PathBuf::from("/no/such/repo"),
9853            "main".to_owned(),
9854            "0000000000000000000000000000000000000000".to_owned(),
9855            "irrelevant".to_owned(),
9856            crate::config::Config::default(),
9857        );
9858        assert_eq!(find_external_merge(&state).await.unwrap(), None);
9859    }
9860
9861    fn pr_run(home: &Path, id: &str, repo: &str, status: RunStatus, url: &str, state: &str) {
9862        let mut run = RunState::new(
9863            PathBuf::from(repo),
9864            "main".to_owned(),
9865            "abcdef1234".to_owned(),
9866            "x".to_owned(),
9867            crate::config::Config::default(),
9868        );
9869        run.id = id.to_owned();
9870        run.status = status;
9871        run.driver_exited = true;
9872        run.pr = Some(crate::run::PrRecord {
9873            number: url.rsplit('/').next().unwrap().parse().unwrap(),
9874            url: url.to_owned(),
9875            state: state.to_owned(),
9876            checks: "red".to_owned(),
9877            round: 0,
9878            rounds: 2,
9879            red_at_merge: Vec::new(),
9880        });
9881        run.save_under(home).unwrap();
9882    }
9883
9884    fn recorded(home: &Path, id: &str) -> String {
9885        let body = std::fs::read_to_string(home.join("runs").join(id).join("run.json")).unwrap();
9886        serde_json::from_str::<RunState>(&body)
9887            .unwrap()
9888            .pr
9889            .unwrap()
9890            .state
9891    }
9892
9893    const PR: &str = "https://github.com/o/r/pull/7";
9894
9895    #[test]
9896    fn write_through_updates_predecessors_and_siblings_only() {
9897        let tmp = tempfile::tempdir().unwrap();
9898        let h = tmp.path();
9899        pr_run(
9900            h,
9901            "20261004-100000-aaaa",
9902            "/repo/r",
9903            RunStatus::Superseded,
9904            PR,
9905            "open",
9906        );
9907        pr_run(
9908            h,
9909            "20261004-100100-bbbb",
9910            "/repo/r",
9911            RunStatus::Blocked,
9912            PR,
9913            "open",
9914        );
9915        // Not terminal: a driver may be writing it.
9916        pr_run(
9917            h,
9918            "20261004-100200-cccc",
9919            "/repo/r",
9920            RunStatus::Landing,
9921            PR,
9922            "open",
9923        );
9924        // Another repository's pull request with the same number.
9925        pr_run(
9926            h,
9927            "20261004-100300-dddd",
9928            "/repo/other",
9929            RunStatus::Blocked,
9930            "https://github.com/o/other/pull/7",
9931            "open",
9932        );
9933        // A different pull request of the same repository.
9934        pr_run(
9935            h,
9936            "20261004-100400-eeee",
9937            "/repo/r",
9938            RunStatus::Blocked,
9939            "https://github.com/o/r/pull/8",
9940            "open",
9941        );
9942        pr_run(
9943            h,
9944            "20261004-100500-ffff",
9945            "/repo/r",
9946            RunStatus::Merged,
9947            PR,
9948            "open",
9949        );
9950        let source = RunState::load_under("20261004-100500-ffff", h).unwrap();
9951
9952        assert_eq!(
9953            write_pr_state_through_in(h, &source, PrLifecycle::Merged),
9954            2
9955        );
9956        assert_eq!(recorded(h, "20261004-100000-aaaa"), "merged");
9957        assert_eq!(recorded(h, "20261004-100100-bbbb"), "merged");
9958        assert_eq!(recorded(h, "20261004-100200-cccc"), "open");
9959        assert_eq!(recorded(h, "20261004-100300-dddd"), "open");
9960        assert_eq!(recorded(h, "20261004-100400-eeee"), "open");
9961        // The source's own record is the caller's to write.
9962        assert_eq!(recorded(h, "20261004-100500-ffff"), "open");
9963        // Idempotent.
9964        assert_eq!(
9965            write_pr_state_through_in(h, &source, PrLifecycle::Merged),
9966            0
9967        );
9968        let hit = RunState::load_under("20261004-100000-aaaa", h).unwrap();
9969        assert!(hit.events.iter().any(|e| e.message.contains("merged")));
9970    }
9971
9972    #[test]
9973    fn lifecycle_updates_preserve_live_and_unknown_terminal_drivers() {
9974        let home = tempfile::tempdir().unwrap();
9975        let live_id = "20261004-100000-aaaa";
9976        let unknown_id = "20261004-100100-bbbb";
9977        for id in [live_id, unknown_id] {
9978            pr_run(home.path(), id, "repo", RunStatus::Ready, PR, "open");
9979            let mut s = RunState::load_under(id, home.path()).unwrap();
9980            s.driver_exited = false;
9981            // Model legacy driver evidence, not a newly reserved unstarted run.
9982            s.driver_claimed = None;
9983            if id == live_id {
9984                s.driver_pid = Some(std::process::id());
9985                s.driver_started_at = crate::proc::process_started_at(std::process::id());
9986            }
9987            s.save_under(home.path()).unwrap();
9988            if id == unknown_id {
9989                assert_eq!(
9990                    s.liveness_under(home.path(), false),
9991                    crate::run::Liveness::Unknown
9992                );
9993            }
9994        }
9995        let known = BTreeMap::from([(PR.to_owned(), PrLifecycle::Merged)]);
9996        assert_eq!(apply_pr_states(home.path(), &known), 0);
9997        for id in [live_id, unknown_id] {
9998            assert_eq!(recorded(home.path(), id), "open");
9999        }
10000    }
10001
10002    #[test]
10003    fn repair_rewrites_merged_and_closed_and_leaves_open_and_unknown() {
10004        let tmp = tempfile::tempdir().unwrap();
10005        let h = tmp.path();
10006        let url = |n: u32| format!("https://github.com/o/r/pull/{n}");
10007        pr_run(
10008            h,
10009            "20261004-100000-aaaa",
10010            "/repo/r",
10011            RunStatus::Superseded,
10012            &url(1),
10013            "open",
10014        );
10015        pr_run(
10016            h,
10017            "20261004-100100-bbbb",
10018            "/repo/r",
10019            RunStatus::Blocked,
10020            &url(2),
10021            "open",
10022        );
10023        pr_run(
10024            h,
10025            "20261004-100200-cccc",
10026            "/repo/r",
10027            RunStatus::Ready,
10028            &url(3),
10029            "open",
10030        );
10031        pr_run(
10032            h,
10033            "20261004-100300-dddd",
10034            "/repo/r",
10035            RunStatus::Ready,
10036            &url(4),
10037            "open",
10038        );
10039        pr_run(
10040            h,
10041            "20261004-100400-eeee",
10042            "/repo/r",
10043            RunStatus::Implementing,
10044            &url(1),
10045            "open",
10046        );
10047        assert_eq!(stale_open_prs(h).len(), 4);
10048
10049        let mut known = BTreeMap::new();
10050        known.insert(url(1), PrLifecycle::Merged);
10051        known.insert(url(2), PrLifecycle::Closed);
10052        known.insert(url(3), PrLifecycle::Open);
10053        // #4: the forge could not be read, so it has no answer.
10054        assert_eq!(apply_pr_states(h, &known), 2);
10055        assert_eq!(recorded(h, "20261004-100000-aaaa"), "merged");
10056        assert_eq!(recorded(h, "20261004-100100-bbbb"), "closed");
10057        assert_eq!(recorded(h, "20261004-100200-cccc"), "open");
10058        assert_eq!(recorded(h, "20261004-100300-dddd"), "open");
10059        assert_eq!(recorded(h, "20261004-100400-eeee"), "open");
10060        assert_eq!(apply_pr_states(h, &known), 0);
10061    }
10062
10063    // --- the land loop against a scripted forge -------------------------
10064
10065    use std::collections::VecDeque;
10066    use std::sync::Mutex;
10067
10068    /// Answers views from a script (the last one repeats), merges from a
10069    /// queue, and records every call so a test can assert the order.
10070    struct Scripted {
10071        public_repo: Option<PathBuf>,
10072        evidence: Mutex<Option<CiEvidence>>,
10073        views: Mutex<VecDeque<Seen>>,
10074        merges: Mutex<VecDeque<(bool, String)>>,
10075        fix: Mutex<Option<Fixed>>,
10076        log: Mutex<Vec<&'static str>>,
10077        argvs: Mutex<Vec<Vec<String>>>,
10078        required: Mutex<Option<BTreeSet<String>>>,
10079        /// Set once a merge answered ok: the forge then reports `merged`,
10080        /// unless `queued` says the merge only entered a queue.
10081        merged: Mutex<bool>,
10082        queued: Mutex<bool>,
10083        /// Views fail once a merge answered ok.
10084        unreadable_after_merge: Mutex<bool>,
10085        /// Workflow runs asked to rerun, and whether that call fails.
10086        reruns: Mutex<Vec<String>>,
10087        rerun_fails: Mutex<bool>,
10088        /// Unix seconds; every poll moves it on by `POLL`.
10089        clock: Mutex<i64>,
10090    }
10091
10092    impl Scripted {
10093        fn new(views: Vec<Seen>, merges: Vec<(bool, &str)>) -> Self {
10094            Self {
10095                public_repo: None,
10096                evidence: Mutex::new(None),
10097                views: Mutex::new(views.into()),
10098                merges: Mutex::new(
10099                    merges
10100                        .into_iter()
10101                        .map(|(ok, m)| (ok, m.to_owned()))
10102                        .collect(),
10103                ),
10104                fix: Mutex::new(None),
10105                log: Mutex::new(Vec::new()),
10106                argvs: Mutex::new(Vec::new()),
10107                required: Mutex::new(None),
10108                merged: Mutex::new(false),
10109                queued: Mutex::new(false),
10110                unreadable_after_merge: Mutex::new(false),
10111                reruns: Mutex::new(Vec::new()),
10112                rerun_fails: Mutex::new(false),
10113                clock: Mutex::new(1_000),
10114            }
10115        }
10116        fn argvs(&self) -> Vec<Vec<String>> {
10117            self.argvs.lock().unwrap().clone()
10118        }
10119        fn calls(&self) -> Vec<&'static str> {
10120            self.log.lock().unwrap().clone()
10121        }
10122    }
10123
10124    impl Forge for Scripted {
10125        async fn attribution(&self, _state: &RunState, _seen: &Seen) -> Option<CiEvidence> {
10126            self.evidence.lock().unwrap().clone()
10127        }
10128        async fn view(&self, _repo: &Path, _url: &str) -> Result<Seen> {
10129            self.log.lock().unwrap().push("view");
10130            if *self.unreadable_after_merge.lock().unwrap()
10131                && !self.argvs.lock().unwrap().is_empty()
10132            {
10133                anyhow::bail!("forge unreachable");
10134            }
10135            let mut seen = {
10136                let mut v = self.views.lock().unwrap();
10137                if v.len() > 1 {
10138                    v.pop_front().unwrap()
10139                } else {
10140                    v[0].clone()
10141                }
10142            };
10143            if seen.head == "@published" {
10144                let head =
10145                    git::remote_head(self.public_repo.as_ref().unwrap(), "origin", "task-head")
10146                        .await?
10147                        .context("missing published head")?;
10148                seen.head.clone_from(&head);
10149                seen.rollup_head = head;
10150            }
10151            if *self.merged.lock().unwrap() {
10152                seen.pr.state = PrLifecycle::Merged;
10153            }
10154            Ok(seen)
10155        }
10156        async fn merge(&self, _repo: &Path, argv: &[String]) -> Result<(bool, String)> {
10157            self.log.lock().unwrap().push("merge");
10158            self.argvs.lock().unwrap().push(argv.to_vec());
10159            let out = self
10160                .merges
10161                .lock()
10162                .unwrap()
10163                .pop_front()
10164                .expect("unscripted merge");
10165            if out.0 && !*self.queued.lock().unwrap() && !argv.iter().any(|a| a == "--disable-auto")
10166            {
10167                *self.merged.lock().unwrap() = true;
10168            }
10169            Ok(out)
10170        }
10171        async fn poll(&self) {
10172            self.log.lock().unwrap().push("poll");
10173            *self.clock.lock().unwrap() += POLL.as_secs() as i64;
10174        }
10175        async fn rerun(&self, _repo: &Path, run: &str) -> Result<()> {
10176            self.log.lock().unwrap().push("rerun");
10177            self.reruns.lock().unwrap().push(run.to_owned());
10178            if *self.rerun_fails.lock().unwrap() {
10179                anyhow::bail!("gh run rerun: no");
10180            }
10181            Ok(())
10182        }
10183        fn now(&self) -> i64 {
10184            *self.clock.lock().unwrap()
10185        }
10186        async fn required_contexts(&self, _repo: &Path, _base: &str) -> Option<BTreeSet<String>> {
10187            self.required.lock().unwrap().clone()
10188        }
10189        async fn fix(
10190            &self,
10191            _state: &mut RunState,
10192            _pr: &PrState,
10193            _round: usize,
10194            _budget: usize,
10195            _reason: &str,
10196            _logs: &str,
10197        ) -> Result<Fixed> {
10198            self.log.lock().unwrap().push("fix");
10199            Ok(self.fix.lock().unwrap().take().expect("unscripted fix"))
10200        }
10201    }
10202
10203    const REFUSED: &str =
10204        "X Pull request #42 is not mergeable: the base branch policy prohibits the merge.";
10205
10206    fn seen(head: &str, checks: Checks, merge_state: &str, comments: bool) -> Seen {
10207        let mut pr = green_pr();
10208        pr.checks = checks;
10209        pr.blocking = Blocking::of(merge_state);
10210        if !comments {
10211            pr.review_comments.clear();
10212        }
10213        Seen {
10214            pr,
10215            title: "feat: x".to_owned(),
10216            failing_urls: Vec::new(),
10217            head: head.to_owned(),
10218            rollup_head: head.to_owned(),
10219            merge_state: merge_state.to_owned(),
10220            contexts: Vec::new(),
10221            base: "main".to_owned(),
10222        }
10223    }
10224
10225    fn landing_state() -> RunState {
10226        crate::run::pin_test_home();
10227        let mut state = run_state();
10228        state.config.graph.land_approval = false;
10229        state
10230    }
10231
10232    #[test]
10233    fn a_pushed_head_is_awaited_case_insensitively_and_an_unreadable_one_is_not_a_match() {
10234        assert!(!awaiting_new_head(None, "aaa"));
10235        assert!(!awaiting_new_head(Some("abc123"), "ABC123"));
10236        assert!(awaiting_new_head(Some("abc123"), "def456"));
10237        assert!(awaiting_new_head(Some("abc123"), ""));
10238    }
10239
10240    #[test]
10241    fn a_refusal_is_judged_by_the_pull_requests_state_not_by_its_wording() {
10242        let open = |c, m: &str| seen("a", c, m, false);
10243        let table = [
10244            (None, false, Refused::Pending),
10245            (
10246                Some(open(Checks::Pending, "BLOCKED")),
10247                false,
10248                Refused::Pending,
10249            ),
10250            (
10251                Some(open(Checks::Unknown, "BLOCKED")),
10252                false,
10253                Refused::Pending,
10254            ),
10255            (
10256                Some(open(Checks::Green, "UNKNOWN")),
10257                false,
10258                Refused::Pending,
10259            ),
10260            (Some(open(Checks::Green, "")), false, Refused::Pending),
10261            (
10262                Some(open(Checks::Green, "BLOCKED")),
10263                false,
10264                Refused::Recheck,
10265            ),
10266            (Some(open(Checks::Green, "BLOCKED")), true, Refused::Final),
10267        ];
10268        for (after, rechecked, want) in table {
10269            assert_eq!(
10270                classify_refusal(after.as_ref(), rechecked, "a", CiExpectation::Expected),
10271                want
10272            );
10273        }
10274        let mut closed = open(Checks::Green, "CLEAN");
10275        closed.pr.state = PrLifecycle::Closed;
10276        assert_eq!(
10277            classify_refusal(Some(&closed), false, "a", CiExpectation::Expected),
10278            Refused::Final
10279        );
10280    }
10281
10282    #[test]
10283    fn behind_precedes_old_ci_and_other_blocking_policies_stay_distinct() {
10284        for checks in [Checks::Pending, Checks::Unknown, Checks::Red, Checks::Green] {
10285            let pr = seen("a", checks, "BEHIND", false).pr;
10286            assert_eq!(
10287                decide_with(&pr, 0, 4, Duration::ZERO, CiExpectation::Expected),
10288                Step::Rebase
10289            );
10290        }
10291        for status in ["DRAFT", "BLOCKED", "UNKNOWN"] {
10292            let current = seen("a", Checks::Green, status, false);
10293            assert_ne!(
10294                decide_with(&current.pr, 0, 4, Duration::ZERO, CiExpectation::Expected),
10295                Step::Rebase
10296            );
10297            assert_ne!(
10298                classify_refusal(Some(&current), false, "a", CiExpectation::Expected),
10299                Refused::Behind
10300            );
10301        }
10302        let mut current = seen("a", Checks::Pending, "BEHIND", false);
10303        current.rollup_head = "old".into();
10304        assert_eq!(
10305            classify_refusal(Some(&current), true, "a", CiExpectation::Expected),
10306            Refused::Behind
10307        );
10308        assert_eq!(
10309            classify_refusal(Some(&current), true, "other", CiExpectation::Expected),
10310            Refused::Pending
10311        );
10312        current.pr.state = PrLifecycle::Closed;
10313        assert_eq!(
10314            classify_refusal(Some(&current), true, "a", CiExpectation::Expected),
10315            Refused::Final
10316        );
10317    }
10318
10319    #[tokio::test]
10320    async fn behind_at_each_landing_boundary_syncs_and_requires_new_head_approval() {
10321        for boundary in ["initial", "premerge", "refusal"] {
10322            let (_tmp, mut state, old) = landing_git_fixture().await;
10323            state.land_sync_pending = false;
10324            advance_landing_base(&state).await;
10325            state.config.verify.gate = vec!["test -f advance".into()];
10326            state.config.verify.e2e = vec!["test -f advance".into()];
10327            approval_gate(&mut state, &green_pr(), "feat: x", None, &old)
10328                .await
10329                .unwrap();
10330            let old_binding = state.land_approval.clone().unwrap();
10331            let store = ask::Questions::open();
10332            let mut question = store.get(&old_binding.question).unwrap();
10333            question
10334                .answer(ask::Answer::Choice(APPROVE.to_owned()))
10335                .unwrap();
10336            store.put(&mut question).unwrap();
10337            let mut views = Vec::new();
10338            if boundary != "initial" {
10339                views.push(seen(&old, Checks::Green, "CLEAN", false));
10340            }
10341            if boundary == "refusal" {
10342                views.push(seen(&old, Checks::Green, "CLEAN", false));
10343            }
10344            let mut behind = seen(&old, Checks::Pending, "BEHIND", false);
10345            behind.rollup_head = "old-ci-head".into();
10346            views.push(behind);
10347            // Publication checks the PR lease while verification has completed.
10348            views.push(seen(&old, Checks::Green, "CLEAN", false));
10349            views.push(seen("@published", Checks::Pending, "CLEAN", false));
10350            views.push(seen("@published", Checks::Green, "CLEAN", false));
10351            let merges = if boundary == "refusal" {
10352                vec![(false, REFUSED)]
10353            } else {
10354                vec![]
10355            };
10356            let mut forge = Scripted::new(views, merges);
10357            forge.public_repo = Some(state.repo.clone());
10358            let run = state.id.clone();
10359            land_with(&mut state, URL, &forge).await.unwrap();
10360            let head = state.pr_pushed_head.clone().unwrap();
10361            assert_ne!(head, old, "{boundary}");
10362            assert_eq!(state.id, run);
10363            assert_eq!(state.pr_branch(), Some("task-head"));
10364            assert_eq!(state.winner().unwrap().branch, "winner");
10365            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
10366            assert!(state.gate_allows_progress());
10367            let e2e = state.head_e2e.as_ref().unwrap();
10368            assert_eq!(e2e.head, head);
10369            assert!(e2e.passed);
10370            assert_eq!(state.land_sync_attempts, 1);
10371            assert!(!state.land_sync_pending);
10372            assert!(state.parked);
10373            let binding = state.land_approval.as_ref().unwrap();
10374            assert_eq!(binding.head, head);
10375            assert_ne!(binding.question, old_binding.question);
10376            assert_eq!(forge.argvs().len(), usize::from(boundary == "refusal"));
10377            // The new question authorizes only the synchronized head on resume.
10378            let mut question = store.get(&binding.question).unwrap();
10379            question
10380                .answer(ask::Answer::Choice(APPROVE.to_owned()))
10381                .unwrap();
10382            store.put(&mut question).unwrap();
10383            let forge = Scripted::new(
10384                vec![seen(&head, Checks::Green, "CLEAN", false)],
10385                vec![(true, "")],
10386            );
10387            land_with(&mut state, URL, &forge).await.unwrap();
10388            assert_eq!(state.status, RunStatus::Merged);
10389            assert_eq!(
10390                value_of(&forge.argvs()[0], "--match-head-commit"),
10391                Some(head.as_str())
10392            );
10393        }
10394    }
10395
10396    #[tokio::test]
10397    async fn behind_refusal_remains_actionable_when_the_next_view_is_clean() {
10398        let (_tmp, mut state, old) = landing_git_fixture().await;
10399        state.land_sync_pending = false;
10400        state.config.graph.land_approval = false;
10401        state.config.verify.gate = vec!["test -f advance && test -f change".into()];
10402        advance_landing_base(&state).await;
10403        let mut forge = Scripted::new(
10404            vec![
10405                seen(&old, Checks::Green, "CLEAN", false),
10406                seen(&old, Checks::Green, "CLEAN", false),
10407                seen(&old, Checks::Green, "BEHIND", false),
10408                // The next observation is the publication lease check. The
10409                // refusal's evidence still applies to exactly this old head.
10410                seen(&old, Checks::Green, "CLEAN", false),
10411                seen("@published", Checks::Green, "CLEAN", false),
10412            ],
10413            vec![(false, REFUSED), (true, "")],
10414        );
10415        forge.public_repo = Some(state.repo.clone());
10416        land_with(&mut state, URL, &forge).await.unwrap();
10417        let head = state.pr_pushed_head.as_deref().unwrap();
10418        assert_ne!(head, old);
10419        assert_eq!(state.land_sync_attempts, 1);
10420        assert_eq!(state.gate_head.as_deref(), Some(head));
10421        assert_eq!(state.status, RunStatus::Merged);
10422        let requests = forge.argvs();
10423        assert_eq!(requests.len(), 2);
10424        assert_eq!(
10425            value_of(&requests[0], "--match-head-commit"),
10426            Some(old.as_str())
10427        );
10428        assert_eq!(value_of(&requests[1], "--match-head-commit"), Some(head));
10429    }
10430
10431    #[tokio::test]
10432    async fn behind_ancestry_failure_stops_without_rebasing_or_publishing() {
10433        let (tmp, mut state, old) = landing_git_fixture().await;
10434        state.land_sync_pending = false;
10435        // A damaged history must not be interpreted as a missing base. Keep
10436        // the head's tree intact so worktree restoration itself can succeed.
10437        let tree = git::rev_parse(&state.repo, "HEAD^{tree}").await.unwrap();
10438        let commit = tmp.path().join("broken-commit");
10439        std::fs::write(
10440            &commit,
10441            format!(
10442                "tree {tree}\nparent {}\nauthor Test <test@example.test> 1 +0000\ncommitter Test <test@example.test> 1 +0000\n\nbroken history\n",
10443                "f".repeat(40)
10444            ),
10445        )
10446        .unwrap();
10447        let replacement = git::git(
10448            &state.repo,
10449            &[
10450                "hash-object",
10451                "-t",
10452                "commit",
10453                "-w",
10454                commit.to_str().unwrap(),
10455            ],
10456        )
10457        .await
10458        .unwrap();
10459        git::git(&state.repo, &["replace", &old, replacement.trim()])
10460            .await
10461            .unwrap();
10462        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10463        land_with(&mut state, URL, &forge).await.unwrap();
10464        assert_eq!(state.land_sync_attempts, 0);
10465        assert_eq!(state.pr_pushed_head.as_deref(), Some(old.as_str()));
10466        assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), old);
10467        assert!(forge.argvs().is_empty());
10468        assert!(
10469            state.events.iter().any(|e| e.message.contains(
10470                "could not determine whether the landing head contains the fetched base"
10471            ))
10472        );
10473    }
10474
10475    #[tokio::test]
10476    async fn behind_fetch_failure_stops_without_rebasing_or_publishing() {
10477        let (_tmp, mut state, old) = landing_git_fixture().await;
10478        state.land_sync_pending = false;
10479        git::git(
10480            &state.repo,
10481            &["remote", "set-url", "origin", "missing-remote"],
10482        )
10483        .await
10484        .unwrap();
10485        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10486        land_with(&mut state, URL, &forge).await.unwrap();
10487        assert_eq!(state.land_sync_attempts, 0);
10488        assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), old);
10489        assert!(
10490            state
10491                .events
10492                .iter()
10493                .any(|e| e.message.contains("cannot fetch landing base"))
10494        );
10495        assert!(forge.argvs().is_empty());
10496    }
10497
10498    #[tokio::test]
10499    async fn behind_without_base_progress_and_exhausted_resume_budget_never_publish() {
10500        let (_tmp, mut state, old) = landing_git_fixture().await;
10501        state.land_sync_pending = false;
10502        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10503        land_with(&mut state, URL, &forge).await.unwrap();
10504        assert_eq!(state.pr_pushed_head.as_deref(), Some(old.as_str()));
10505        assert_eq!(state.land_sync_attempts, 0);
10506        assert!(
10507            state
10508                .events
10509                .iter()
10510                .any(|e| e.message.contains("already included"))
10511        );
10512        advance_landing_base(&state).await;
10513        state.land_sync_attempts = state.config.graph.land_rounds;
10514        state.land_sync_pending = true;
10515        state.save().unwrap();
10516        let mut restored = RunState::load(&state.id).unwrap();
10517        assert!(
10518            resume_observed_head(&mut restored, &old)
10519                .await
10520                .unwrap_err()
10521                .to_string()
10522                .contains("budget exhausted")
10523        );
10524        assert_eq!(
10525            git::remote_head(&state.repo, "origin", "task-head")
10526                .await
10527                .unwrap(),
10528            Some(old)
10529        );
10530    }
10531
10532    #[tokio::test]
10533    async fn a_normal_landing_merges_on_the_first_look() {
10534        let mut state = landing_state();
10535        let forge = Scripted::new(
10536            vec![seen("a", Checks::Green, "CLEAN", false)],
10537            vec![(true, "")],
10538        );
10539        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10540            .await
10541            .unwrap();
10542        // One fresh read, then the head-bound merge.
10543        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10544        assert_eq!(state.status, RunStatus::Merged);
10545    }
10546
10547    #[tokio::test]
10548    async fn a_successful_merge_command_that_only_queued_is_not_a_merge() {
10549        let mut state = landing_state();
10550        let forge = Scripted::new(
10551            vec![seen("a", Checks::Green, "CLEAN", false)],
10552            std::iter::repeat_n((true, ""), 100).collect(),
10553        );
10554        *forge.queued.lock().unwrap() = true;
10555        let task = async {
10556            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10557                .await
10558                .unwrap();
10559        };
10560        // Still open after the command succeeded: it keeps watching and
10561        // never records a merge (it stops at the wait ceiling instead).
10562        task.await;
10563        assert_ne!(state.status, RunStatus::Merged);
10564    }
10565
10566    #[tokio::test]
10567    async fn an_unreadable_forge_after_a_merge_command_is_not_a_confirmation() {
10568        let mut state = landing_state();
10569        let forge = Scripted::new(
10570            vec![seen("a", Checks::Green, "CLEAN", false)],
10571            std::iter::repeat_n((true, ""), 100).collect(),
10572        );
10573        *forge.unreadable_after_merge.lock().unwrap() = true;
10574        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10575            .await
10576            .ok();
10577        assert_ne!(state.status, RunStatus::Merged);
10578    }
10579
10580    #[tokio::test]
10581    async fn a_task_public_head_is_awaited_on_land_entry() {
10582        let mut state = landing_state();
10583        state.pr_head = Some("magi/task-abcd-1234".into());
10584        state.pr_pushed_head = Some("new".into());
10585        let forge = Scripted::new(
10586            vec![
10587                seen("old", Checks::Green, "CLEAN", false),
10588                seen("new", Checks::Green, "CLEAN", false),
10589            ],
10590            vec![(true, "")],
10591        );
10592        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10593            .await
10594            .unwrap();
10595        assert_eq!(
10596            forge.calls(),
10597            ["view", "poll", "view", "view", "merge", "view"]
10598        );
10599        assert_eq!(state.status, RunStatus::Merged);
10600    }
10601
10602    #[tokio::test]
10603    async fn a_superseded_public_head_owner_cannot_reenter_land() {
10604        let mut state = landing_state();
10605        state.pr_taken_over_by = Some("next".into());
10606        let forge = Scripted::new(vec![seen("a", Checks::Green, "CLEAN", false)], vec![]);
10607        assert!(
10608            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10609                .await
10610                .is_err()
10611        );
10612        assert!(forge.calls().is_empty());
10613    }
10614
10615    #[tokio::test]
10616    async fn after_a_pushed_fix_no_merge_is_tried_until_the_head_matches() {
10617        let mut state = landing_state();
10618        let forge = Scripted::new(
10619            vec![
10620                seen("old", Checks::Green, "CLEAN", true),
10621                // The forge has not moved to the new head yet: still green.
10622                seen("old", Checks::Green, "CLEAN", true),
10623                seen("new", Checks::Pending, "BLOCKED", true),
10624                seen("new", Checks::Green, "CLEAN", true),
10625            ],
10626            vec![(true, "")],
10627        );
10628        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10629            head: "NEW".to_owned(),
10630        });
10631        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10632            .await
10633            .unwrap();
10634        assert_eq!(
10635            forge.calls(),
10636            [
10637                "view", "fix", "poll", "view", "poll", "view", "poll", "view", "view", "merge",
10638                "view"
10639            ]
10640        );
10641        assert_eq!(state.status, RunStatus::Merged);
10642    }
10643
10644    #[tokio::test]
10645    async fn a_head_that_never_arrives_stops_naming_both_commits() {
10646        let mut state = landing_state();
10647        let forge = Scripted::new(
10648            vec![
10649                seen("old", Checks::Green, "CLEAN", true),
10650                seen("someone-elses", Checks::Green, "CLEAN", true),
10651            ],
10652            vec![],
10653        );
10654        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10655            head: "mine".to_owned(),
10656        });
10657        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10658            .await
10659            .unwrap();
10660        assert!(!forge.calls().contains(&"merge"));
10661        let why = state.merge.as_ref().unwrap().detail.clone();
10662        assert!(
10663            why.contains("mine") && why.contains("someone-elses"),
10664            "{why}"
10665        );
10666        assert_eq!(state.status, RunStatus::Blocked);
10667    }
10668
10669    #[tokio::test]
10670    async fn a_policy_refusal_while_checks_run_waits_and_then_merges() {
10671        let mut state = landing_state();
10672        let forge = Scripted::new(
10673            vec![
10674                seen("a", Checks::Green, "CLEAN", false),
10675                seen("a", Checks::Green, "CLEAN", false),
10676                seen("a", Checks::Pending, "BLOCKED", false),
10677                seen("a", Checks::Pending, "BLOCKED", false),
10678                seen("a", Checks::Green, "CLEAN", false),
10679            ],
10680            vec![(false, REFUSED), (true, "")],
10681        );
10682        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10683            .await
10684            .unwrap();
10685        assert_eq!(
10686            forge.calls(),
10687            [
10688                "view", "view", "merge", "view", "poll", "view", "poll", "view", "view", "merge",
10689                "view"
10690            ]
10691        );
10692        assert_eq!(state.status, RunStatus::Merged);
10693    }
10694
10695    #[tokio::test]
10696    async fn a_refusal_that_outlives_settled_checks_stops_with_the_merge_state() {
10697        let mut state = landing_state();
10698        let forge = Scripted::new(
10699            vec![
10700                seen("a", Checks::Green, "CLEAN", false),
10701                seen("a", Checks::Green, "BLOCKED", false),
10702            ],
10703            vec![(false, REFUSED), (false, REFUSED)],
10704        );
10705        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10706            .await
10707            .unwrap();
10708        // One re-look is allowed for the forge's own lag, then it is final.
10709        assert_eq!(forge.calls().iter().filter(|c| **c == "merge").count(), 2);
10710        let why = state.merge.as_ref().unwrap().detail.clone();
10711        assert!(
10712            why.contains("policy prohibits") && why.contains("BLOCKED") && why.contains("refused"),
10713            "{why}"
10714        );
10715        assert_eq!(state.status, RunStatus::Blocked);
10716    }
10717
10718    #[test]
10719    fn a_decision_is_bound_to_a_head_only_when_every_signal_agrees() {
10720        assert_eq!(bound_head("abc", "abc", None), Some("abc"));
10721        assert_eq!(bound_head("abc", "ABC", Some("abc")), Some("abc"));
10722        // The pull request is still on the commit before the push.
10723        assert_eq!(bound_head("old", "old", Some("new")), None);
10724        // The checks are the previous commit's.
10725        assert_eq!(bound_head("new", "old", Some("new")), None);
10726        assert_eq!(bound_head("new", "old", None), None);
10727        // Nothing readable.
10728        assert_eq!(bound_head("", "", None), None);
10729        assert_eq!(bound_head("", "", Some("new")), None);
10730        assert_eq!(bound_head("abc", "", None), None);
10731    }
10732
10733    fn view_json(head: &str) -> String {
10734        format!(
10735            r#"{{"url":"https://github.com/o/r/pull/42","number":42,"state":"OPEN",
10736            "title":"t","headRefOid":"{head}","mergeStateStatus":"CLEAN",
10737            "reviews":[],"comments":[]}}"#
10738        )
10739    }
10740
10741    fn node_json(oid: &str, check: &str, has_next: bool) -> String {
10742        format!(
10743            r#"{{"data":{{"repository":{{"pullRequest":{{"commits":{{"nodes":[{{"commit":
10744            {{"oid":"{oid}","statusCheckRollup":{{"contexts":{{"pageInfo":{{"hasNextPage":{has_next}}},
10745            "nodes":[{{"__typename":"CheckRun","name":"ci","status":"COMPLETED",
10746            "conclusion":"{check}","detailsUrl":"https://example.test/1"}}]}}}}}}}}]}}}}}}}}}}"#
10747        )
10748    }
10749
10750    #[test]
10751    fn rollup_is_bound_to_the_commit_in_the_same_node() {
10752        // The view already points at the new head, but the node still answers
10753        // for the old commit with its red check: the head stays unbound.
10754        let s = seen_from(&view_json("new"), Some(&node_json("old", "FAILURE", false))).unwrap();
10755        assert_eq!(s.rollup_head, "old");
10756        assert_eq!(s.pr.checks, Checks::Red);
10757        assert_eq!(bound_head(&s.head, &s.rollup_head, Some("new")), None);
10758        assert_eq!(s.failing_urls.len(), 1);
10759    }
10760
10761    #[test]
10762    fn checks_come_from_the_node_not_the_view() {
10763        let view = view_json("new").replace(
10764            r#""reviews""#,
10765            r#""statusCheckRollup":[{"name":"ci","status":"COMPLETED","conclusion":"FAILURE"}],"reviews""#,
10766        );
10767        let s = seen_from(&view, Some(&node_json("new", "SUCCESS", false))).unwrap();
10768        assert_eq!(s.pr.checks, Checks::Green);
10769        assert!(s.pr.failing.is_empty());
10770        assert_eq!(
10771            bound_head(&s.head, &s.rollup_head, Some("new")),
10772            Some("new")
10773        );
10774    }
10775
10776    #[test]
10777    fn an_unreadable_or_paged_node_leaves_the_head_unbound() {
10778        for node in [
10779            None,
10780            Some("not json".to_owned()),
10781            Some(r#"{"errors":[{"message":"x"}]}"#.to_owned()),
10782            Some(node_json("new", "SUCCESS", true)),
10783        ] {
10784            let s = seen_from(&view_json("new"), node.as_deref()).unwrap();
10785            assert!(s.rollup_head.is_empty());
10786            assert_eq!(s.pr.checks, Checks::Unknown);
10787            assert_eq!(bound_head(&s.head, &s.rollup_head, None), None);
10788        }
10789    }
10790
10791    #[test]
10792    fn the_merge_command_is_pinned_to_the_observed_head() {
10793        let argv = merge_argv_at(7, "feat: x", "deadbeef");
10794        let at = argv
10795            .iter()
10796            .position(|a| a == "--match-head-commit")
10797            .unwrap();
10798        assert_eq!(argv[at + 1], "deadbeef");
10799    }
10800
10801    #[tokio::test]
10802    async fn stale_checks_after_a_fix_push_never_reach_a_merge() {
10803        let mut state = landing_state();
10804        // The pull request is on the pushed head but the rollup is still the
10805        // previous commit's red, non-required result.
10806        let mut stale = seen("new", Checks::Red, "CLEAN", false);
10807        stale.rollup_head = "old".to_owned();
10808        let forge = Scripted::new(
10809            vec![seen("old", Checks::Green, "CLEAN", true), stale],
10810            vec![],
10811        );
10812        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10813            head: "new".to_owned(),
10814        });
10815        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10816            .await
10817            .unwrap();
10818        assert!(!forge.calls().contains(&"merge"));
10819        assert_eq!(state.status, RunStatus::Blocked);
10820        let why = state.merge.as_ref().unwrap().detail.clone();
10821        assert!(why.contains("new") && why.contains("old"), "{why}");
10822    }
10823
10824    #[test]
10825    fn a_refusal_read_against_another_commits_checks_is_pending() {
10826        let mut after = seen("a", Checks::Green, "BLOCKED", false);
10827        after.rollup_head = "old".to_owned();
10828        assert_eq!(
10829            classify_refusal(Some(&after), true, "a", CiExpectation::Expected),
10830            Refused::Pending
10831        );
10832    }
10833
10834    #[tokio::test]
10835    async fn absent_ci_empty_rollup_reaches_approval_then_merges_on_the_approved_head() {
10836        let mut state = landing_state();
10837        state.config.merge.ci = crate::config::MergeCi::None;
10838        state.config.graph.land_approval = true;
10839        let forge = Scripted::new(
10840            vec![seen("a", Checks::Unknown, "CLEAN", false)],
10841            vec![(true, "")],
10842        );
10843        land_with(&mut state, URL, &forge).await.unwrap();
10844        assert!(state.parked);
10845        assert_eq!(forge.calls(), ["view"]);
10846        let store = ask::Questions::open();
10847        let mut q = store
10848            .get(&state.land_approval.as_ref().unwrap().question)
10849            .unwrap();
10850        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
10851        store.put(&mut q).unwrap();
10852
10853        land_with(&mut state, URL, &forge).await.unwrap();
10854        assert_eq!(forge.calls(), ["view", "view", "view", "merge", "view"]);
10855        assert_eq!(state.status, RunStatus::Merged);
10856        assert_eq!(
10857            value_of(&forge.argvs()[0], "--match-head-commit"),
10858            Some("a")
10859        );
10860    }
10861
10862    #[tokio::test]
10863    async fn absent_ci_ignores_failed_workflow_runs_without_rerunning_them() {
10864        let mut state = landing_state();
10865        state.config.merge.ci = crate::config::MergeCi::None;
10866        let forge = Scripted::new(vec![red("a", Some("7"))], vec![(true, "")]);
10867        land_with(&mut state, URL, &forge).await.unwrap();
10868        assert!(forge.reruns.lock().unwrap().is_empty());
10869        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10870        assert_eq!(state.status, RunStatus::Merged);
10871    }
10872
10873    #[test]
10874    fn absent_ci_still_requires_a_readable_matching_head_and_resolved_comments() {
10875        let shown = BTreeSet::new();
10876        let guard = |s: Option<&Seen>| {
10877            direct_merge_is_safe(s, "a", &shown, 0, 4, Duration::ZERO, CiExpectation::Absent)
10878        };
10879        let mut fresh = seen("a", Checks::Unknown, "CLEAN", false);
10880        assert!(guard(Some(&fresh)));
10881        assert!(!guard(None));
10882        fresh.rollup_head = "old".to_owned();
10883        assert!(!guard(Some(&fresh)));
10884        fresh.rollup_head = "a".to_owned();
10885        fresh.head = "b".to_owned();
10886        assert!(!guard(Some(&fresh)));
10887        assert!(!guard(Some(&seen("a", Checks::Unknown, "CLEAN", true))));
10888        assert!(!guard(Some(&seen("a", Checks::Unknown, "DIRTY", false))));
10889    }
10890
10891    #[test]
10892    fn absent_ci_refusal_does_not_wait_for_third_party_checks() {
10893        for checks in [Checks::Unknown, Checks::Pending, Checks::Red, Checks::Green] {
10894            let after = seen("a", checks, "BLOCKED", false);
10895            assert_eq!(
10896                classify_refusal(Some(&after), false, "a", CiExpectation::Absent),
10897                Refused::Recheck
10898            );
10899            assert_eq!(
10900                classify_refusal(Some(&after), true, "a", CiExpectation::Absent),
10901                Refused::Final
10902            );
10903        }
10904    }
10905
10906    #[tokio::test]
10907    async fn a_matching_head_with_red_non_required_checks_still_merges() {
10908        let mut state = landing_state();
10909        let forge = Scripted::new(
10910            vec![seen("a", Checks::Red, "CLEAN", false)],
10911            vec![(true, "")],
10912        );
10913        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10914            .await
10915            .unwrap();
10916        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10917        assert_eq!(state.status, RunStatus::Merged);
10918    }
10919
10920    #[tokio::test]
10921    async fn a_merge_refused_because_the_head_moved_looks_again_instead_of_failing() {
10922        let mut state = landing_state();
10923        let forge = Scripted::new(
10924            vec![
10925                seen("a", Checks::Green, "CLEAN", false),
10926                seen("a", Checks::Green, "CLEAN", false),
10927                // Re-viewed after the refusal: someone pushed.
10928                seen("b", Checks::Green, "BLOCKED", false),
10929                seen("b", Checks::Green, "CLEAN", false),
10930            ],
10931            vec![(false, REFUSED), (true, "")],
10932        );
10933        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10934            .await
10935            .unwrap();
10936        assert_eq!(
10937            forge.calls(),
10938            [
10939                "view", "view", "merge", "view", "poll", "view", "view", "merge", "view"
10940            ]
10941        );
10942        assert_eq!(state.status, RunStatus::Merged);
10943    }
10944
10945    fn merged_view(head: &str) -> Seen {
10946        let mut m = seen(head, Checks::Green, "CLEAN", false);
10947        m.pr.state = PrLifecycle::Merged;
10948        m
10949    }
10950
10951    fn has(argv: &[String], flag: &str) -> bool {
10952        argv.iter().any(|a| a == flag)
10953    }
10954
10955    fn value_of<'a>(argv: &'a [String], flag: &str) -> Option<&'a str> {
10956        let at = argv.iter().position(|a| a == flag)?;
10957        argv.get(at + 1).map(String::as_str)
10958    }
10959
10960    const URL: &str = "https://github.com/o/r/pull/42";
10961
10962    #[tokio::test]
10963    async fn the_merge_step_merges_directly_on_the_observed_head_and_never_arms() {
10964        let mut state = landing_state();
10965        let forge = Scripted::new(
10966            vec![
10967                seen("abc", Checks::Green, "CLEAN", false),
10968                seen("abc", Checks::Green, "CLEAN", false),
10969            ],
10970            vec![(true, "")],
10971        );
10972        land_with(&mut state, URL, &forge).await.unwrap();
10973        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10974        let argv = &forge.argvs()[0];
10975        assert!(has(argv, "--squash") && has(argv, "--subject"));
10976        assert!(!has(argv, "--auto") && !has(argv, "--admin"));
10977        assert_eq!(value_of(argv, "--match-head-commit"), Some("abc"));
10978        assert_eq!(state.status, RunStatus::Merged);
10979        assert!(state.land_armed_head.is_none());
10980    }
10981
10982    #[tokio::test]
10983    async fn a_resume_disables_an_arm_left_by_an_older_build_before_merging() {
10984        let mut state = landing_state();
10985        state.land_armed_head = Some("a".to_owned());
10986        let forge = Scripted::new(
10987            vec![seen("a", Checks::Green, "CLEAN", false)],
10988            vec![(true, ""), (true, "")],
10989        );
10990        land_with(&mut state, URL, &forge).await.unwrap();
10991        let argvs = forge.argvs();
10992        assert!(has(&argvs[0], "--disable-auto"));
10993        assert!(!has(&argvs[1], "--auto"));
10994        assert_eq!(value_of(&argvs[1], "--match-head-commit"), Some("a"));
10995        assert_eq!(state.status, RunStatus::Merged);
10996        assert!(state.land_armed_head.is_none());
10997    }
10998
10999    #[tokio::test]
11000    async fn an_approval_never_carries_over_to_a_new_head() {
11001        crate::run::pin_test_home();
11002        let mut state = run_state();
11003        state.config.graph.land_approval = true;
11004        let pr = green_pr();
11005        let store = ask::Questions::open();
11006
11007        approval_gate(&mut state, &pr, "feat: x", None, "aaa")
11008            .await
11009            .unwrap();
11010        let mut q = store
11011            .list()
11012            .into_iter()
11013            .find(|q| q.run == state.id)
11014            .unwrap();
11015        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
11016        store.put(&mut q).unwrap();
11017        assert_eq!(
11018            approval_gate(&mut state, &pr, "feat: x", None, "AAA")
11019                .await
11020                .unwrap(),
11021            ApprovalGate::Approved,
11022            "the same head keeps its approval"
11023        );
11024
11025        // A new head is a new question, not the old word.
11026        assert_eq!(
11027            approval_gate(&mut state, &pr, "feat: x", None, "bbb")
11028                .await
11029                .unwrap(),
11030            ApprovalGate::Pending
11031        );
11032        let all: Vec<_> = store
11033            .list()
11034            .into_iter()
11035            .filter(|q| q.run == state.id)
11036            .collect();
11037        assert_eq!(all.len(), 2);
11038
11039        // A question recorded before heads were tracked is not reused either.
11040        state.land_approval = None;
11041        assert_eq!(
11042            approval_gate(&mut state, &pr, "feat: x", None, "bbb")
11043                .await
11044                .unwrap(),
11045            ApprovalGate::Pending
11046        );
11047        let open = store
11048            .list()
11049            .into_iter()
11050            .filter(|q| q.run == state.id && q.status.open())
11051            .count();
11052        assert_eq!(open, 1, "the superseded question was retired");
11053    }
11054
11055    #[tokio::test]
11056    async fn the_merge_is_bound_to_the_head_it_was_decided_on() {
11057        let mut state = landing_state();
11058        let forge = Scripted::new(
11059            vec![
11060                seen("a", Checks::Green, "CLEAN", false),
11061                // The fresh read before the merge: someone pushed.
11062                seen("b", Checks::Green, "CLEAN", false),
11063            ],
11064            vec![(true, "")],
11065        );
11066        land_with(&mut state, URL, &forge).await.unwrap();
11067        let argvs = forge.argvs();
11068        assert_eq!(argvs.len(), 1, "no merge was tried on the moved head");
11069        assert!(!has(&argvs[0], "--auto"));
11070        assert_eq!(value_of(&argvs[0], "--match-head-commit"), Some("b"));
11071        assert_eq!(state.status, RunStatus::Merged);
11072    }
11073
11074    fn passing(label: &str) -> CheckInfo {
11075        CheckInfo {
11076            label: label.to_owned(),
11077            verdict: Verdict::Pass,
11078            required: Some(false),
11079            run: None,
11080        }
11081    }
11082
11083    fn failing(label: &str, run: Option<&str>) -> (String, Option<String>) {
11084        (label.to_owned(), run.map(str::to_owned))
11085    }
11086
11087    fn reran(head: &str, runs: &[(&str, i64)]) -> LandReruns {
11088        LandReruns {
11089            head: head.to_owned(),
11090            runs: runs.iter().map(|(r, at)| ((*r).to_owned(), *at)).collect(),
11091        }
11092    }
11093
11094    #[test]
11095    fn a_failed_run_is_rerun_once_then_waited_on_then_left_to_the_fixer() {
11096        let f = [failing("test (macos)", Some("7"))];
11097        assert_eq!(
11098            rerun_step(&f, None, "h", 100),
11099            RerunStep::Rerun(vec!["7".to_owned()])
11100        );
11101        let rec = reran("h", &[("7", 100)]);
11102        let grace = crate::release_watch::RERUN_GRACE;
11103        assert_eq!(
11104            rerun_step(&f, Some(&rec), "h", 100 + grace - 1),
11105            RerunStep::Grace
11106        );
11107        assert_eq!(rerun_step(&f, Some(&rec), "h", 100 + grace), RerunStep::Fix);
11108    }
11109
11110    #[test]
11111    fn a_failure_without_a_run_id_goes_to_the_fixer() {
11112        let f = [failing("a", Some("7")), failing("ci/external", None)];
11113        assert_eq!(rerun_step(&f, None, "h", 0), RerunStep::Fix);
11114        assert_eq!(rerun_step(&[], None, "h", 0), RerunStep::Fix);
11115    }
11116
11117    #[test]
11118    fn a_moved_head_forgets_the_reruns() {
11119        let f = [failing("a", Some("7"))];
11120        let rec = reran("old", &[("7", 100)]);
11121        assert_eq!(
11122            rerun_step(&f, Some(&rec), "new", 101),
11123            RerunStep::Rerun(vec!["7".to_owned()])
11124        );
11125    }
11126
11127    #[test]
11128    fn only_unrerun_runs_are_rerun_and_duplicates_collapse() {
11129        let f = [
11130            failing("a", Some("7")),
11131            failing("b", Some("7")),
11132            failing("c", Some("8")),
11133        ];
11134        assert_eq!(
11135            rerun_step(&f, None, "h", 0),
11136            RerunStep::Rerun(vec!["7".to_owned(), "8".to_owned()])
11137        );
11138        let rec = reran("h", &[("7", 0)]);
11139        assert_eq!(
11140            rerun_step(&f, Some(&rec), "h", 1),
11141            RerunStep::Rerun(vec!["8".to_owned()])
11142        );
11143    }
11144
11145    #[test]
11146    fn only_blocking_failures_are_candidates_for_a_rerun() {
11147        let check = |label: &str, verdict, required, run: &str| CheckInfo {
11148            label: label.to_owned(),
11149            verdict,
11150            required,
11151            run: Some(run.to_owned()),
11152        };
11153        let got = rerunnable(&[
11154            check("passed", Verdict::Pass, Some(true), "1"),
11155            check("optional", Verdict::Fail, Some(false), "2"),
11156            check("required", Verdict::Fail, Some(true), "3"),
11157            check("unknown", Verdict::Fail, None, "4"),
11158        ]);
11159        let labels: Vec<_> = got.iter().map(|(l, _)| l.as_str()).collect();
11160        assert_eq!(labels, ["required", "unknown"]);
11161    }
11162
11163    fn unrelated_ci_fixture() -> CiEvidence {
11164        let failure = CiFailure {
11165            path: "tests/web_render.rs".into(),
11166            start_line: 42,
11167            end_line: 42,
11168            title: "question_identity_disclosure_copy_and_live_updates".into(),
11169            message: "assertion failed".into(),
11170        };
11171        CiEvidence {
11172            head: "a".into(),
11173            base: "base-sha".into(),
11174            changed: vec![
11175                "AGENTS.md".into(),
11176                "src/talk.rs".into(),
11177                "tests/consult_investigation.rs".into(),
11178            ],
11179            checks: vec![CiCheckEvidence {
11180                label: "coverage".into(),
11181                head_check: 70,
11182                base_check: 60,
11183                app: 1,
11184                run: "7".into(),
11185                base_run: "6".into(),
11186                head_failures: vec![failure.clone()],
11187                base_failures: vec![failure],
11188                rerun_exhausted: true,
11189            }],
11190        }
11191    }
11192
11193    #[test]
11194    fn unrelated_ci_requires_complete_structural_evidence_for_every_failure() {
11195        let good = unrelated_ci_fixture();
11196        let red = vec!["coverage".into()];
11197        assert!(good.unrelated("a", &red));
11198        assert!(!good.unrelated("another-head", &red));
11199        assert!(!good.unrelated("a", &["coverage".into(), "test".into()]));
11200        assert!(!good.unrelated("a", &[]));
11201        for mutation in 0..8 {
11202            let mut bad = good.clone();
11203            match mutation {
11204                0 => bad.checks[0].rerun_exhausted = false,
11205                1 => bad.checks[0].base_failures.clear(),
11206                2 => bad.checks[0].head_failures.clear(),
11207                3 => bad.changed.push("tests/web_render.rs".into()),
11208                4 => bad.changed.push(".github/workflows/ci.yml".into()),
11209                5 => bad.checks[0].base_failures[0].message = "different failure".into(),
11210                6 => bad.checks.push(bad.checks[0].clone()),
11211                _ => bad.base.clear(),
11212            }
11213            assert!(!bad.unrelated("a", &red), "mutation {mutation}");
11214        }
11215    }
11216
11217    #[test]
11218    fn red_unknown_merge_state_waits_before_repair_but_never_implies_merge() {
11219        let pr = seen("a", Checks::Red, "UNKNOWN", false).pr;
11220        assert_eq!(decide(&pr, 0, 2, Duration::ZERO), Step::Wait);
11221        assert!(matches!(decide(&pr, 0, 2, CHECKS_GRACE), Step::Fix { .. }));
11222        assert!(matches!(
11223            decide(&pr, 2, 2, CHECKS_GRACE),
11224            Step::GiveUp { .. }
11225        ));
11226        let optional = CheckInfo {
11227            label: "coverage".into(),
11228            verdict: Verdict::Fail,
11229            required: Some(false),
11230            run: Some("7".into()),
11231        };
11232        assert!(rerunnable_with(std::slice::from_ref(&optional), false).is_empty());
11233        assert_eq!(
11234            rerunnable_with(&[optional], true),
11235            vec![("coverage".into(), Some("7".into()))]
11236        );
11237    }
11238
11239    #[tokio::test]
11240    async fn unrelated_ci_after_a_comment_round_does_not_charge_a_no_commit_stop() {
11241        let mut state = landing_state();
11242        let mut red = coverage_unknown();
11243        red.pr = seen("a", Checks::Red, "BLOCKED", true).pr;
11244        red.pr.failing = vec!["coverage".into()];
11245        let forge = Scripted::new(vec![red], vec![]);
11246        *forge.evidence.lock().unwrap() = Some(unrelated_ci_fixture());
11247        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11248        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11249        assert!(forge.calls().contains(&"fix"));
11250        assert!(state.land_unrelated.is_some());
11251        assert!(state.parked);
11252        assert!(
11253            !state
11254                .events
11255                .iter()
11256                .any(|e| e.message.contains("fixer produced no commit"))
11257        );
11258    }
11259
11260    fn coverage_unknown() -> Seen {
11261        let mut s = red("a", Some("7"));
11262        s.pr.blocking = Blocking::Unsaid;
11263        s.merge_state = "UNKNOWN".into();
11264        s.pr.failing = vec!["coverage".into()];
11265        s.contexts[0].label = "coverage".into();
11266        s.contexts[0].required = Some(false);
11267        s
11268    }
11269
11270    #[tokio::test]
11271    async fn run_196c_unknown_then_unstable_does_not_spend_a_fix_round() {
11272        let mut state = landing_state();
11273        let unknown = coverage_unknown();
11274        let mut unstable = unknown.clone();
11275        unstable.pr.blocking = Blocking::of("UNSTABLE");
11276        unstable.merge_state = "UNSTABLE".into();
11277        let forge = Scripted::new(vec![unknown, unstable], vec![(true, "")]);
11278        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11279        assert!(!forge.calls().contains(&"fix"));
11280        assert!(!forge.calls().contains(&"rerun"));
11281        assert_eq!(state.status, RunStatus::Merged);
11282        assert_eq!(state.pr.unwrap().round, 0);
11283    }
11284
11285    #[tokio::test]
11286    async fn run_196c_persistent_unknown_reruns_optional_once_then_parks_with_evidence() {
11287        let mut state = landing_state();
11288        let forge = Scripted::new(vec![coverage_unknown()], vec![]);
11289        *forge.evidence.lock().unwrap() = Some(unrelated_ci_fixture());
11290        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11291        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11292        assert!(!forge.calls().contains(&"fix"));
11293        assert!(state.parked);
11294        assert_eq!(state.status, RunStatus::Landing);
11295        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11296        let hold = state.land_unrelated.as_ref().unwrap();
11297        let q = ask::Questions::open().get(&hold.question).unwrap();
11298        assert!(
11299            q.actions
11300                .values()
11301                .any(|a| matches!(a, ask::ChoiceAction::Resume { .. }))
11302        );
11303        assert!(
11304            state
11305                .events
11306                .iter()
11307                .any(|e| e.message.contains("[ci-unrelated]") && e.message.contains("base-sha"))
11308        );
11309        let first = state.land_unsaid.clone();
11310        // A resume on this head neither extends UNKNOWN grace nor reruns 7.
11311        state.parked = false;
11312        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11313        assert_eq!(state.land_unsaid, first);
11314        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11315    }
11316
11317    fn red(head: &str, run: Option<&str>) -> Seen {
11318        let mut s = seen(head, Checks::Red, "BLOCKED", false);
11319        s.pr.failing = vec!["test (macos)".to_owned()];
11320        s.contexts = vec![CheckInfo {
11321            label: "test (macos)".to_owned(),
11322            verdict: Verdict::Fail,
11323            required: Some(true),
11324            run: run.map(str::to_owned),
11325        }];
11326        s
11327    }
11328
11329    const RERUN_PR: &str = "https://github.com/o/r/pull/42";
11330
11331    #[tokio::test]
11332    async fn a_flaky_red_check_is_rerun_without_a_fix_round_and_then_merges() {
11333        let mut state = landing_state();
11334        let forge = Scripted::new(
11335            vec![
11336                red("a", Some("7")),
11337                seen("a", Checks::Pending, "BLOCKED", false),
11338                seen("a", Checks::Green, "CLEAN", false),
11339            ],
11340            vec![(true, "")],
11341        );
11342        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11343        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11344        assert!(!forge.calls().contains(&"fix"));
11345        assert_eq!(state.status, RunStatus::Merged);
11346        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11347        let argvs = forge.argvs();
11348        assert_eq!(value_of(&argvs[0], "--match-head-commit"), Some("a"));
11349        assert!(
11350            state
11351                .events
11352                .iter()
11353                .any(|e| e.message.contains("test (macos)") && e.message.contains("run 7"))
11354        );
11355    }
11356
11357    #[tokio::test]
11358    async fn still_red_after_the_grace_goes_to_the_fixer_and_a_run_is_not_rerun_twice() {
11359        let mut state = landing_state();
11360        let forge = Scripted::new(
11361            vec![
11362                red("a", Some("7")),
11363                seen("a", Checks::Green, "CLEAN", false),
11364            ],
11365            vec![(true, "")],
11366        );
11367        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11368        // The red view repeats for the grace, then the fixer is asked once.
11369        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11370        assert_eq!(forge.reruns.lock().unwrap().len(), 1);
11371        let calls = forge.calls();
11372        let rerun_at = calls.iter().position(|c| *c == "rerun").unwrap();
11373        let fix_at = calls.iter().position(|c| *c == "fix");
11374        assert!(fix_at.is_none_or(|f| f > rerun_at));
11375    }
11376
11377    #[tokio::test]
11378    async fn a_failed_run_is_rerun_while_another_run_is_still_pending() {
11379        let mut state = landing_state();
11380        let mut v = red("a", Some("7"));
11381        v.pr.checks = Checks::Pending;
11382        v.contexts.push(CheckInfo {
11383            label: "slow".to_owned(),
11384            verdict: Verdict::Pending,
11385            required: Some(true),
11386            run: Some("8".to_owned()),
11387        });
11388        let forge = Scripted::new(
11389            vec![v, seen("a", Checks::Green, "CLEAN", false)],
11390            vec![(true, "")],
11391        );
11392        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11393        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11394        assert_eq!(state.status, RunStatus::Merged);
11395    }
11396
11397    #[test]
11398    fn a_run_with_a_job_still_going_is_not_rerun_yet() {
11399        let mut v = red("a", Some("7"));
11400        v.contexts.push(CheckInfo {
11401            label: "same run, still going".to_owned(),
11402            verdict: Verdict::Pending,
11403            required: Some(true),
11404            run: Some("7".to_owned()),
11405        });
11406        assert!(rerunnable(&v.contexts).is_empty());
11407    }
11408
11409    #[tokio::test]
11410    async fn the_rerun_is_made_even_when_the_fix_budget_is_spent() {
11411        let mut state = landing_state();
11412        state.config.graph.land_rounds = 0;
11413        let forge = Scripted::new(
11414            vec![
11415                red("a", Some("7")),
11416                seen("a", Checks::Green, "CLEAN", false),
11417            ],
11418            vec![(true, "")],
11419        );
11420        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11421        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11422        assert_eq!(state.status, RunStatus::Merged);
11423        assert!(!forge.calls().contains(&"fix"));
11424        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11425    }
11426
11427    #[tokio::test]
11428    async fn a_deferred_landing_fix_keeps_its_round_for_resume() {
11429        let mut state = landing_state();
11430        state.config.graph.land_rounds = 1;
11431        let forge = Scripted::new(vec![seen("a", Checks::Green, "CLEAN", true)], vec![]);
11432        *forge.fix.lock().unwrap() = Some(Fixed::Deferred);
11433        let pr = land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11434        assert_eq!(pr.state, PrLifecycle::Open);
11435        assert_eq!(state.status, RunStatus::Blocked);
11436        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11437        assert!(
11438            state.merge_decision.is_none(),
11439            "no ordinary failure handoff"
11440        );
11441        assert!(forge.argvs().is_empty(), "no merge on outage");
11442
11443        let recovered = Scripted::new(
11444            vec![
11445                seen("a", Checks::Green, "CLEAN", true),
11446                seen("b", Checks::Green, "CLEAN", false),
11447            ],
11448            vec![(true, "")],
11449        );
11450        *recovered.fix.lock().unwrap() = Some(Fixed::Committed { head: "b".into() });
11451        land_with(&mut state, RERUN_PR, &recovered).await.unwrap();
11452        assert_eq!(state.status, RunStatus::Merged);
11453        assert_eq!(state.pr.as_ref().unwrap().round, 1);
11454        assert_eq!(recovered.calls().iter().filter(|c| **c == "fix").count(), 1);
11455    }
11456
11457    #[tokio::test]
11458    async fn the_last_fix_rounds_new_head_gets_its_rerun() {
11459        let mut state = landing_state();
11460        state.config.graph.land_rounds = 1;
11461        let forge = Scripted::new(
11462            vec![
11463                seen("a", Checks::Green, "CLEAN", true),
11464                red("b", Some("7")),
11465                seen("b", Checks::Green, "CLEAN", false),
11466            ],
11467            vec![(true, "")],
11468        );
11469        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
11470            head: "b".to_owned(),
11471        });
11472        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11473        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11474        assert_eq!(forge.calls().iter().filter(|c| **c == "fix").count(), 1);
11475        assert_eq!(state.pr.as_ref().unwrap().round, 1);
11476        assert_eq!(state.status, RunStatus::Merged);
11477        assert_eq!(state.land_reruns.as_ref().unwrap().head, "b");
11478        assert_eq!(
11479            value_of(&forge.argvs()[0], "--match-head-commit"),
11480            Some("b")
11481        );
11482    }
11483
11484    #[tokio::test]
11485    async fn a_failed_rerun_call_falls_through_to_the_fix_in_the_same_lap() {
11486        let mut state = landing_state();
11487        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11488        *forge.rerun_fails.lock().unwrap() = true;
11489        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11490        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11491        assert_eq!(forge.reruns.lock().unwrap().len(), 1, "never retried");
11492        assert_eq!(
11493            forge.calls().iter().filter(|c| **c == "fix").count(),
11494            1,
11495            "{:?}",
11496            forge.calls()
11497        );
11498    }
11499
11500    #[tokio::test]
11501    async fn a_saved_rerun_record_stops_a_restart_from_rerunning() {
11502        let mut state = landing_state();
11503        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11504        // The record was written just before the previous pass died.
11505        state.land_reruns = Some(reran("a", &[("7", *forge.clock.lock().unwrap())]));
11506        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11507        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11508        assert!(forge.reruns.lock().unwrap().is_empty());
11509    }
11510
11511    #[tokio::test]
11512    async fn the_switch_off_and_a_missing_run_id_go_straight_to_the_fixer() {
11513        let mut state = landing_state();
11514        state.config.graph.rerun_flaky_checks = false;
11515        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11516        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11517        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11518        assert!(forge.reruns.lock().unwrap().is_empty());
11519        assert!(forge.calls().contains(&"fix"));
11520
11521        let mut state = landing_state();
11522        let forge = Scripted::new(vec![red("a", None)], vec![]);
11523        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11524        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11525        assert!(forge.reruns.lock().unwrap().is_empty());
11526        assert!(forge.calls().contains(&"fix"));
11527    }
11528
11529    fn names(xs: &[&str]) -> BTreeSet<String> {
11530        xs.iter().map(|x| (*x).to_owned()).collect()
11531    }
11532
11533    #[test]
11534    fn a_required_check_the_rollup_never_listed_is_named() {
11535        let req = names(&["build"]);
11536        let why = waiting_on("BLOCKED", &[passing("review")], Some(&req));
11537        assert!(why.contains("never reported: build"), "{why}");
11538        assert!(!why.contains("probably waiting for a review"), "{why}");
11539    }
11540
11541    #[test]
11542    fn an_unreadable_required_list_is_not_read_as_a_review_wait() {
11543        let why = waiting_on("BLOCKED", &[passing("review")], None);
11544        assert!(why.contains("could not be read"), "{why}");
11545        assert!(!why.contains("probably waiting for a review"), "{why}");
11546    }
11547
11548    #[test]
11549    fn all_required_reported_keeps_the_review_guess() {
11550        let req = names(&["build"]);
11551        let why = waiting_on("BLOCKED", &[passing("build")], Some(&req));
11552        assert!(why.contains("probably waiting for a review"), "{why}");
11553        assert!(!why.contains("never reported"), "{why}");
11554    }
11555
11556    #[test]
11557    fn required_names_match_the_rollup_ignoring_case_only() {
11558        let req = names(&["Build"]);
11559        let why = waiting_on("BLOCKED", &[passing("build")], Some(&req));
11560        assert!(!why.contains("never reported"), "{why}");
11561    }
11562
11563    #[test]
11564    fn required_contexts_are_read_from_protection_and_rulesets() {
11565        let classic = r#"{"contexts":["build"],"checks":[{"context":"lint","app_id":1}]}"#;
11566        assert_eq!(
11567            parse_classic_required(classic),
11568            Some(names(&["build", "lint"]))
11569        );
11570        let rules = r#"[{"type":"pull_request","parameters":{}},
11571            {"type":"required_status_checks","parameters":{"required_status_checks":[{"context":"test"}]}}]"#;
11572        assert_eq!(parse_ruleset_required(rules), Some(names(&["test"])));
11573        assert_eq!(parse_ruleset_required("nope"), None);
11574        assert_eq!(encode_path_segment("release/1.x"), "release%2F1.x");
11575    }
11576
11577    #[test]
11578    fn the_direct_merge_guard_needs_the_approved_head_bound_to_its_checks() {
11579        let shown = BTreeSet::new();
11580        let ok = seen("a", Checks::Green, "CLEAN", false);
11581        let guard = |s: Option<&Seen>| {
11582            direct_merge_is_safe(
11583                s,
11584                "A",
11585                &shown,
11586                0,
11587                4,
11588                Duration::ZERO,
11589                CiExpectation::Expected,
11590            )
11591        };
11592        assert!(guard(Some(&ok)));
11593        assert!(!guard(None));
11594        assert!(!guard(Some(&seen("b", Checks::Green, "CLEAN", false))));
11595        let mut stale = ok.clone();
11596        stale.rollup_head = "old".to_owned();
11597        assert!(!guard(Some(&stale)));
11598        assert!(!guard(Some(&seen("a", Checks::Pending, "BLOCKED", false))));
11599        assert!(!guard(Some(&merged_view("a"))));
11600    }
11601
11602    #[test]
11603    fn the_rollup_node_carries_whether_each_check_is_required() {
11604        let node = node_json("new", "SUCCESS", false)
11605            .replace(r#""name":"ci","#, r#""name":"ci","isRequired":true,"#);
11606        let s = seen_from(&view_json("new"), Some(&node)).unwrap();
11607        assert_eq!(s.contexts.len(), 1);
11608        assert_eq!(s.contexts[0].required, Some(true));
11609        let s = seen_from(&view_json("new"), Some(&node_json("new", "SUCCESS", false))).unwrap();
11610        assert_eq!(s.contexts[0].required, None);
11611    }
11612
11613    #[tokio::test]
11614    async fn a_resume_that_cannot_disable_a_recorded_arm_stops_and_keeps_the_record() {
11615        let mut state = landing_state();
11616        state.land_armed_head = Some("a".to_owned());
11617        let forge = Scripted::new(
11618            vec![seen("a", Checks::Green, "CLEAN", true)],
11619            vec![(false, "disable exploded")],
11620        );
11621        land_with(&mut state, URL, &forge).await.unwrap();
11622        assert!(!forge.calls().contains(&"fix"));
11623        assert_eq!(state.status, RunStatus::Blocked);
11624        assert_eq!(state.land_armed_head.as_deref(), Some("a"));
11625        let why = state.merge.as_ref().unwrap().detail.clone();
11626        assert!(why.contains("disable exploded"), "{why}");
11627    }
11628}