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) => target,
4001        // Older records lack the target checkpoint, but Git retains the
4002        // exact target of an interrupted operation. It is a continuation too.
4003        None if git::rebase_in_progress(&scratch).await => {
4004            crate::rebase::rebase_target(&scratch).await?
4005        }
4006        None => {
4007            anyhow::ensure!(
4008                state.land_sync_attempts < state.config.graph.land_rounds,
4009                "landing base synchronization budget exhausted"
4010            );
4011            let target = git::rev_parse(&state.repo, onto).await?;
4012            state.land_sync_attempts += 1;
4013            state.land_sync_target = Some(target.clone());
4014            target
4015        }
4016    };
4017    state.land_sync_target = Some(target.clone());
4018    state.land_sync_pending = true;
4019    state.land_rebase_from = Some(git::rev_parse(&winner.worktree, "HEAD").await?);
4020    state.save()?;
4021    // A continuation owns the attempt already charged above, including a
4022    // crash before the scratch rebase started. Finish its pinned base first;
4023    // a newer base must use another attempt on the next observation.
4024    let result = crate::rebase::rebase_with_fixer(state, &scratch, &winner.branch, &target).await?;
4025    state.land_sync_target = None;
4026    state.save()?;
4027    if result == crate::rebase::Rebased::Applied {
4028        restore_landing_worktree(state).await?;
4029    }
4030    Ok(result)
4031}
4032
4033/// Reconcile a stopped landing before changing its branch. This also handles
4034/// old records whose graph status or merge detail no longer identifies land.
4035async fn resume_landing_head<F: Forge>(
4036    state: &mut RunState,
4037    observed: &str,
4038    pr_url: &str,
4039    forge: &F,
4040    reason: Option<Blocking>,
4041) -> Result<String> {
4042    crate::pr_head::ensure_owner(state)?;
4043    let winner = state.winner().cloned().context("landing has no winner")?;
4044    let local = git::rev_parse(&winner.worktree, "HEAD").await?;
4045    let expected = state
4046        .pr_pushed_head
4047        .as_deref()
4048        .or(state.gate_head.as_deref())
4049        .context("missing public head lease")?;
4050    anyhow::ensure!(
4051        observed == expected
4052            || (observed == local
4053                && ((state.gate_head.as_deref() == Some(&local) && state.gate_allows_progress())
4054                    || git::is_ancestor(&winner.worktree, expected, &local).await)),
4055        "public head moved outside this run; refusing to sync"
4056    );
4057    // An operator may have extended and published the winner while approval
4058    // was pending. Matching local/public history can be adopted as the lease,
4059    // but publish_landing_head must gate its new SHA before proceeding. A
4060    // remote-only or divergent update still cannot be overwritten.
4061    // Save reconciliation before rebasing again; a prior push may have reached
4062    // the remote immediately before the previous driver's last save.
4063    state.pr_pushed_head = Some(observed.to_owned());
4064    state.save()?;
4065    restore_landing_worktree(state).await?;
4066    // Recover a rebase that finished before its completion checkpoint was
4067    // saved. Restoration above has already reconciled its files and ancestry.
4068    if let Some(target) = &state.land_sync_target
4069        && !git::rebase_in_progress(&state.dir().join("rebase")).await
4070        && git::ancestry(&winner.worktree, target, &local).await?
4071    {
4072        state.land_sync_target = None;
4073        state.save()?;
4074    }
4075    let remote = state.config.merge.remote.clone();
4076    let base = state.base_branch.clone();
4077    let fetched = git::fetch(&state.repo, &remote, &base).await?;
4078    anyhow::ensure!(
4079        fetched.ok(),
4080        "cannot fetch landing base: {}",
4081        fetched.stderr
4082    );
4083    anyhow::ensure!(
4084        !owner_requested_stop(state)?,
4085        "owner requested stop before base synchronization"
4086    );
4087    let onto = format!("{remote}/{base}");
4088    let tip = git::rev_parse(&state.repo, &onto).await?;
4089    let contains_base = git::ancestry(&state.repo, &tip, &local)
4090        .await
4091        .context("could not determine whether the landing head contains the fetched base")?;
4092    anyhow::ensure!(
4093        reason != Some(Blocking::Behind) || !contains_base,
4094        "BEHIND reported but the fetched base is already included; synchronization made no progress"
4095    );
4096    if !contains_base || reason == Some(Blocking::Conflict) {
4097        match rebase_landing_worktree(state, &onto).await? {
4098            crate::rebase::Rebased::Applied => {}
4099            crate::rebase::Rebased::Stopped(why) => bail!("landing rebase stopped: {why}"),
4100        }
4101    }
4102    if reason == Some(Blocking::Behind) {
4103        anyhow::ensure!(
4104            git::rev_parse(&winner.worktree, "HEAD").await? != local,
4105            "BEHIND synchronization left the head unchanged"
4106        );
4107    }
4108    publish_landing_head(state, observed, pr_url, forge).await
4109}
4110
4111/// Share the synchronization path with structured evidence retained after a refusal.
4112async fn synchronize_landing<F: Forge>(
4113    state: &mut RunState,
4114    pr: &mut PrState,
4115    observed: &str,
4116    pr_url: &str,
4117    forge: &F,
4118) -> Result<Option<String>> {
4119    if owner_stop(state, pr, forge).await? {
4120        return Ok(None);
4121    }
4122    state.event(
4123        "land",
4124        format!("{} base synchronization: {:?}", pr.url, pr.blocking),
4125    );
4126    state.save()?;
4127    let synced = resume_landing_head(state, observed, pr_url, forge, Some(pr.blocking)).await;
4128    if owner_stop(state, pr, forge).await? {
4129        return Ok(None);
4130    }
4131    match synced {
4132        Ok(head) => {
4133            if let Some(branch) = state.winner().map(|w| w.branch.clone()) {
4134                crate::graph::refresh_reviewed_commits(state, &branch).await;
4135            }
4136            Ok(Some(head))
4137        }
4138        Err(e) if e.is::<crate::repo_lock::ResourceBlocked>() => Err(e),
4139        Err(e) => {
4140            let repo = state.repo.clone();
4141            stop(
4142                state,
4143                &repo,
4144                pr,
4145                &format!("could not synchronize landing base: {e:#}"),
4146            )
4147            .await?;
4148            Ok(None)
4149        }
4150    }
4151}
4152
4153async fn land_with<F: Forge>(state: &mut RunState, pr_url: &str, forge: &F) -> Result<PrState> {
4154    crate::pr_head::ensure_owner(state)?;
4155    state.land_unrelated = None;
4156    let reopening_hold = crate::merge_decision::resumable_hold(state);
4157    let repo = state.repo.clone();
4158    let budget = state.config.graph.land_rounds;
4159    let mut round = 0usize;
4160    let ci = state.config.merge.ci.expectation();
4161    if ci == CiExpectation::Absent {
4162        state.event(
4163            "land",
4164            "CI not expected ([merge] ci = \"none\"); check status ignored",
4165        );
4166    }
4167    let mut waited = Duration::ZERO;
4168    // Comment bodies the fixer has already been shown. A comment is
4169    // outstanding until it has been handed over once; after that it is a
4170    // recorded decision, not an open question, and re-feeding it would loop the
4171    // budget away on a comment the fixer already declined with an argument.
4172    let mut shown: BTreeSet<String> = BTreeSet::new();
4173    // Await the last successfully published head, including across resumes.
4174    let mut awaiting_head: Option<String> = state.pr_pushed_head.clone();
4175    // Whether a settled-checks refusal has already been given its one re-look.
4176    let mut rechecked = false;
4177
4178    // Marks the run resumable through exactly this function, not through a
4179    // fresh competition: `RunStatus::resumable` excludes only `Merged`,
4180    // `Ready` and `Failed`, and `merge`'s own re-entry guard looks for this
4181    // status specifically to know a resumed run belongs back in `land`
4182    // rather than at a second `gh pr create`. Set on every entry - fresh or
4183    // resumed - because a resume that parked here again must keep reading
4184    // `Landing`, not whatever a first pass through `merge` left behind.
4185    state.status = RunStatus::Landing;
4186    state.event("land", format!("watching {pr_url}"));
4187    state.save()?;
4188
4189    // An armed merge recorded by an earlier pass may or may not have reached
4190    // the forge (the record is written before the call). It is taken back on
4191    // the first observation, where a pull request is known to stop with.
4192    let mut resumed_armed = state.land_armed_head.is_some();
4193
4194    'landing: loop {
4195        let seen = forge.view(&repo, pr_url).await?;
4196        let mut pr = seen.pr.clone();
4197        pr.review_comments.retain(|c| !shown.contains(&c.body));
4198        state.pr = Some(crate::run::PrRecord {
4199            url: pr.url.clone(),
4200            number: pr.number,
4201            state: pr.state.as_str().to_owned(),
4202            checks: pr.checks.as_str().to_owned(),
4203            round,
4204            rounds: budget,
4205            red_at_merge: Vec::new(),
4206        });
4207        state.save()?;
4208
4209        if pr.state == PrLifecycle::Open {
4210            state.observe_branch_owner_holds(&seen.head).await;
4211            state.save()?;
4212        }
4213        crate::pr_head::ensure_owner(state)?;
4214        if reopening_hold {
4215            anyhow::ensure!(
4216                pr.state == PrLifecycle::Open,
4217                "held PR is no longer open; cannot request a fresh decision"
4218            );
4219            // An explicit resume authorizes a fresh question only. Preserve the
4220            // answered card, and never enter repair/rebase/merge on this pass.
4221            disarm(forge, state, &repo, pr.number)
4222                .await
4223                .map_err(anyhow::Error::msg)?;
4224            let previous = state.merge_decision.take();
4225            let binding = state.land_approval.take();
4226            state.config.graph.land_approval = true;
4227            let subject = merge_subject(
4228                crate::graph::landing_title(state, &seen.title),
4229                &crate::graph::landing_subject_source(state),
4230            );
4231            let contested = contested_to_ask(state);
4232            if let Err(error) =
4233                approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head).await
4234            {
4235                state.merge_decision = previous;
4236                state.land_approval = binding;
4237                return Err(error);
4238            }
4239            state.end_pass_parked(crate::run::ParkCause::Question);
4240            state.parked = true;
4241            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()));
4242            state.save()?;
4243            return Ok(pr);
4244        }
4245        if owner_stop(state, &mut pr, forge).await? {
4246            return Ok(pr);
4247        }
4248
4249        if std::mem::take(&mut resumed_armed) && pr.state == PrLifecycle::Open {
4250            // An approval already given for the same head is reused, so
4251            // nothing is asked twice. A failed disable
4252            // stops the run with the record kept: pushing on could change the
4253            // head under an arm that is still live.
4254            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4255                let why = format!(
4256                    "a previous pass may have armed auto-merge and it could not be disabled \
4257                     on resume: {e}"
4258                );
4259                stop(state, &repo, &pr, &why).await?;
4260                return Ok(pr);
4261            }
4262        }
4263
4264        // The head moved away from the one auto-merge was armed on, by
4265        // someone other than this loop. The arm is pinned and would refuse to
4266        // merge the new commit, but the approval was for the old one: take it
4267        // back and go through the normal path again.
4268        if pr.state == PrLifecycle::Open
4269            && !seen.head.is_empty()
4270            && state
4271                .land_armed_head
4272                .as_deref()
4273                .is_some_and(|armed| !armed.eq_ignore_ascii_case(&seen.head))
4274        {
4275            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4276                let why = format!(
4277                    "the head moved while auto-merge was armed and it could not be disabled: {e}"
4278                );
4279                stop(state, &repo, &pr, &why).await?;
4280                return Ok(pr);
4281            }
4282        }
4283
4284        if state.land_sync_pending && pr.state == PrLifecycle::Open {
4285            // Disarming can outlive an owner answer. Consume it before our
4286            // own rebase invalidates the head shown on the decision card.
4287            if owner_stop(state, &mut pr, forge).await? {
4288                return Ok(pr);
4289            }
4290            let repair_answer = state.land_approval.as_ref().is_some_and(|binding| {
4291                binding.head.eq_ignore_ascii_case(&seen.head)
4292                    && ask::Questions::open()
4293                        .get_for_effects(&binding.question)
4294                        .is_ok_and(|q| {
4295                            q.run == state.id
4296                                && q.node == APPROVAL_NODE
4297                                && q.status == ask::QuestionStatus::Answered
4298                                && matches!(approval(q.resolution().as_deref()), Approval::Repair)
4299                        })
4300            });
4301            if repair_answer {
4302                let subject = merge_subject(
4303                    crate::graph::landing_title(state, &seen.title),
4304                    &crate::graph::landing_subject_source(state),
4305                );
4306                let contested = contested_to_ask(state);
4307                if matches!(
4308                    approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head).await?,
4309                    ApprovalGate::Repair
4310                ) {
4311                    if let Err(why) = disarm(forge, state, &repo, pr.number).await {
4312                        state.event("repair", format!("auto-merge could not be disabled: {why}; repair preflight will retry"));
4313                        state.save()?;
4314                    }
4315                    return Ok(pr);
4316                }
4317            }
4318            let synced = resume_landing_head(state, &seen.head, pr_url, forge, None).await;
4319            // A stop detected before publication must apply its durable
4320            // decision, even when verification returned an error meanwhile.
4321            if owner_stop(state, &mut pr, forge).await? {
4322                return Ok(pr);
4323            }
4324            let head = synced?;
4325            awaiting_head = Some(head);
4326            waited = Duration::ZERO;
4327            rechecked = false;
4328            // Read CI and approvals afresh, never from the pre-push observation.
4329            continue;
4330        }
4331
4332        // A stale base is independent of the CI rollup. Keep the public-head
4333        // lease, but synchronize before waiting for checks on the old tree.
4334        if pr.state == PrLifecycle::Open
4335            && pr.blocking == Blocking::Behind
4336            && bound_head(&seen.head, &seen.head, awaiting_head.as_deref()).is_some()
4337        {
4338            let synced = synchronize_landing(state, &mut pr, &seen.head, pr_url, forge).await?;
4339            let Some(head) = synced else {
4340                return Ok(pr);
4341            };
4342            awaiting_head = Some(head);
4343            rechecked = false;
4344            waited = Duration::ZERO;
4345            continue;
4346        }
4347
4348        if pr.state == PrLifecycle::Open {
4349            if bound_head(&seen.head, &seen.rollup_head, awaiting_head.as_deref()).is_none() {
4350                if waited >= WAIT_CEILING {
4351                    let want = awaiting_head.as_deref().unwrap_or_default();
4352                    let why = format!(
4353                        "the pull request's checks were still not about one readable head after \
4354                         {} minutes (expected {}, pull request points at {}, checks are for {}); \
4355                         someone may have pushed over it",
4356                        WAIT_CEILING.as_secs() / 60,
4357                        if want.is_empty() { "any" } else { want },
4358                        if seen.head.is_empty() {
4359                            "nothing readable"
4360                        } else {
4361                            &seen.head
4362                        },
4363                        if seen.rollup_head.is_empty() {
4364                            "nothing readable"
4365                        } else {
4366                            &seen.rollup_head
4367                        },
4368                    );
4369                    stop_disarmed(forge, state, &repo, &pr, &why).await?;
4370                    return Ok(pr);
4371                }
4372                waited += POLL;
4373                forge.poll().await;
4374                continue;
4375            }
4376            // Reset once, when the awaited head first shows up; resetting on
4377            // every re-observation would let a standing refusal wait forever.
4378            if awaiting_head.take().is_some() {
4379                // The checks now being read belong to the new head; give them
4380                // the same grace a fresh pull request gets.
4381                waited = Duration::ZERO;
4382            }
4383        }
4384
4385        // The merge-state grace is head-bound and durable. Reruns reset the
4386        // checks clock, but must not extend this deadline across resumes.
4387        let decision_wait = if pr.checks == Checks::Red && pr.blocking == Blocking::Unsaid {
4388            let first = state
4389                .land_unsaid
4390                .get_or_insert_with(|| (seen.head.clone(), forge.now()));
4391            if !first.0.eq_ignore_ascii_case(&seen.head) {
4392                *first = (seen.head.clone(), forge.now());
4393            }
4394            let elapsed = Duration::from_secs(forge.now().saturating_sub(first.1).max(0) as u64);
4395            state.save()?;
4396            elapsed
4397        } else {
4398            waited
4399        };
4400        let proposed = decide_with(&pr, round, budget, decision_wait, ci);
4401        if pr.checks == Checks::Red && pr.blocking == Blocking::Unsaid && proposed == Step::Wait {
4402            if waited >= WAIT_CEILING {
4403                stop_disarmed(
4404                    forge,
4405                    state,
4406                    &repo,
4407                    &pr,
4408                    "merge state remained unreadable; refusing to merge on a guess",
4409                )
4410                .await?;
4411                return Ok(pr);
4412            }
4413            waited += POLL;
4414            forge.poll().await;
4415            continue;
4416        }
4417
4418        // A failed workflow run is rerun once, judged by its own run rather
4419        // than by the rollup's aggregate: another run still pending, or a fix
4420        // budget already spent, must not keep a flaky failure from its one
4421        // rerun. It spends no round and no attempt.
4422        if ci == CiExpectation::Expected
4423            && pr.state == PrLifecycle::Open
4424            && state.config.graph.rerun_flaky_checks
4425        {
4426            let include_optional = pr.checks == Checks::Red
4427                && matches!(proposed, Step::Fix { .. } | Step::GiveUp { .. });
4428            let failing = rerunnable_with(&seen.contexts, include_optional);
4429            let now = forge.now();
4430            match rerun_step(&failing, state.land_reruns.as_ref(), &seen.head, now) {
4431                RerunStep::Rerun(runs) => {
4432                    let rec = state.land_reruns.get_or_insert_with(Default::default);
4433                    if !rec.head.eq_ignore_ascii_case(&seen.head) {
4434                        *rec = LandReruns {
4435                            head: seen.head.clone(),
4436                            runs: BTreeMap::new(),
4437                        };
4438                    }
4439                    for run in &runs {
4440                        rec.runs.insert(run.clone(), now);
4441                    }
4442                    // Durable before the call: a restart must not
4443                    // rerun the same run twice. A save that fails
4444                    // means no rerun.
4445                    state.save()?;
4446                    let mut any = false;
4447                    for run in &runs {
4448                        let names = failing
4449                            .iter()
4450                            .filter(|(_, r)| r.as_deref() == Some(run))
4451                            .map(|(l, _)| l.as_str())
4452                            .collect::<Vec<_>>()
4453                            .join(", ");
4454                        match forge.rerun(&repo, run).await {
4455                            Ok(()) => {
4456                                any = true;
4457                                state.event(
4458                                    "land",
4459                                    format!("reran failed check(s) {names} (run {run})"),
4460                                );
4461                            }
4462                            // Stays recorded: never a retry loop.
4463                            Err(e) => state.event(
4464                                "land",
4465                                format!("could not rerun check(s) {names} (run {run}): {e:#}"),
4466                            ),
4467                        }
4468                    }
4469                    state.save()?;
4470                    if any {
4471                        waited = Duration::ZERO;
4472                        forge.poll().await;
4473                        continue;
4474                    }
4475                }
4476                RerunStep::Grace => {
4477                    if waited >= WAIT_CEILING {
4478                        let why = format!(
4479                            "checks were still failing after a rerun and {} minutes",
4480                            WAIT_CEILING.as_secs() / 60
4481                        );
4482                        stop(state, &repo, &pr, &why).await?;
4483                        return Ok(pr);
4484                    }
4485                    waited += POLL;
4486                    forge.poll().await;
4487                    continue;
4488                }
4489                RerunStep::Fix => {}
4490            }
4491        }
4492
4493        let step = proposed;
4494        // Armed on exactly this head: the forge is doing the waiting. A
4495        // decision to merge (or keep waiting) is only watched, never re-armed
4496        // and never re-approved; anything else - a red check, a comment, a
4497        // conflict - falls through to its own arm, which disarms first.
4498        let armed_here = state
4499            .land_armed_head
4500            .as_deref()
4501            .is_some_and(|armed| armed.eq_ignore_ascii_case(&seen.head));
4502        if armed_here && matches!(step, Step::Merge | Step::Wait) {
4503            if waited >= WAIT_CEILING {
4504                let required = if seen.base.is_empty() {
4505                    None
4506                } else {
4507                    forge.required_contexts(&repo, &seen.base).await
4508                };
4509                let why = format!(
4510                    "auto-merge was armed on {} but the pull request did not merge within {} \
4511                     minutes ({})",
4512                    seen.head,
4513                    WAIT_CEILING.as_secs() / 60,
4514                    waiting_on(&seen.merge_state, &seen.contexts, required.as_ref())
4515                );
4516                stop_disarmed(forge, state, &repo, &pr, &why).await?;
4517                return Ok(pr);
4518            }
4519            waited += POLL;
4520            forge.poll().await;
4521            continue;
4522        }
4523        if armed_here && !matches!(step, Step::Done { .. }) {
4524            // Not merging or waiting any more: whatever is next may change the
4525            // head or give up, and neither may leave the arm standing.
4526            if let Err(e) = disarm(forge, state, &repo, pr.number).await {
4527                let why = format!("auto-merge could not be disabled: {e}");
4528                stop(state, &repo, &pr, &why).await?;
4529                return Ok(pr);
4530            }
4531        }
4532        if pr.checks == Checks::Red
4533            && matches!(step, Step::Fix { .. } | Step::GiveUp { .. })
4534            && pr.review_comments.is_empty()
4535            && let Some(evidence) = forge.attribution(state, &seen).await
4536            && evidence.unrelated(&seen.head, &pr.failing)
4537        {
4538            if owner_stop(state, &mut pr, forge).await? {
4539                return Ok(pr);
4540            }
4541            // Attribution does not authorize action against an unseen push.
4542            let fresh = forge.view(&repo, pr_url).await?;
4543            if fresh.head != seen.head
4544                || fresh.rollup_head != seen.rollup_head
4545                || fresh.pr.state != PrLifecycle::Open
4546                || fresh.pr.checks != Checks::Red
4547                || fresh.pr.failing != pr.failing
4548                || fresh
4549                    .pr
4550                    .review_comments
4551                    .iter()
4552                    .any(|c| !shown.contains(&c.body))
4553            {
4554                continue;
4555            }
4556            hold_unrelated(state, &pr, evidence).await?;
4557            return Ok(pr);
4558        }
4559        match step {
4560            Step::Wait => {
4561                if waited >= WAIT_CEILING {
4562                    let why = format!(
4563                        "checks were still running after {} minutes",
4564                        WAIT_CEILING.as_secs() / 60
4565                    );
4566                    stop(state, &repo, &pr, &why).await?;
4567                    return Ok(pr);
4568                }
4569                waited += POLL;
4570                forge.poll().await;
4571            }
4572            Step::Done { merged } => {
4573                if merged {
4574                    state.pr_merged_head = (!seen.head.is_empty()).then(|| seen.head.clone());
4575                }
4576                // Auto-merge is pinned to the approved head, but the forge's
4577                // own handling of a later push is not something magi can
4578                // see: if the pull request merged on another commit, say so
4579                // loudly rather than record a clean landing.
4580                if let Some(armed) = state.land_armed_head.take() {
4581                    if merged && !seen.head.is_empty() && !armed.eq_ignore_ascii_case(&seen.head) {
4582                        let msg = format!(
4583                            "{} merged on {} but the owner approved {armed}; review what landed",
4584                            pr.url, seen.head
4585                        );
4586                        tracing::warn!("{msg}");
4587                        state.event("land", msg);
4588                        // Only an arm left by an older build can get here.
4589                        // The wording is fixed so a repeat does not relight
4590                        // the notice.
4591                        crate::notices::raise_with(
4592                            crate::notices::Notice::warn(
4593                                &format!("merged-unapproved-head:{}", state.id),
4594                                "A pull request merged on a commit the owner did not approve; \
4595                                 review what landed",
4596                            )
4597                            .link(crate::notices::Link::Run {
4598                                id: state.id.clone(),
4599                            }),
4600                            &state.config.notify,
4601                        );
4602                    }
4603                }
4604                state.status = if merged {
4605                    RunStatus::Merged
4606                } else {
4607                    RunStatus::Ready
4608                };
4609                let detail = if merged {
4610                    format!("{} was merged", pr.url)
4611                } else {
4612                    format!("{} was closed without merging", pr.url)
4613                };
4614                state.merge = Some(MergeOutcome {
4615                    mode: MergeMode::Pr,
4616                    ok: merged,
4617                    detail: detail.clone(),
4618                    empty: false,
4619                });
4620                state.event("land", detail);
4621                state.save()?;
4622                write_pr_state_through(state, pr.state);
4623                return Ok(pr);
4624            }
4625            Step::Merge => {
4626                state.check_delivery_evidence(&seen.head)?;
4627                let subject = merge_subject(
4628                    crate::graph::landing_title(state, &seen.title),
4629                    &crate::graph::landing_subject_source(state),
4630                );
4631                // The owner sees the panel before the one irreversible step,
4632                // and an unanswered question is a hold: silence never merges.
4633                //
4634                // The dedicated policy includes existing consent and post-repair
4635                // decisions; repair choice availability never grants merge authority.
4636                let contested = contested_to_ask(state);
4637                if !approval_reasons(state).is_empty() {
4638                    match approval_gate(state, &pr, &subject, contested.as_ref(), &seen.head)
4639                        .await?
4640                    {
4641                        ApprovalGate::Approved => {}
4642                        ApprovalGate::Repair => {
4643                            // The driver consumes the saved request under the existing
4644                            // run/task claim. No merge, no second run or task.
4645                            if let Err(why) = disarm(forge, state, &repo, pr.number).await {
4646                                state.event("repair", format!("auto-merge could not be disabled: {why}; repair preflight will retry"));
4647                                state.save()?;
4648                            }
4649                            return Ok(pr);
4650                        }
4651                        ApprovalGate::Held => {
4652                            // Another entry point may have saved a stop after
4653                            // the first read above. Apply its durable action.
4654                            if owner_stop(state, &mut pr, forge).await? {
4655                                return Ok(pr);
4656                            }
4657                            stop(
4658                                state,
4659                                &repo,
4660                                &pr,
4661                                "the owner did not approve the merge (held or unanswered)",
4662                            )
4663                            .await?;
4664                            return Ok(pr);
4665                        }
4666                        // Filed (or still standing from an earlier visit) and
4667                        // not yet answered. Park here rather than wait: the
4668                        // question survives on disk, the daemon hands this
4669                        // run's slot to something else, and a later resume
4670                        // re-enters `land`, finds the same question, and
4671                        // either merges or stops depending on what it says
4672                        // by then.
4673                        ApprovalGate::Pending => {
4674                            state.end_pass_parked(crate::run::ParkCause::Question);
4675                            state.parked = true;
4676                            state.event(
4677                                "land",
4678                                "parked awaiting merge approval - resumes once answered",
4679                            );
4680                            state.save()?;
4681                            return Ok(pr);
4682                        }
4683                    }
4684                }
4685                // Open and past the gate above, so `seen.head` is the commit
4686                // the checks were bound to and the owner approved.
4687                //
4688                // Merge directly, bound to that commit. Auto-merge is not
4689                // armed any more: the forge checks `--match-head-commit` only
4690                // when the request is made, so an arm outlives the head it
4691                // was made for, and a push of another commit whose
4692                // requirements are met first would merge without approval.
4693                // A direct merge is checked by the forge at the moment it
4694                // happens, so only the approved head can land.
4695                let observed_head = seen.head.clone();
4696                // Read the pull request again just before: the state seen
4697                // above can be a moment old.
4698                {
4699                    let fresh = forge.view(&repo, pr_url).await.ok();
4700                    if fresh.as_ref().is_some_and(|current| {
4701                        current.pr.state == PrLifecycle::Open
4702                            && current.head.eq_ignore_ascii_case(&observed_head)
4703                            && Blocking::of(&current.merge_state) == Blocking::Behind
4704                    }) {
4705                        pr.blocking = Blocking::Behind;
4706                        let synced =
4707                            synchronize_landing(state, &mut pr, &observed_head, pr_url, forge)
4708                                .await?;
4709                        let Some(head) = synced else {
4710                            return Ok(pr);
4711                        };
4712                        awaiting_head = Some(head);
4713                        rechecked = false;
4714                        waited = Duration::ZERO;
4715                        continue 'landing;
4716                    }
4717                    if !direct_merge_is_safe(
4718                        fresh.as_ref(),
4719                        &observed_head,
4720                        &shown,
4721                        round,
4722                        budget,
4723                        waited,
4724                        ci,
4725                    ) {
4726                        if waited >= WAIT_CEILING {
4727                            let why = "the pull request did not settle on the approved head \
4728                                       before it could be merged";
4729                            stop(state, &repo, &pr, why).await?;
4730                            return Ok(pr);
4731                        }
4732                        state.event(
4733                            "land",
4734                            "the pull request changed before merging; looking again",
4735                        );
4736                        waited += POLL;
4737                        forge.poll().await;
4738                        continue;
4739                    }
4740                }
4741                let argv = merge_argv_at(pr.number, &subject, &observed_head);
4742                let out = {
4743                    let merge_lock = repo_merge_lock(&repo);
4744                    let _merge_slot = merge_lock.lock().await;
4745                    crate::pr_head::ensure_owner(state)?;
4746                    if let Some(task_id) = state
4747                        .origin
4748                        .as_ref()
4749                        .and_then(|origin| origin.task.as_ref())
4750                    {
4751                        let task = crate::queue::Queue::open()
4752                            .get(task_id)
4753                            .context("cannot verify the task owner immediately before merge")?;
4754                        if task.execution_runs().last() != Some(&state.id)
4755                            || task.operator_held()
4756                            || task.status == crate::queue::TaskStatus::Done
4757                        {
4758                            bail!(
4759                                "task ownership or an operator hold superseded this merge approval"
4760                            );
4761                        }
4762                    }
4763                    if let Some(binding) = &state.land_approval {
4764                        let current = ask::Questions::open().get_for_effects(&binding.question)?;
4765                        if merge_consent_superseded(state, &current)?
4766                            || current.run != state.id
4767                            || !binding.head.eq_ignore_ascii_case(&observed_head)
4768                            || approval(current.resolution().as_deref()) != Approval::Merge
4769                            || current.merge_target.as_ref().is_some_and(|t| {
4770                                t.pr != pr.url || !t.head.eq_ignore_ascii_case(&observed_head)
4771                            })
4772                        {
4773                            bail!(
4774                                "merge decision is stale or no longer authorizes the reviewed head"
4775                            );
4776                        }
4777                    }
4778                    forge.merge(&repo, &argv).await?
4779                };
4780                if out.0 {
4781                    // Exit 0 is not proof of a merge: with a merge queue `gh`
4782                    // enqueues (or reports the pull request already queued)
4783                    // and succeeds while it is still open. Ask the forge; an
4784                    // unreadable answer is not a confirmation either, so it
4785                    // is looked at again rather than recorded as merged.
4786                    let confirmed = forge.view(&repo, pr_url).await.is_ok_and(|c| {
4787                        if c.pr.state == PrLifecycle::Merged {
4788                            state.pr_merged_head = (!c.head.is_empty()).then_some(c.head);
4789                            true
4790                        } else {
4791                            false
4792                        }
4793                    });
4794                    if !confirmed {
4795                        if waited >= WAIT_CEILING {
4796                            let why = "the merge request succeeded but the pull request \
4797                                       could not be confirmed merged after waiting";
4798                            stop(state, &repo, &pr, why).await?;
4799                            return Ok(pr);
4800                        }
4801                        state.event(
4802                            "land",
4803                            "merge accepted but the pull request is not confirmed merged yet; waiting",
4804                        );
4805                        state.save()?;
4806                        waited += POLL;
4807                        forge.poll().await;
4808                        continue;
4809                    }
4810                    pr.state = PrLifecycle::Merged;
4811                    state.status = RunStatus::Merged;
4812                    state.merge = Some(MergeOutcome {
4813                        mode: MergeMode::Pr,
4814                        ok: true,
4815                        detail: format!("gh {}", argv.join(" ")),
4816                        empty: false,
4817                    });
4818                    // The last `state.pr` snapshot is whatever the poll before
4819                    // this merge observed - still `open` - and nothing below
4820                    // refreshes it from GitHub again, so the UI's round rail
4821                    // would otherwise keep animating a merged run forever.
4822                    if let Some(pr_record) = state.pr.as_mut() {
4823                        pr_record.state = pr.state.as_str().to_owned();
4824                    }
4825                    state.event("land", format!("merged {} as `{subject}`", pr.url));
4826                    announce_red_merge(state, &pr).await;
4827                    state.save()?;
4828                    write_pr_state_through(state, pr.state);
4829                    return Ok(pr);
4830                }
4831                let after_seen = forge.view(&repo, pr_url).await.ok();
4832                let after = after_seen.as_ref().map(|s| s.pr.state);
4833                if let Some(outcome) = merged_after_all(&argv, &out.1, after) {
4834                    state.pr_merged_head = after_seen
4835                        .as_ref()
4836                        .map(|s| s.head.clone())
4837                        .filter(|h| !h.is_empty());
4838                    pr.state = PrLifecycle::Merged;
4839                    state.status = RunStatus::Merged;
4840                    state.merge = Some(outcome);
4841                    if let Some(pr_record) = state.pr.as_mut() {
4842                        pr_record.state = pr.state.as_str().to_owned();
4843                    }
4844                    state.event("land", format!("merged {} as `{subject}`", pr.url));
4845                    announce_red_merge(state, &pr).await;
4846                    state.save()?;
4847                    write_pr_state_through(state, pr.state);
4848                    return Ok(pr);
4849                }
4850                let verdict = classify_refusal(after_seen.as_ref(), rechecked, &observed_head, ci);
4851                match verdict {
4852                    Refused::Behind => {
4853                        pr.blocking = Blocking::Behind;
4854                        let synced =
4855                            synchronize_landing(state, &mut pr, &observed_head, pr_url, forge)
4856                                .await?;
4857                        let Some(head) = synced else {
4858                            return Ok(pr);
4859                        };
4860                        awaiting_head = Some(head);
4861                        rechecked = false;
4862                        waited = Duration::ZERO;
4863                        continue 'landing;
4864                    }
4865                    Refused::Final => {
4866                        let merge_state = after_seen
4867                            .as_ref()
4868                            .map(|s| s.merge_state.as_str())
4869                            .filter(|m| !m.is_empty())
4870                            .unwrap_or("unknown");
4871                        // Which refusal this was decides what a person has to
4872                        // do about it, so the two are worded apart; both carry
4873                        // the forge's own message.
4874                        let why = format!(
4875                            "the merge was refused: {} (merge state: {merge_state})",
4876                            out.1
4877                        );
4878                        stop(state, &repo, &pr, &why).await?;
4879                        return Ok(pr);
4880                    }
4881                    verdict => {
4882                        // Back to the top, which re-decides and passes the
4883                        // approval gate again, a poll later. `waited` is not
4884                        // reset here: only a pushed fix restarts it, or a
4885                        // standing refusal would wait forever.
4886                        if waited >= WAIT_CEILING {
4887                            let why = format!(
4888                                "the merge was still refused after {} minutes: {}",
4889                                WAIT_CEILING.as_secs() / 60,
4890                                out.1
4891                            );
4892                            stop(state, &repo, &pr, &why).await?;
4893                            return Ok(pr);
4894                        }
4895                        if verdict == Refused::Recheck {
4896                            rechecked = true;
4897                        }
4898                        state.event(
4899                            "land",
4900                            "merge refused while the branch policy is not satisfied yet; waiting",
4901                        );
4902                        state.save()?;
4903                        waited += POLL;
4904                        forge.poll().await;
4905                    }
4906                }
4907            }
4908            Step::Rebase => {
4909                let synced = synchronize_landing(state, &mut pr, &seen.head, pr_url, forge).await?;
4910                let Some(head) = synced else {
4911                    return Ok(pr);
4912                };
4913                awaiting_head = Some(head);
4914                rechecked = false;
4915                waited = Duration::ZERO;
4916                continue 'landing;
4917            }
4918            Step::GiveUp { reason } => {
4919                stop(state, &repo, &pr, &reason).await?;
4920                return Ok(pr);
4921            }
4922            Step::Fix { reason } => {
4923                round += 1;
4924                waited = Duration::ZERO;
4925                for c in &pr.review_comments {
4926                    shown.insert(c.body.clone());
4927                }
4928                state.event("land", format!("round {round}: {reason}"));
4929                state.save()?;
4930
4931                let logs = failing_logs(&repo, &seen.failing_urls).await;
4932                let was_red = pr.checks == Checks::Red;
4933                if owner_stop(state, &mut pr, forge).await? {
4934                    return Ok(pr);
4935                }
4936                let fixed = forge.fix(state, &pr, round, budget, &reason, &logs).await?;
4937                if owner_stop(state, &mut pr, forge).await? {
4938                    return Ok(pr);
4939                }
4940                match fixed {
4941                    Fixed::Committed { head } => {
4942                        // Whatever the next look shows may still be the
4943                        // previous head; see `awaiting_new_head`.
4944                        state.pr_pushed_head = Some(head.clone());
4945                        awaiting_head = Some(head);
4946                        rechecked = false;
4947                        waited = Duration::ZERO;
4948                        forge.poll().await;
4949                    }
4950                    Fixed::Declined if was_red => {
4951                        // Review comments may have required this round even
4952                        // when CI was unrelated. Once the fixer has read them,
4953                        // use the same structural attribution before charging
4954                        // a no-commit stop to the task.
4955                        if let Some(evidence) = forge.attribution(state, &seen).await
4956                            && evidence.unrelated(&seen.head, &pr.failing)
4957                        {
4958                            let fresh = forge.view(&repo, pr_url).await?;
4959                            if fresh.head != seen.head
4960                                || fresh.rollup_head != seen.rollup_head
4961                                || fresh.pr.state != PrLifecycle::Open
4962                                || fresh.pr.checks != Checks::Red
4963                                || fresh.pr.failing != pr.failing
4964                                || fresh
4965                                    .pr
4966                                    .review_comments
4967                                    .iter()
4968                                    .any(|c| !shown.contains(&c.body))
4969                            {
4970                                continue;
4971                            }
4972                            if owner_stop(state, &mut pr, forge).await? {
4973                                return Ok(pr);
4974                            }
4975                            hold_unrelated(state, &pr, evidence).await?;
4976                            return Ok(pr);
4977                        }
4978                        let why = format!(
4979                            "the fixer produced no commit while {} check(s) were failing \
4980                             ({}); stopping instead of looping on an unchanged tree",
4981                            pr.failing.len(),
4982                            pr.failing.join(", ")
4983                        );
4984                        stop(state, &repo, &pr, &why).await?;
4985                        return Ok(pr);
4986                    }
4987                    // Comment-driven round with no commit: the fixer read the
4988                    // comments and changed nothing, which is a decision it is
4989                    // allowed to make. The comments are recorded as shown, so
4990                    // the next observation sees a clean pull request.
4991                    Fixed::Declined => state.event(
4992                        "land",
4993                        format!("round {round}: fixer declined the comments, nothing committed"),
4994                    ),
4995                    Fixed::Deferred => {
4996                        // No fixer was available to judge these comments or
4997                        // checks. Keep the previous completed-round count and
4998                        // return without handing the PR off as a task failure.
4999                        state.status = RunStatus::Blocked;
5000                        state.save()?;
5001                        return Ok(pr);
5002                    }
5003                    Fixed::Failed(why) => {
5004                        stop(state, &repo, &pr, &format!("the fix round failed: {why}")).await?;
5005                        return Ok(pr);
5006                    }
5007                }
5008                state.save()?;
5009            }
5010        }
5011    }
5012}
5013
5014/// Owner decision for a CI failure independently reproduced on the base.
5015pub const CI_HOLD_NODE: &str = "land-ci-unrelated";
5016
5017/// Durable machine-hold evidence, bound to one observed PR head.
5018#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5019pub struct CiHold {
5020    /// Head that exhibited the independently reproduced failures.
5021    pub head: String,
5022    /// Typed owner question controlling resumption.
5023    pub question: String,
5024    /// Complete structured facts used to attribute the failures.
5025    pub evidence: CiEvidence,
5026}
5027
5028/// Only structured forge annotations are compared, never log prose.
5029#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
5030struct CiFailure {
5031    path: String,
5032    start_line: u64,
5033    end_line: u64,
5034    title: String,
5035    message: String,
5036}
5037
5038#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5039struct CiCheckEvidence {
5040    label: String,
5041    head_check: u64,
5042    base_check: u64,
5043    app: u64,
5044    run: String,
5045    base_run: String,
5046    head_failures: Vec<CiFailure>,
5047    base_failures: Vec<CiFailure>,
5048    rerun_exhausted: bool,
5049}
5050
5051/// Pinned Git diff and forge failure annotations used for CI attribution.
5052#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5053pub struct CiEvidence {
5054    head: String,
5055    base: String,
5056    changed: Vec<String>,
5057    checks: Vec<CiCheckEvidence>,
5058}
5059
5060impl CiEvidence {
5061    /// Every red check must have the same located failure on the base, outside
5062    /// the diff. Changes to CI/build configuration invalidate this inference.
5063    fn unrelated(&self, head: &str, failing: &[String]) -> bool {
5064        if self.head != head
5065            || self.base.is_empty()
5066            || failing.is_empty()
5067            || self.changed.iter().any(|p| {
5068                p.starts_with(".github/")
5069                    || p.starts_with(".config/")
5070                    || p.starts_with(".cargo/")
5071                    || matches!(
5072                        p.rsplit('/').next().unwrap_or(p),
5073                        "Cargo.toml"
5074                            | "Cargo.lock"
5075                            | "Makefile.toml"
5076                            | "build.rs"
5077                            | "rust-toolchain.toml"
5078                    )
5079            })
5080        {
5081            return false;
5082        }
5083        failing.iter().all(|label| {
5084            let matches: Vec<_> = self.checks.iter().filter(|c| &c.label == label).collect();
5085            matches.len() == 1
5086                && matches[0].rerun_exhausted
5087                && !matches[0].head_failures.is_empty()
5088                && matches[0].head_failures.iter().all(|f| {
5089                    // Workflow-level exit-code annotations do not identify a
5090                    // failing test or source file, and prove nothing here.
5091                    !f.path.is_empty()
5092                        && !f.path.starts_with('.')
5093                        && !f.path.contains("..")
5094                        && !f.path.starts_with('/')
5095                        && !self.changed.contains(&f.path)
5096                        && matches[0].base_failures.contains(f)
5097                })
5098        })
5099    }
5100}
5101
5102async fn ci_json(repo: &Path, endpoint: String) -> Option<serde_json::Value> {
5103    let (ok, body) = gh(repo, &["api".into(), endpoint]).await.ok()?;
5104    if !ok {
5105        return None;
5106    }
5107    serde_json::from_str(&body).ok()
5108}
5109
5110async fn ci_annotations(repo: &Path, check: &serde_json::Value) -> Option<Vec<CiFailure>> {
5111    let count = check.pointer("/output/annotations_count")?.as_u64()?;
5112    if count == 0 || count >= 100 {
5113        return None;
5114    }
5115    let id = check.get("id")?.as_u64()?;
5116    let value = ci_json(
5117        repo,
5118        format!("repos/{{owner}}/{{repo}}/check-runs/{id}/annotations?per_page=100"),
5119    )
5120    .await?;
5121    let annotations = value.as_array()?;
5122    if annotations.len() != count as usize {
5123        return None;
5124    }
5125    annotations
5126        .iter()
5127        .filter(|a| a["annotation_level"] == "failure")
5128        .map(|a| {
5129            Some(CiFailure {
5130                path: a["path"].as_str()?.into(),
5131                start_line: a["start_line"].as_u64()?,
5132                end_line: a["end_line"].as_u64()?,
5133                title: a["title"].as_str()?.into(),
5134                message: a["message"].as_str()?.into(),
5135            })
5136        })
5137        .collect()
5138}
5139
5140async fn ci_runs(repo: &Path, sha: &str) -> Option<Vec<serde_json::Value>> {
5141    let value = ci_json(
5142        repo,
5143        format!("repos/{{owner}}/{{repo}}/commits/{sha}/check-runs?per_page=100&filter=latest"),
5144    )
5145    .await?;
5146    let runs = value["check_runs"].as_array()?;
5147    if value["total_count"].as_u64()? != runs.len() as u64 || runs.len() >= 100 {
5148        return None;
5149    }
5150    Some(runs.clone())
5151}
5152
5153async fn collect_ci_evidence(state: &RunState, seen: &Seen) -> Option<CiEvidence> {
5154    let repo = &state.repo;
5155    let base_ref = format!("refs/remotes/{}/{}", state.config.merge.remote, seen.base);
5156    let base = git::git_raw(repo, &["rev-parse", "--verify", &base_ref])
5157        .await
5158        .ok()?;
5159    if !base.ok() {
5160        return None;
5161    }
5162    let range = format!("{}...{}", base.stdout, seen.head);
5163    // No rename detection: both old and new paths must count as changed.
5164    let diff = git::git_raw(
5165        repo,
5166        &["diff", "--no-renames", "--name-only", "-z", &range, "--"],
5167    )
5168    .await
5169    .ok()?;
5170    if !diff.ok() {
5171        return None;
5172    }
5173    let head_runs = ci_runs(repo, &seen.head).await?;
5174    let base_runs = ci_runs(repo, &base.stdout).await?;
5175    let mut checks = Vec::new();
5176    for label in &seen.pr.failing {
5177        let matching = |runs: &[serde_json::Value]| {
5178            runs.iter()
5179                .filter(|r| r["name"].as_str() == Some(label))
5180                .cloned()
5181                .collect::<Vec<_>>()
5182        };
5183        let heads = matching(&head_runs);
5184        let bases = matching(&base_runs);
5185        if heads.len() != 1 || bases.len() != 1 {
5186            return None;
5187        }
5188        let h = &heads[0];
5189        let b = &bases[0];
5190        if h["conclusion"] != "failure"
5191            || b["conclusion"] != "failure"
5192            || h["status"] != "completed"
5193            || b["status"] != "completed"
5194            || h["head_sha"].as_str()? != seen.head
5195            || b["head_sha"].as_str()? != base.stdout
5196            || h.pointer("/app/id")?.as_u64()? != b.pointer("/app/id")?.as_u64()?
5197        {
5198            return None;
5199        }
5200        let run = run_of(h["details_url"].as_str()?)?;
5201        let contexts: Vec<_> = seen.contexts.iter().filter(|c| &c.label == label).collect();
5202        if contexts.len() != 1
5203            || contexts[0].run.as_ref() != Some(&run)
5204            || contexts[0].verdict != Verdict::Fail
5205        {
5206            return None;
5207        }
5208        // A persisted request alone is not a completed rerun: require the
5209        // workflow's structured attempt number as well.
5210        let workflow =
5211            ci_json(repo, format!("repos/{{owner}}/{{repo}}/actions/runs/{run}")).await?;
5212        let base_run = run_of(b["details_url"].as_str()?)?;
5213        let base_workflow = ci_json(
5214            repo,
5215            format!("repos/{{owner}}/{{repo}}/actions/runs/{base_run}"),
5216        )
5217        .await?;
5218        if base_workflow["head_sha"].as_str()? != base.stdout
5219            || base_workflow["head_branch"].as_str()? != seen.base
5220            || base_workflow["status"] != "completed"
5221            || base_workflow["conclusion"] != "failure"
5222            || base_workflow["workflow_id"].as_u64()? != workflow["workflow_id"].as_u64()?
5223        {
5224            return None;
5225        }
5226        let exhausted = state
5227            .land_reruns
5228            .as_ref()
5229            .is_some_and(|r| r.head == seen.head && r.runs.contains_key(&run))
5230            && workflow["head_sha"].as_str()? == seen.head
5231            && workflow["run_attempt"].as_u64()? > 1
5232            && workflow["status"] == "completed";
5233        checks.push(CiCheckEvidence {
5234            label: label.clone(),
5235            head_check: h["id"].as_u64()?,
5236            base_check: b["id"].as_u64()?,
5237            app: h.pointer("/app/id")?.as_u64()?,
5238            run,
5239            base_run,
5240            head_failures: ci_annotations(repo, h).await?,
5241            base_failures: ci_annotations(repo, b).await?,
5242            rerun_exhausted: exhausted,
5243        });
5244    }
5245    Some(CiEvidence {
5246        head: seen.head.clone(),
5247        base: base.stdout,
5248        changed: diff
5249            .stdout
5250            .split('\0')
5251            .filter(|p| !p.is_empty())
5252            .map(str::to_owned)
5253            .collect(),
5254        checks,
5255    })
5256}
5257
5258async fn hold_unrelated(state: &mut RunState, pr: &PrState, evidence: CiEvidence) -> Result<()> {
5259    let detail = serde_json::to_string(&evidence)?;
5260    let resume = "daemon: CI を確認して同じ run を再開する".to_owned();
5261    let hold = "operator: 保留して後で判断する".to_owned();
5262    let mut q = ask::Question::new(
5263        state.id.clone(),
5264        CI_HOLD_NODE.into(),
5265        "land".into(),
5266        "base でも再現する CI の失敗を検出したため、試行を消費せず保留しました".into(),
5267        format!(
5268            "必須チェックや承認は省略しません。再開時にも同じ workflow run は自動再実行しません。\n構造化された判定根拠:\n{detail}"
5269        ),
5270        vec![resume.clone(), hold.clone()],
5271    );
5272    q.actions.insert(
5273        resume,
5274        ask::ChoiceAction::Resume {
5275            run: state.id.clone(),
5276        },
5277    );
5278    q.actions.insert(hold, ask::ChoiceAction::Hold);
5279    ask::Questions::open().put_executable(&mut q)?;
5280    state.land_unrelated = Some(CiHold {
5281        head: evidence.head.clone(),
5282        question: q.id.clone(),
5283        evidence,
5284    });
5285    state.event("land", format!("[ci-unrelated] base reproduces every located failure after rerun; owner question {}: {detail}", q.id));
5286    state.end_pass_parked(crate::run::ParkCause::Question);
5287    state.parked = true;
5288    state.save()?;
5289    if let Err(e) = ask::notify(&state.config.notify, &q).await {
5290        tracing::warn!("could not notify about CI hold: {e:#}");
5291    }
5292    // A durable question and evidence are sufficient even if commenting fails.
5293    let body = stop_comment(
5294        &state.id,
5295        "CI failures independently reproduced on the base; awaiting an owner decision without charging the task attempt",
5296    );
5297    let (_, body) = crate::github_text::prepare(state, "", &body);
5298    gh(
5299        &state.repo,
5300        &[
5301            "pr".into(),
5302            "comment".into(),
5303            pr.number.to_string(),
5304            "--body".into(),
5305            body,
5306        ],
5307    )
5308    .await
5309    .ok();
5310    Ok(())
5311}
5312
5313/// One observation, plus the two things [`PrState`] deliberately does not carry:
5314/// the title (needed for the squash subject) and where the failing checks'
5315/// logs live.
5316#[derive(Clone)]
5317struct Seen {
5318    pr: PrState,
5319    title: String,
5320    failing_urls: Vec<(String, String)>,
5321    /// `headRefOid`: the commit this observation, checks included, is about.
5322    head: String,
5323    /// The commit the checks belong to, read from the same GraphQL node as
5324    /// the checks themselves. Empty when unreadable.
5325    rollup_head: String,
5326    /// `mergeStateStatus` as the forge spelled it. [`Blocking`] folds BLOCKED
5327    /// and DRAFT together, and a stop reason has to say which.
5328    merge_state: String,
5329    /// Every check of the rollup, for naming what an armed merge waits on.
5330    contexts: Vec<CheckInfo>,
5331    /// `baseRefName`, to look up which contexts the base requires.
5332    base: String,
5333}
5334
5335/// One check of the rollup as far as a stop reason needs it.
5336#[derive(Clone)]
5337struct CheckInfo {
5338    label: String,
5339    verdict: Verdict,
5340    required: Option<bool>,
5341    /// The workflow run the check belongs to; `None` for an external status.
5342    run: Option<String>,
5343}
5344
5345/// What to do with a red head before a fix round is spent on it.
5346#[derive(Debug, Clone, PartialEq, Eq)]
5347enum RerunStep {
5348    /// Rerun these workflow runs (each not yet rerun for this head).
5349    Rerun(Vec<String>),
5350    /// Reran already and the forge may still report the old failure: wait.
5351    Grace,
5352    /// Nothing to rerun, or the rerun did not help: the fixer's turn.
5353    Fix,
5354}
5355
5356/// Failed checks a rerun may help: a failure of a check that blocks (`required`
5357/// unreadable counts), as `(label, run)`. Judged one workflow run at a time;
5358/// pending checks in another run do not delay this run's rerun.
5359#[cfg(test)]
5360fn rerunnable(contexts: &[CheckInfo]) -> Vec<(String, Option<String>)> {
5361    rerunnable_with(contexts, false)
5362}
5363
5364fn rerunnable_with(
5365    contexts: &[CheckInfo],
5366    include_optional: bool,
5367) -> Vec<(String, Option<String>)> {
5368    contexts
5369        .iter()
5370        .filter(|c| c.verdict == Verdict::Fail && (include_optional || c.required != Some(false)))
5371        // `gh run rerun --failed` refuses a run with a job still going.
5372        .filter(|c| {
5373            c.run.as_ref().is_none_or(|r| {
5374                !contexts.iter().any(|o| {
5375                    matches!(o.verdict, Verdict::Pending | Verdict::Unknown)
5376                        && o.run.as_ref() == Some(r)
5377                })
5378            })
5379        })
5380        .map(|c| (c.label.clone(), c.run.clone()))
5381        .collect()
5382}
5383
5384/// Pure: rerun once per run id, wait out the grace, then hand over.
5385fn rerun_step(
5386    failing: &[(String, Option<String>)],
5387    record: Option<&LandReruns>,
5388    head: &str,
5389    now: i64,
5390) -> RerunStep {
5391    // A failure with no workflow run (an external status) cannot be rerun, and
5392    // the fixer's push re-runs everything anyway.
5393    if failing.is_empty() || failing.iter().any(|(_, run)| run.is_none()) {
5394        return RerunStep::Fix;
5395    }
5396    // Reruns belong to the head they were made on.
5397    let record = record.filter(|r| r.head.eq_ignore_ascii_case(head));
5398    let mut fresh: Vec<String> = Vec::new();
5399    let mut recent = false;
5400    for run in failing.iter().filter_map(|(_, run)| run.as_deref()) {
5401        match record.and_then(|r| r.runs.get(run)) {
5402            None => {
5403                if !fresh.iter().any(|f| f == run) {
5404                    fresh.push(run.to_owned());
5405                }
5406            }
5407            Some(&at) if now - at < crate::release_watch::RERUN_GRACE => recent = true,
5408            Some(_) => {}
5409        }
5410    }
5411    if !fresh.is_empty() {
5412        RerunStep::Rerun(fresh)
5413    } else if recent {
5414        RerunStep::Grace
5415    } else {
5416        RerunStep::Fix
5417    }
5418}
5419
5420/// Read the pull request: `gh pr view` for the top-level thread and merge
5421/// state, `gh api graphql` for the last commit and its checks, `gh api` for the
5422/// inline review comments `gh pr view` does not report.
5423async fn observe(repo: &Path, pr_url: &str) -> Result<Seen> {
5424    let view = gh(
5425        repo,
5426        &[
5427            "pr".to_owned(),
5428            "view".to_owned(),
5429            pr_url.to_owned(),
5430            "--json".to_owned(),
5431            "url,number,state,title,reviews,comments,mergeStateStatus,headRefOid,baseRefName"
5432                .to_owned(),
5433        ],
5434    )
5435    .await?;
5436    if !view.0 {
5437        bail!("gh pr view {pr_url}: {}", view.1);
5438    }
5439    let number = parse_pr(&view.1)?.number;
5440    let node = last_commit_node(repo, number).await;
5441    let mut seen = seen_from(&view.1, node.as_deref())?;
5442
5443    let inline = gh(
5444        repo,
5445        &[
5446            "api".to_owned(),
5447            format!("repos/{{owner}}/{{repo}}/pulls/{}/comments", seen.pr.number),
5448        ],
5449    )
5450    .await?;
5451    if inline.0 {
5452        match parse_inline_comments(&inline.1) {
5453            Ok(mut comments) => seen.pr.review_comments.append(&mut comments),
5454            // An unreadable inline thread must not end a landing: the rollup
5455            // and the top-level thread are still real signal.
5456            Err(e) => tracing::warn!("inline review comments unreadable: {e}"),
5457        }
5458    } else {
5459        tracing::warn!("gh api pulls/{}/comments: {}", seen.pr.number, inline.1);
5460    }
5461    Ok(seen)
5462}
5463
5464/// Build a [`Seen`] from the `gh pr view` json and the last-commit node
5465/// response. No I/O.
5466///
5467/// The commit oid and the checks are read from the *same* node, so the rollup
5468/// is bound to the commit it belongs to by construction; two reads that agree
5469/// before and after another response prove nothing about what that response
5470/// held. The view's own rollup is never used. A node that is missing,
5471/// unreadable, carries GraphQL errors, or whose checks run past the page
5472/// leaves `rollup_head` empty and the checks `Unknown`, which the loop treats
5473/// as "look again" and never as a reason to merge.
5474fn seen_from(view_json: &str, node_json: Option<&str>) -> Result<Seen> {
5475    let mut pr = parse_pr(view_json)?;
5476    let raw: GhPr = serde_json::from_str(view_json).context("re-read pull request json")?;
5477
5478    let mut rollup_head = String::new();
5479    let mut failing_urls = Vec::new();
5480    let mut contexts = Vec::new();
5481    let mut checks = Checks::Unknown;
5482    let mut failing = Vec::new();
5483    if let Some((oid, rollup)) = node_json.and_then(parse_last_commit_node) {
5484        (checks, failing) = rollup_verdict(&rollup);
5485        failing_urls = rollup
5486            .iter()
5487            .filter(|c| c.verdict() == Verdict::Fail)
5488            .filter_map(|c| c.url().map(|u| (c.label(), u.to_owned())))
5489            .collect();
5490        contexts = rollup
5491            .iter()
5492            .map(|c| CheckInfo {
5493                label: c.label(),
5494                verdict: c.verdict(),
5495                required: c.is_required,
5496                run: c.url().and_then(run_of),
5497            })
5498            .collect();
5499        rollup_head = oid;
5500    }
5501    pr.checks = checks;
5502    pr.failing = failing;
5503
5504    Ok(Seen {
5505        pr,
5506        title: raw.title,
5507        failing_urls,
5508        head: raw.head_ref_oid,
5509        rollup_head,
5510        merge_state: raw.merge_state_status,
5511        contexts,
5512        base: raw.base_ref_name,
5513    })
5514}
5515
5516/// The last commit's oid and its checks from one GraphQL response, `None`
5517/// when anything about it cannot be trusted.
5518fn parse_last_commit_node(json: &str) -> Option<(String, Vec<GhCheck>)> {
5519    let v: serde_json::Value = serde_json::from_str(json).ok()?;
5520    if v.get("errors").is_some_and(|e| !e.is_null()) {
5521        return None;
5522    }
5523    let commit = v.pointer("/data/repository/pullRequest/commits/nodes/0/commit")?;
5524    let oid = commit.get("oid")?.as_str().filter(|o| !o.is_empty())?;
5525    let contexts = commit.pointer("/statusCheckRollup/contexts");
5526    let Some(contexts) = contexts.filter(|c| !c.is_null()) else {
5527        // No rollup at all: the commit has no checks.
5528        return Some((oid.to_owned(), Vec::new()));
5529    };
5530    if contexts.pointer("/pageInfo/hasNextPage")?.as_bool()? {
5531        return None;
5532    }
5533    let nodes = contexts.get("nodes")?.as_array()?;
5534    let rollup = nodes
5535        .iter()
5536        .map(|n| serde_json::from_value::<GhCheck>(n.clone()))
5537        .collect::<Result<Vec<_>, _>>()
5538        .ok()?;
5539    Some((oid.to_owned(), rollup))
5540}
5541
5542/// The pull request's last commit and its checks, in one response. `None`
5543/// when the forge could not be asked.
5544async fn last_commit_node(repo: &Path, number: u64) -> Option<String> {
5545    let out = gh(
5546        repo,
5547        &[
5548            "api".to_owned(),
5549            "graphql".to_owned(),
5550            "-F".to_owned(),
5551            "owner={owner}".to_owned(),
5552            "-F".to_owned(),
5553            "repo={repo}".to_owned(),
5554            "-F".to_owned(),
5555            format!("number={number}"),
5556            "-f".to_owned(),
5557            "query=query($owner:String!,$repo:String!,$number:Int!){repository(owner:$owner,\
5558             name:$repo){pullRequest(number:$number){commits(last:1){nodes{commit{oid \
5559             statusCheckRollup{contexts(first:100){pageInfo{hasNextPage} nodes{\
5560             ... on CheckRun{name status conclusion detailsUrl \
5561             isRequired(pullRequestNumber:$number)} \
5562             ... on StatusContext{context state targetUrl \
5563             isRequired(pullRequestNumber:$number)}}}}}}}}}}"
5564                .to_owned(),
5565        ],
5566    )
5567    .await
5568    .ok()?;
5569    out.0.then_some(out.1)
5570}
5571
5572/// What a fix round did.
5573#[doc(hidden)]
5574#[derive(Debug, PartialEq)]
5575pub enum Fixed {
5576    /// The fixer committed something, and this is the head that was pushed.
5577    Committed {
5578        /// The commit now at the tip of the pushed branch.
5579        head: String,
5580    },
5581    /// The fixer ran and chose to change nothing.
5582    Declined,
5583    /// Machine availability prevented a result; retry this round on resume.
5584    Deferred,
5585    /// The fixer could not run, or said nothing usable.
5586    Failed(String),
5587}
5588
5589/// Hand the failures and the comments to the fixer, then commit and push.
5590///
5591/// The fixer works in the winner's own worktree so its commits land on the
5592/// branch the pull request is built from, and it runs with `allow_write` for
5593/// the same reason.
5594#[doc(hidden)]
5595pub async fn fix_round(
5596    state: &mut RunState,
5597    pr: &PrState,
5598    round: usize,
5599    budget: usize,
5600    reason: &str,
5601    logs: &str,
5602) -> Result<Fixed> {
5603    let winner = state
5604        .winner()
5605        .cloned()
5606        .context("landing needs a winning candidate; none is recorded on this run")?;
5607    let roles = state
5608        .config
5609        .resolve_roles()
5610        .context("resolve the roster for the fix round")?;
5611    // Same chain as the review loop (see `crate::fixer`): the configured
5612    // fixers in order, otherwise the winner's own author continuing its own
5613    // conversation - the competition is over, so its context is pure benefit.
5614    let attempts = crate::fixer::attempts(state, &roles, &winner);
5615    let ids: Vec<String> = attempts.iter().map(|(s, _)| s.id.clone()).collect();
5616
5617    let prompt = fix_prompt(state, pr, round, budget, reason, logs);
5618    let mut artifacts = agent::artifacts_dir(&state.dir());
5619    if let Some(request) = state
5620        .merge_repairs
5621        .last()
5622        .filter(|r| r.phase == crate::run::MergeRepairPhase::Fixing)
5623    {
5624        artifacts = artifacts.join(format!("merge-repair-{}", request.question));
5625    }
5626    let prompt = if state.config.cache_dir().is_some() {
5627        format!("{prompt}\n\n{}", prompt::build_cache_note("fix", true))
5628    } else {
5629        prompt
5630    };
5631    // Read before the fixer runs: it normally commits for itself, so HEAD has
5632    // already moved by the time it returns and a later read would see no
5633    // progress (run 20261004-041622-5769 stopped on a fix that had landed).
5634    let before = git::rev_parse(&winner.worktree, "HEAD").await?;
5635    // Each id at most once, forward only: the next one is asked only when the
5636    // call advances, and only the last attempt's result is judged below, so an
5637    // exhausted chain ends as a single failed fixer does.
5638    let mut last = None;
5639    for (i, (spec, seat_key)) in attempts.into_iter().enumerate() {
5640        if owner_requested_stop(state)? {
5641            return Ok(Fixed::Declined);
5642        }
5643        let mut seat = seat_of(state, &seat_key, &spec.id);
5644        let stem = if i == 0 {
5645            format!("land-{round}")
5646        } else {
5647            format!("land-{round}-{}", spec.id)
5648        };
5649        let out = agent::invoke(
5650            &spec,
5651            &mut seat,
5652            &Invocation {
5653                coordination: state.config.coordination.as_ref(),
5654                fetched_base: state.fetched_base.as_ref(),
5655                cwd: &winner.worktree,
5656                prompt: &prompt,
5657                timeout: Duration::from_secs(state.config.graph.timeout_fix),
5658                allow_write: true,
5659                sessions: state.config.graph.sessions,
5660                artifacts: &artifacts,
5661                stem: &stem,
5662                run: &state.id,
5663                node: "land",
5664                cache_dir: state.config.cache_dir().as_deref(),
5665                attachments: &[],
5666                writable: &[],
5667            },
5668        )
5669        .await;
5670        state.seats.insert(seat.key.clone(), seat);
5671        if let Some(next) = ids.get(i + 1)
5672            && agent::chain_advances(&out)
5673        {
5674            let (class, why) = crate::fixer::failure_of(&out);
5675            crate::graph::record_handover(state, "land", &seat_key, &spec.id, next, &class, &why);
5676            continue;
5677        }
5678        last = Some((seat_key, out));
5679        break;
5680    }
5681    let (seat_key, out) = last.expect("the fixer chain always has an entry");
5682
5683    match out {
5684        Ok(o) if o.quota_exhausted() => {
5685            let loss = crate::run::QuotaLoss::from_report(seat_key, "land", o.quota.as_ref());
5686            crate::graph::block_machine_outage(state, "land", std::slice::from_ref(&loss));
5687            state.quota.push(loss);
5688            state.status = RunStatus::Blocked;
5689            state.save()?;
5690            // Keep partial edits reachable on the winner branch and leave a
5691            // clean tree for resume_landing_head. The resumed landing gates
5692            // this new commit before it can publish it; no push happens here.
5693            let inherited = crate::repo_lock::WaitPolicy::current();
5694            let wait = crate::repo_lock::WaitPolicy::new(
5695                Duration::from_secs(state.config.graph.timeout_resource_wait),
5696                move || inherited.cancelled(),
5697            );
5698            let _coordination = crate::repo_lock::SeatLease::operation_with(
5699                &winner.worktree,
5700                state.config.coordination.as_ref(),
5701                &wait,
5702            )
5703            .await?;
5704            let rescue = git::rescue_commit(
5705                &winner.worktree,
5706                &format!("magi: deferred land round {round} (uncommitted work)"),
5707            )
5708            .await?;
5709            state.note_withheld("land", &rescue.withheld);
5710            state.save()?;
5711            return Ok(Fixed::Deferred);
5712        }
5713        Ok(o) if !o.usable() => {
5714            return Ok(Fixed::Failed(format!(
5715                "the fixer produced nothing usable ({})",
5716                crate::notices::turn_status(o.exit_code, o.timed_out, o.quota_exhausted())
5717            )));
5718        }
5719        Ok(_) => {}
5720        Err(e) if e.is::<crate::repo_lock::ResourceBlocked>() => return Err(e),
5721        Err(e) => return Ok(Fixed::Failed(format!("{e:#}"))),
5722    }
5723
5724    if owner_requested_stop(state)? {
5725        return Ok(Fixed::Declined);
5726    }
5727
5728    // An agent that edited files but never committed would otherwise push
5729    // nothing and look like a refusal.
5730    let wait = crate::repo_lock::WaitPolicy::new(
5731        Duration::from_secs(state.config.graph.timeout_resource_wait),
5732        || false,
5733    );
5734    let coordination = crate::repo_lock::SeatLease::operation_with(
5735        &winner.worktree,
5736        state.config.coordination.as_ref(),
5737        &wait,
5738    )
5739    .await?;
5740    match git::rescue_commit(
5741        &winner.worktree,
5742        &format!("magi: land round {round} fixes (uncommitted work)"),
5743    )
5744    .await
5745    {
5746        Ok(r) => state.note_withheld("land", &r.withheld),
5747        Err(e)
5748            if state
5749                .merge_repairs
5750                .last()
5751                .is_some_and(|r| r.phase == crate::run::MergeRepairPhase::Fixing) =>
5752        {
5753            return Ok(Fixed::Failed(format!("saving repair commit failed: {e:#}")));
5754        }
5755        Err(_) => {}
5756    }
5757    let after = git::rev_parse(&winner.worktree, "HEAD").await?;
5758    drop(coordination);
5759    if after == before {
5760        return Ok(Fixed::Declined);
5761    }
5762
5763    if owner_requested_stop(state)? {
5764        return Ok(Fixed::Declined);
5765    }
5766    crate::pr_head::ensure_owner(state)?;
5767    let remote = state.config.merge.remote.clone();
5768    anyhow::ensure!(
5769        crate::foreign_checkout::write_back(state, &after).await?,
5770        "foreign checkout delivery is blocked; see the run events"
5771    );
5772    let public_head = state.pr_branch().unwrap_or(&winner.branch).to_owned();
5773    let push = if state.pr_head.is_some() {
5774        let expected = state
5775            .pr_pushed_head
5776            .as_deref()
5777            .context("missing public head lease")?;
5778        git::push_as(
5779            &winner.worktree,
5780            &remote,
5781            &winner.branch,
5782            &public_head,
5783            expected,
5784        )
5785        .await?
5786    } else {
5787        git::push(&winner.worktree, &remote, &winner.branch).await?
5788    };
5789    if !push.ok() {
5790        return Ok(Fixed::Failed(format!(
5791            "pushing {} to {remote} failed: {}",
5792            public_head, push.stderr
5793        )));
5794    }
5795    state.event(
5796        "land",
5797        format!("round {round}: pushed a fix to {public_head}"),
5798    );
5799    state.pr_pushed_head = Some(after.clone());
5800    state.save()?;
5801    Ok(Fixed::Committed { head: after })
5802}
5803
5804/// Fetch or create a seat, keeping its conversation across nodes.
5805pub(crate) fn seat_of(state: &mut RunState, key: &str, agent: &str) -> SeatState {
5806    crate::fixer::seat_for(state, key, agent)
5807}
5808
5809/// Recheck the live PR and local worktree before spending the requested fix.
5810/// A moved/closed PR is held, never repaired using obsolete evidence.
5811pub(crate) async fn repair_preflight(state: &RunState, url: &str, head: &str) -> Result<PrState> {
5812    let seen = observe(&state.repo, url).await?;
5813    let winner = state.winner().context("no winning branch to repair")?;
5814    if seen.pr.state != PrLifecycle::Open || seen.head != head {
5815        anyhow::bail!(
5816            "PR is closed or its head changed; review the current head before requesting repair again"
5817        );
5818    }
5819    if git::rev_parse(&winner.worktree, "HEAD").await? != head
5820        || !git::is_clean(&winner.worktree).await?
5821    {
5822        anyhow::bail!(
5823            "repair worktree is missing, dirty or at a different head; restore the reviewed branch and resume this run"
5824        );
5825    }
5826    // Always disable any forge-side reservation, including one not recorded
5827    // by this run. A repair request is never merge authorization.
5828    let view = gh(
5829        &state.repo,
5830        &[
5831            "pr".into(),
5832            "view".into(),
5833            url.into(),
5834            "--json".into(),
5835            "autoMergeRequest,headRefOid,state,headRefName,baseRefName,isCrossRepository".into(),
5836        ],
5837    )
5838    .await?;
5839    if !view.0 {
5840        bail!("cannot check auto-merge: {}", view.1);
5841    }
5842    let live: serde_json::Value = serde_json::from_str(&view.1)?;
5843    let public = state.pr_branch().unwrap_or(&winner.branch);
5844    if live["state"] != "OPEN"
5845        || live["headRefOid"] != head
5846        || live["headRefName"] != public
5847        || live["baseRefName"] != state.base_branch
5848        || live["isCrossRepository"] != false
5849    {
5850        bail!("PR changed during repair preflight; review its current head explicitly");
5851    }
5852    let auto_merge = live
5853        .get("autoMergeRequest")
5854        .context("cannot read the PR auto-merge reservation; repair held")?;
5855    if !auto_merge.is_null() {
5856        let out = gh(&state.repo, &disable_automerge_argv(seen.pr.number)).await?;
5857        if !out.0 {
5858            bail!("cannot disable auto-merge; repair held: {}", out.1);
5859        }
5860    }
5861    Ok(seen.pr)
5862}
5863
5864/// What the fixer is told.
5865fn fix_prompt(
5866    state: &RunState,
5867    pr: &PrState,
5868    round: usize,
5869    budget: usize,
5870    reason: &str,
5871    logs: &str,
5872) -> String {
5873    let mut s = format!(
5874        "Your patch is open as a pull request and it is not landing. Land round \
5875         {round} of {budget}.\n\n\
5876         Pull request: {}\n\n\
5877         What is holding it: {reason}\n\n\
5878         # The task\n\n{}\n",
5879        pr.url, state.instruction
5880    );
5881
5882    if pr.failing.is_empty() {
5883        s.push_str("\n# Failing checks\n\n(none)\n");
5884    } else {
5885        let _ = write!(s, "\n# Failing checks\n\n- {}\n", pr.failing.join("\n- "));
5886        if logs.trim().is_empty() {
5887            s.push_str(
5888                "\nNo log could be read; investigate the failure with necessary focused checks.\n",
5889            );
5890        } else {
5891            let _ = write!(s, "\n## Failing log tails\n\n{logs}\n");
5892        }
5893    }
5894
5895    if pr.review_comments.is_empty() {
5896        s.push_str("\n# Review comments\n\n(none)\n");
5897    } else {
5898        s.push_str("\n# Review comments\n");
5899        for c in &pr.review_comments {
5900            let where_ = match (&c.path, c.line) {
5901                (Some(p), Some(l)) => format!(" ({p}:{l})"),
5902                (Some(p), None) => format!(" ({p})"),
5903                _ => String::new(),
5904            };
5905            let _ = write!(s, "\n## {}{where_}\n\n{}\n", c.author, c.body.trim());
5906        }
5907    }
5908
5909    s.push_str(
5910        "\n# Rules\n\n\
5911         1. Fix the cause, never the symptom. Do not delete, skip, or weaken a \
5912            failing test; do not silence a lint with an allow attribute; do not \
5913            stretch a timeout to hide a race. If the check is right, the code is \
5914            wrong.\n\
5915         2. Change nothing the checks and the comments did not raise. A \
5916            drive-by refactor turns a one-line fix into a pull request that \
5917            needs reviewing again.\n\
5918         3. If a comment is wrong, say so with a checkable argument and change \
5919            nothing for it. A declined comment with a reason is a correct \
5920            outcome; a change made to appease a reviewer is not.\n\
5921         4. Commit in this worktree. magi pushes to the pull request's branch \
5922            for you; do not push, merge, or close anything yourself.\n\
5923         5. Never name yourself, your vendor, or your model, anywhere.\n\n\
5924         # Output\n\n\
5925         Say what you changed and why, and what you declined and why.",
5926    );
5927
5928    let language = &state.config.graph.language;
5929    if !(language.trim().is_empty() || language.eq_ignore_ascii_case("en")) {
5930        let _ = write!(s, "\n\nWrite all prose in {language}.");
5931    }
5932    // After the language line, so the exception is the last word on it.
5933    s.push_str(&crate::prompt::github_rule(
5934        language,
5935        &state.config.graph.github_language,
5936    ));
5937    if let Some(overlay) = state.config.prompts.overlay("fix") {
5938        let _ = write!(s, "\n\n{overlay}");
5939    }
5940    s.push('\n');
5941    s.push_str(crate::prompt::child_run_ownership());
5942    s
5943}
5944
5945/// Failing log tails, the way the operator collects them by hand:
5946/// `gh run view --log-failed`.
5947async fn failing_logs(repo: &Path, failing: &[(String, String)]) -> String {
5948    let mut out = String::new();
5949    for (name, url) in failing.iter().take(MAX_LOGS) {
5950        let args = match (job_of(url), run_of(url)) {
5951            (Some(job), _) => vec![
5952                "run".to_owned(),
5953                "view".to_owned(),
5954                "--log-failed".to_owned(),
5955                "--job".to_owned(),
5956                job,
5957            ],
5958            (None, Some(run)) => vec![
5959                "run".to_owned(),
5960                "view".to_owned(),
5961                run,
5962                "--log-failed".to_owned(),
5963            ],
5964            // Not a GitHub Actions check - an external status has no log here.
5965            (None, None) => continue,
5966        };
5967        let (ok, body) = match gh(repo, &args).await {
5968            Ok(v) => v,
5969            Err(e) => (false, format!("{e:#}")),
5970        };
5971        if !ok && body.trim().is_empty() {
5972            continue;
5973        }
5974        let _ = write!(out, "### {name}\n\n```\n{}\n```\n\n", tail(&body, LOG_TAIL));
5975    }
5976    out
5977}
5978
5979/// Job id out of a check's `detailsUrl`
5980/// (`https://github.com/o/r/actions/runs/<run>/job/<job>`).
5981fn job_of(details_url: &str) -> Option<String> {
5982    let after = details_url.split("/job/").nth(1)?;
5983    let id: String = after.chars().take_while(char::is_ascii_digit).collect();
5984    (!id.is_empty()).then_some(id)
5985}
5986
5987/// Workflow run id out of a check's `detailsUrl`.
5988pub(crate) fn run_of(details_url: &str) -> Option<String> {
5989    let after = details_url.split("/actions/runs/").nth(1)?;
5990    let id: String = after.chars().take_while(char::is_ascii_digit).collect();
5991    (!id.is_empty()).then_some(id)
5992}
5993
5994/// The comment `stop` posts. Fixed English, whatever `[graph] language` says:
5995/// it lands on GitHub, not in front of the operator. Pure so a test can hold
5996/// it to that.
5997fn stop_comment(run_id: &str, why: &str) -> String {
5998    format!(
5999        "{MARKER}\nmagi stopped landing this pull request: {why}\n\n\
6000         The branch is untouched and the run is `{run_id}`. Nothing was merged."
6001    )
6002}
6003
6004/// Leave the pull request open, say why on it, and mark the run blocked.
6005///
6006/// The comment is what makes an unattended stop actionable: the operator wakes
6007/// up to a pull request that explains itself rather than to a silent queue.
6008async fn stop(state: &mut RunState, repo: &Path, pr: &PrState, why: &str) -> Result<()> {
6009    let body = stop_comment(&state.id, why);
6010    let (_, mut body) = crate::github_text::prepare(state, "", &body);
6011    if !body.contains(MARKER) {
6012        body = format!("{MARKER}\n{body}");
6013    }
6014    let posted = gh(
6015        repo,
6016        &[
6017            "pr".to_owned(),
6018            "comment".to_owned(),
6019            pr.number.to_string(),
6020            "--body".to_owned(),
6021            body,
6022        ],
6023    )
6024    .await;
6025    match posted {
6026        Ok((true, _)) => {}
6027        Ok((false, out)) => tracing::warn!("could not comment on {}: {out}", pr.url),
6028        Err(e) => tracing::warn!("could not comment on {}: {e:#}", pr.url),
6029    }
6030    state.status = RunStatus::Blocked;
6031    state.merge = Some(MergeOutcome {
6032        mode: MergeMode::Pr,
6033        ok: false,
6034        detail: why.to_owned(),
6035        empty: false,
6036    });
6037    state.event("land", format!("stopped: {why}"));
6038    state.save()?;
6039    Ok(())
6040}
6041
6042/// Run `gh` in `repo`, returning success and the combined output.
6043///
6044/// Combined because `gh` reports a refused merge on stderr and the pull request
6045/// json on stdout, and both are evidence.
6046///
6047/// `GH_REPO` is stripped from the child's environment: every call site here
6048/// passes an explicit `cwd` (or a full pull request URL) meaning to operate
6049/// on *that* checkout's own remote, and `gh` prefers `GH_REPO` over the
6050/// checkout it is sitting in when no `--repo` flag is given. Left unset, a
6051/// `GH_REPO` the operator happens to have exported for an unrelated script
6052/// would silently redirect [`repo_slug`] (and every other cwd-scoped call
6053/// below) to a different repository than the one actually on disk - which
6054/// for the same-repo guard in [`correct_manual_merge`] would mean the check
6055/// could be made to agree with whatever repository a forged `--merged` URL
6056/// claims, defeating it entirely.
6057pub(crate) async fn gh(cwd: &Path, args: &[String]) -> Result<(bool, String)> {
6058    let out = tokio::process::Command::new("gh")
6059        .args(args)
6060        .current_dir(cwd)
6061        .env_remove("GH_REPO")
6062        .quiet()
6063        .stdin(std::process::Stdio::null())
6064        .output()
6065        .await
6066        .with_context(|| format!("spawn gh {}", args.join(" ")))?;
6067    let mut body = String::from_utf8_lossy(&out.stdout).into_owned();
6068    let err = String::from_utf8_lossy(&out.stderr);
6069    if body.trim().is_empty() {
6070        body = err.into_owned();
6071    } else if !err.trim().is_empty() {
6072        body.push_str(&err);
6073    }
6074    Ok((out.status.success(), body.trim().to_owned()))
6075}
6076
6077/// Verdict of one entry in the status rollup.
6078#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6079pub(crate) enum Verdict {
6080    Pass,
6081    Fail,
6082    Pending,
6083    Unknown,
6084}
6085
6086impl Verdict {
6087    /// Short operator-facing check result.
6088    pub(crate) fn label(self) -> &'static str {
6089        match self {
6090            Self::Pass => "passed",
6091            Self::Fail => "failed",
6092            Self::Pending => "pending",
6093            Self::Unknown => "unknown",
6094        }
6095    }
6096}
6097
6098#[derive(Debug, Deserialize)]
6099#[serde(rename_all = "camelCase")]
6100struct GhPr {
6101    #[serde(default)]
6102    url: String,
6103    #[serde(default)]
6104    number: u64,
6105    #[serde(default)]
6106    state: String,
6107    #[serde(default)]
6108    title: String,
6109    #[serde(default)]
6110    status_check_rollup: Vec<GhCheck>,
6111    /// GitHub's own verdict on whether the pull request can be merged.
6112    ///
6113    /// Worth asking for because it is the only place the *required* check set
6114    /// is applied: the rollup lists every check equally, so a repository that
6115    /// deliberately does not require `coverage` still looks red here. See
6116    /// [`Blocking`].
6117    #[serde(default)]
6118    merge_state_status: String,
6119    /// The commit the pull request currently points at. Compared with the
6120    /// commit a fix round pushed, it is how the loop knows the forge has moved
6121    /// on and the rollup belongs to the new head.
6122    #[serde(default)]
6123    head_ref_oid: String,
6124    #[serde(default)]
6125    base_ref_name: String,
6126    #[serde(default)]
6127    reviews: Vec<GhReview>,
6128    #[serde(default)]
6129    comments: Vec<GhComment>,
6130}
6131
6132/// One rollup entry. `gh` mixes two GraphQL types in this array: a `CheckRun`
6133/// has `name`/`status`/`conclusion`, while a `StatusContext` - the old commit
6134/// status API, which is how CodeRabbit reports - has `context`/`state` and no
6135/// conclusion at all.
6136#[derive(Debug, Deserialize)]
6137#[serde(rename_all = "camelCase")]
6138struct GhCheck {
6139    #[serde(default)]
6140    name: Option<String>,
6141    #[serde(default)]
6142    context: Option<String>,
6143    #[serde(default)]
6144    status: Option<String>,
6145    #[serde(default)]
6146    conclusion: Option<String>,
6147    #[serde(default)]
6148    state: Option<String>,
6149    #[serde(default)]
6150    details_url: Option<String>,
6151    #[serde(default)]
6152    target_url: Option<String>,
6153    /// Whether the base branch requires this check. Only the GraphQL node
6154    /// carries it; `None` is "not read", never "not required".
6155    #[serde(default)]
6156    is_required: Option<bool>,
6157}
6158
6159impl GhCheck {
6160    /// Name to show a human and hand to the fixer.
6161    fn label(&self) -> String {
6162        self.name
6163            .clone()
6164            .or_else(|| self.context.clone())
6165            .unwrap_or_else(|| "(unnamed check)".to_owned())
6166    }
6167
6168    /// Where this check's logs live, when it has any.
6169    fn url(&self) -> Option<&str> {
6170        self.details_url
6171            .as_deref()
6172            .or(self.target_url.as_deref())
6173            .filter(|u| !u.is_empty())
6174    }
6175
6176    /// Did it pass?
6177    ///
6178    /// `SKIPPED` and `NEUTRAL` count as passed: the Claude review workflow
6179    /// skips release and bot pull requests by design, and a skip that blocked
6180    /// landing would block exactly the pull requests that need no review.
6181    /// `CANCELLED` counts as failed - a cancelled check did not pass, and
6182    /// merging over one is merging over a check that never ran.
6183    fn verdict(&self) -> Verdict {
6184        if let Some(status) = self.status.as_deref() {
6185            if !status.eq_ignore_ascii_case("COMPLETED") {
6186                return Verdict::Pending;
6187            }
6188        }
6189        let outcome = self
6190            .conclusion
6191            .as_deref()
6192            .or(self.state.as_deref())
6193            .unwrap_or("");
6194        match outcome.to_ascii_uppercase().as_str() {
6195            "SUCCESS" | "SKIPPED" | "NEUTRAL" => Verdict::Pass,
6196            "FAILURE" | "ERROR" | "TIMED_OUT" | "CANCELLED" | "STARTUP_FAILURE"
6197            | "ACTION_REQUIRED" => Verdict::Fail,
6198            "PENDING" | "EXPECTED" | "QUEUED" | "IN_PROGRESS" | "WAITING" | "REQUESTED" => {
6199                Verdict::Pending
6200            }
6201            _ => Verdict::Unknown,
6202        }
6203    }
6204}
6205
6206#[derive(Debug, Deserialize)]
6207struct GhAuthor {
6208    #[serde(default)]
6209    login: String,
6210}
6211
6212#[derive(Debug, Deserialize)]
6213struct GhReview {
6214    #[serde(default)]
6215    author: GhAuthor,
6216    #[serde(default)]
6217    body: String,
6218}
6219
6220#[derive(Debug, Deserialize)]
6221struct GhComment {
6222    #[serde(default)]
6223    author: GhAuthor,
6224    #[serde(default)]
6225    body: String,
6226}
6227
6228#[derive(Debug, Deserialize)]
6229struct GhUser {
6230    #[serde(default)]
6231    login: String,
6232}
6233
6234#[derive(Debug, Deserialize)]
6235struct GhInline {
6236    #[serde(default)]
6237    user: GhUser,
6238    #[serde(default)]
6239    path: Option<String>,
6240    #[serde(default)]
6241    line: Option<u64>,
6242    #[serde(default)]
6243    body: String,
6244}
6245
6246impl Default for GhAuthor {
6247    fn default() -> Self {
6248        Self {
6249            login: "(unknown)".to_owned(),
6250        }
6251    }
6252}
6253
6254impl Default for GhUser {
6255    fn default() -> Self {
6256        Self {
6257            login: "(unknown)".to_owned(),
6258        }
6259    }
6260}
6261
6262#[cfg(test)]
6263pub(crate) mod tests {
6264    use super::*;
6265    use crate::run::{Candidate, ReviewRecord, ReviewRound, Tally};
6266
6267    fn head_json(head: &str, base: &str, state: &str, cross: bool) -> String {
6268        format!(
6269            r#"{{"headRefName":"{head}","headRefOid":"aaa","baseRefName":"{base}","state":"{state}","isCrossRepository":{cross}}}"#
6270        )
6271    }
6272
6273    #[test]
6274    fn a_pull_request_is_closed_only_when_its_head_is_exactly_the_runs_branch() {
6275        let ok = head_json("magi/27b2/A", "main", "OPEN", false);
6276        assert_eq!(
6277            closable(&ok, "magi/27b2/A", "main", &["aaa".to_owned()]),
6278            Ok(())
6279        );
6280        for (json, why) in [
6281            (head_json("magi/27b2/B", "main", "OPEN", false), "head"),
6282            (head_json("magi/27b2/A-2", "main", "OPEN", false), "head"),
6283            (head_json("magi/27b2/A", "main", "OPEN", true), "fork"),
6284            (head_json("magi/27b2/A", "dev", "OPEN", false), "targets"),
6285            (head_json("magi/27b2/A", "main", "MERGED", false), "already"),
6286            (head_json("magi/27b2/A", "main", "CLOSED", false), "already"),
6287        ] {
6288            let err = closable(&json, "magi/27b2/A", "main", &["aaa".to_owned()])
6289                .unwrap_err()
6290                .why;
6291            assert!(err.contains(why), "{json}: {err}");
6292        }
6293        // A head that moved on past what was verified is left alone.
6294        let moved = head_json("magi/27b2/A", "main", "OPEN", false);
6295        let err = closable(&moved, "magi/27b2/A", "main", &["bbb".to_owned()]).unwrap_err();
6296        assert!(err.retry && err.why.contains("not a commit"), "{err:?}");
6297        assert!(
6298            !closable(
6299                &head_json("x", "main", "OPEN", false),
6300                "magi/27b2/A",
6301                "main",
6302                &[]
6303            )
6304            .unwrap_err()
6305            .retry
6306        );
6307        assert!(is_forge_url("https://github.com/o/r.git"));
6308        assert!(is_forge_url("git@github.com:o/r.git"));
6309        assert!(!is_forge_url("/tmp/origin.git"));
6310        assert!(!is_forge_url("C:\\work\\origin.git"));
6311        assert!(!is_forge_url("file:///tmp/origin.git"));
6312        assert!(forge_unavailable(
6313            "gh pr list failed: none of the git remotes configured for this repository point to a known GitHub host."
6314        ));
6315        assert!(!forge_unavailable(
6316            "gh pr list failed: error connecting to api.github.com"
6317        ));
6318        assert!(closable("not json", "magi/27b2/A", "main", &[]).is_err());
6319        // A record that does not say whether it is a fork is not trusted.
6320        assert!(
6321            closable(
6322                r#"{"headRefName":"b","headRefOid":"aaa","baseRefName":"main","state":"OPEN"}"#,
6323                "b",
6324                "main",
6325                &["aaa".to_owned()]
6326            )
6327            .is_err()
6328        );
6329    }
6330
6331    #[test]
6332    fn the_close_comment_names_the_commit_on_the_base() {
6333        let e = crate::already::Evidence {
6334            proof: crate::already::Proof::PatchId,
6335            tip: "1234567890".to_owned(),
6336            commits: vec!["0e368de0000".to_owned()],
6337        };
6338        let c = superseded_comment("main", &e);
6339        assert!(c.contains("0e368de") && c.contains("`main`"), "{c}");
6340    }
6341
6342    /// 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.
6343    const GREEN_OPEN: &str = r####"{
6344  "url": "https://github.com/yukimemi/magi/pull/10",
6345  "number": 10,
6346  "state": "OPEN",
6347  "mergeStateStatus": "CLEAN",
6348  "statusCheckRollup": [
6349    {
6350      "__typename": "CheckRun",
6351      "conclusion": "SKIPPED",
6352      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278334/job/99378963755",
6353      "name": "review",
6354      "status": "COMPLETED",
6355      "workflowName": "claude-review"
6356    },
6357    {
6358      "__typename": "CheckRun",
6359      "conclusion": "SUCCESS",
6360      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278338/job/99378963144",
6361      "name": "check (ubuntu-latest)",
6362      "status": "COMPLETED",
6363      "workflowName": "CI"
6364    },
6365    {
6366      "__typename": "CheckRun",
6367      "conclusion": "SUCCESS",
6368      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33356278338/job/99378963095",
6369      "name": "rustfmt",
6370      "status": "COMPLETED",
6371      "workflowName": "CI"
6372    },
6373    {
6374      "__typename": "StatusContext",
6375      "context": "CodeRabbit",
6376      "state": "SUCCESS",
6377      "targetUrl": ""
6378    }
6379  ],
6380  "reviews": [],
6381  "comments": [
6382    {
6383      "author": {
6384        "login": "coderabbitai"
6385      },
6386      "authorAssociation": "NONE",
6387      "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"
6388    }
6389  ]
6390}"####;
6391
6392    /// Real output for the open pull request #9 (the daily kata-apply), whose `editorconfig` check failed while everything else passed.
6393    const RED_OPEN: &str = r####"{
6394  "url": "https://github.com/yukimemi/magi/pull/9",
6395  "number": 9,
6396  "state": "OPEN",
6397  "mergeStateStatus": "UNSTABLE",
6398  "statusCheckRollup": [
6399    {
6400      "__typename": "CheckRun",
6401      "conclusion": "SUCCESS",
6402      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323744",
6403      "name": "check (ubuntu-latest)",
6404      "status": "COMPLETED",
6405      "workflowName": "CI"
6406    },
6407    {
6408      "__typename": "CheckRun",
6409      "conclusion": "SUCCESS",
6410      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323811",
6411      "name": "rustfmt",
6412      "status": "COMPLETED",
6413      "workflowName": "CI"
6414    },
6415    {
6416      "__typename": "CheckRun",
6417      "conclusion": "FAILURE",
6418      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572",
6419      "name": "editorconfig",
6420      "status": "COMPLETED",
6421      "workflowName": "CI"
6422    },
6423    {
6424      "__typename": "StatusContext",
6425      "context": "CodeRabbit",
6426      "state": "SUCCESS",
6427      "targetUrl": ""
6428    }
6429  ],
6430  "reviews": [],
6431  "comments": [
6432    {
6433      "author": {
6434        "login": "coderabbitai"
6435      },
6436      "authorAssociation": "NONE",
6437      "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"
6438    }
6439  ]
6440}"####;
6441
6442    /// 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.
6443    const PENDING_OPEN: &str = r####"{
6444  "url": "https://github.com/yukimemi/magi/pull/9",
6445  "number": 9,
6446  "state": "OPEN",
6447  "statusCheckRollup": [
6448    {
6449      "__typename": "CheckRun",
6450      "conclusion": "SUCCESS",
6451      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323744",
6452      "name": "check (ubuntu-latest)",
6453      "status": "COMPLETED",
6454      "workflowName": "CI"
6455    },
6456    {
6457      "__typename": "CheckRun",
6458      "conclusion": "SUCCESS",
6459      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323811",
6460      "name": "rustfmt",
6461      "status": "COMPLETED",
6462      "workflowName": "CI"
6463    },
6464    {
6465      "__typename": "CheckRun",
6466      "conclusion": null,
6467      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572",
6468      "name": "editorconfig",
6469      "status": "IN_PROGRESS",
6470      "workflowName": "CI"
6471    },
6472    {
6473      "__typename": "StatusContext",
6474      "context": "CodeRabbit",
6475      "state": "SUCCESS",
6476      "targetUrl": ""
6477    }
6478  ],
6479  "reviews": [],
6480  "comments": []
6481}"####;
6482
6483    /// Real output for pull request #16 after it was merged - the shape landing sees when a person merged underneath it.
6484    const MERGED: &str = r####"{
6485  "url": "https://github.com/yukimemi/magi/pull/16",
6486  "number": 16,
6487  "state": "MERGED",
6488  "statusCheckRollup": [
6489    {
6490      "__typename": "CheckRun",
6491      "conclusion": "SUCCESS",
6492      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33636587933/job/100268878095",
6493      "name": "check (ubuntu-latest)",
6494      "status": "COMPLETED",
6495      "workflowName": "CI"
6496    },
6497    {
6498      "__typename": "CheckRun",
6499      "conclusion": "SUCCESS",
6500      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33636587918/job/100268876427",
6501      "name": "review",
6502      "status": "COMPLETED",
6503      "workflowName": "claude-review"
6504    }
6505  ],
6506  "reviews": [],
6507  "comments": []
6508}"####;
6509
6510    /// 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.
6511    const REVIEWED_OPEN: &str = r####"{
6512  "url": "https://github.com/yukimemi/magi/pull/12",
6513  "number": 12,
6514  "state": "OPEN",
6515  "statusCheckRollup": [
6516    {
6517      "__typename": "CheckRun",
6518      "conclusion": "SUCCESS",
6519      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33571212506/job/100065355258",
6520      "name": "check (ubuntu-latest)",
6521      "status": "COMPLETED",
6522      "workflowName": "CI"
6523    },
6524    {
6525      "__typename": "CheckRun",
6526      "conclusion": "SUCCESS",
6527      "detailsUrl": "https://github.com/yukimemi/magi/actions/runs/33571212566/job/100065355810",
6528      "name": "review",
6529      "status": "COMPLETED",
6530      "workflowName": "claude-review"
6531    }
6532  ],
6533  "reviews": [
6534    {
6535      "author": {
6536        "login": "claude"
6537      },
6538      "state": "COMMENTED",
6539      "body": ""
6540    }
6541  ],
6542  "comments": [
6543    {
6544      "author": {
6545        "login": "coderabbitai"
6546      },
6547      "authorAssociation": "NONE",
6548      "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"
6549    },
6550    {
6551      "author": {
6552        "login": "claude"
6553      },
6554      "authorAssociation": "NONE",
6555      "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"
6556    }
6557  ]
6558}"####;
6559
6560    /// Real `gh api repos/{owner}/{repo}/pulls/12/comments` output: one inline finding with its file and line.
6561    const INLINE: &str = r####"[
6562  {
6563    "user": {
6564      "login": "claude[bot]"
6565    },
6566    "path": "src/graph.rs",
6567    "line": 231,
6568    "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"
6569  }
6570]"####;
6571
6572    /// CodeRabbit's real trigger notice: a checkbox, a `<details>` block, and its own "skip review" marker.
6573    const CODERABBIT_TRIGGER: &str = r####"<!-- This is an auto-generated comment: summarize by coderabbit.ai -->
6574<!-- This is an auto-generated comment: skip review by coderabbit.ai -->
6575
6576> [!IMPORTANT]
6577> - [ ] <!-- {"checkboxId":"e9bb8d72-00e8-4f67-9cb2-caf3b22574fe"} --> 🔍 Trigger review
6578> 
6579> This repository does not receive automatic reviews because it has fewer than 10 stars.
6580> 
6581> <details>
6582> <summary>⚙️ Run configuration</summary>
6583> 
6584> **Configuration used**: defaults
6585> 
6586> **Review profile**: CHILL
6587> 
6588> **Plan**: Team
6589> 
6590> **Run ID**: `c1e2a68f-87fc-4b35-9ec4-e75c7854966a`
6591> 
6592> </details>
6593
6594<!-- end of auto-generated comment: skip review by coderabbit.ai -->
6595
6596<!-- tips_start -->
6597
6598---
6599
6600Thanks 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.
6601
6602<details>
6603<summary>❤️ Share</summary>
6604
6605- [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"####;
6606
6607    /// 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.
6608    const CLAUDE_CHECKLIST: &str = r####"**Claude finished @yukimemi's task in 4m 14s** —— [View job](https://github.com/yukimemi/magi/actions/runs/33636587918)
6609
6610---
6611### Reviewing PR #16
6612
6613- [x] Read AGENTS.md conventions
6614- [x] Review `src/daemon.rs` changes
6615- [x] Review `src/main.rs` changes (new `doctor` reporting)
6616- [x] Review `src/web.rs` changes (reuse of unreadable-run count)
6617- [x] Check test coverage for new behavior
6618- [x] Run verification commands (blocked — see note)
6619- [x] Post findings"####;
6620
6621    /// The same job's real comment on pull request #12 once it had something to say.
6622    const CLAUDE_FINDING: &str = r####"**Claude finished @yukimemi's task in 3m 52s** —— [View job](https://github.com/yukimemi/magi/actions/runs/33571212566)
6623
6624---
6625### Review: `magi review <branch>` — cheap-half-only graph
6626
6627Read 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.
6628
6629**Correctness**
6630
6631- 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"####;
6632
6633    fn pr(checks: Checks, failing: &[&str], comments: usize) -> PrState {
6634        PrState {
6635            url: "https://github.com/yukimemi/magi/pull/16".to_owned(),
6636            number: 16,
6637            state: PrLifecycle::Open,
6638            checks,
6639            // These tests are about red-means-fix, so a red here is one the
6640            // forge gates on. Without saying so they would assert the new
6641            // "merge past a check nobody requires" path by accident.
6642            blocking: if matches!(checks, Checks::Red) {
6643                Blocking::Yes
6644            } else {
6645                Blocking::No
6646            },
6647            failing: failing.iter().map(|s| (*s).to_owned()).collect(),
6648            review_comments: (0..comments)
6649                .map(|i| ReviewComment {
6650                    author: "coderabbitai".to_owned(),
6651                    path: Some("src/graph.rs".to_owned()),
6652                    line: Some(231),
6653                    body: format!("finding {i}"),
6654                })
6655                .collect(),
6656        }
6657    }
6658
6659    #[test]
6660    fn expected_ci_is_exactly_decide_and_absent_ci_never_waits_for_checks() {
6661        use CiExpectation::{Absent, Expected};
6662        for checks in [Checks::Pending, Checks::Unknown, Checks::Green, Checks::Red] {
6663            let p = pr(checks, &["x"], 0);
6664            for waited in [Duration::ZERO, CHECKS_GRACE] {
6665                assert_eq!(
6666                    decide_with(&p, 0, 4, waited, Expected),
6667                    decide(&p, 0, 4, waited)
6668                );
6669            }
6670        }
6671        // Nothing will ever report: no wait, no give-up, no fix round.
6672        for checks in [Checks::Pending, Checks::Unknown, Checks::Red] {
6673            let p = pr(checks, &["x"], 0);
6674            assert_eq!(decide_with(&p, 0, 4, Duration::ZERO, Absent), Step::Merge);
6675            assert_eq!(decide_with(&p, 4, 4, CHECKS_GRACE, Absent), Step::Merge);
6676        }
6677        // Third-party statuses never change the review decision, even at budget.
6678        for comments in [0, 1] {
6679            for round in [0, 4] {
6680                let absent = decide_with(
6681                    &pr(Checks::Unknown, &[], comments),
6682                    round,
6683                    4,
6684                    CHECKS_GRACE,
6685                    Absent,
6686                );
6687                for checks in [Checks::Green, Checks::Red, Checks::Pending] {
6688                    assert_eq!(
6689                        decide_with(
6690                            &pr(checks, &["third-party"], comments),
6691                            round,
6692                            4,
6693                            Duration::ZERO,
6694                            Absent
6695                        ),
6696                        absent
6697                    );
6698                }
6699                if comments != 0 {
6700                    assert!(matches!(absent, Step::Fix { .. } | Step::GiveUp { .. }));
6701                    assert_eq!(matches!(absent, Step::GiveUp { .. }), round == 4);
6702                }
6703            }
6704        }
6705        let empty = pr(Checks::Unknown, &[], 0);
6706        for waited in [Duration::ZERO, CHECKS_GRACE + POLL] {
6707            assert_eq!(decide_with(&empty, 0, 4, waited, Absent), Step::Merge);
6708        }
6709        assert_eq!(
6710            decide_with(&empty, 0, 4, Duration::ZERO, Expected),
6711            Step::Wait
6712        );
6713        assert_eq!(
6714            decide_with(&empty, 0, 4, CHECKS_GRACE, Expected),
6715            Step::GiveUp { reason: "no check status is readable on the pull request after 3 minute(s); refusing to merge on a guess".to_owned() }
6716        );
6717        // A conflict is not a check: it still wants the rebase.
6718        let mut p = pr(Checks::Unknown, &[], 0);
6719        p.blocking = Blocking::Conflict;
6720        assert_eq!(decide_with(&p, 0, 4, Duration::ZERO, Absent), Step::Rebase);
6721        // And a pull request that left our hands is still done.
6722        p.state = PrLifecycle::Merged;
6723        assert_eq!(
6724            decide_with(&p, 0, 4, Duration::ZERO, Absent),
6725            Step::Done { merged: true }
6726        );
6727    }
6728
6729    #[test]
6730    fn a_green_pull_request_with_nothing_outstanding_parses_as_ready_to_merge() {
6731        let state = parse_pr(GREEN_OPEN).expect("green fixture parses");
6732        assert_eq!(state.number, 10);
6733        assert_eq!(state.state, PrLifecycle::Open);
6734        assert_eq!(state.checks, Checks::Green);
6735        assert!(state.failing.is_empty());
6736        assert!(
6737            state.review_comments.is_empty(),
6738            "the only comment is CodeRabbit's trigger notice: {:?}",
6739            state.review_comments
6740        );
6741        assert_eq!(decide(&state, 0, 4, Duration::ZERO), Step::Merge);
6742    }
6743
6744    #[test]
6745    fn a_failing_check_parses_as_red_and_is_named() {
6746        let state = parse_pr(RED_OPEN).expect("red fixture parses");
6747        assert_eq!(state.checks, Checks::Red);
6748        assert_eq!(state.failing, vec!["editorconfig".to_owned()]);
6749        // The captured payload says `UNSTABLE` - mergeable, with a check
6750        // nobody requires red - which is exactly the shape that had to be
6751        // merged by hand. Asserted separately, in
6752        // `a_red_check_nobody_requires_does_not_buy_a_fix_round`. What this
6753        // test is about is that a red check is *named*, so the reason a fixer
6754        // is handed says which one; so it asks the blocking question here.
6755        let mut blocking = state.clone();
6756        blocking.blocking = Blocking::Yes;
6757        match decide(&blocking, 0, 4, Duration::ZERO) {
6758            Step::Fix { reason } => {
6759                assert!(reason.contains("editorconfig"), "reason: {reason}");
6760                assert!(reason.contains("failing"), "reason: {reason}");
6761            }
6762            other => panic!("expected a fix round, got {other:?}"),
6763        }
6764    }
6765
6766    #[test]
6767    fn a_check_still_running_parses_as_pending_and_is_waited_for() {
6768        let state = parse_pr(PENDING_OPEN).expect("pending fixture parses");
6769        assert_eq!(state.checks, Checks::Pending);
6770        assert_eq!(decide(&state, 0, 4, Duration::ZERO), Step::Wait);
6771    }
6772
6773    #[test]
6774    fn a_pull_request_merged_underneath_us_is_done_rather_than_a_failure() {
6775        let state = parse_pr(MERGED).expect("merged fixture parses");
6776        assert_eq!(state.state, PrLifecycle::Merged);
6777        assert_eq!(
6778            decide(&state, 0, 4, Duration::ZERO),
6779            Step::Done { merged: true }
6780        );
6781    }
6782
6783    #[test]
6784    fn a_review_that_found_something_is_outstanding_and_holds_the_merge() {
6785        let state = parse_pr(REVIEWED_OPEN).expect("reviewed fixture parses");
6786        assert_eq!(state.checks, Checks::Green);
6787        let authors: Vec<&str> = state
6788            .review_comments
6789            .iter()
6790            .map(|c| c.author.as_str())
6791            .collect();
6792        assert_eq!(
6793            authors,
6794            vec!["claude"],
6795            "CodeRabbit's walkthrough is machinery; Claude's review is a finding"
6796        );
6797        match decide(&state, 0, 4, Duration::ZERO) {
6798            Step::Fix { reason } => assert!(reason.contains("unresolved"), "reason: {reason}"),
6799            other => panic!("expected a fix round, got {other:?}"),
6800        }
6801    }
6802
6803    #[test]
6804    fn inline_review_comments_keep_their_file_and_line() {
6805        let comments = parse_inline_comments(INLINE).expect("inline fixture parses");
6806        assert_eq!(comments.len(), 1);
6807        assert_eq!(comments[0].author, "claude[bot]");
6808        assert_eq!(comments[0].path.as_deref(), Some("src/graph.rs"));
6809        assert_eq!(comments[0].line, Some(231));
6810        assert!(comments[0].body.contains("empty"), "{}", comments[0].body);
6811    }
6812
6813    #[test]
6814    fn a_status_only_bot_comment_does_not_trigger_a_fix_round() {
6815        assert!(
6816            is_noise(CODERABBIT_TRIGGER),
6817            "CodeRabbit's trigger notice declares itself not a review"
6818        );
6819        assert!(
6820            is_noise(CLAUDE_CHECKLIST),
6821            "a progress checklist asks for nothing"
6822        );
6823        assert!(
6824            !is_noise(CLAUDE_FINDING),
6825            "a review that names a bug is input, not noise"
6826        );
6827
6828        let mut clean = pr(Checks::Green, &[], 0);
6829        clean.review_comments.push(ReviewComment {
6830            author: "coderabbitai".to_owned(),
6831            path: None,
6832            line: None,
6833            body: CODERABBIT_TRIGGER.to_owned(),
6834        });
6835        clean.review_comments.retain(|c| !is_noise(&c.body));
6836        assert_eq!(decide(&clean, 0, 4, Duration::ZERO), Step::Merge);
6837
6838        let mut found = pr(Checks::Green, &[], 0);
6839        found.review_comments.push(ReviewComment {
6840            author: "claude".to_owned(),
6841            path: None,
6842            line: None,
6843            body: CLAUDE_FINDING.to_owned(),
6844        });
6845        found.review_comments.retain(|c| !is_noise(&c.body));
6846        assert!(matches!(
6847            decide(&found, 0, 4, Duration::ZERO),
6848            Step::Fix { .. }
6849        ));
6850    }
6851
6852    #[test]
6853    fn the_policy_table_holds_for_every_combination_that_matters() {
6854        let cases: Vec<(&str, PrState, usize, usize, Duration, Step)> = vec![
6855            (
6856                "pending checks are waited for, even on the last round",
6857                pr(Checks::Pending, &[], 0),
6858                4,
6859                4,
6860                Duration::ZERO,
6861                Step::Wait,
6862            ),
6863            (
6864                "red checks are fixed",
6865                pr(Checks::Red, &["editorconfig"], 0),
6866                0,
6867                4,
6868                Duration::ZERO,
6869                Step::Fix {
6870                    reason: "1 check(s) failing: editorconfig".to_owned(),
6871                },
6872            ),
6873            (
6874                "green with comments is fixed, not merged",
6875                pr(Checks::Green, &[], 2),
6876                1,
6877                4,
6878                Duration::ZERO,
6879                Step::Fix {
6880                    reason: "checks are green but 2 review comment(s) are unresolved: coderabbitai"
6881                        .to_owned(),
6882                },
6883            ),
6884            (
6885                "green and clean merges",
6886                pr(Checks::Green, &[], 0),
6887                3,
6888                4,
6889                Duration::ZERO,
6890                Step::Merge,
6891            ),
6892            (
6893                "an unreadable rollup is waited on while the grace lasts",
6894                pr(Checks::Unknown, &[], 0),
6895                0,
6896                4,
6897                Duration::ZERO,
6898                Step::Wait,
6899            ),
6900            (
6901                "an unreadable rollup is never merged once the grace is spent",
6902                pr(Checks::Unknown, &[], 0),
6903                0,
6904                4,
6905                CHECKS_GRACE,
6906                Step::GiveUp {
6907                    reason: "no check status is readable on the pull request after 3 minute(s); \
6908                             refusing to merge on a guess"
6909                        .to_owned(),
6910                },
6911            ),
6912        ];
6913        for (what, state, round, budget, waited, want) in cases {
6914            assert_eq!(decide(&state, round, budget, waited), want, "{what}");
6915        }
6916    }
6917
6918    #[test]
6919    fn the_forge_verdict_survives_the_round_trip_from_gh() {
6920        // Read off `gh pr view --json ...,mergeStateStatus`, because a field
6921        // requested but never parsed is the kind of thing that looks wired up
6922        // and answers `Unsaid` forever.
6923        let green = parse_pr(GREEN_OPEN).expect("parse");
6924        assert_eq!(green.blocking, Blocking::No);
6925        let red = parse_pr(RED_OPEN).expect("parse");
6926        assert_eq!(
6927            red.blocking,
6928            Blocking::No,
6929            "`UNSTABLE` is mergeable: the red check is one nobody requires"
6930        );
6931        assert_eq!(red.checks, Checks::Red, "and it is still reported as red");
6932        // A payload from an older `gh` has no such field at all.
6933        let quiet =
6934            parse_pr(&GREEN_OPEN.replace("\"mergeStateStatus\": \"CLEAN\",", "")).expect("parse");
6935        assert_eq!(quiet.blocking, Blocking::Unsaid);
6936    }
6937
6938    #[test]
6939    fn a_red_check_nobody_requires_does_not_buy_a_fix_round() {
6940        // Pull request 37's only red check was `editorconfig`, failing
6941        // because the action could not fetch its own binary after
6942        // editorconfig-checker v4 renamed its release assets. The repository
6943        // does not require it. magi answered by asking a fixer to repair a
6944        // change that was fine, and the pull request had to be merged by hand.
6945        let mut nonblocking = pr(Checks::Red, &["editorconfig", "coverage"], 0);
6946        nonblocking.blocking = Blocking::No;
6947        assert_eq!(
6948            decide(&nonblocking, 0, 4, Duration::ZERO),
6949            Step::Merge,
6950            "the forge says nothing is in the way, so nothing is"
6951        );
6952
6953        // The same red, gated on: that is a fix round, as before.
6954        let mut blocking = pr(Checks::Red, &["test (ubuntu-latest)"], 0);
6955        blocking.blocking = Blocking::Yes;
6956        assert!(matches!(
6957            decide(&blocking, 0, 4, Duration::ZERO),
6958            Step::Fix { .. }
6959        ));
6960
6961        // A review comment still outranks green-enough: a non-required red
6962        // must not become a way to merge past an unanswered reviewer.
6963        let mut commented = pr(Checks::Red, &["coverage"], 1);
6964        commented.blocking = Blocking::No;
6965        assert!(matches!(
6966            decide(&commented, 0, 4, Duration::ZERO),
6967            Step::Fix { .. }
6968        ));
6969
6970        // And silence from the forge is not consent.
6971        let mut unsaid = pr(Checks::Red, &["coverage"], 0);
6972        unsaid.blocking = Blocking::Unsaid;
6973        assert_eq!(decide(&unsaid, 0, 4, Duration::ZERO), Step::Wait);
6974        assert!(matches!(
6975            decide(&unsaid, 0, 4, CHECKS_GRACE),
6976            Step::Fix { .. }
6977        ));
6978    }
6979
6980    #[test]
6981    fn a_red_merge_is_announced_with_every_failing_check_and_a_green_one_is_not() {
6982        let mut red = pr(Checks::Red, &["test (windows-latest)", "coverage"], 0);
6983        red.blocking = Blocking::No;
6984        assert_eq!(
6985            decide(&red, 0, 4, Duration::ZERO),
6986            Step::Merge,
6987            "announcing must not change the decision"
6988        );
6989        let said = red_merge_summary("yukimemi/magi", &red).expect("red merge is announced");
6990        assert!(said.contains("yukimemi/magi"), "{said}");
6991        assert!(said.contains("#16"), "{said}");
6992        assert!(
6993            said.contains("https://github.com/yukimemi/magi/pull/16"),
6994            "{said}"
6995        );
6996        assert!(
6997            said.contains("test (windows-latest)") && said.contains("coverage"),
6998            "{said}"
6999        );
7000
7001        // `failing` can be left over on a green observation; only `checks` counts.
7002        let green = pr(Checks::Green, &["stale"], 0);
7003        assert_eq!(red_merge_summary("yukimemi/magi", &green), None);
7004    }
7005
7006    #[test]
7007    fn red_merge_notices_omit_empty_check_details() {
7008        for checks in [vec![], vec!["", "  "]] {
7009            let red = pr(Checks::Red, &checks, 0);
7010            let summary = red_merge_summary("owner/repo", &red).unwrap();
7011            let notice = crate::notices::merged_red("run-1", &summary);
7012            assert_eq!(
7013                notice.message,
7014                format!("Merged owner/repo PR #16 with red checks ({})", red.url)
7015            );
7016            assert_eq!(notice.severity, crate::notices::Severity::Warn);
7017        }
7018        let red = pr(Checks::Red, &["", " test ", " "], 0);
7019        let summary = red_merge_summary("owner/repo", &red).unwrap();
7020        assert!(summary.contains("with red checks: test ("), "{summary}");
7021    }
7022
7023    #[test]
7024    fn the_repo_label_comes_from_the_pull_request_url() {
7025        let p = Path::new("/tmp/checkout");
7026        assert_eq!(
7027            repo_label(p, "https://github.com/yukimemi/magi/pull/16"),
7028            "yukimemi/magi"
7029        );
7030        assert_eq!(repo_label(p, "not a url"), "checkout");
7031    }
7032
7033    #[test]
7034    fn a_branch_the_base_moved_under_is_rebased_not_fixed() {
7035        // Pull requests 35 and 37 were both rebased by hand: a competition
7036        // that runs for two hours against a repository merging pull requests
7037        // all day conflicts on the way in, and that is arithmetic rather
7038        // than a defect in the change.
7039        let mut conflicted = pr(Checks::Green, &[], 0);
7040        conflicted.blocking = Blocking::Conflict;
7041        assert_eq!(decide(&conflicted, 0, 4, Duration::ZERO), Step::Rebase);
7042
7043        // Decided before the checks, and even with the rounds spent: every
7044        // check on a branch that cannot land is an answer about a state that
7045        // cannot land, and a conflict is not the change's fault.
7046        let mut red = pr(Checks::Red, &["test (ubuntu-latest)"], 2);
7047        red.blocking = Blocking::Conflict;
7048        assert_eq!(decide(&red, 4, 4, Duration::ZERO), Step::Rebase);
7049
7050        // The lifecycle still wins over everything, conflict included.
7051        let mut merged = pr(Checks::Red, &[], 0);
7052        merged.blocking = Blocking::Conflict;
7053        merged.state = PrLifecycle::Merged;
7054        assert_eq!(
7055            decide(&merged, 0, 4, Duration::ZERO),
7056            Step::Done { merged: true }
7057        );
7058    }
7059
7060    #[test]
7061    fn the_forge_verdict_is_read_off_merge_state_status() {
7062        // The spellings that mean "mergeable". `UNSTABLE` is the one that
7063        // matters: mergeable, with a non-required check red or still running.
7064        for ok in ["CLEAN", "UNSTABLE", "unstable", "HAS_HOOKS"] {
7065            assert_eq!(Blocking::of(ok), Blocking::No, "{ok}");
7066            assert!(!Blocking::of(ok).stops_a_merge(), "{ok}");
7067        }
7068        assert_eq!(Blocking::of("DIRTY"), Blocking::Conflict);
7069        assert_eq!(Blocking::of("BLOCKED"), Blocking::Yes);
7070        assert_eq!(Blocking::of("BEHIND"), Blocking::Behind);
7071        // An older `gh`, or a token without the scope, says nothing - and
7072        // refusing to guess is the rule everywhere else in this module.
7073        for quiet in ["", "UNKNOWN"] {
7074            assert_eq!(Blocking::of(quiet), Blocking::Unsaid);
7075            assert!(Blocking::of(quiet).stops_a_merge());
7076        }
7077    }
7078
7079    #[test]
7080    fn a_merge_command_that_failed_after_merging_is_still_a_merge() {
7081        let argv = merge_argv(28, "fix: retry uploads on transient network errors");
7082        // The exact stderr from run ec12, in a jj-colocated repository.
7083        let jj = "could not determine current branch: failed to run git: not on any branch";
7084
7085        let landed = merged_after_all(&argv, jj, Some(PrLifecycle::Merged))
7086            .expect("the forge says merged, so it merged");
7087        assert!(landed.ok);
7088        assert!(
7089            landed.detail.contains("but the pull request is merged"),
7090            "the record must not read as a clean success: {}",
7091            landed.detail
7092        );
7093        assert!(
7094            landed.detail.contains("not on any branch"),
7095            "and it must keep what the command actually said: {}",
7096            landed.detail
7097        );
7098
7099        // A pull request still open means the merge really failed.
7100        assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Open)).is_none());
7101        assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Closed)).is_none());
7102        // And an unreadable answer is not evidence of success.
7103        assert!(merged_after_all(&argv, jj, None).is_none());
7104    }
7105
7106    #[test]
7107    fn a_pull_request_closed_underneath_us_is_done_and_not_merged() {
7108        let mut state = pr(Checks::Red, &["editorconfig"], 3);
7109        state.state = PrLifecycle::Closed;
7110        assert_eq!(
7111            decide(&state, 0, 4, Duration::ZERO),
7112            Step::Done { merged: false },
7113            "a human closing the pull request ends the loop, whatever CI says"
7114        );
7115    }
7116
7117    #[test]
7118    fn the_last_round_gives_up_with_a_reason_naming_what_is_still_failing() {
7119        let red = decide(
7120            &pr(Checks::Red, &["editorconfig", "test (macos)"], 0),
7121            4,
7122            4,
7123            Duration::ZERO,
7124        );
7125        match red {
7126            Step::GiveUp { reason } => {
7127                assert!(reason.contains("editorconfig"), "reason: {reason}");
7128                assert!(reason.contains("test (macos)"), "reason: {reason}");
7129                assert!(reason.contains("4 fix round(s)"), "reason: {reason}");
7130            }
7131            other => panic!("expected a give-up, got {other:?}"),
7132        }
7133
7134        let commented = decide(&pr(Checks::Green, &[], 1), 2, 2, Duration::ZERO);
7135        match commented {
7136            Step::GiveUp { reason } => {
7137                assert!(reason.contains("unresolved"), "reason: {reason}");
7138                assert!(reason.contains("2 fix round(s)"), "reason: {reason}");
7139            }
7140            other => panic!("expected a give-up, got {other:?}"),
7141        }
7142    }
7143
7144    #[test]
7145    fn the_merge_command_squashes_deletes_the_branch_and_sets_its_own_subject() {
7146        let candidate_commit = "magi: candidate A (uncommitted work)";
7147        let subject = merge_subject(candidate_commit, "add retries to the uploader");
7148        let argv = merge_argv(16, &subject);
7149
7150        assert!(argv.contains(&"--squash".to_owned()));
7151        assert!(argv.contains(&"--delete-branch".to_owned()));
7152        assert!(argv.contains(&"--subject".to_owned()));
7153        assert_eq!(
7154            argv.last().map(String::as_str),
7155            Some("add retries to the uploader"),
7156            "the subject must not be the candidate commit message"
7157        );
7158        assert_ne!(subject, candidate_commit);
7159    }
7160
7161    #[test]
7162    fn a_real_pull_request_title_is_used_as_the_squash_subject_verbatim() {
7163        assert_eq!(
7164            merge_subject("feat: a queue, an unattended loop, and a phone UI", "task"),
7165            "feat: a queue, an unattended loop, and a phone UI"
7166        );
7167        assert_eq!(
7168            merge_subject("", "# port the retry logic\n\ndetails"),
7169            "port the retry logic",
7170            "an empty title falls back to the task's first line, heading marks stripped"
7171        );
7172    }
7173
7174    #[test]
7175    fn a_failing_checks_details_url_yields_the_job_to_read_logs_from() {
7176        let url = "https://github.com/yukimemi/magi/actions/runs/33587406996/job/100114323572";
7177        assert_eq!(job_of(url).as_deref(), Some("100114323572"));
7178        assert_eq!(run_of(url).as_deref(), Some("33587406996"));
7179        assert_eq!(job_of("https://coderabbit.ai/status"), None);
7180        assert_eq!(run_of(""), None);
7181    }
7182
7183    #[test]
7184    fn magis_own_stop_comment_is_never_read_back_as_a_finding() {
7185        let mut out = Vec::new();
7186        push_if_outstanding(
7187            &mut out,
7188            ReviewComment {
7189                author: "yukimemi".to_owned(),
7190                path: None,
7191                line: None,
7192                body: format!("{MARKER}\nmagi stopped landing this pull request: 1 check failing"),
7193            },
7194        );
7195        assert!(out.is_empty());
7196    }
7197
7198    /// A run with no tally, so [`RunState::winner`] is `None` and the panel
7199    /// falls back to the repository - which keeps these tests free of a
7200    /// worktree, a `git` invocation and a network.
7201    fn run_state() -> RunState {
7202        let mut state = RunState::new(
7203            std::path::PathBuf::from("/repo/magi"),
7204            "main".to_owned(),
7205            "abcdef1234".to_owned(),
7206            "add retries to the uploader".to_owned(),
7207            crate::config::Config::default(),
7208        );
7209        // These fixtures test execution flow, independent of host disk capacity.
7210        state.config.disk.min_free_bytes = 0;
7211        // Tests run in parallel against one persistent home and the ids
7212        // `RunState::new` draws from the clock can repeat, so two tests would
7213        // share a run's questions. The home also outlives the process, so the
7214        // counter alone would reuse an earlier run's ids.
7215        static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
7216        let nanos = std::time::SystemTime::now()
7217            .duration_since(std::time::UNIX_EPOCH)
7218            .map_or(0, |d| d.subsec_nanos() % 1_000_000);
7219        state.id = format!(
7220            "20261004-{nanos:06}-{:04x}",
7221            NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
7222        );
7223        state
7224    }
7225
7226    fn green_pr() -> PrState {
7227        PrState {
7228            url: "https://github.com/yukimemi/magi/pull/42".to_owned(),
7229            number: 42,
7230            state: PrLifecycle::Open,
7231            checks: Checks::Green,
7232            // The forge sees nothing in the way unless a test says otherwise.
7233            blocking: Blocking::No,
7234            failing: Vec::new(),
7235            review_comments: vec![ReviewComment {
7236                author: "coderabbitai".to_owned(),
7237                path: Some("src/land.rs".to_owned()),
7238                line: Some(212),
7239                body: "this branch never checks the exit code".to_owned(),
7240            }],
7241        }
7242    }
7243
7244    #[test]
7245    fn land_fixer_defers_review_and_verification_without_a_cache() {
7246        let state = run_state();
7247        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7248        assert!(p.contains(crate::prompt::child_run_ownership()), "{p}");
7249        assert!(p.contains("Commit in this worktree"), "{p}");
7250    }
7251
7252    #[test]
7253    fn github_facing_land_text_is_english_whatever_the_language() {
7254        let mut state = run_state();
7255        state.config.graph.language = "ja".to_owned();
7256        let comment = stop_comment(&state.id, "checks are still red");
7257        assert!(crate::github_text::check("", &comment).is_empty());
7258        assert!(comment.is_ascii(), "{comment}");
7259        assert!(comment.starts_with(MARKER));
7260
7261        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7262        let ja_at = p.find("Write all prose in ja").unwrap();
7263        let rule_at = p.find(crate::prompt::GITHUB_ENGLISH_HEADING).unwrap();
7264        assert!(ja_at < rule_at, "{p}");
7265        assert!(p.contains("stays in Japanese"), "{p}");
7266
7267        state.config.graph.language = "en".to_owned();
7268        let p = fix_prompt(&state, &green_pr(), 1, 2, "red", "");
7269        assert!(p.contains(crate::prompt::GITHUB_ENGLISH_HEADING), "{p}");
7270        assert!(!p.contains("does not apply"), "{p}");
7271    }
7272
7273    const NUMSTAT: &str = "12\t3\tsrc/land.rs\n40\t1\tsrc/web.rs\n-\t-\tassets/logo.png";
7274
7275    fn panel() -> String {
7276        approval_panel(
7277            &run_state(),
7278            &green_pr(),
7279            NUMSTAT,
7280            "diff --git a/src/land.rs b/src/land.rs\n@@ -1,2 +1,2 @@\n-old line\n+new line\n context",
7281            &[
7282                "land: ask before merging".to_owned(),
7283                "land: colour the diff".to_owned(),
7284            ],
7285            "feat: merge approval from the phone",
7286        )
7287    }
7288
7289    #[test]
7290    fn the_approval_panel_carries_the_whole_case_for_the_merge() {
7291        let html = panel();
7292        for needle in [
7293            "42",
7294            "main",
7295            "src/land.rs",
7296            "src/web.rs",
7297            "assets/logo.png",
7298            "feat: merge approval from the phone",
7299            "land: ask before merging",
7300            "land: colour the diff",
7301            "coderabbitai",
7302            "this branch never checks the exit code",
7303            "green",
7304        ] {
7305            assert!(html.contains(needle), "the panel must state `{needle}`");
7306        }
7307    }
7308
7309    async fn landing_git_fixture() -> (tempfile::TempDir, RunState, String) {
7310        crate::run::pin_test_home();
7311        let tmp = tempfile::tempdir().unwrap();
7312        let repo = tmp.path().join("repo");
7313        let remote = tmp.path().join("remote.git");
7314        std::fs::create_dir(&repo).unwrap();
7315        git::git(tmp.path(), &["init", "--bare", remote.to_str().unwrap()])
7316            .await
7317            .unwrap();
7318        git::git(&repo, &["init", "-b", "main"]).await.unwrap();
7319        git::git(&repo, &["config", "user.name", "Test"])
7320            .await
7321            .unwrap();
7322        git::git(&repo, &["config", "user.email", "test@example.test"])
7323            .await
7324            .unwrap();
7325        std::fs::write(repo.join("base"), "base").unwrap();
7326        git::git(&repo, &["add", "."]).await.unwrap();
7327        git::git(&repo, &["commit", "-m", "base"]).await.unwrap();
7328        git::git(
7329            &repo,
7330            &["remote", "add", "origin", remote.to_str().unwrap()],
7331        )
7332        .await
7333        .unwrap();
7334        git::git(&repo, &["push", "origin", "main"]).await.unwrap();
7335        git::git(&repo, &["checkout", "-b", "winner"])
7336            .await
7337            .unwrap();
7338        std::fs::write(repo.join("change"), "change").unwrap();
7339        git::git(&repo, &["add", "."]).await.unwrap();
7340        git::git(&repo, &["commit", "-m", "change"]).await.unwrap();
7341        let head = git::rev_parse(&repo, "HEAD").await.unwrap();
7342        git::git(&repo, &["push", "origin", "HEAD:refs/heads/task-head"])
7343            .await
7344            .unwrap();
7345        let mut state = run_state();
7346        state.repo = repo.clone();
7347        state.base_commit = git::rev_parse(&repo, "origin/main").await.unwrap();
7348        state.config.graph.land = true;
7349        state.config.graph.land_approval = true;
7350        state.pr_head = Some("task-head".into());
7351        state.pr_pushed_head = Some(head.clone());
7352        state.candidates = vec![winning_candidate("change")];
7353        state.candidates[0].worktree = repo;
7354        state.candidates[0].branch = "winner".into();
7355        state.tally = Some(uncontested_tally());
7356        state.gate_ran = true;
7357        state.gate_head = Some(head.clone());
7358        state.land_sync_pending = true;
7359        state.save().unwrap();
7360        (tmp, state, head)
7361    }
7362
7363    async fn resume_observed_head(state: &mut RunState, head: &str) -> Result<String> {
7364        let forge = Scripted::new(vec![seen(head, Checks::Green, "CLEAN", false)], vec![]);
7365        resume_landing_head(state, head, &green_pr().url, &forge, None).await
7366    }
7367
7368    async fn advance_landing_base(state: &RunState) {
7369        git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7370        std::fs::write(state.repo.join("advance"), "advance").unwrap();
7371        git::git(&state.repo, &["add", "."]).await.unwrap();
7372        git::git(&state.repo, &["commit", "-m", "advance base"])
7373            .await
7374            .unwrap();
7375        git::git(&state.repo, &["push", "origin", "main"])
7376            .await
7377            .unwrap();
7378        git::git(&state.repo, &["checkout", "winner"])
7379            .await
7380            .unwrap();
7381    }
7382
7383    async fn foreign_landing_fixture() -> (tempfile::TempDir, RunState, String, std::path::PathBuf)
7384    {
7385        let (tmp, mut state, old) = landing_git_fixture().await;
7386        let path = tmp.path().join("foreign");
7387        git::worktree_add_branch(&state.repo, &path, "task-head", &old)
7388            .await
7389            .unwrap();
7390        state.foreign_checkout = Some(
7391            crate::foreign_checkout::inspect(&state.repo, "task-head", &path)
7392                .await
7393                .unwrap(),
7394        );
7395        state.config.merge.mode = crate::config::MergeMode::Pr;
7396        state.save().unwrap();
7397        (tmp, state, old, path)
7398    }
7399
7400    #[tokio::test]
7401    async fn foreign_landing_sync_and_interrupted_resumes_preserve_delivery_ancestry() {
7402        for phase in 0..4 {
7403            let (_tmp, mut state, old, path) = foreign_landing_fixture().await;
7404            advance_landing_base(&state).await;
7405            state.config.verify.gate = vec!["test -f advance && test -f change".into()];
7406            if phase == 0 {
7407                // The live Step::Rebase path uses this same synchronization
7408                // and publication pair, without going through resume.
7409                assert_eq!(
7410                    rebase_landing_worktree(&mut state, "origin/main")
7411                        .await
7412                        .unwrap(),
7413                    crate::rebase::Rebased::Applied
7414                );
7415            } else {
7416                interrupt_landing_rebase(&mut state).await;
7417                let repaired_tree = git::tree_of(&state.repo, "HEAD").await.unwrap();
7418                if phase == 2 {
7419                    git::sync_to_head(&state.repo).await.unwrap();
7420                } else if phase == 3 {
7421                    // Crash after joining history, before clearing its saved
7422                    // start. Repeating restoration must not add another merge.
7423                    restore_landing_worktree(&mut state).await.unwrap();
7424                    let joined = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7425                    state.land_rebase_from = Some(old.clone());
7426                    state.save().unwrap();
7427                    restore_landing_worktree(&mut state).await.unwrap();
7428                    assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), joined);
7429                }
7430                state.save().unwrap();
7431                state = RunState::load(&state.id).unwrap();
7432                restore_landing_worktree(&mut state).await.unwrap();
7433                assert_eq!(
7434                    git::tree_of(&state.repo, "HEAD").await.unwrap(),
7435                    repaired_tree
7436                );
7437            }
7438            let head = if phase == 0 {
7439                let forge = Scripted::new(vec![seen(&old, Checks::Green, "CLEAN", false)], vec![]);
7440                publish_landing_head(&mut state, &old, &green_pr().url, &forge)
7441                    .await
7442                    .unwrap()
7443            } else {
7444                resume_observed_head(&mut state, &old).await.unwrap()
7445            };
7446            assert!(git::is_ancestor(&state.repo, &old, &head).await);
7447            assert!(git::is_ancestor(&state.repo, "origin/main", &head).await);
7448            assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), head);
7449            assert_eq!(
7450                git::remote_head(&state.repo, "origin", "task-head")
7451                    .await
7452                    .unwrap(),
7453                Some(head.clone())
7454            );
7455            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7456            assert_eq!(state.foreign_checkout.as_ref().unwrap().synced_head, head);
7457            assert!(state.gate_allows_progress());
7458            assert!(state.land_rebase_from.is_none());
7459            assert!(!state.land_sync_pending);
7460            assert!(git::is_clean(&path).await.unwrap());
7461        }
7462    }
7463
7464    #[tokio::test]
7465    async fn foreign_landing_conflict_repair_can_resume_and_publish_without_losing_ancestry() {
7466        let (_tmp, mut state, old, path) = foreign_landing_fixture().await;
7467        git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7468        std::fs::write(state.repo.join("change"), "conflicting base change").unwrap();
7469        git::commit_all(&state.repo, "conflicting base")
7470            .await
7471            .unwrap();
7472        git::git(&state.repo, &["push", "origin", "main"])
7473            .await
7474            .unwrap();
7475        git::git(&state.repo, &["checkout", "winner"])
7476            .await
7477            .unwrap();
7478        landing_gate_fixer(
7479            &mut state,
7480            "cat >/dev/null; printf resolved > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"resolved\"}'",
7481        );
7482        state.config.graph.gate_fix_rounds = 0;
7483        state.config.verify.gate = vec!["exit 1".into()];
7484        assert!(resume_observed_head(&mut state, &old).await.is_err());
7485        assert!(state.rebase_fixes.iter().any(|fix| fix.finished));
7486        let repaired = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7487        assert!(git::is_ancestor(&state.repo, &old, &repaired).await);
7488        assert_eq!(
7489            std::fs::read_to_string(state.repo.join("change")).unwrap(),
7490            "resolved"
7491        );
7492        // A red gate must neither deliver nor publish the repaired tree.
7493        assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), old);
7494        assert_eq!(
7495            git::remote_head(&state.repo, "origin", "task-head")
7496                .await
7497                .unwrap(),
7498            Some(old.clone())
7499        );
7500        state = RunState::load(&state.id).unwrap();
7501        state.config.verify.gate = vec!["grep -q resolved change".into()];
7502        let head = resume_observed_head(&mut state, &old).await.unwrap();
7503        assert_eq!(head, repaired);
7504        assert_eq!(git::rev_parse(&path, "HEAD").await.unwrap(), head);
7505        assert_eq!(
7506            std::fs::read_to_string(path.join("change")).unwrap(),
7507            "resolved"
7508        );
7509        assert_eq!(
7510            git::remote_head(&state.repo, "origin", "task-head")
7511                .await
7512                .unwrap(),
7513            Some(head.clone())
7514        );
7515        assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7516        assert!(git::is_ancestor(&state.repo, "origin/main", &head).await);
7517        assert!(git::is_clean(&path).await.unwrap());
7518    }
7519
7520    #[tokio::test]
7521    async fn landing_resume_completes_the_last_charged_sync_attempt() {
7522        for (scratch_started, saved_target) in [(false, true), (true, true), (true, false)] {
7523            let (_tmp, mut state, old) = landing_git_fixture().await;
7524            git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7525            std::fs::write(state.repo.join("change"), "conflicting base change").unwrap();
7526            git::commit_all(&state.repo, "conflicting base")
7527                .await
7528                .unwrap();
7529            git::git(&state.repo, &["push", "origin", "main"])
7530                .await
7531                .unwrap();
7532            git::git(&state.repo, &["checkout", "winner"])
7533                .await
7534                .unwrap();
7535            let target = git::rev_parse(&state.repo, "origin/main").await.unwrap();
7536            state.config.graph.land_rounds = 1;
7537            state.land_sync_attempts = 1;
7538            state.land_sync_target = saved_target.then(|| target.clone());
7539            state.land_rebase_from = Some(old.clone());
7540            landing_gate_fixer(
7541                &mut state,
7542                "cat >/dev/null; printf resolved > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"resolved\"}'",
7543            );
7544            state.config.verify.gate = vec!["grep -q resolved change".into()];
7545            state.save().unwrap();
7546            // Simulate interruption before the scratch start and at a conflict.
7547            if scratch_started {
7548                assert!(matches!(
7549                    git::rebase_start(&state.repo, &state.dir().join("rebase"), "winner", &target)
7550                        .await
7551                        .unwrap(),
7552                    git::RebaseStart::Conflicted(_)
7553                ));
7554            }
7555            state = RunState::load(&state.id).unwrap();
7556            let head = resume_observed_head(&mut state, &old).await.unwrap();
7557            assert_ne!(head, old);
7558            assert_eq!(state.land_sync_attempts, 1);
7559            assert!(state.land_sync_target.is_none());
7560            assert!(state.land_rebase_from.is_none());
7561            assert!(!state.land_sync_pending);
7562            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7563            assert!(state.gate_allows_progress());
7564            assert_eq!(
7565                git::remote_head(&state.repo, "origin", "task-head")
7566                    .await
7567                    .unwrap(),
7568                Some(head)
7569            );
7570            assert!(
7571                rebase_landing_worktree(&mut state, "origin/main")
7572                    .await
7573                    .unwrap_err()
7574                    .to_string()
7575                    .contains("budget exhausted")
7576            );
7577        }
7578    }
7579
7580    #[tokio::test]
7581    async fn landing_resume_gates_rebased_sha_and_publishes_it_to_the_existing_head() {
7582        let (_tmp, mut state, old) = landing_git_fixture().await;
7583        advance_landing_base(&state).await;
7584        state.config.verify.gate = vec!["test -f advance".into()];
7585        let head = resume_observed_head(&mut state, &old).await.unwrap();
7586        assert_ne!(head, old);
7587        assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
7588        assert!(state.gate_allows_progress());
7589        assert_eq!(
7590            git::remote_head(&state.repo, "origin", "task-head")
7591                .await
7592                .unwrap(),
7593            Some(head.clone())
7594        );
7595        assert_eq!(state.pr_pushed_head, Some(head));
7596        assert!(!state.land_sync_pending);
7597        assert!(state.config.graph.land_approval);
7598    }
7599
7600    fn landing_gate_fixer(state: &mut RunState, script: &str) {
7601        state.config.disk.min_free_bytes = 0;
7602        state.config.graph.gate_fix_rounds = 1;
7603        state.config.agents = vec![crate::config::AgentSpec {
7604            id: "mock".into(),
7605            kind: crate::config::AgentKind::Command,
7606            model: None,
7607            command: vec!["sh".into(), "-c".into(), script.into()],
7608            extra_args: Vec::new(),
7609            env: Default::default(),
7610            prompt_delivery: None,
7611            max_turn_secs: None,
7612        }];
7613        state.candidates[0].agent = "mock".into();
7614    }
7615
7616    #[tokio::test]
7617    async fn landing_resume_revalidates_an_operator_published_winner_extension() {
7618        let (_tmp, mut state, old) = landing_git_fixture().await;
7619        std::fs::write(state.repo.join("change"), "operator update").unwrap();
7620        git::commit_all(&state.repo, "extend winner").await.unwrap();
7621        let updated = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7622        git::git(
7623            &state.repo,
7624            &["push", "origin", "HEAD:refs/heads/task-head"],
7625        )
7626        .await
7627        .unwrap();
7628        state.config.verify.gate = vec!["exit 1".into()];
7629        state.config.graph.gate_fix_rounds = 0;
7630        assert!(resume_observed_head(&mut state, &updated).await.is_err());
7631        assert_ne!(old, updated);
7632        assert_eq!(state.gate_head.as_ref(), Some(&updated));
7633        assert!(!state.gate_allows_progress());
7634        assert!(state.land_sync_pending);
7635        state.config.verify.gate = vec!["grep -q 'operator update' change".into()];
7636        let head = resume_observed_head(&mut state, &updated).await.unwrap();
7637        assert_eq!(head, updated);
7638        assert!(state.gate_allows_progress());
7639        assert!(!state.land_sync_pending);
7640        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7641        land_with(&mut state, &green_pr().url, &forge)
7642            .await
7643            .unwrap();
7644        assert!(state.parked);
7645        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7646        assert!(forge.argvs().is_empty());
7647    }
7648
7649    #[tokio::test]
7650    async fn landing_resume_refuses_remote_only_and_divergent_operator_updates() {
7651        for divergent in [false, true] {
7652            let (_tmp, mut state, old) = landing_git_fixture().await;
7653            if divergent {
7654                git::git(&state.repo, &["reset", "--hard", "origin/main"])
7655                    .await
7656                    .unwrap();
7657            }
7658            std::fs::write(state.repo.join("external"), "external").unwrap();
7659            git::commit_all(&state.repo, "external update")
7660                .await
7661                .unwrap();
7662            let external = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7663            git::git(
7664                &state.repo,
7665                &["push", "--force", "origin", "HEAD:refs/heads/task-head"],
7666            )
7667            .await
7668            .unwrap();
7669            if !divergent {
7670                git::git(&state.repo, &["reset", "--hard", &old])
7671                    .await
7672                    .unwrap();
7673            }
7674            let error = resume_observed_head(&mut state, &external)
7675                .await
7676                .unwrap_err();
7677            assert!(
7678                error
7679                    .to_string()
7680                    .contains("public head moved outside this run")
7681            );
7682            assert_eq!(state.pr_pushed_head.as_ref(), Some(&old));
7683            assert_eq!(
7684                git::remote_head(&state.repo, "origin", "task-head")
7685                    .await
7686                    .unwrap(),
7687                Some(external)
7688            );
7689        }
7690    }
7691
7692    #[tokio::test]
7693    async fn landing_resume_repairs_a_failed_rebased_gate_before_publication() {
7694        let (_tmp, mut state, old) = landing_git_fixture().await;
7695        advance_landing_base(&state).await;
7696        landing_gate_fixer(
7697            &mut state,
7698            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7699        );
7700        state.config.verify.gate =
7701            vec!["grep -q fixed change || { echo 'change needs repair'; exit 1; }".into()];
7702        state.config.verify.e2e = vec!["test -f advance".into()];
7703        // First save a red gate without spending a fixer round. Resume must
7704        // still offer the remaining budget for this exact same failed head.
7705        state.config.graph.gate_fix_rounds = 0;
7706        assert!(resume_observed_head(&mut state, &old).await.is_err());
7707        assert_eq!(
7708            git::remote_head(&state.repo, "origin", "task-head")
7709                .await
7710                .unwrap(),
7711            Some(old.clone())
7712        );
7713        state.config.graph.gate_fix_rounds = 1;
7714        let head = resume_observed_head(&mut state, &old).await.unwrap();
7715        assert_eq!(state.gate_fixes.len(), 1);
7716        assert!(state.gate_fixes[0].committed);
7717        assert!(state.gate_allows_progress());
7718        assert_eq!(state.gate_head.as_ref(), Some(&head));
7719        assert_eq!(
7720            git::remote_head(&state.repo, "origin", "task-head")
7721                .await
7722                .unwrap(),
7723            Some(head.clone())
7724        );
7725        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7726        land_with(&mut state, &green_pr().url, &forge)
7727            .await
7728            .unwrap();
7729        assert!(state.parked);
7730        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7731        assert!(forge.argvs().is_empty());
7732    }
7733
7734    #[tokio::test]
7735    async fn landing_gate_repairs_stop_at_the_saved_budget_without_publishing() {
7736        let (_tmp, mut state, old) = landing_git_fixture().await;
7737        advance_landing_base(&state).await;
7738        landing_gate_fixer(
7739            &mut state,
7740            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7741        );
7742        state.config.verify.gate = vec!["echo still red; exit 1".into()];
7743        for _ in 0..2 {
7744            assert!(resume_observed_head(&mut state, &old).await.is_err());
7745            assert_eq!(state.gate_fixes.len(), 1);
7746            assert_eq!(
7747                git::remote_head(&state.repo, "origin", "task-head")
7748                    .await
7749                    .unwrap(),
7750                Some(old.clone())
7751            );
7752        }
7753    }
7754
7755    #[tokio::test]
7756    async fn landing_gate_repair_cannot_publish_failed_e2e_on_repeated_resumes() {
7757        let (_tmp, mut state, old) = landing_git_fixture().await;
7758        advance_landing_base(&state).await;
7759        landing_gate_fixer(
7760            &mut state,
7761            "cat >/dev/null; printf fixed > change; printf '{\"addressed\":[],\"rejected\":[],\"notes\":\"fixed\"}'",
7762        );
7763        state.config.verify.gate =
7764            vec!["grep -q fixed change || { echo 'change needs repair'; exit 1; }".into()];
7765        // The repair makes the gate green while breaking an e2e invariant.
7766        state.config.verify.e2e = vec!["grep -q '^change$' change".into()];
7767        for resume in 0..3 {
7768            assert!(resume_observed_head(&mut state, &old).await.is_err());
7769            state = RunState::load(&state.id).unwrap();
7770            let evidence = state.gate_repair_e2e.as_ref().unwrap();
7771            let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
7772            assert_eq!(evidence.head, head);
7773            assert!(!evidence.passed);
7774            assert!(evidence.outcomes.iter().any(|o| !o.ok()));
7775            assert_eq!(state.gate_fixes.len(), 1);
7776            assert_eq!(
7777                git::remote_head(&state.repo, "origin", "task-head")
7778                    .await
7779                    .unwrap(),
7780                Some(old.clone())
7781            );
7782            if resume > 0 {
7783                assert!(
7784                    state.gate_allows_progress(),
7785                    "a green gate must not bypass red e2e"
7786                );
7787            }
7788        }
7789        // Once e2e genuinely succeeds on the same SHA, the saved requirement
7790        // can be satisfied without another fixer or approval bypass.
7791        state.config.verify.e2e = vec!["grep -q fixed change".into()];
7792        let head = resume_observed_head(&mut state, &old).await.unwrap();
7793        assert!(state.gate_repair_e2e.as_ref().unwrap().passed);
7794        assert_eq!(state.gate_repair_e2e.as_ref().unwrap().head, head);
7795        assert_eq!(state.gate_fixes.len(), 1);
7796        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
7797        land_with(&mut state, &green_pr().url, &forge)
7798            .await
7799            .unwrap();
7800        assert!(state.parked);
7801        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
7802        assert!(forge.argvs().is_empty());
7803    }
7804
7805    #[tokio::test]
7806    async fn landing_resumes_recheck_pending_deferred_and_stale_repair_e2e() {
7807        for phase in 0..3 {
7808            let (_tmp, mut state, old) = landing_git_fixture().await;
7809            advance_landing_base(&state).await;
7810            let head = resume_observed_head(&mut state, &old).await.unwrap();
7811            // Persist the shapes left by interruption, resource deferral,
7812            // and a successful check for a different (older) SHA.
7813            state.land_sync_pending = true;
7814            state.config.verify.e2e = vec!["echo e2e is red; exit 1".into()];
7815            state.gate_repair_e2e = Some(crate::run::GateRepairE2e {
7816                head: if phase == 2 {
7817                    old.clone()
7818                } else {
7819                    head.clone()
7820                },
7821                passed: phase == 2,
7822                outcomes: if phase == 1 {
7823                    vec![crate::run::CommandOutcome {
7824                        command: state.config.verify.e2e[0].clone(),
7825                        code: None,
7826                        output_tail: "verification resource unavailable".into(),
7827                        duration_ms: 0,
7828                        resource_blocked: true,
7829                    }]
7830                } else {
7831                    Vec::new()
7832                },
7833            });
7834            state.save().unwrap();
7835            for _ in 0..2 {
7836                state = RunState::load(&state.id).unwrap();
7837                assert!(resume_observed_head(&mut state, &head).await.is_err());
7838                let evidence = state.gate_repair_e2e.as_ref().unwrap();
7839                assert_eq!(evidence.head, head);
7840                assert!(!evidence.passed);
7841                assert!(!evidence.outcomes.is_empty());
7842                assert_eq!(
7843                    git::remote_head(&state.repo, "origin", "task-head")
7844                        .await
7845                        .unwrap(),
7846                    Some(head.clone())
7847                );
7848                assert!(state.land_sync_pending);
7849            }
7850        }
7851    }
7852
7853    async fn interrupt_landing_rebase(state: &mut RunState) {
7854        state.land_rebase_from = Some(git::rev_parse(&state.repo, "HEAD").await.unwrap());
7855        state.save().unwrap();
7856        let scratch = state.dir().join("rebase");
7857        assert_eq!(
7858            crate::rebase::rebase_with_fixer(state, &scratch, "winner", "origin/main")
7859                .await
7860                .unwrap(),
7861            crate::rebase::Rebased::Applied
7862        );
7863        assert!(!git::is_clean(&state.repo).await.unwrap());
7864    }
7865
7866    async fn landing_setup(state: &mut RunState) {
7867        git::git(
7868            &state.repo,
7869            &["config", "extensions.worktreeConfig", "true"],
7870        )
7871        .await
7872        .unwrap();
7873        state.config.worktree.setup =
7874            vec![toml::from_str("run = \"printf secret > .env\"").unwrap()];
7875        crate::worktree_setup::prepare(&state.config, &state.repo, &state.repo)
7876            .await
7877            .unwrap();
7878        state.config.verify.gate = vec!["test -f advance && test -f .env".into()];
7879    }
7880
7881    #[tokio::test]
7882    async fn landing_resume_restores_setup_after_both_fresh_and_interrupted_rebases() {
7883        for phase in 0..3 {
7884            let (_tmp, mut state, old) = landing_git_fixture().await;
7885            advance_landing_base(&state).await;
7886            landing_setup(&mut state).await;
7887            if phase > 0 {
7888                interrupt_landing_rebase(&mut state).await;
7889                if phase == 2 {
7890                    // Crash after clean removed setup products, before setup.
7891                    git::sync_to_head(&state.repo).await.unwrap();
7892                    assert!(!state.repo.join(".env").exists());
7893                }
7894                state = RunState::load(&state.id).unwrap();
7895            }
7896            let head = resume_observed_head(&mut state, &old).await.unwrap();
7897            assert_ne!(head, old);
7898            assert!(state.gate_allows_progress());
7899            assert!(state.land_rebase_from.is_none());
7900            assert_eq!(
7901                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
7902                "secret"
7903            );
7904            assert!(git::is_clean(&state.repo).await.unwrap());
7905            assert!(
7906                !git::git(&state.repo, &["ls-tree", "--name-only", "HEAD"])
7907                    .await
7908                    .unwrap()
7909                    .contains(".env")
7910            );
7911        }
7912    }
7913
7914    #[tokio::test]
7915    async fn landing_restoration_protects_ignored_files_outside_setup_products() {
7916        let (_tmp, mut state, _) = landing_git_fixture().await;
7917        advance_landing_base(&state).await;
7918        landing_setup(&mut state).await;
7919        interrupt_landing_rebase(&mut state).await;
7920        // Exercise unusual names without asking Windows to create an invalid
7921        // control-character filename. Unix also covers embedded newlines.
7922        let locals = [
7923            "local notes",
7924            #[cfg(unix)]
7925            "local\nnotes",
7926        ];
7927        let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
7928            .await
7929            .unwrap();
7930        std::fs::write(state.repo.join(excludes), "local*\n").unwrap();
7931        for local in locals {
7932            std::fs::write(state.repo.join(local), "keep these notes").unwrap();
7933            assert!(
7934                git::git_raw(&state.repo, &["check-ignore", "--quiet", local])
7935                    .await
7936                    .unwrap()
7937                    .ok()
7938            );
7939        }
7940        restore_landing_worktree(&mut state).await.unwrap();
7941        for local in locals {
7942            assert_eq!(
7943                std::fs::read_to_string(state.repo.join(local)).unwrap(),
7944                "keep these notes"
7945            );
7946        }
7947        assert_eq!(
7948            std::fs::read_to_string(state.repo.join(".env")).unwrap(),
7949            "secret"
7950        );
7951        assert!(git::is_clean(&state.repo).await.unwrap());
7952        assert!(state.land_rebase_from.is_none());
7953    }
7954
7955    #[tokio::test]
7956    async fn landing_restoration_rejects_ignored_paths_conflicting_with_the_new_tree() {
7957        for local in ["advance", "advance/notes", "new-directory"] {
7958            let (_tmp, mut state, _) = landing_git_fixture().await;
7959            advance_landing_base(&state).await;
7960            // Also cover a local file blocking a new tracked directory.
7961            git::git(&state.repo, &["checkout", "main"]).await.unwrap();
7962            std::fs::create_dir(state.repo.join("new-directory")).unwrap();
7963            std::fs::write(state.repo.join("new-directory/tracked"), "new").unwrap();
7964            git::git(&state.repo, &["add", "."]).await.unwrap();
7965            git::git(&state.repo, &["commit", "-m", "add directory"])
7966                .await
7967                .unwrap();
7968            git::git(&state.repo, &["push", "origin", "main"])
7969                .await
7970                .unwrap();
7971            git::git(&state.repo, &["checkout", "winner"])
7972                .await
7973                .unwrap();
7974            let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
7975                .await
7976                .unwrap();
7977            std::fs::write(state.repo.join(excludes), "advance\nnew-directory\n").unwrap();
7978            let path = state.repo.join(local);
7979            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
7980            std::fs::write(&path, "local notes").unwrap();
7981            interrupt_landing_rebase(&mut state).await;
7982            let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
7983            let checkpoint = state.land_rebase_from.clone();
7984            let error = restore_landing_worktree(&mut state).await.unwrap_err();
7985            assert!(
7986                error.to_string().contains("conflicting with HEAD"),
7987                "{error:#}"
7988            );
7989            assert_eq!(std::fs::read_to_string(&path).unwrap(), "local notes");
7990            assert_eq!(
7991                git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
7992                before
7993            );
7994            assert_eq!(state.land_rebase_from, checkpoint);
7995        }
7996    }
7997
7998    #[tokio::test]
7999    async fn landing_resume_preserves_ignored_gate_artifacts_without_setup() {
8000        for interrupted in [false, true] {
8001            let (_tmp, mut state, old) = landing_git_fixture().await;
8002            assert!(state.config.worktree.setup.is_empty());
8003            // A gate product exists before the base moves, without setup metadata.
8004            let excludes = git::git(&state.repo, &["rev-parse", "--git-path", "info/exclude"])
8005                .await
8006                .unwrap();
8007            std::fs::write(state.repo.join(excludes), "target/\n").unwrap();
8008            state.config.verify.gate =
8009                vec!["mkdir -p target && printf artifact > target/probe".into()];
8010            state.gate_ran = false;
8011            resume_observed_head(&mut state, &old).await.unwrap();
8012            assert_eq!(
8013                std::fs::read_to_string(state.repo.join("target/probe")).unwrap(),
8014                "artifact"
8015            );
8016            advance_landing_base(&state).await;
8017            if interrupted {
8018                interrupt_landing_rebase(&mut state).await;
8019                state = RunState::load(&state.id).unwrap();
8020            }
8021            state.config.verify.gate =
8022                vec!["test -f advance && test \"$(cat target/probe)\" = artifact".into()];
8023            let head = resume_observed_head(&mut state, &old).await.unwrap();
8024            assert_ne!(head, old);
8025            assert!(state.gate_allows_progress());
8026            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
8027            assert_eq!(
8028                std::fs::read_to_string(state.repo.join("target/probe")).unwrap(),
8029                "artifact"
8030            );
8031            assert!(state.land_rebase_from.is_none());
8032            assert_eq!(
8033                git::remote_head(&state.repo, "origin", "task-head")
8034                    .await
8035                    .unwrap(),
8036                Some(head.clone())
8037            );
8038            let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8039            land_with(&mut state, &green_pr().url, &forge)
8040                .await
8041                .unwrap();
8042            assert!(state.parked);
8043            assert_eq!(state.land_approval.as_ref().unwrap().head, head);
8044            assert!(forge.argvs().is_empty());
8045        }
8046    }
8047
8048    #[tokio::test]
8049    #[cfg(unix)]
8050    async fn landing_restoration_waits_for_external_coordination_before_changing_files() {
8051        use std::os::fd::AsRawFd as _;
8052
8053        for interrupted in [false, true] {
8054            let (_tmp, mut state, _) = landing_git_fixture().await;
8055            advance_landing_base(&state).await;
8056            landing_setup(&mut state).await;
8057            if interrupted {
8058                interrupt_landing_rebase(&mut state).await;
8059            }
8060            state.config.worktree.setup =
8061                vec![toml::from_str("run = \"printf restored > .env\"").unwrap()];
8062            let common = crate::repo_lock::common_dir(&state.repo)
8063                .await
8064                .unwrap()
8065                .unwrap();
8066            std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8067            state.config.coordination = crate::config::test_coordination();
8068            state.config.graph.timeout_resource_wait = 0;
8069            let external = std::fs::OpenOptions::new()
8070                .read(true)
8071                .write(true)
8072                .create(true)
8073                .truncate(false)
8074                .open(common.join("updater.lock"))
8075                .unwrap();
8076            // SAFETY: the descriptor belongs to `external` and remains open.
8077            let locked =
8078                unsafe { libc::flock(external.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
8079            assert_eq!(locked, 0);
8080            let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
8081            let checkpoint = state.land_rebase_from.clone();
8082            let error = restore_landing_worktree(&mut state).await.unwrap_err();
8083            assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8084            assert_eq!(
8085                git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
8086                before
8087            );
8088            assert_eq!(state.land_rebase_from, checkpoint);
8089            assert_eq!(
8090                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8091                "secret"
8092            );
8093
8094            drop(external);
8095            state.config.graph.timeout_resource_wait = 2;
8096            restore_landing_worktree(&mut state).await.unwrap();
8097            assert!(git::is_clean(&state.repo).await.unwrap());
8098            assert!(state.land_rebase_from.is_none());
8099            assert_eq!(
8100                std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8101                "restored"
8102            );
8103        }
8104    }
8105
8106    #[tokio::test]
8107    #[cfg(unix)]
8108    async fn landing_restoration_inherits_cancellation_while_waiting_for_a_local_seat() {
8109        use std::sync::atomic::{AtomicBool, Ordering};
8110
8111        let (_tmp, mut state, _) = landing_git_fixture().await;
8112        advance_landing_base(&state).await;
8113        landing_setup(&mut state).await;
8114        interrupt_landing_rebase(&mut state).await;
8115        let common = crate::repo_lock::common_dir(&state.repo)
8116            .await
8117            .unwrap()
8118            .unwrap();
8119        std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8120        state.config.coordination = crate::config::test_coordination();
8121        let holder = crate::repo_lock::SeatLease::for_checkout(
8122            &state.repo,
8123            true,
8124            state.config.coordination.as_ref(),
8125        )
8126        .await
8127        .unwrap();
8128        assert!(holder.is_some());
8129        let cancelled = Arc::new(AtomicBool::new(false));
8130        let signal = cancelled.clone();
8131        let wait = crate::repo_lock::WaitPolicy::new(Duration::from_secs(30), move || {
8132            signal.load(Ordering::SeqCst)
8133        });
8134        let before = git::git(&state.repo, &["diff", "HEAD"]).await.unwrap();
8135        let checkpoint = state.land_rebase_from.clone();
8136        let (result, ()) = tokio::join!(
8137            tokio::time::timeout(
8138                Duration::from_secs(2),
8139                wait.scope(restore_landing_worktree(&mut state)),
8140            ),
8141            async {
8142                tokio::time::sleep(Duration::from_millis(100)).await;
8143                cancelled.store(true, Ordering::SeqCst);
8144            }
8145        );
8146        let error = result
8147            .expect("cancellation must release the waiting driver")
8148            .unwrap_err();
8149        assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8150        assert_eq!(
8151            git::git(&state.repo, &["diff", "HEAD"]).await.unwrap(),
8152            before
8153        );
8154        assert_eq!(state.land_rebase_from, checkpoint);
8155        assert_eq!(
8156            std::fs::read_to_string(state.repo.join(".env")).unwrap(),
8157            "secret"
8158        );
8159        drop(holder);
8160        restore_landing_worktree(&mut state).await.unwrap();
8161        assert!(state.land_rebase_from.is_none());
8162        assert!(git::is_clean(&state.repo).await.unwrap());
8163    }
8164
8165    #[tokio::test]
8166    #[cfg(unix)]
8167    async fn landing_verification_inherits_cancellation_while_waiting_for_a_local_seat() {
8168        use std::sync::atomic::{AtomicBool, Ordering};
8169
8170        for e2e in [false, true] {
8171            let (_tmp, mut state, head) = landing_git_fixture().await;
8172            let common = crate::repo_lock::common_dir(&state.repo)
8173                .await
8174                .unwrap()
8175                .unwrap();
8176            std::fs::write(common.join("updater.contract"), "test-protocol-v1\n").unwrap();
8177            state.config.coordination = crate::config::test_coordination();
8178            if e2e {
8179                state.config.verify.e2e = vec!["true".into()];
8180                state.gate_repair_e2e = Some(crate::run::GateRepairE2e {
8181                    head: head.clone(),
8182                    passed: false,
8183                    outcomes: Vec::new(),
8184                });
8185            } else {
8186                state.config.verify.gate = vec!["true".into()];
8187                state.gate_ran = false;
8188            }
8189            let holder = crate::repo_lock::SeatLease::for_checkout(
8190                &state.repo,
8191                true,
8192                state.config.coordination.as_ref(),
8193            )
8194            .await
8195            .unwrap();
8196            assert!(holder.is_some());
8197            let cancelled = Arc::new(AtomicBool::new(false));
8198            let signal = cancelled.clone();
8199            let waiting = Arc::new(tokio::sync::Notify::new());
8200            let observed = waiting.clone();
8201            let wait = crate::repo_lock::WaitPolicy::new(Duration::from_secs(30), move || {
8202                observed.notify_one();
8203                signal.load(Ordering::SeqCst)
8204            });
8205            let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8206            let url = green_pr().url;
8207            let result = {
8208                let mut publishing =
8209                    Box::pin(wait.scope(publish_landing_head(&mut state, &head, &url, &forge)));
8210                // Git and fixture I/O precede local coordination. Start the
8211                // cancellation deadline only once the inherited wait policy
8212                // is polled, rather than timing those unrelated subprocesses.
8213                tokio::time::timeout(Duration::from_secs(30), async {
8214                    tokio::select! {
8215                        result = &mut publishing => panic!(
8216                            "verification must wait behind the held seat: {result:?}"
8217                        ),
8218                        () = waiting.notified() => {}
8219                    }
8220                })
8221                .await
8222                .expect("verification must reach the inherited coordination wait");
8223                cancelled.store(true, Ordering::SeqCst);
8224                tokio::time::timeout(Duration::from_secs(2), publishing).await
8225            };
8226            let error = result
8227                .expect("cancellation must release the verification waiter")
8228                .unwrap_err();
8229            assert!(error.is::<crate::repo_lock::ResourceBlocked>(), "{error:#}");
8230            assert!(error.to_string().contains("cancelled"), "{error:#}");
8231            assert!(forge.argvs().is_empty());
8232            assert_eq!(
8233                git::remote_head(&state.repo, "origin", "task-head")
8234                    .await
8235                    .unwrap(),
8236                Some(head.clone())
8237            );
8238            drop(holder);
8239            // Cancellation must release its reservation so another attempt can verify.
8240            assert_eq!(
8241                publish_landing_head(&mut state, &head, &url, &forge)
8242                    .await
8243                    .unwrap(),
8244                head
8245            );
8246        }
8247    }
8248
8249    #[tokio::test]
8250    async fn landing_resume_preserves_user_edits_after_an_interrupted_rebase() {
8251        for staged in [false, true] {
8252            let (_tmp, mut state, old) = landing_git_fixture().await;
8253            advance_landing_base(&state).await;
8254            interrupt_landing_rebase(&mut state).await;
8255            std::fs::write(state.repo.join("change"), "user edit").unwrap();
8256            if staged {
8257                git::git(&state.repo, &["add", "change"]).await.unwrap();
8258            }
8259            assert!(resume_observed_head(&mut state, &old).await.is_err());
8260            assert_eq!(
8261                std::fs::read_to_string(state.repo.join("change")).unwrap(),
8262                "user edit"
8263            );
8264            assert_eq!(
8265                git::remote_head(&state.repo, "origin", "task-head")
8266                    .await
8267                    .unwrap(),
8268                Some(old)
8269            );
8270        }
8271    }
8272
8273    #[tokio::test]
8274    async fn landing_resume_returns_to_approval_wait_and_closed_pr_skips_sync() {
8275        let (_tmp, mut state, head) = landing_git_fixture().await;
8276        let forge = Scripted::new(vec![seen(&head, Checks::Green, "CLEAN", false)], vec![]);
8277        let id = state.id.clone();
8278        let pr = land_with(&mut state, &green_pr().url, &forge)
8279            .await
8280            .unwrap();
8281        assert_eq!(pr.state, PrLifecycle::Open);
8282        assert_eq!(state.id, id);
8283        assert!(state.parked);
8284        assert_eq!(state.status, RunStatus::Landing);
8285        assert_eq!(state.land_approval.as_ref().unwrap().head, head);
8286        assert!(forge.argvs().is_empty());
8287
8288        state.land_sync_pending = true;
8289        std::fs::write(state.repo.join("dirty"), "do not touch").unwrap();
8290        let mut closed = seen("foreign", Checks::Green, "CLEAN", false);
8291        closed.pr.state = PrLifecycle::Closed;
8292        let forge = Scripted::new(vec![closed], vec![]);
8293        assert_eq!(
8294            land_with(&mut state, &green_pr().url, &forge)
8295                .await
8296                .unwrap()
8297                .state,
8298            PrLifecycle::Closed
8299        );
8300        assert_eq!(
8301            std::fs::read_to_string(state.repo.join("dirty")).unwrap(),
8302            "do not touch"
8303        );
8304        assert!(forge.argvs().is_empty());
8305    }
8306
8307    #[tokio::test]
8308    async fn landing_resume_does_not_publish_a_failed_rebased_gate() {
8309        let (_tmp, mut state, old) = landing_git_fixture().await;
8310        advance_landing_base(&state).await;
8311        state.config.verify.gate = vec!["exit 1".into()];
8312        assert!(resume_observed_head(&mut state, &old).await.is_err());
8313        assert_ne!(state.gate_head.as_deref(), Some(old.as_str()));
8314        assert!(!state.gate_allows_progress());
8315        assert_eq!(
8316            git::remote_head(&state.repo, "origin", "task-head")
8317                .await
8318                .unwrap(),
8319            Some(old)
8320        );
8321        assert!(state.land_sync_pending);
8322    }
8323
8324    #[tokio::test]
8325    async fn landing_publication_recovers_a_push_before_save_and_refuses_a_lease_conflict() {
8326        let (_tmp, mut state, old) = landing_git_fixture().await;
8327        advance_landing_base(&state).await;
8328        let pushed = resume_observed_head(&mut state, &old).await.unwrap();
8329        // Model a crash after the push but before saving its published SHA.
8330        state.pr_pushed_head = Some(old.clone());
8331        state.land_sync_pending = true;
8332        assert_eq!(
8333            resume_observed_head(&mut state, &pushed).await.unwrap(),
8334            pushed
8335        );
8336        // A writer races the observed PR snapshot: the explicit remote lease
8337        // must reject the push even though preflight saw our expected head.
8338        git::git(
8339            &state.repo,
8340            &["push", "--force", "origin", "main:refs/heads/task-head"],
8341        )
8342        .await
8343        .unwrap();
8344        assert!(
8345            publish_landing_head(
8346                &mut state,
8347                &pushed,
8348                &green_pr().url,
8349                &Scripted::new(vec![seen(&pushed, Checks::Green, "CLEAN", false)], vec![])
8350            )
8351            .await
8352            .unwrap_err()
8353            .to_string()
8354            .contains("publishing gated")
8355        );
8356        assert!(
8357            resume_observed_head(&mut state, "foreign-head")
8358                .await
8359                .is_err()
8360        );
8361    }
8362    #[tokio::test]
8363    async fn landing_publication_refuses_a_pr_closed_during_gate() {
8364        let (_tmp, mut state, head) = landing_git_fixture().await;
8365        let mut closed = seen(&head, Checks::Green, "CLEAN", false);
8366        closed.pr.state = PrLifecycle::Closed;
8367        let forge = Scripted::new(vec![closed], vec![]);
8368        assert!(
8369            publish_landing_head(&mut state, &head, &green_pr().url, &forge)
8370                .await
8371                .unwrap_err()
8372                .to_string()
8373                .contains("PR closed or merged")
8374        );
8375    }
8376
8377    /// A candidate selected by the uncontested tally.
8378    fn winning_candidate(summary: &str) -> Candidate {
8379        Candidate {
8380            index: 0,
8381            label: 'A',
8382            agent: "opus".to_owned(),
8383            branch: "magi/x/A".to_owned(),
8384            worktree: PathBuf::from("/wt/A"),
8385            summary: summary.to_owned(),
8386            stat: String::new(),
8387            files: 1,
8388            commits: 1,
8389            empty: false,
8390            failed: None,
8391            verified_noop: None,
8392            duration_ms: 0,
8393            folded: false,
8394        }
8395    }
8396
8397    fn uncontested_tally() -> Tally {
8398        Tally {
8399            first_choice: BTreeMap::from([('A', 1)]),
8400            borda: BTreeMap::new(),
8401            winner: 'A',
8402            rankings: 1,
8403            unanimous_initial: true,
8404            deliberated: false,
8405            changed_votes: 0,
8406            unanimous_final: true,
8407            tie_break: None,
8408            judges: 1,
8409            present: 1,
8410            quorum: 1,
8411            met_quorum: true,
8412            uncontested: None,
8413        }
8414    }
8415
8416    fn review_record(reviewer: usize, agent: &str, summary: &str) -> ReviewRecord {
8417        ReviewRecord {
8418            attempts: 0,
8419            reviewer,
8420            agent: agent.to_owned(),
8421            summary: summary.to_owned(),
8422            findings: Vec::new(),
8423            vote: None,
8424            failed: None,
8425            duration_ms: 0,
8426        }
8427    }
8428
8429    fn review_round(round: usize, reviews: Vec<ReviewRecord>) -> ReviewRound {
8430        let answered = reviews.len();
8431        ReviewRound {
8432            round,
8433            head: "abc1234".to_owned(),
8434            verified_head: None,
8435            verified_at: None,
8436            reviews,
8437            e2e: Vec::new(),
8438            verify_retried: false,
8439            e2e_deferred: false,
8440            e2e_defer_reason: None,
8441            fix: None,
8442            blocking: 0,
8443            answered,
8444            expected: answered,
8445            clean: true,
8446            progressed: false,
8447            vote_split: false,
8448            reconsideration: Vec::new(),
8449            verdict: None,
8450        }
8451    }
8452
8453    #[test]
8454    fn the_approval_panel_states_the_task_verbatim_in_either_language() {
8455        let en = panel();
8456        assert!(en.contains("Task"), "{en}");
8457        assert!(en.contains("add retries to the uploader"), "{en}");
8458
8459        let mut state = run_state();
8460        state.config.graph.language = "ja".to_owned();
8461        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8462        assert!(ja.contains("タスク"), "{ja}");
8463        assert!(
8464            ja.contains("add retries to the uploader"),
8465            "the task itself is not translated: {ja}"
8466        );
8467    }
8468
8469    #[test]
8470    fn the_approval_panel_omits_what_changed_and_review_verdict_with_no_data() {
8471        // `run_state()` has no candidates, no tally and no reviews - exactly
8472        // the shape a run has before anything has judged or reviewed it, and
8473        // the panel must not print an empty box for either.
8474        let html = panel();
8475        assert!(!html.contains("What changed"), "{html}");
8476        assert!(!html.contains("Review verdict"), "{html}");
8477    }
8478
8479    #[test]
8480    fn the_approval_panel_omits_what_changed_when_the_winners_summary_is_empty() {
8481        let mut state = run_state();
8482        state.candidates = vec![winning_candidate("")];
8483        state.tally = Some(uncontested_tally());
8484        let html = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8485        assert!(
8486            !html.contains("What changed"),
8487            "an empty summary must not render an empty box: {html}"
8488        );
8489    }
8490
8491    #[test]
8492    fn the_approval_panel_shows_the_winners_own_account_in_either_language() {
8493        let mut state = run_state();
8494        state.candidates = vec![winning_candidate(
8495            "Added a retry loop around the uploader PUT call.",
8496        )];
8497        state.tally = Some(uncontested_tally());
8498        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8499        assert!(en.contains("What changed"), "{en}");
8500        assert!(
8501            en.contains("Added a retry loop around the uploader PUT call."),
8502            "{en}"
8503        );
8504
8505        state.config.graph.language = "ja".to_owned();
8506        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8507        assert!(ja.contains("変更内容"), "{ja}");
8508        assert!(
8509            ja.contains("Added a retry loop around the uploader PUT call."),
8510            "{ja}"
8511        );
8512    }
8513
8514    #[test]
8515    fn the_approval_panel_shows_only_the_last_review_rounds_verdict() {
8516        let mut state = run_state();
8517        state.reviews = vec![
8518            review_round(
8519                1,
8520                vec![review_record(1, "alpha", "found a race, sent back")],
8521            ),
8522            review_round(2, vec![review_record(1, "alpha", "race is fixed, clean")]),
8523        ];
8524        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8525        assert!(en.contains("Review verdict"), "{en}");
8526        assert!(en.contains("race is fixed, clean"), "{en}");
8527        assert!(
8528            !en.contains("found a race, sent back"),
8529            "only the round that actually cleared the merge should show: {en}"
8530        );
8531
8532        state.config.graph.language = "ja".to_owned();
8533        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8534        assert!(ja.contains("レビューの結論"), "{ja}");
8535        assert!(ja.contains("レビュアー"), "{ja}");
8536        assert!(ja.contains("race is fixed, clean"), "{ja}");
8537    }
8538
8539    /// The `incomplete_review = "warn"` policy (see
8540    /// `graph::Runner::review_loop`) can push a `clean` round to
8541    /// `state.reviews` while one seat's own record still has `failed: Some`
8542    /// and an empty `summary` - a seat that never answered, not one that
8543    /// answered with nothing to say.
8544    fn unanswered_review_record(reviewer: usize, agent: &str, reason: &str) -> ReviewRecord {
8545        ReviewRecord {
8546            attempts: 0,
8547            reviewer,
8548            agent: agent.to_owned(),
8549            summary: String::new(),
8550            findings: Vec::new(),
8551            vote: None,
8552            failed: Some(reason.to_owned()),
8553            duration_ms: 0,
8554        }
8555    }
8556
8557    #[test]
8558    fn the_approval_panel_never_shows_an_unanswered_seat_as_a_blank_verdict() {
8559        let mut state = run_state();
8560        state.reviews = vec![review_round(
8561            1,
8562            vec![
8563                review_record(1, "alpha", "clean, nothing to add"),
8564                unanswered_review_record(2, "beta", "timed out"),
8565            ],
8566        )];
8567        let en = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8568        assert!(en.contains("clean, nothing to add"), "{en}");
8569        assert!(
8570            en.contains("produced no answer: timed out"),
8571            "a seat that never answered must say so, not render a blank box: {en}"
8572        );
8573        assert!(
8574            !en.contains("<div style=\"white-space:pre-wrap;font-size:13px\"></div>"),
8575            "no reviewer box may be left empty: {en}"
8576        );
8577
8578        state.config.graph.language = "ja".to_owned();
8579        let ja = approval_panel(&state, &green_pr(), NUMSTAT, "", &[], "feat: x");
8580        assert!(ja.contains("回答なし: timed out"), "{ja}");
8581    }
8582
8583    #[test]
8584    fn the_approval_panel_contains_nothing_the_frames_policy_would_block() {
8585        let html = panel();
8586        assert!(!html.contains("<script"), "no script survives the csp");
8587        assert!(!html.contains("<form"), "form-action is 'none'");
8588        let pr = green_pr();
8589        assert_eq!(
8590            html.matches("http").count(),
8591            html.matches(pr.url.as_str()).count(),
8592            "the only http url in the panel is the pull request's own link"
8593        );
8594        assert!(
8595            html.contains("target=\"_blank\""),
8596            "the PR link must open in a new tab so it escapes the iframe"
8597        );
8598        assert!(
8599            html.contains("rel=\"noopener noreferrer\""),
8600            "external links opening in new tabs must carry noopener noreferrer"
8601        );
8602    }
8603
8604    #[test]
8605    fn added_and_removed_diff_lines_are_distinguishable_without_colour() {
8606        let html = panel();
8607        assert!(
8608            html.contains(">+</span>"),
8609            "an added line carries a `+` in the gutter, not only a background"
8610        );
8611        assert!(
8612            html.contains(">-</span>"),
8613            "a removed line carries a `-` in the gutter, not only a background"
8614        );
8615        assert!(
8616            html.contains(">new line</span>"),
8617            "the marker is moved to the gutter, so the body is printed once without it"
8618        );
8619    }
8620
8621    #[test]
8622    fn a_diff_past_the_threshold_is_cut_with_an_honest_count() {
8623        let total = DIFF_MAX_LINES + 100;
8624        let diff: String = (0..total).map(|i| format!("+line {i}\n")).collect();
8625        let html = approval_panel(
8626            &run_state(),
8627            &green_pr(),
8628            NUMSTAT,
8629            &diff,
8630            &[],
8631            "feat: something long",
8632        );
8633        assert!(
8634            html.contains(&format!("100 of {total} diff lines omitted")),
8635            "the note must say exactly how much was cut"
8636        );
8637        assert!(html.contains(&format!("line {}", DIFF_MAX_LINES - 1)));
8638        assert!(
8639            !html.contains(&format!("line {DIFF_MAX_LINES}")),
8640            "nothing past the threshold is rendered"
8641        );
8642        assert!(
8643            html.contains("/repo/magi"),
8644            "the note says where the rest is"
8645        );
8646    }
8647
8648    #[test]
8649    fn a_path_with_html_metacharacters_is_escaped_rather_than_rendered() {
8650        let html = approval_panel(
8651            &run_state(),
8652            &green_pr(),
8653            "1\t2\tsrc/<b>&\"x\"'.rs",
8654            "",
8655            &[],
8656            "subject",
8657        );
8658        assert!(html.contains("src/&lt;b&gt;&amp;&quot;x&quot;&#39;.rs"));
8659        assert!(
8660            !html.contains("<b>"),
8661            "an agent-influenced path must never become markup"
8662        );
8663    }
8664
8665    #[tokio::test]
8666    async fn the_merge_lock_serialises_one_repository_but_never_a_different_one() {
8667        let a = std::path::PathBuf::from("/repo/a");
8668        let b = std::path::PathBuf::from("/repo/b");
8669
8670        let held = repo_merge_lock(&a).lock_owned().await;
8671
8672        // A second, concurrent land run against the *same* repository must
8673        // wait - `try_lock` fails while `held` is alive.
8674        assert!(
8675            repo_merge_lock(&a).try_lock().is_err(),
8676            "a second merge into the same repository must not proceed concurrently"
8677        );
8678
8679        // A run against a *different* repository must not be blocked by it -
8680        // this is what keeps a slow rebase or `gh pr merge` in one
8681        // repository from also stalling a land-approval resume in another.
8682        assert!(
8683            repo_merge_lock(&b).try_lock().is_ok(),
8684            "a different repository's merge lock must be independent"
8685        );
8686
8687        drop(held);
8688        assert!(
8689            repo_merge_lock(&a).try_lock().is_ok(),
8690            "the lock is released once the holder is done"
8691        );
8692    }
8693
8694    pub(crate) fn repair_state(major: bool, reject: bool) -> RunState {
8695        let mut state = landing_state();
8696        let mut rec = review_record(1, "alpha", "precise rejection reason");
8697        rec.vote = Some(if reject {
8698            crate::verdict::ReviewVote::Reject
8699        } else {
8700            crate::verdict::ReviewVote::Approve
8701        });
8702        if major {
8703            rec.findings = contested().findings;
8704        }
8705        let mut round = review_round(1, vec![rec]);
8706        round.clean = false;
8707        round.blocking = usize::from(major);
8708        state.reviews.push(round);
8709        state.config.graph.review_rounds = 1;
8710        state
8711    }
8712
8713    #[test]
8714    fn approval_policy_controls_are_independent_and_keep_all_reasons() {
8715        for every in [false, true] {
8716            for contested in [false, true] {
8717                for major in [false, true] {
8718                    for reject in [false, true] {
8719                        let mut state = repair_state(major, reject);
8720                        state.config.graph.land_approval = every;
8721                        state.config.graph.hold_contested_merge = contested;
8722                        let reasons = approval_reasons(&state);
8723                        assert_eq!(reasons.contains(&ApprovalReason::EveryMerge), every);
8724                        assert_eq!(
8725                            reasons.contains(&ApprovalReason::OpenBlockingFindings),
8726                            contested && major
8727                        );
8728                        assert_eq!(
8729                            reasons.contains(&ApprovalReason::FinalReject),
8730                            contested && reject
8731                        );
8732                        assert_eq!(
8733                            reasons.len(),
8734                            usize::from(every)
8735                                + usize::from(contested && major)
8736                                + usize::from(contested && reject)
8737                        );
8738                    }
8739                }
8740            }
8741        }
8742    }
8743
8744    #[test]
8745    fn approval_policy_and_rendering_follow_reconsideration_in_both_directions() {
8746        use crate::verdict::ReviewVote::{Approve, Reject};
8747        for (initial_reject, final_vote) in [(true, Approve), (false, Reject)] {
8748            let mut state = repair_state(false, initial_reject);
8749            state.reviews[0]
8750                .reconsideration
8751                .push(crate::run::ReviewRevoteRecord {
8752                    reviewer: 1,
8753                    agent: "alpha".into(),
8754                    vote: Some(final_vote),
8755                    reason: "changed after reading the panel <evidence>".into(),
8756                    failed: None,
8757                });
8758            assert_eq!(
8759                approval_reasons(&state).contains(&ApprovalReason::FinalReject),
8760                final_vote == Reject
8761            );
8762            for language in ["en", "ja"] {
8763                state.config.graph.language = language.into();
8764                let evidence = approval_evidence(&state);
8765                assert!(evidence.contains(&format!("→ {}", final_vote.label())));
8766                assert!(evidence.contains("changed after reading the panel <evidence>"));
8767                let html = approval_panel(&state, &green_pr(), "", "", &[], "subject");
8768                assert!(html.contains("changed after reading the panel &lt;evidence&gt;"));
8769                assert!(!html.contains("<evidence>"));
8770            }
8771            state.reviews[0].reconsideration[0].vote = None;
8772            state.reviews[0].reconsideration[0].failed = Some("timed out".into());
8773            assert_eq!(
8774                approval_reasons(&state).contains(&ApprovalReason::FinalReject),
8775                initial_reject
8776            );
8777            assert!(approval_evidence(&state).contains("timed out"));
8778        }
8779    }
8780
8781    #[tokio::test]
8782    async fn approval_merge_paths_apply_controls_to_major_and_reject_independently() {
8783        for every in [false, true] {
8784            for contested in [false, true] {
8785                for (major, reject) in [(false, false), (false, true), (true, false), (true, true)]
8786                {
8787                    let mut state = repair_state(major, reject);
8788                    state.config.graph.land_approval = every;
8789                    state.config.graph.hold_contested_merge = contested;
8790                    let forge = Scripted::new(
8791                        vec![seen("abc", Checks::Green, "CLEAN", false)],
8792                        vec![(true, "")],
8793                    );
8794                    land_with(&mut state, URL, &forge).await.unwrap();
8795                    let expected = every || (contested && (major || reject));
8796                    assert_eq!(state.land_approval.is_some(), expected);
8797                    assert_eq!(forge.calls().contains(&"merge"), !expected);
8798                    if expected {
8799                        assert!(state.parked);
8800                    }
8801                }
8802            }
8803        }
8804    }
8805
8806    #[tokio::test]
8807    async fn reviewed_branch_hold_is_read_before_landing_decision() {
8808        for (base, control) in [
8809            (false, "land_approval"),
8810            (true, "land_approval"),
8811            (false, "hold_contested_merge"),
8812        ] {
8813            let (_tmp, mut state, _) = landing_git_fixture().await;
8814            state.config.graph.land_approval = base;
8815            state.config.graph.hold_contested_merge = false;
8816            state.reviewed_commits = Some(Vec::new());
8817            if control == "hold_contested_merge" {
8818                state.reviews = repair_state(false, true).reviews;
8819            }
8820            std::fs::write(
8821                state.repo.join("magi.toml"),
8822                format!("[graph]\n{control} = {}\n", !base),
8823            )
8824            .unwrap();
8825            git::git(&state.repo, &["add", "magi.toml"]).await.unwrap();
8826            git::git(&state.repo, &["commit", "-m", "approval policy"])
8827                .await
8828                .unwrap();
8829            let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8830            state.land_sync_pending = false;
8831            state.pr_pushed_head = Some(head.clone());
8832            state.gate_head = Some(head.clone());
8833            let forge = Scripted::new(
8834                vec![seen(&head, Checks::Green, "CLEAN", false)],
8835                vec![(true, "")],
8836            );
8837            land_with(&mut state, URL, &forge).await.unwrap();
8838            assert!(
8839                state.land_approval.is_some(),
8840                "base={base}, control={control}"
8841            );
8842            assert!(!forge.calls().contains(&"merge"));
8843            if !base {
8844                let question = ask::Questions::open()
8845                    .get(&state.land_approval.as_ref().unwrap().question)
8846                    .unwrap();
8847                assert!(question.detail.contains(&format!(
8848                    "{control}=true from the reviewed branch's magi.toml"
8849                )));
8850            }
8851        }
8852    }
8853
8854    #[tokio::test]
8855    async fn reviewed_branch_hold_asks_and_survives_removal_and_resume() {
8856        for file in ["magi.toml", ".magi/config.toml"] {
8857            for control in crate::config::OwnerHold::ALL {
8858                let (_tmp, mut state, _) = landing_git_fixture().await;
8859                state.config.graph.land_approval = false;
8860                state.config.graph.hold_contested_merge = false;
8861                state.reviewed_commits = Some(Vec::new());
8862                if control == crate::config::OwnerHold::HoldContestedMerge {
8863                    state.reviews = repair_state(false, true).reviews;
8864                }
8865                let config = state.repo.join(file);
8866                std::fs::create_dir_all(config.parent().unwrap()).unwrap();
8867                std::fs::write(
8868                    &config,
8869                    format!(
8870                        "[graph]\n{} = true\n[verify]\ngate = ['untrusted']\n",
8871                        control.key()
8872                    ),
8873                )
8874                .unwrap();
8875                git::git(&state.repo, &["add", file]).await.unwrap();
8876                git::git(&state.repo, &["commit", "-m", "require approval"])
8877                    .await
8878                    .unwrap();
8879                let head = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8880                let gate = state.config.verify.gate.clone();
8881                state.observe_branch_owner_holds(&head).await;
8882                assert_eq!(state.config.verify.gate, gate);
8883                assert!(state.owner_hold(control));
8884                let holds = state.branch_owner_holds.clone();
8885                git::git(&state.repo, &["rm", file]).await.unwrap();
8886                git::git(&state.repo, &["commit", "-m", "remove config"])
8887                    .await
8888                    .unwrap();
8889                let later = git::rev_parse(&state.repo, "HEAD").await.unwrap();
8890                state.save().unwrap();
8891                state = RunState::load(&state.id).unwrap();
8892                state.observe_branch_owner_holds(&later).await;
8893                assert_eq!(state.branch_owner_holds, holds);
8894                assert_eq!(state.branch_owner_holds[0].head, head);
8895                state.land_sync_pending = false;
8896                state.pr_pushed_head = Some(later.clone());
8897                state.gate_head = Some(later.clone());
8898                let forge = Scripted::new(
8899                    vec![seen(&later, Checks::Green, "CLEAN", false)],
8900                    vec![(true, "")],
8901                );
8902                land_with(&mut state, URL, &forge).await.unwrap();
8903                assert!(!forge.calls().contains(&"merge"));
8904                assert!(state.parked);
8905                let question = ask::Questions::open()
8906                    .get(&state.land_approval.as_ref().unwrap().question)
8907                    .unwrap();
8908                assert!(question.detail.contains("Approval required because:"));
8909                assert!(question.detail.contains(&format!(
8910                    "{}=true from the reviewed branch's {file}",
8911                    control.key()
8912                )));
8913                assert_eq!(state.branch_owner_holds, holds);
8914                state.save().unwrap();
8915                let resumed = RunState::load(&state.id).unwrap();
8916                assert!(resumed.owner_hold(control));
8917                assert_eq!(resumed.branch_owner_holds, holds);
8918                assert_eq!(
8919                    resumed.land_approval.unwrap().question,
8920                    state.land_approval.unwrap().question
8921                );
8922            }
8923        }
8924    }
8925
8926    #[tokio::test]
8927    async fn approval_snapshot_exposes_minor_findings_and_survives_disabled_controls() {
8928        let mut state = repair_state(false, true);
8929        state.reviews[0].clean = true;
8930        let mut finding = contested().findings.remove(0);
8931        finding.severity = crate::verdict::Severity::Minor;
8932        state.reviews[0].reviews[0].findings.push(finding);
8933        assert!(state.open_findings().is_empty());
8934        let mut pr = green_pr();
8935        pr.review_comments.clear();
8936        for language in ["en", "ja"] {
8937            state.config.graph.language = language.into();
8938            let html = approval_panel(&state, &pr, "", "", &[], "subject");
8939            assert!(html.contains("[R3-1-1] minor"));
8940            assert!(html.contains(if language == "ja" {
8941                "内部指摘の解決を意味するものではありません"
8942            } else {
8943                "This does not mean internal findings are resolved"
8944            }));
8945            assert!(
8946                html.find(if language == "ja" {
8947                    "承認が必要な理由:"
8948                } else {
8949                    "Approval required because:"
8950                })
8951                .unwrap()
8952                    < html.find("[R3-1-1]").unwrap()
8953            );
8954        }
8955        state.config.graph.language = "en".into();
8956        let observed = seen("abc", Checks::Green, "CLEAN", false);
8957        assert_eq!(
8958            approval_gate(&mut state, &observed.pr, "subject", None, "abc")
8959                .await
8960                .unwrap(),
8961            ApprovalGate::Pending
8962        );
8963        let id = state.land_approval.as_ref().unwrap().question.clone();
8964        let q = ask::Questions::open().get(&id).unwrap();
8965        assert!(q.detail.starts_with("Approval required because:"));
8966        assert!(q.detail.contains("final reviewer reject"));
8967        assert!(q.detail.contains("[R3-1-1] minor"));
8968        assert!(
8969            q.detail
8970                .contains("No adoption or resolution evidence recorded")
8971        );
8972        state.config.graph.land_approval = false;
8973        state.config.graph.hold_contested_merge = false;
8974        state.reviews.clear();
8975        assert_eq!(approval_reasons(&state), [ApprovalReason::ExistingDecision]);
8976        assert!(deputy_brief(&q, Some(&state)).contains("final reviewer reject"));
8977        assert!(deputy_brief(&q, None).contains("[R3-1-1] minor"));
8978        let forge = Scripted::new(vec![observed], vec![]);
8979        land_with(&mut state, URL, &forge).await.unwrap();
8980        assert!(!forge.calls().contains(&"merge"));
8981        assert_eq!(state.land_approval.as_ref().unwrap().question, id);
8982        assert_eq!(ask::Questions::open().get(&id).unwrap().detail, q.detail);
8983    }
8984
8985    #[tokio::test]
8986    async fn approval_evidence_keeps_all_findings_and_bounds_unicode_prose() {
8987        let mut state = repair_state(false, true);
8988        state.config.graph.land_approval = false;
8989        let long_reason = format!("{}REASON_TAIL", "拒否🦀".repeat(200));
8990        let long_detail = format!("{}DETAIL_TAIL", "詳細🦀".repeat(200));
8991        let long_title = format!("{}TITLE_TAIL", "題🦀".repeat(100));
8992        state.reviews[0].reviews[0].summary = long_reason.clone();
8993        for i in 1..=10 {
8994            let mut finding = contested().findings.remove(0);
8995            finding.id = format!("R1-1-{i}");
8996            finding.severity = if i == 9 {
8997                crate::verdict::Severity::Major
8998            } else {
8999                crate::verdict::Severity::Minor
9000            };
9001            finding.title = long_title.clone();
9002            finding.detail = long_detail.clone();
9003            state.reviews[0].reviews[0].findings.push(finding);
9004        }
9005        state.reviews[0].fix = Some(crate::run::FixRecord {
9006            agent: "fixer".into(),
9007            addressed: vec!["R1-1-9".into()],
9008            rejected: vec![crate::verdict::Rejection {
9009                id: "R1-1-10".into(),
9010                why: long_reason.clone(),
9011            }],
9012            notes: long_detail.clone(),
9013            committed: false,
9014            failed: None,
9015            duration_ms: 0,
9016            continuation: None,
9017        });
9018        assert_eq!(
9019            approval_reasons(&state),
9020            [
9021                ApprovalReason::OpenBlockingFindings,
9022                ApprovalReason::FinalReject
9023            ]
9024        );
9025        let excerpt = approval_excerpt(&long_reason, 300);
9026        assert_eq!(excerpt.chars().count(), 300);
9027        assert!(excerpt.ends_with('…'));
9028        let boundary = "拒".repeat(300);
9029        assert_eq!(approval_excerpt(&boundary, 300), boundary);
9030        for language in ["en", "ja"] {
9031            state.config.graph.language = language.into();
9032            for revote in [
9033                None,
9034                Some(crate::verdict::ReviewVote::Reject),
9035                Some(crate::verdict::ReviewVote::Approve),
9036            ] {
9037                state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Reject);
9038                state.reviews[0].reconsideration.clear();
9039                if let Some(vote) = revote {
9040                    state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Approve);
9041                    state.reviews[0]
9042                        .reconsideration
9043                        .push(crate::run::ReviewRevoteRecord {
9044                            reviewer: 1,
9045                            agent: "alpha".into(),
9046                            vote: Some(vote),
9047                            reason: long_reason.clone(),
9048                            failed: None,
9049                        });
9050                }
9051                let evidence = approval_evidence(&state);
9052                let final_vote = revote.unwrap_or(crate::verdict::ReviewVote::Reject);
9053                assert!(evidence.contains(&format!("#1 (alpha): {}", final_vote.label())));
9054                assert!(approval_reasons(&state).contains(&ApprovalReason::OpenBlockingFindings));
9055                assert_eq!(
9056                    approval_reasons(&state).contains(&ApprovalReason::FinalReject),
9057                    final_vote == crate::verdict::ReviewVote::Reject
9058                );
9059                assert!(evidence.contains(&excerpt));
9060                assert!(evidence.contains("[R1-1-8] minor"));
9061                assert!(evidence.contains("[R1-1-9] major"));
9062                assert!(evidence.contains("[R1-1-10] minor"));
9063                for tail in ["REASON_TAIL", "DETAIL_TAIL", "TITLE_TAIL"] {
9064                    assert!(!evidence.contains(tail));
9065                }
9066                assert!(evidence.contains(if language == "ja" {
9067                    "採用申告(解決未確認)"
9068                } else {
9069                    "claimed addressed (resolution unconfirmed)"
9070                }));
9071                assert!(evidence.contains(if language == "ja" {
9072                    "不採用理由"
9073                } else {
9074                    "declined"
9075                }));
9076                let major_evidence = evidence
9077                    .split("[R1-1-9] major")
9078                    .nth(1)
9079                    .unwrap()
9080                    .split("[R1-1-10]")
9081                    .next()
9082                    .unwrap();
9083                assert!(major_evidence.contains(if language == "ja" {
9084                    "採用申告(解決未確認)"
9085                } else {
9086                    "claimed addressed (resolution unconfirmed)"
9087                }));
9088                let last_evidence = evidence.split("[R1-1-10] minor").nth(1).unwrap();
9089                assert!(last_evidence.contains(if language == "ja" {
9090                    "不採用理由"
9091                } else {
9092                    "declined"
9093                }));
9094                let html = approval_panel(&state, &green_pr(), "", "", &[], "subject");
9095                assert!(html.contains(&esc(&evidence)));
9096                assert_eq!(
9097                    approval_gate(&mut state, &green_pr(), "subject", None, "abc")
9098                        .await
9099                        .unwrap(),
9100                    ApprovalGate::Pending
9101                );
9102                let id = &state.land_approval.take().unwrap().question;
9103                let q = ask::Questions::open().get(id).unwrap();
9104                assert!(q.detail.starts_with(&evidence));
9105            }
9106            state.reviews[0].reviews[0].vote = Some(crate::verdict::ReviewVote::Reject);
9107        }
9108    }
9109
9110    #[test]
9111    fn merge_repair_choice_covers_major_only_and_reject_only_without_contested_and() {
9112        for (major, reject) in [(true, false), (false, true), (true, true)] {
9113            let state = repair_state(major, reject);
9114            assert!(repair_available(&state));
9115            assert_eq!(&approval_choices(&state)[..3], [APPROVE, HOLD, REPAIR]);
9116        }
9117        assert!(!repair_available(&repair_state(false, false)));
9118        let mut clean = repair_state(true, false);
9119        clean.reviews[0].clean = true;
9120        assert_eq!(&approval_choices(&clean)[..3], [APPROVE, HOLD, REPAIR]);
9121        assert_eq!(approval(Some(REPAIR)), Approval::Repair);
9122    }
9123
9124    #[tokio::test]
9125    async fn merge_repair_upgrades_legacy_questions_and_snapshots_exact_evidence_once() {
9126        let mut state = repair_state(true, false);
9127        let pr = green_pr();
9128        approval_gate(&mut state, &pr, "feat: x", None, "abc")
9129            .await
9130            .unwrap();
9131        let store = ask::Questions::open();
9132        let id = state.land_approval.as_ref().unwrap().question.clone();
9133        // Simulate an unanswered two-choice question created by an older build.
9134        store
9135            .update(&id, |q| {
9136                q.choices = vec![APPROVE.into(), HOLD.into()];
9137                Ok(())
9138            })
9139            .unwrap();
9140        let upgraded = store.get(&id).unwrap();
9141        assert_eq!(upgraded.choices, approval_choices(&state));
9142        assert!(!upgraded.actions.contains_key(HOLD));
9143        assert_eq!(store.get(&id).unwrap().choices, upgraded.choices);
9144        assert!(
9145            store
9146                .list()
9147                .iter()
9148                .any(|q| q.id == id && q.choices == upgraded.choices)
9149        );
9150        assert!(
9151            crate::prompt::chat_consult(&upgraded).contains("--reply 'fix findings and re-review'")
9152        );
9153        assert!(deputy_brief(&upgraded, Some(&state)).contains("never approves a merge"));
9154        store
9155            .update(&id, |q| q.answer(ask::Answer::Choice(REPAIR.into())))
9156            .unwrap();
9157        // An earlier build may have recorded the repair answer and stopped
9158        // before any driver consumed it. Reconcile that durable decision too.
9159        store
9160            .update(&id, |q| {
9161                q.actions.clear();
9162                Ok(())
9163            })
9164            .unwrap();
9165        assert_eq!(
9166            store.get(&id).unwrap().chosen_action(),
9167            Some(&ask::ChoiceAction::Resume {
9168                run: state.id.clone()
9169            })
9170        );
9171        let binding = state.land_approval.clone();
9172        assert_eq!(
9173            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9174                .await
9175                .unwrap(),
9176            ApprovalGate::Repair
9177        );
9178        assert!(state.land_approval.is_none());
9179        assert_eq!(state.merge_repairs.len(), 1);
9180        let request = &state.merge_repairs[0];
9181        assert_eq!(request.question, id);
9182        assert_eq!(request.head, "abc");
9183        assert_eq!(request.pr, pr.url);
9184        assert_eq!(
9185            request.reviews[0].reviews[0].summary,
9186            "precise rejection reason"
9187        );
9188        assert_eq!(request.reviews[0].reviews[0].findings[0].id, "R3-1-1");
9189        assert_eq!(
9190            request.reviews[0].reviews[0].findings[0].detail,
9191            state.reviews[0].reviews[0].findings[0].detail
9192        );
9193        // A repeated consumption of the same answer never dispatches another repair.
9194        state.land_approval = binding;
9195        assert_eq!(
9196            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9197                .await
9198                .unwrap(),
9199            ApprovalGate::Repair
9200        );
9201        assert_eq!(state.merge_repairs.len(), 1);
9202        state.land_approval = None;
9203        state.config.graph.land_approval = false;
9204        state.config.graph.hold_contested_merge = false;
9205        state.reviews.clear();
9206        assert_eq!(approval_reasons(&state), [ApprovalReason::AfterRepair]);
9207        assert_eq!(
9208            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9209                .await
9210                .unwrap(),
9211            ApprovalGate::Pending
9212        );
9213        let fresh_id = &state.land_approval.as_ref().unwrap().question;
9214        assert_ne!(fresh_id, &id);
9215        let fresh = store.get(fresh_id).unwrap();
9216        assert!(
9217            fresh
9218                .detail
9219                .contains("fresh owner approval after merge repair")
9220        );
9221        assert!(fresh.detail.contains("No review recorded"));
9222        assert!(!fresh.detail.contains("precise rejection reason"));
9223    }
9224
9225    #[tokio::test]
9226    async fn merge_repair_answer_never_merges_and_hold_never_requests_repair() {
9227        for choice in [REPAIR, HOLD] {
9228            let mut state = repair_state(false, true);
9229            let observed = seen("abc", Checks::Green, "CLEAN", false);
9230            approval_gate(&mut state, &observed.pr, "feat: x", None, "abc")
9231                .await
9232                .unwrap();
9233            let id = state.land_approval.as_ref().unwrap().question.clone();
9234            ask::Questions::open()
9235                .update(&id, |q| q.answer(ask::Answer::Choice(choice.into())))
9236                .unwrap();
9237            let forge = Scripted::new(vec![observed], vec![(true, "")]);
9238            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
9239                .await
9240                .unwrap();
9241            assert!(
9242                forge
9243                    .argvs()
9244                    .iter()
9245                    .all(|a| a.iter().any(|s| s == "--disable-auto"))
9246            );
9247            assert!(!forge.calls().contains(&"fix"));
9248            assert_eq!(state.merge_repairs.len(), usize::from(choice == REPAIR));
9249            assert_ne!(state.status, RunStatus::Merged);
9250        }
9251    }
9252
9253    #[test]
9254    fn only_the_merge_choice_merges_and_silence_holds() {
9255        let table = [
9256            (None, Approval::Hold),
9257            (Some("merge"), Approval::Merge),
9258            (Some(" merge\n"), Approval::Merge),
9259            (Some("hold"), Approval::Hold),
9260            (Some(""), Approval::Hold),
9261            (Some("yes"), Approval::Hold),
9262        ];
9263        for (answer, want) in table {
9264            assert_eq!(
9265                approval(answer),
9266                want,
9267                "answer {answer:?} must resolve to {want:?}"
9268            );
9269        }
9270    }
9271
9272    #[tokio::test]
9273    async fn a_first_visit_to_the_merge_gate_files_a_question_and_returns_pending_at_once() {
9274        let mut state = landing_state();
9275        state.config.graph.land_approval = true;
9276        let pr = green_pr();
9277
9278        let gate = approval_gate(&mut state, &pr, "feat: x", None, "abc")
9279            .await
9280            .unwrap();
9281        assert_eq!(gate, ApprovalGate::Pending, "nobody has answered yet");
9282        assert!(
9283            !state.parked,
9284            "approval_gate itself never sets `parked`; only its caller does"
9285        );
9286
9287        let store = ask::Questions::open();
9288        let filed: Vec<_> = store
9289            .list()
9290            .into_iter()
9291            .filter(|q| q.run == state.id)
9292            .collect();
9293        assert_eq!(filed.len(), 1, "exactly one question is filed");
9294        assert_eq!(filed[0].node, APPROVAL_NODE);
9295        assert_eq!(filed[0].choices, approval_choices(&state));
9296        assert!(filed[0].status.open());
9297
9298        // A second visit - standing in for a resumed run whose slot the
9299        // daemon handed to something else while nobody had answered - must
9300        // find the same question rather than filing a second one.
9301        let again = approval_gate(&mut state, &pr, "feat: x", None, "abc")
9302            .await
9303            .unwrap();
9304        assert_eq!(again, ApprovalGate::Pending);
9305        let still_one = store
9306            .list()
9307            .into_iter()
9308            .filter(|q| q.run == state.id)
9309            .count();
9310        assert_eq!(
9311            still_one, 1,
9312            "asking twice must not double-file the question"
9313        );
9314    }
9315
9316    #[tokio::test]
9317    async fn approving_the_existing_question_is_read_back_as_approved() {
9318        crate::run::pin_test_home();
9319        let mut state = run_state();
9320        state.config.graph.land_approval = true;
9321        let pr = green_pr();
9322        assert_eq!(
9323            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9324                .await
9325                .unwrap(),
9326            ApprovalGate::Pending
9327        );
9328
9329        let store = ask::Questions::open();
9330        let mut q = store
9331            .list()
9332            .into_iter()
9333            .find(|q| q.run == state.id)
9334            .expect("filed above");
9335        let talks = crate::talk::Talks::open();
9336        let cfg = crate::config::Config {
9337            agents: vec![crate::config::AgentSpec {
9338                id: "mock".into(),
9339                kind: crate::config::AgentKind::Command,
9340                model: None,
9341                command: vec!["true".into()],
9342                extra_args: Vec::new(),
9343                env: Default::default(),
9344                prompt_delivery: None,
9345                max_turn_secs: None,
9346            }],
9347            ..crate::config::Config::default()
9348        };
9349        let mut talk = crate::talk::begin(&talks, &cfg, state.repo.clone(), Some("mock")).unwrap();
9350        crate::consult::begin(&store, &talks, &q, &talk).unwrap();
9351        crate::talk::drain(&mut talk, &talks).unwrap();
9352        assert_eq!(
9353            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9354                .await
9355                .unwrap(),
9356            ApprovalGate::Pending,
9357            "consultation cannot approve or hold the merge"
9358        );
9359        q = store.get(&q.id).unwrap();
9360        assert!(q.answer.is_none());
9361        // The owner's merge answer (from the chat or the card) is the approval.
9362        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
9363        store.put(&mut q).unwrap();
9364
9365        assert_eq!(
9366            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9367                .await
9368                .unwrap(),
9369            ApprovalGate::Approved
9370        );
9371    }
9372
9373    #[tokio::test]
9374    async fn legacy_hold_actions_are_removed_on_get_and_list_before_answering() {
9375        crate::run::pin_test_home();
9376        let store = ask::Questions::open();
9377        for via_list in [false, true] {
9378            let mut state = repair_state(false, true);
9379            let pr = green_pr();
9380            approval_gate(&mut state, &pr, "feat: x", None, "abc")
9381                .await
9382                .unwrap();
9383            let id = state.land_approval.as_ref().unwrap().question.clone();
9384            store
9385                .update(&id, |q| {
9386                    q.actions.insert(
9387                        HOLD.to_owned(),
9388                        ask::ChoiceAction::Resume {
9389                            run: state.id.clone(),
9390                        },
9391                    );
9392                    Ok(())
9393                })
9394                .unwrap();
9395            let q = if via_list {
9396                store.list().into_iter().find(|q| q.id == id).unwrap()
9397            } else {
9398                store.get(&id).unwrap()
9399            };
9400            assert!(!q.actions.contains_key(HOLD));
9401            store
9402                .update(&id, |q| {
9403                    // Check the persisted migration, without another read upgrade.
9404                    assert!(!q.actions.contains_key(HOLD));
9405                    assert!(!upgrade_repair_choice(q, &state));
9406                    q.answer(ask::Answer::Choice(HOLD.to_owned()))
9407                })
9408                .unwrap();
9409            assert!(store.get(&id).unwrap().chosen_action().is_none());
9410            assert_eq!(
9411                approval_gate(&mut state, &pr, "feat: x", None, "abc")
9412                    .await
9413                    .unwrap(),
9414                ApprovalGate::Held
9415            );
9416        }
9417    }
9418
9419    #[tokio::test]
9420    async fn explicit_hold_stays_held_but_expired_approval_is_reasked() {
9421        crate::run::pin_test_home();
9422        let store = ask::Questions::open();
9423
9424        let mut held_state = run_state();
9425        held_state.config.graph.land_approval = true;
9426        let pr = green_pr();
9427        approval_gate(&mut held_state, &pr, "feat: x", None, "abc")
9428            .await
9429            .unwrap();
9430        let mut q = store
9431            .list()
9432            .into_iter()
9433            .find(|q| q.run == held_state.id)
9434            .expect("filed above");
9435        q.answer(ask::Answer::Choice(HOLD.to_owned())).unwrap();
9436        store.put(&mut q).unwrap();
9437        assert_eq!(
9438            approval_gate(&mut held_state, &pr, "feat: x", None, "abc")
9439                .await
9440                .unwrap(),
9441            ApprovalGate::Held
9442        );
9443
9444        let mut abandoned_state = run_state();
9445        abandoned_state.config.graph.land_approval = true;
9446        approval_gate(&mut abandoned_state, &pr, "feat: x", None, "abc")
9447            .await
9448            .unwrap();
9449        let mut q = store
9450            .list()
9451            .into_iter()
9452            .find(|q| q.run == abandoned_state.id)
9453            .expect("filed above");
9454        q.abandon("no answer within the timeout");
9455        store.put(&mut q).unwrap();
9456        assert_eq!(
9457            approval_gate(&mut abandoned_state, &pr, "feat: x", None, "abc")
9458                .await
9459                .unwrap(),
9460            ApprovalGate::Pending,
9461            "an expired approval must ask again without merging"
9462        );
9463        assert_eq!(
9464            store.get(&q.id).unwrap().status,
9465            ask::QuestionStatus::Abandoned
9466        );
9467        assert_ne!(
9468            abandoned_state.land_approval.as_ref().unwrap().question,
9469            q.id
9470        );
9471    }
9472
9473    fn contested() -> ContestedHandoff {
9474        let finding = |id: &str, n: u32| crate::verdict::Finding {
9475            id: id.to_owned(),
9476            severity: crate::verdict::Severity::Major,
9477            file: Some("src/a.rs".to_owned()),
9478            line: Some(n),
9479            title: format!("problem {id}"),
9480            detail: String::new(),
9481        };
9482        ContestedHandoff {
9483            findings: (1..=7).map(|n| finding(&format!("R3-1-{n}"), n)).collect(),
9484            rejecters: vec![(1, "alpha".to_owned())],
9485        }
9486    }
9487
9488    #[test]
9489    fn the_contested_record_is_asked_about_unless_the_switch_is_off() {
9490        let mut state = run_state();
9491        assert!(contested_to_ask(&state).is_none(), "nothing recorded");
9492        state.contested_handoff = Some(contested());
9493        assert!(contested_to_ask(&state).is_some());
9494        state.config.graph.hold_contested_merge = false;
9495        assert!(
9496            contested_to_ask(&state).is_none(),
9497            "the switch restores today"
9498        );
9499    }
9500
9501    #[test]
9502    fn the_deputy_brief_carries_the_pr_the_findings_and_names_what_is_missing() {
9503        let q = ask::Question::new(
9504            "run-1".to_owned(),
9505            APPROVAL_NODE.to_owned(),
9506            "land".to_owned(),
9507            "Merge?".to_owned(),
9508            String::new(),
9509            vec![APPROVE.to_owned(), HOLD.to_owned()],
9510        );
9511        let none = deputy_brief(&q, None);
9512        assert!(none.contains("could not be read"), "{none}");
9513        assert!(none.contains("Silence is a hold"), "{none}");
9514
9515        let mut state = run_state();
9516        state.pr = Some(crate::run::PrRecord {
9517            url: "https://example.test/pull/7".to_owned(),
9518            number: 7,
9519            state: "open".to_owned(),
9520            checks: "green".to_owned(),
9521            round: 0,
9522            rounds: 3,
9523            red_at_merge: Vec::new(),
9524        });
9525        state.contested_handoff = Some(contested());
9526        let b = deputy_brief(&q, Some(&state));
9527        assert!(b.contains("https://example.test/pull/7"), "{b}");
9528        assert!(b.contains("not recorded in this legacy question"), "{b}");
9529        assert!(!b.contains("This question was filed although"));
9530        state.contested_handoff = None;
9531        assert!(deputy_brief(&q, Some(&state)).contains("not recorded in this legacy question"));
9532    }
9533
9534    #[test]
9535    fn the_contested_question_names_the_pr_the_findings_and_the_rejecter() {
9536        for lang in ["en", "ja"] {
9537            let mut cfg = crate::config::Config::default();
9538            cfg.graph.language = lang.to_owned();
9539            let w = words(&cfg.graph.language);
9540            let text = w.approval_detail(
9541                "https://github.com/yukimemi/magi/pull/42",
9542                "main",
9543                "feat: x",
9544                Some(&contested()),
9545            );
9546            assert!(text.contains("pull/42"), "{text}");
9547            assert!(
9548                text.contains("R3-1-1 major src/a.rs:1: problem R3-1-1"),
9549                "{text}"
9550            );
9551            assert!(text.contains("R3-1-5"), "{text}");
9552            assert!(!text.contains("R3-1-6"), "the list is capped: {text}");
9553            assert!(text.contains("2"), "the rest are counted: {text}");
9554            assert!(text.contains("#1 (alpha)"), "{text}");
9555        }
9556        let plain = words("en").approval_detail("u", "main", "s", None);
9557        assert!(!plain.contains("reject"), "{plain}");
9558    }
9559
9560    #[tokio::test]
9561    async fn a_contested_question_is_filed_once_and_a_resume_finds_the_same_one() {
9562        crate::run::pin_test_home();
9563        let mut state = run_state();
9564        state.config.graph.land_approval = false;
9565        state.contested_handoff = Some(contested());
9566        let pr = green_pr();
9567        let c = contested_to_ask(&state);
9568        assert_eq!(
9569            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9570                .await
9571                .unwrap(),
9572            ApprovalGate::Pending,
9573            "silence is a hold"
9574        );
9575        let store = ask::Questions::open();
9576        let filed: Vec<_> = store
9577            .list()
9578            .into_iter()
9579            .filter(|q| q.run == state.id)
9580            .collect();
9581        assert_eq!(filed.len(), 1);
9582        assert!(filed[0].detail.contains("R3-1-1"), "{}", filed[0].detail);
9583
9584        assert_eq!(
9585            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9586                .await
9587                .unwrap(),
9588            ApprovalGate::Pending
9589        );
9590        let mut q = store
9591            .list()
9592            .into_iter()
9593            .find(|q| q.run == state.id)
9594            .unwrap();
9595        assert_eq!(q.id, filed[0].id, "the same question after a resume");
9596        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
9597        store.put(&mut q).unwrap();
9598        assert_eq!(
9599            approval_gate(&mut state, &pr, "feat: x", c.as_ref(), "abc")
9600                .await
9601                .unwrap(),
9602            ApprovalGate::Approved
9603        );
9604    }
9605
9606    #[test]
9607    fn the_diffstat_table_is_ordered_by_churn_with_binaries_last() {
9608        let rows = parse_numstat(NUMSTAT);
9609        assert_eq!(
9610            rows.iter().map(|r| r.path.as_str()).collect::<Vec<_>>(),
9611            ["src/web.rs", "src/land.rs", "assets/logo.png"]
9612        );
9613        assert_eq!(rows[2].added, None, "a binary file has no line counts");
9614    }
9615    #[test]
9616    fn the_approval_speaks_the_language_the_repository_is_configured_for() {
9617        // Reported from a real run: the merge question arrived in English on a
9618        // repository with `language = "ja"`. magi's own strings have to follow
9619        // that setting too - "it is a literal in Rust" is not an answer.
9620        let mut state = run_state();
9621        state.config.graph.language = "ja".to_owned();
9622        let pr = green_pr();
9623        let commits = ["c1".to_owned()];
9624
9625        let ja = approval_panel(&state, &pr, "3\t1\tsrc/a.rs", "+ x", &commits, "feat: x");
9626        assert!(ja.contains("lang=\"ja\""), "the document must declare it");
9627        assert!(ja.contains("squash されるコミット"), "{ja}");
9628        assert!(ja.contains("レビューコメント"), "{ja}");
9629        assert!(ja.contains("差分"), "{ja}");
9630        assert!(
9631            !ja.contains("Commits being squashed"),
9632            "no English left over"
9633        );
9634
9635        let w = words("ja");
9636        assert!(w.approval_summary(17, "feat: x").contains("マージ"));
9637        assert!(
9638            w.approval_detail("http://x/1", "main", "feat: x", None)
9639                .contains("パネル")
9640        );
9641
9642        // The evidence itself is language-neutral and must survive either way.
9643        assert!(ja.contains("src/a.rs"), "the diffstat is not prose");
9644        assert!(ja.contains("feat: x"), "nor is the merge subject");
9645
9646        // English stays the default, and a language magi cannot check falls
9647        // back to it rather than shipping a guess.
9648        state.config.graph.language = "en".to_owned();
9649        let en = approval_panel(&state, &pr, "3\t1\tsrc/a.rs", "+ x", &commits, "feat: x");
9650        assert!(en.contains("Commits being squashed"), "{en}");
9651        assert_eq!(words("Klingon").html_lang, "en");
9652    }
9653
9654    /// A `gh pr list` result naming exactly one pull request whose base and
9655    /// merge time both fit the run is exactly the case
9656    /// [`find_external_merge`] exists to act on.
9657    #[test]
9658    fn pick_open_pr_classifies_by_count_and_base() {
9659        let one = r#"[{"number":58,"url":"https://x/pull/58","title":"t","baseRefName":"main"}]"#;
9660        assert_eq!(
9661            pick_open_pr(one, "main").unwrap(),
9662            OpenPr::One {
9663                url: "https://x/pull/58".into(),
9664                title: "t".into()
9665            }
9666        );
9667        assert_eq!(pick_open_pr("[]", "main").unwrap(), OpenPr::None);
9668        assert_eq!(pick_open_pr(one, "dev").unwrap(), OpenPr::None);
9669        let two = r#"[{"number":1,"url":"u1","title":"","baseRefName":"main"},
9670                     {"number":2,"url":"u2","title":"","baseRefName":"main"}]"#;
9671        assert_eq!(
9672            pick_open_pr(two, "main").unwrap(),
9673            OpenPr::Many(vec!["u1".into(), "u2".into()])
9674        );
9675        // A fork's same-named branch is not a pull request for this head.
9676        let fork = r#"[{"url":"f","baseRefName":"main","isCrossRepository":true}]"#;
9677        assert_eq!(pick_open_pr(fork, "main").unwrap(), OpenPr::None);
9678        assert!(pick_open_pr("not json", "main").is_err());
9679        // An incomplete record is an error, never "nothing open".
9680        assert!(pick_open_pr(r#"[{"url":"u","title":"t"}]"#, "main").is_err());
9681        assert!(pick_open_pr(r#"[{"title":"t","baseRefName":"main"}]"#, "main").is_err());
9682    }
9683
9684    #[test]
9685    fn pick_merged_pr_picks_the_unique_match() {
9686        let json = r#"[
9687            {"url": "https://github.com/o/r/pull/42", "number": 42,
9688             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "main"}
9689        ]"#;
9690        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9691        let found = pick_merged_pr(json, "main", created_at)
9692            .expect("valid json")
9693            .expect("one unambiguous match");
9694        assert_eq!(found.url, "https://github.com/o/r/pull/42");
9695        assert_eq!(found.number, 42);
9696    }
9697
9698    /// Two candidates surviving the filter is exactly as uninformative as
9699    /// zero — a branch name can be reused across runs — so neither is
9700    /// preferred over the other and nothing is recorded automatically.
9701    #[test]
9702    fn pick_merged_pr_refuses_when_more_than_one_candidate_survives() {
9703        let json = r#"[
9704            {"url": "https://github.com/o/r/pull/42", "number": 42,
9705             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "main"},
9706            {"url": "https://github.com/o/r/pull/43", "number": 43,
9707             "mergedAt": "2026-09-21T10:00:00Z", "baseRefName": "main"}
9708        ]"#;
9709        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9710        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9711    }
9712
9713    /// A pull request that targets a different base branch cannot be this
9714    /// run's, whatever its head branch is named — a reused branch name from
9715    /// an unrelated task must not be recorded as this run's merge.
9716    #[test]
9717    fn pick_merged_pr_ignores_a_different_base_branch() {
9718        let json = r#"[
9719            {"url": "https://github.com/o/r/pull/42", "number": 42,
9720             "mergedAt": "2026-09-20T10:00:00Z", "baseRefName": "release"}
9721        ]"#;
9722        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9723        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9724    }
9725
9726    /// A pull request merged before this run was even created cannot be this
9727    /// run's winner, no matter how its head branch is spelled.
9728    #[test]
9729    fn pick_merged_pr_ignores_a_merge_that_predates_the_run() {
9730        let json = r#"[
9731            {"url": "https://github.com/o/r/pull/42", "number": 42,
9732             "mergedAt": "2026-09-18T10:00:00Z", "baseRefName": "main"}
9733        ]"#;
9734        let created_at: Timestamp = "2026-09-19T00:00:00Z".parse().unwrap();
9735        assert_eq!(pick_merged_pr(json, "main", created_at).unwrap(), None);
9736    }
9737
9738    #[test]
9739    fn slug_of_pr_url_reads_host_owner_and_repo() {
9740        assert_eq!(
9741            slug_of_pr_url("https://github.com/yukimemi/shun/pull/272").as_deref(),
9742            Some("github.com/yukimemi/shun")
9743        );
9744    }
9745
9746    #[test]
9747    fn slug_of_pr_url_refuses_a_url_with_no_pull_segment() {
9748        assert_eq!(slug_of_pr_url("https://github.com/yukimemi/shun"), None);
9749        assert_eq!(slug_of_pr_url("not a url at all"), None);
9750        assert_eq!(slug_of_pr_url("https://github.com"), None);
9751    }
9752
9753    #[test]
9754    fn slug_of_repo_url_reads_host_owner_and_repo() {
9755        assert_eq!(
9756            slug_of_repo_url("https://github.com/yukimemi/magi").as_deref(),
9757            Some("github.com/yukimemi/magi")
9758        );
9759        assert_eq!(slug_of_repo_url("https://github.com"), None);
9760    }
9761
9762    #[test]
9763    fn ensure_same_repo_accepts_a_matching_slug_regardless_of_case() {
9764        ensure_same_repo("github.com/yukimemi/magi", "GitHub.Com/YukiMemi/Magi")
9765            .expect("same repo, different case");
9766    }
9767
9768    /// The shun/8c75 incident: an id-less `--merged` picked this repository's
9769    /// own in-progress run and rewrote its status from a pull request in a
9770    /// completely different repository. This is the guard that must catch
9771    /// that even when an explicit (but wrong) id is given.
9772    #[test]
9773    fn ensure_same_repo_refuses_a_different_repo() {
9774        let err =
9775            ensure_same_repo("github.com/yukimemi/magi", "github.com/yukimemi/shun").unwrap_err();
9776        let msg = format!("{err:#}");
9777        assert!(msg.contains("github.com/yukimemi/magi"), "{msg}");
9778        assert!(msg.contains("github.com/yukimemi/shun"), "{msg}");
9779    }
9780
9781    /// Same owner/repo on two different forge hosts (a GitHub Enterprise
9782    /// instance mirroring a `github.com` repository's name, say) must not be
9783    /// treated as the same repository just because the trailing path
9784    /// matches.
9785    #[test]
9786    fn ensure_same_repo_refuses_the_same_slug_on_a_different_host() {
9787        let err = ensure_same_repo(
9788            "github.com/yukimemi/magi",
9789            "github.example.com/yukimemi/magi",
9790        )
9791        .unwrap_err();
9792        let msg = format!("{err:#}");
9793        assert!(msg.contains("github.com/yukimemi/magi"), "{msg}");
9794        assert!(msg.contains("github.example.com/yukimemi/magi"), "{msg}");
9795    }
9796
9797    /// No winner decided yet means there is no branch to ask GitHub about at
9798    /// all — `find_external_merge` must return `None` without ever spawning
9799    /// `gh`, which this proves by never providing a real repository to spawn
9800    /// it in.
9801    #[tokio::test]
9802    async fn find_external_merge_returns_none_without_a_winner() {
9803        let state = RunState::new(
9804            PathBuf::from("/no/such/repo"),
9805            "main".to_owned(),
9806            "0000000000000000000000000000000000000000".to_owned(),
9807            "irrelevant".to_owned(),
9808            crate::config::Config::default(),
9809        );
9810        assert_eq!(find_external_merge(&state).await.unwrap(), None);
9811    }
9812
9813    fn pr_run(home: &Path, id: &str, repo: &str, status: RunStatus, url: &str, state: &str) {
9814        let mut run = RunState::new(
9815            PathBuf::from(repo),
9816            "main".to_owned(),
9817            "abcdef1234".to_owned(),
9818            "x".to_owned(),
9819            crate::config::Config::default(),
9820        );
9821        run.id = id.to_owned();
9822        run.status = status;
9823        run.driver_exited = true;
9824        run.pr = Some(crate::run::PrRecord {
9825            number: url.rsplit('/').next().unwrap().parse().unwrap(),
9826            url: url.to_owned(),
9827            state: state.to_owned(),
9828            checks: "red".to_owned(),
9829            round: 0,
9830            rounds: 2,
9831            red_at_merge: Vec::new(),
9832        });
9833        run.save_under(home).unwrap();
9834    }
9835
9836    fn recorded(home: &Path, id: &str) -> String {
9837        let body = std::fs::read_to_string(home.join("runs").join(id).join("run.json")).unwrap();
9838        serde_json::from_str::<RunState>(&body)
9839            .unwrap()
9840            .pr
9841            .unwrap()
9842            .state
9843    }
9844
9845    const PR: &str = "https://github.com/o/r/pull/7";
9846
9847    #[test]
9848    fn write_through_updates_predecessors_and_siblings_only() {
9849        let tmp = tempfile::tempdir().unwrap();
9850        let h = tmp.path();
9851        pr_run(
9852            h,
9853            "20261004-100000-aaaa",
9854            "/repo/r",
9855            RunStatus::Superseded,
9856            PR,
9857            "open",
9858        );
9859        pr_run(
9860            h,
9861            "20261004-100100-bbbb",
9862            "/repo/r",
9863            RunStatus::Blocked,
9864            PR,
9865            "open",
9866        );
9867        // Not terminal: a driver may be writing it.
9868        pr_run(
9869            h,
9870            "20261004-100200-cccc",
9871            "/repo/r",
9872            RunStatus::Landing,
9873            PR,
9874            "open",
9875        );
9876        // Another repository's pull request with the same number.
9877        pr_run(
9878            h,
9879            "20261004-100300-dddd",
9880            "/repo/other",
9881            RunStatus::Blocked,
9882            "https://github.com/o/other/pull/7",
9883            "open",
9884        );
9885        // A different pull request of the same repository.
9886        pr_run(
9887            h,
9888            "20261004-100400-eeee",
9889            "/repo/r",
9890            RunStatus::Blocked,
9891            "https://github.com/o/r/pull/8",
9892            "open",
9893        );
9894        pr_run(
9895            h,
9896            "20261004-100500-ffff",
9897            "/repo/r",
9898            RunStatus::Merged,
9899            PR,
9900            "open",
9901        );
9902        let source = RunState::load_under("20261004-100500-ffff", h).unwrap();
9903
9904        assert_eq!(
9905            write_pr_state_through_in(h, &source, PrLifecycle::Merged),
9906            2
9907        );
9908        assert_eq!(recorded(h, "20261004-100000-aaaa"), "merged");
9909        assert_eq!(recorded(h, "20261004-100100-bbbb"), "merged");
9910        assert_eq!(recorded(h, "20261004-100200-cccc"), "open");
9911        assert_eq!(recorded(h, "20261004-100300-dddd"), "open");
9912        assert_eq!(recorded(h, "20261004-100400-eeee"), "open");
9913        // The source's own record is the caller's to write.
9914        assert_eq!(recorded(h, "20261004-100500-ffff"), "open");
9915        // Idempotent.
9916        assert_eq!(
9917            write_pr_state_through_in(h, &source, PrLifecycle::Merged),
9918            0
9919        );
9920        let hit = RunState::load_under("20261004-100000-aaaa", h).unwrap();
9921        assert!(hit.events.iter().any(|e| e.message.contains("merged")));
9922    }
9923
9924    #[test]
9925    fn lifecycle_updates_preserve_live_and_unknown_terminal_drivers() {
9926        let home = tempfile::tempdir().unwrap();
9927        let live_id = "20261004-100000-aaaa";
9928        let unknown_id = "20261004-100100-bbbb";
9929        for id in [live_id, unknown_id] {
9930            pr_run(home.path(), id, "repo", RunStatus::Ready, PR, "open");
9931            let mut s = RunState::load_under(id, home.path()).unwrap();
9932            s.driver_exited = false;
9933            // Model legacy driver evidence, not a newly reserved unstarted run.
9934            s.driver_claimed = None;
9935            if id == live_id {
9936                s.driver_pid = Some(std::process::id());
9937                s.driver_started_at = crate::proc::process_started_at(std::process::id());
9938            }
9939            s.save_under(home.path()).unwrap();
9940            if id == unknown_id {
9941                assert_eq!(
9942                    s.liveness_under(home.path(), false),
9943                    crate::run::Liveness::Unknown
9944                );
9945            }
9946        }
9947        let known = BTreeMap::from([(PR.to_owned(), PrLifecycle::Merged)]);
9948        assert_eq!(apply_pr_states(home.path(), &known), 0);
9949        for id in [live_id, unknown_id] {
9950            assert_eq!(recorded(home.path(), id), "open");
9951        }
9952    }
9953
9954    #[test]
9955    fn repair_rewrites_merged_and_closed_and_leaves_open_and_unknown() {
9956        let tmp = tempfile::tempdir().unwrap();
9957        let h = tmp.path();
9958        let url = |n: u32| format!("https://github.com/o/r/pull/{n}");
9959        pr_run(
9960            h,
9961            "20261004-100000-aaaa",
9962            "/repo/r",
9963            RunStatus::Superseded,
9964            &url(1),
9965            "open",
9966        );
9967        pr_run(
9968            h,
9969            "20261004-100100-bbbb",
9970            "/repo/r",
9971            RunStatus::Blocked,
9972            &url(2),
9973            "open",
9974        );
9975        pr_run(
9976            h,
9977            "20261004-100200-cccc",
9978            "/repo/r",
9979            RunStatus::Ready,
9980            &url(3),
9981            "open",
9982        );
9983        pr_run(
9984            h,
9985            "20261004-100300-dddd",
9986            "/repo/r",
9987            RunStatus::Ready,
9988            &url(4),
9989            "open",
9990        );
9991        pr_run(
9992            h,
9993            "20261004-100400-eeee",
9994            "/repo/r",
9995            RunStatus::Implementing,
9996            &url(1),
9997            "open",
9998        );
9999        assert_eq!(stale_open_prs(h).len(), 4);
10000
10001        let mut known = BTreeMap::new();
10002        known.insert(url(1), PrLifecycle::Merged);
10003        known.insert(url(2), PrLifecycle::Closed);
10004        known.insert(url(3), PrLifecycle::Open);
10005        // #4: the forge could not be read, so it has no answer.
10006        assert_eq!(apply_pr_states(h, &known), 2);
10007        assert_eq!(recorded(h, "20261004-100000-aaaa"), "merged");
10008        assert_eq!(recorded(h, "20261004-100100-bbbb"), "closed");
10009        assert_eq!(recorded(h, "20261004-100200-cccc"), "open");
10010        assert_eq!(recorded(h, "20261004-100300-dddd"), "open");
10011        assert_eq!(recorded(h, "20261004-100400-eeee"), "open");
10012        assert_eq!(apply_pr_states(h, &known), 0);
10013    }
10014
10015    // --- the land loop against a scripted forge -------------------------
10016
10017    use std::collections::VecDeque;
10018    use std::sync::Mutex;
10019
10020    /// Answers views from a script (the last one repeats), merges from a
10021    /// queue, and records every call so a test can assert the order.
10022    struct Scripted {
10023        public_repo: Option<PathBuf>,
10024        evidence: Mutex<Option<CiEvidence>>,
10025        views: Mutex<VecDeque<Seen>>,
10026        merges: Mutex<VecDeque<(bool, String)>>,
10027        fix: Mutex<Option<Fixed>>,
10028        log: Mutex<Vec<&'static str>>,
10029        argvs: Mutex<Vec<Vec<String>>>,
10030        required: Mutex<Option<BTreeSet<String>>>,
10031        /// Set once a merge answered ok: the forge then reports `merged`,
10032        /// unless `queued` says the merge only entered a queue.
10033        merged: Mutex<bool>,
10034        queued: Mutex<bool>,
10035        /// Views fail once a merge answered ok.
10036        unreadable_after_merge: Mutex<bool>,
10037        /// Workflow runs asked to rerun, and whether that call fails.
10038        reruns: Mutex<Vec<String>>,
10039        rerun_fails: Mutex<bool>,
10040        /// Unix seconds; every poll moves it on by `POLL`.
10041        clock: Mutex<i64>,
10042    }
10043
10044    impl Scripted {
10045        fn new(views: Vec<Seen>, merges: Vec<(bool, &str)>) -> Self {
10046            Self {
10047                public_repo: None,
10048                evidence: Mutex::new(None),
10049                views: Mutex::new(views.into()),
10050                merges: Mutex::new(
10051                    merges
10052                        .into_iter()
10053                        .map(|(ok, m)| (ok, m.to_owned()))
10054                        .collect(),
10055                ),
10056                fix: Mutex::new(None),
10057                log: Mutex::new(Vec::new()),
10058                argvs: Mutex::new(Vec::new()),
10059                required: Mutex::new(None),
10060                merged: Mutex::new(false),
10061                queued: Mutex::new(false),
10062                unreadable_after_merge: Mutex::new(false),
10063                reruns: Mutex::new(Vec::new()),
10064                rerun_fails: Mutex::new(false),
10065                clock: Mutex::new(1_000),
10066            }
10067        }
10068        fn argvs(&self) -> Vec<Vec<String>> {
10069            self.argvs.lock().unwrap().clone()
10070        }
10071        fn calls(&self) -> Vec<&'static str> {
10072            self.log.lock().unwrap().clone()
10073        }
10074    }
10075
10076    impl Forge for Scripted {
10077        async fn attribution(&self, _state: &RunState, _seen: &Seen) -> Option<CiEvidence> {
10078            self.evidence.lock().unwrap().clone()
10079        }
10080        async fn view(&self, _repo: &Path, _url: &str) -> Result<Seen> {
10081            self.log.lock().unwrap().push("view");
10082            if *self.unreadable_after_merge.lock().unwrap()
10083                && !self.argvs.lock().unwrap().is_empty()
10084            {
10085                anyhow::bail!("forge unreachable");
10086            }
10087            let mut seen = {
10088                let mut v = self.views.lock().unwrap();
10089                if v.len() > 1 {
10090                    v.pop_front().unwrap()
10091                } else {
10092                    v[0].clone()
10093                }
10094            };
10095            if seen.head == "@published" {
10096                let head =
10097                    git::remote_head(self.public_repo.as_ref().unwrap(), "origin", "task-head")
10098                        .await?
10099                        .context("missing published head")?;
10100                seen.head.clone_from(&head);
10101                seen.rollup_head = head;
10102            }
10103            if *self.merged.lock().unwrap() {
10104                seen.pr.state = PrLifecycle::Merged;
10105            }
10106            Ok(seen)
10107        }
10108        async fn merge(&self, _repo: &Path, argv: &[String]) -> Result<(bool, String)> {
10109            self.log.lock().unwrap().push("merge");
10110            self.argvs.lock().unwrap().push(argv.to_vec());
10111            let out = self
10112                .merges
10113                .lock()
10114                .unwrap()
10115                .pop_front()
10116                .expect("unscripted merge");
10117            if out.0 && !*self.queued.lock().unwrap() && !argv.iter().any(|a| a == "--disable-auto")
10118            {
10119                *self.merged.lock().unwrap() = true;
10120            }
10121            Ok(out)
10122        }
10123        async fn poll(&self) {
10124            self.log.lock().unwrap().push("poll");
10125            *self.clock.lock().unwrap() += POLL.as_secs() as i64;
10126        }
10127        async fn rerun(&self, _repo: &Path, run: &str) -> Result<()> {
10128            self.log.lock().unwrap().push("rerun");
10129            self.reruns.lock().unwrap().push(run.to_owned());
10130            if *self.rerun_fails.lock().unwrap() {
10131                anyhow::bail!("gh run rerun: no");
10132            }
10133            Ok(())
10134        }
10135        fn now(&self) -> i64 {
10136            *self.clock.lock().unwrap()
10137        }
10138        async fn required_contexts(&self, _repo: &Path, _base: &str) -> Option<BTreeSet<String>> {
10139            self.required.lock().unwrap().clone()
10140        }
10141        async fn fix(
10142            &self,
10143            _state: &mut RunState,
10144            _pr: &PrState,
10145            _round: usize,
10146            _budget: usize,
10147            _reason: &str,
10148            _logs: &str,
10149        ) -> Result<Fixed> {
10150            self.log.lock().unwrap().push("fix");
10151            Ok(self.fix.lock().unwrap().take().expect("unscripted fix"))
10152        }
10153    }
10154
10155    const REFUSED: &str =
10156        "X Pull request #42 is not mergeable: the base branch policy prohibits the merge.";
10157
10158    fn seen(head: &str, checks: Checks, merge_state: &str, comments: bool) -> Seen {
10159        let mut pr = green_pr();
10160        pr.checks = checks;
10161        pr.blocking = Blocking::of(merge_state);
10162        if !comments {
10163            pr.review_comments.clear();
10164        }
10165        Seen {
10166            pr,
10167            title: "feat: x".to_owned(),
10168            failing_urls: Vec::new(),
10169            head: head.to_owned(),
10170            rollup_head: head.to_owned(),
10171            merge_state: merge_state.to_owned(),
10172            contexts: Vec::new(),
10173            base: "main".to_owned(),
10174        }
10175    }
10176
10177    fn landing_state() -> RunState {
10178        crate::run::pin_test_home();
10179        let mut state = run_state();
10180        state.config.graph.land_approval = false;
10181        state
10182    }
10183
10184    #[test]
10185    fn a_pushed_head_is_awaited_case_insensitively_and_an_unreadable_one_is_not_a_match() {
10186        assert!(!awaiting_new_head(None, "aaa"));
10187        assert!(!awaiting_new_head(Some("abc123"), "ABC123"));
10188        assert!(awaiting_new_head(Some("abc123"), "def456"));
10189        assert!(awaiting_new_head(Some("abc123"), ""));
10190    }
10191
10192    #[test]
10193    fn a_refusal_is_judged_by_the_pull_requests_state_not_by_its_wording() {
10194        let open = |c, m: &str| seen("a", c, m, false);
10195        let table = [
10196            (None, false, Refused::Pending),
10197            (
10198                Some(open(Checks::Pending, "BLOCKED")),
10199                false,
10200                Refused::Pending,
10201            ),
10202            (
10203                Some(open(Checks::Unknown, "BLOCKED")),
10204                false,
10205                Refused::Pending,
10206            ),
10207            (
10208                Some(open(Checks::Green, "UNKNOWN")),
10209                false,
10210                Refused::Pending,
10211            ),
10212            (Some(open(Checks::Green, "")), false, Refused::Pending),
10213            (
10214                Some(open(Checks::Green, "BLOCKED")),
10215                false,
10216                Refused::Recheck,
10217            ),
10218            (Some(open(Checks::Green, "BLOCKED")), true, Refused::Final),
10219        ];
10220        for (after, rechecked, want) in table {
10221            assert_eq!(
10222                classify_refusal(after.as_ref(), rechecked, "a", CiExpectation::Expected),
10223                want
10224            );
10225        }
10226        let mut closed = open(Checks::Green, "CLEAN");
10227        closed.pr.state = PrLifecycle::Closed;
10228        assert_eq!(
10229            classify_refusal(Some(&closed), false, "a", CiExpectation::Expected),
10230            Refused::Final
10231        );
10232    }
10233
10234    #[test]
10235    fn behind_precedes_old_ci_and_other_blocking_policies_stay_distinct() {
10236        for checks in [Checks::Pending, Checks::Unknown, Checks::Red, Checks::Green] {
10237            let pr = seen("a", checks, "BEHIND", false).pr;
10238            assert_eq!(
10239                decide_with(&pr, 0, 4, Duration::ZERO, CiExpectation::Expected),
10240                Step::Rebase
10241            );
10242        }
10243        for status in ["DRAFT", "BLOCKED", "UNKNOWN"] {
10244            let current = seen("a", Checks::Green, status, false);
10245            assert_ne!(
10246                decide_with(&current.pr, 0, 4, Duration::ZERO, CiExpectation::Expected),
10247                Step::Rebase
10248            );
10249            assert_ne!(
10250                classify_refusal(Some(&current), false, "a", CiExpectation::Expected),
10251                Refused::Behind
10252            );
10253        }
10254        let mut current = seen("a", Checks::Pending, "BEHIND", false);
10255        current.rollup_head = "old".into();
10256        assert_eq!(
10257            classify_refusal(Some(&current), true, "a", CiExpectation::Expected),
10258            Refused::Behind
10259        );
10260        assert_eq!(
10261            classify_refusal(Some(&current), true, "other", CiExpectation::Expected),
10262            Refused::Pending
10263        );
10264        current.pr.state = PrLifecycle::Closed;
10265        assert_eq!(
10266            classify_refusal(Some(&current), true, "a", CiExpectation::Expected),
10267            Refused::Final
10268        );
10269    }
10270
10271    #[tokio::test]
10272    async fn behind_at_each_landing_boundary_syncs_and_requires_new_head_approval() {
10273        for boundary in ["initial", "premerge", "refusal"] {
10274            let (_tmp, mut state, old) = landing_git_fixture().await;
10275            state.land_sync_pending = false;
10276            advance_landing_base(&state).await;
10277            state.config.verify.gate = vec!["test -f advance".into()];
10278            state.config.verify.e2e = vec!["test -f advance".into()];
10279            approval_gate(&mut state, &green_pr(), "feat: x", None, &old)
10280                .await
10281                .unwrap();
10282            let old_binding = state.land_approval.clone().unwrap();
10283            let store = ask::Questions::open();
10284            let mut question = store.get(&old_binding.question).unwrap();
10285            question
10286                .answer(ask::Answer::Choice(APPROVE.to_owned()))
10287                .unwrap();
10288            store.put(&mut question).unwrap();
10289            let mut views = Vec::new();
10290            if boundary != "initial" {
10291                views.push(seen(&old, Checks::Green, "CLEAN", false));
10292            }
10293            if boundary == "refusal" {
10294                views.push(seen(&old, Checks::Green, "CLEAN", false));
10295            }
10296            let mut behind = seen(&old, Checks::Pending, "BEHIND", false);
10297            behind.rollup_head = "old-ci-head".into();
10298            views.push(behind);
10299            // Publication checks the PR lease while verification has completed.
10300            views.push(seen(&old, Checks::Green, "CLEAN", false));
10301            views.push(seen("@published", Checks::Pending, "CLEAN", false));
10302            views.push(seen("@published", Checks::Green, "CLEAN", false));
10303            let merges = if boundary == "refusal" {
10304                vec![(false, REFUSED)]
10305            } else {
10306                vec![]
10307            };
10308            let mut forge = Scripted::new(views, merges);
10309            forge.public_repo = Some(state.repo.clone());
10310            let run = state.id.clone();
10311            land_with(&mut state, URL, &forge).await.unwrap();
10312            let head = state.pr_pushed_head.clone().unwrap();
10313            assert_ne!(head, old, "{boundary}");
10314            assert_eq!(state.id, run);
10315            assert_eq!(state.pr_branch(), Some("task-head"));
10316            assert_eq!(state.winner().unwrap().branch, "winner");
10317            assert_eq!(state.gate_head.as_deref(), Some(head.as_str()));
10318            assert!(state.gate_allows_progress());
10319            let e2e = state.head_e2e.as_ref().unwrap();
10320            assert_eq!(e2e.head, head);
10321            assert!(e2e.passed);
10322            assert_eq!(state.land_sync_attempts, 1);
10323            assert!(!state.land_sync_pending);
10324            assert!(state.parked);
10325            let binding = state.land_approval.as_ref().unwrap();
10326            assert_eq!(binding.head, head);
10327            assert_ne!(binding.question, old_binding.question);
10328            assert_eq!(forge.argvs().len(), usize::from(boundary == "refusal"));
10329            // The new question authorizes only the synchronized head on resume.
10330            let mut question = store.get(&binding.question).unwrap();
10331            question
10332                .answer(ask::Answer::Choice(APPROVE.to_owned()))
10333                .unwrap();
10334            store.put(&mut question).unwrap();
10335            let forge = Scripted::new(
10336                vec![seen(&head, Checks::Green, "CLEAN", false)],
10337                vec![(true, "")],
10338            );
10339            land_with(&mut state, URL, &forge).await.unwrap();
10340            assert_eq!(state.status, RunStatus::Merged);
10341            assert_eq!(
10342                value_of(&forge.argvs()[0], "--match-head-commit"),
10343                Some(head.as_str())
10344            );
10345        }
10346    }
10347
10348    #[tokio::test]
10349    async fn behind_refusal_remains_actionable_when_the_next_view_is_clean() {
10350        let (_tmp, mut state, old) = landing_git_fixture().await;
10351        state.land_sync_pending = false;
10352        state.config.graph.land_approval = false;
10353        state.config.verify.gate = vec!["test -f advance && test -f change".into()];
10354        advance_landing_base(&state).await;
10355        let mut forge = Scripted::new(
10356            vec![
10357                seen(&old, Checks::Green, "CLEAN", false),
10358                seen(&old, Checks::Green, "CLEAN", false),
10359                seen(&old, Checks::Green, "BEHIND", false),
10360                // The next observation is the publication lease check. The
10361                // refusal's evidence still applies to exactly this old head.
10362                seen(&old, Checks::Green, "CLEAN", false),
10363                seen("@published", Checks::Green, "CLEAN", false),
10364            ],
10365            vec![(false, REFUSED), (true, "")],
10366        );
10367        forge.public_repo = Some(state.repo.clone());
10368        land_with(&mut state, URL, &forge).await.unwrap();
10369        let head = state.pr_pushed_head.as_deref().unwrap();
10370        assert_ne!(head, old);
10371        assert_eq!(state.land_sync_attempts, 1);
10372        assert_eq!(state.gate_head.as_deref(), Some(head));
10373        assert_eq!(state.status, RunStatus::Merged);
10374        let requests = forge.argvs();
10375        assert_eq!(requests.len(), 2);
10376        assert_eq!(
10377            value_of(&requests[0], "--match-head-commit"),
10378            Some(old.as_str())
10379        );
10380        assert_eq!(value_of(&requests[1], "--match-head-commit"), Some(head));
10381    }
10382
10383    #[tokio::test]
10384    async fn behind_ancestry_failure_stops_without_rebasing_or_publishing() {
10385        let (tmp, mut state, old) = landing_git_fixture().await;
10386        state.land_sync_pending = false;
10387        // A damaged history must not be interpreted as a missing base. Keep
10388        // the head's tree intact so worktree restoration itself can succeed.
10389        let tree = git::rev_parse(&state.repo, "HEAD^{tree}").await.unwrap();
10390        let commit = tmp.path().join("broken-commit");
10391        std::fs::write(
10392            &commit,
10393            format!(
10394                "tree {tree}\nparent {}\nauthor Test <test@example.test> 1 +0000\ncommitter Test <test@example.test> 1 +0000\n\nbroken history\n",
10395                "f".repeat(40)
10396            ),
10397        )
10398        .unwrap();
10399        let replacement = git::git(
10400            &state.repo,
10401            &[
10402                "hash-object",
10403                "-t",
10404                "commit",
10405                "-w",
10406                commit.to_str().unwrap(),
10407            ],
10408        )
10409        .await
10410        .unwrap();
10411        git::git(&state.repo, &["replace", &old, replacement.trim()])
10412            .await
10413            .unwrap();
10414        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10415        land_with(&mut state, URL, &forge).await.unwrap();
10416        assert_eq!(state.land_sync_attempts, 0);
10417        assert_eq!(state.pr_pushed_head.as_deref(), Some(old.as_str()));
10418        assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), old);
10419        assert!(forge.argvs().is_empty());
10420        assert!(
10421            state.events.iter().any(|e| e.message.contains(
10422                "could not determine whether the landing head contains the fetched base"
10423            ))
10424        );
10425    }
10426
10427    #[tokio::test]
10428    async fn behind_fetch_failure_stops_without_rebasing_or_publishing() {
10429        let (_tmp, mut state, old) = landing_git_fixture().await;
10430        state.land_sync_pending = false;
10431        git::git(
10432            &state.repo,
10433            &["remote", "set-url", "origin", "missing-remote"],
10434        )
10435        .await
10436        .unwrap();
10437        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10438        land_with(&mut state, URL, &forge).await.unwrap();
10439        assert_eq!(state.land_sync_attempts, 0);
10440        assert_eq!(git::rev_parse(&state.repo, "HEAD").await.unwrap(), old);
10441        assert!(
10442            state
10443                .events
10444                .iter()
10445                .any(|e| e.message.contains("cannot fetch landing base"))
10446        );
10447        assert!(forge.argvs().is_empty());
10448    }
10449
10450    #[tokio::test]
10451    async fn behind_without_base_progress_and_exhausted_resume_budget_never_publish() {
10452        let (_tmp, mut state, old) = landing_git_fixture().await;
10453        state.land_sync_pending = false;
10454        let forge = Scripted::new(vec![seen(&old, Checks::Green, "BEHIND", false)], vec![]);
10455        land_with(&mut state, URL, &forge).await.unwrap();
10456        assert_eq!(state.pr_pushed_head.as_deref(), Some(old.as_str()));
10457        assert_eq!(state.land_sync_attempts, 0);
10458        assert!(
10459            state
10460                .events
10461                .iter()
10462                .any(|e| e.message.contains("already included"))
10463        );
10464        advance_landing_base(&state).await;
10465        state.land_sync_attempts = state.config.graph.land_rounds;
10466        state.land_sync_pending = true;
10467        state.save().unwrap();
10468        let mut restored = RunState::load(&state.id).unwrap();
10469        assert!(
10470            resume_observed_head(&mut restored, &old)
10471                .await
10472                .unwrap_err()
10473                .to_string()
10474                .contains("budget exhausted")
10475        );
10476        assert_eq!(
10477            git::remote_head(&state.repo, "origin", "task-head")
10478                .await
10479                .unwrap(),
10480            Some(old)
10481        );
10482    }
10483
10484    #[tokio::test]
10485    async fn a_normal_landing_merges_on_the_first_look() {
10486        let mut state = landing_state();
10487        let forge = Scripted::new(
10488            vec![seen("a", Checks::Green, "CLEAN", false)],
10489            vec![(true, "")],
10490        );
10491        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10492            .await
10493            .unwrap();
10494        // One fresh read, then the head-bound merge.
10495        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10496        assert_eq!(state.status, RunStatus::Merged);
10497    }
10498
10499    #[tokio::test]
10500    async fn a_successful_merge_command_that_only_queued_is_not_a_merge() {
10501        let mut state = landing_state();
10502        let forge = Scripted::new(
10503            vec![seen("a", Checks::Green, "CLEAN", false)],
10504            std::iter::repeat_n((true, ""), 100).collect(),
10505        );
10506        *forge.queued.lock().unwrap() = true;
10507        let task = async {
10508            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10509                .await
10510                .unwrap();
10511        };
10512        // Still open after the command succeeded: it keeps watching and
10513        // never records a merge (it stops at the wait ceiling instead).
10514        task.await;
10515        assert_ne!(state.status, RunStatus::Merged);
10516    }
10517
10518    #[tokio::test]
10519    async fn an_unreadable_forge_after_a_merge_command_is_not_a_confirmation() {
10520        let mut state = landing_state();
10521        let forge = Scripted::new(
10522            vec![seen("a", Checks::Green, "CLEAN", false)],
10523            std::iter::repeat_n((true, ""), 100).collect(),
10524        );
10525        *forge.unreadable_after_merge.lock().unwrap() = true;
10526        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10527            .await
10528            .ok();
10529        assert_ne!(state.status, RunStatus::Merged);
10530    }
10531
10532    #[tokio::test]
10533    async fn a_task_public_head_is_awaited_on_land_entry() {
10534        let mut state = landing_state();
10535        state.pr_head = Some("magi/task-abcd-1234".into());
10536        state.pr_pushed_head = Some("new".into());
10537        let forge = Scripted::new(
10538            vec![
10539                seen("old", Checks::Green, "CLEAN", false),
10540                seen("new", Checks::Green, "CLEAN", false),
10541            ],
10542            vec![(true, "")],
10543        );
10544        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10545            .await
10546            .unwrap();
10547        assert_eq!(
10548            forge.calls(),
10549            ["view", "poll", "view", "view", "merge", "view"]
10550        );
10551        assert_eq!(state.status, RunStatus::Merged);
10552    }
10553
10554    #[tokio::test]
10555    async fn a_superseded_public_head_owner_cannot_reenter_land() {
10556        let mut state = landing_state();
10557        state.pr_taken_over_by = Some("next".into());
10558        let forge = Scripted::new(vec![seen("a", Checks::Green, "CLEAN", false)], vec![]);
10559        assert!(
10560            land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10561                .await
10562                .is_err()
10563        );
10564        assert!(forge.calls().is_empty());
10565    }
10566
10567    #[tokio::test]
10568    async fn after_a_pushed_fix_no_merge_is_tried_until_the_head_matches() {
10569        let mut state = landing_state();
10570        let forge = Scripted::new(
10571            vec![
10572                seen("old", Checks::Green, "CLEAN", true),
10573                // The forge has not moved to the new head yet: still green.
10574                seen("old", Checks::Green, "CLEAN", true),
10575                seen("new", Checks::Pending, "BLOCKED", true),
10576                seen("new", Checks::Green, "CLEAN", true),
10577            ],
10578            vec![(true, "")],
10579        );
10580        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10581            head: "NEW".to_owned(),
10582        });
10583        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10584            .await
10585            .unwrap();
10586        assert_eq!(
10587            forge.calls(),
10588            [
10589                "view", "fix", "poll", "view", "poll", "view", "poll", "view", "view", "merge",
10590                "view"
10591            ]
10592        );
10593        assert_eq!(state.status, RunStatus::Merged);
10594    }
10595
10596    #[tokio::test]
10597    async fn a_head_that_never_arrives_stops_naming_both_commits() {
10598        let mut state = landing_state();
10599        let forge = Scripted::new(
10600            vec![
10601                seen("old", Checks::Green, "CLEAN", true),
10602                seen("someone-elses", Checks::Green, "CLEAN", true),
10603            ],
10604            vec![],
10605        );
10606        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10607            head: "mine".to_owned(),
10608        });
10609        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10610            .await
10611            .unwrap();
10612        assert!(!forge.calls().contains(&"merge"));
10613        let why = state.merge.as_ref().unwrap().detail.clone();
10614        assert!(
10615            why.contains("mine") && why.contains("someone-elses"),
10616            "{why}"
10617        );
10618        assert_eq!(state.status, RunStatus::Blocked);
10619    }
10620
10621    #[tokio::test]
10622    async fn a_policy_refusal_while_checks_run_waits_and_then_merges() {
10623        let mut state = landing_state();
10624        let forge = Scripted::new(
10625            vec![
10626                seen("a", Checks::Green, "CLEAN", false),
10627                seen("a", Checks::Green, "CLEAN", false),
10628                seen("a", Checks::Pending, "BLOCKED", false),
10629                seen("a", Checks::Pending, "BLOCKED", false),
10630                seen("a", Checks::Green, "CLEAN", false),
10631            ],
10632            vec![(false, REFUSED), (true, "")],
10633        );
10634        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10635            .await
10636            .unwrap();
10637        assert_eq!(
10638            forge.calls(),
10639            [
10640                "view", "view", "merge", "view", "poll", "view", "poll", "view", "view", "merge",
10641                "view"
10642            ]
10643        );
10644        assert_eq!(state.status, RunStatus::Merged);
10645    }
10646
10647    #[tokio::test]
10648    async fn a_refusal_that_outlives_settled_checks_stops_with_the_merge_state() {
10649        let mut state = landing_state();
10650        let forge = Scripted::new(
10651            vec![
10652                seen("a", Checks::Green, "CLEAN", false),
10653                seen("a", Checks::Green, "BLOCKED", false),
10654            ],
10655            vec![(false, REFUSED), (false, REFUSED)],
10656        );
10657        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10658            .await
10659            .unwrap();
10660        // One re-look is allowed for the forge's own lag, then it is final.
10661        assert_eq!(forge.calls().iter().filter(|c| **c == "merge").count(), 2);
10662        let why = state.merge.as_ref().unwrap().detail.clone();
10663        assert!(
10664            why.contains("policy prohibits") && why.contains("BLOCKED") && why.contains("refused"),
10665            "{why}"
10666        );
10667        assert_eq!(state.status, RunStatus::Blocked);
10668    }
10669
10670    #[test]
10671    fn a_decision_is_bound_to_a_head_only_when_every_signal_agrees() {
10672        assert_eq!(bound_head("abc", "abc", None), Some("abc"));
10673        assert_eq!(bound_head("abc", "ABC", Some("abc")), Some("abc"));
10674        // The pull request is still on the commit before the push.
10675        assert_eq!(bound_head("old", "old", Some("new")), None);
10676        // The checks are the previous commit's.
10677        assert_eq!(bound_head("new", "old", Some("new")), None);
10678        assert_eq!(bound_head("new", "old", None), None);
10679        // Nothing readable.
10680        assert_eq!(bound_head("", "", None), None);
10681        assert_eq!(bound_head("", "", Some("new")), None);
10682        assert_eq!(bound_head("abc", "", None), None);
10683    }
10684
10685    fn view_json(head: &str) -> String {
10686        format!(
10687            r#"{{"url":"https://github.com/o/r/pull/42","number":42,"state":"OPEN",
10688            "title":"t","headRefOid":"{head}","mergeStateStatus":"CLEAN",
10689            "reviews":[],"comments":[]}}"#
10690        )
10691    }
10692
10693    fn node_json(oid: &str, check: &str, has_next: bool) -> String {
10694        format!(
10695            r#"{{"data":{{"repository":{{"pullRequest":{{"commits":{{"nodes":[{{"commit":
10696            {{"oid":"{oid}","statusCheckRollup":{{"contexts":{{"pageInfo":{{"hasNextPage":{has_next}}},
10697            "nodes":[{{"__typename":"CheckRun","name":"ci","status":"COMPLETED",
10698            "conclusion":"{check}","detailsUrl":"https://example.test/1"}}]}}}}}}}}]}}}}}}}}}}"#
10699        )
10700    }
10701
10702    #[test]
10703    fn rollup_is_bound_to_the_commit_in_the_same_node() {
10704        // The view already points at the new head, but the node still answers
10705        // for the old commit with its red check: the head stays unbound.
10706        let s = seen_from(&view_json("new"), Some(&node_json("old", "FAILURE", false))).unwrap();
10707        assert_eq!(s.rollup_head, "old");
10708        assert_eq!(s.pr.checks, Checks::Red);
10709        assert_eq!(bound_head(&s.head, &s.rollup_head, Some("new")), None);
10710        assert_eq!(s.failing_urls.len(), 1);
10711    }
10712
10713    #[test]
10714    fn checks_come_from_the_node_not_the_view() {
10715        let view = view_json("new").replace(
10716            r#""reviews""#,
10717            r#""statusCheckRollup":[{"name":"ci","status":"COMPLETED","conclusion":"FAILURE"}],"reviews""#,
10718        );
10719        let s = seen_from(&view, Some(&node_json("new", "SUCCESS", false))).unwrap();
10720        assert_eq!(s.pr.checks, Checks::Green);
10721        assert!(s.pr.failing.is_empty());
10722        assert_eq!(
10723            bound_head(&s.head, &s.rollup_head, Some("new")),
10724            Some("new")
10725        );
10726    }
10727
10728    #[test]
10729    fn an_unreadable_or_paged_node_leaves_the_head_unbound() {
10730        for node in [
10731            None,
10732            Some("not json".to_owned()),
10733            Some(r#"{"errors":[{"message":"x"}]}"#.to_owned()),
10734            Some(node_json("new", "SUCCESS", true)),
10735        ] {
10736            let s = seen_from(&view_json("new"), node.as_deref()).unwrap();
10737            assert!(s.rollup_head.is_empty());
10738            assert_eq!(s.pr.checks, Checks::Unknown);
10739            assert_eq!(bound_head(&s.head, &s.rollup_head, None), None);
10740        }
10741    }
10742
10743    #[test]
10744    fn the_merge_command_is_pinned_to_the_observed_head() {
10745        let argv = merge_argv_at(7, "feat: x", "deadbeef");
10746        let at = argv
10747            .iter()
10748            .position(|a| a == "--match-head-commit")
10749            .unwrap();
10750        assert_eq!(argv[at + 1], "deadbeef");
10751    }
10752
10753    #[tokio::test]
10754    async fn stale_checks_after_a_fix_push_never_reach_a_merge() {
10755        let mut state = landing_state();
10756        // The pull request is on the pushed head but the rollup is still the
10757        // previous commit's red, non-required result.
10758        let mut stale = seen("new", Checks::Red, "CLEAN", false);
10759        stale.rollup_head = "old".to_owned();
10760        let forge = Scripted::new(
10761            vec![seen("old", Checks::Green, "CLEAN", true), stale],
10762            vec![],
10763        );
10764        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
10765            head: "new".to_owned(),
10766        });
10767        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10768            .await
10769            .unwrap();
10770        assert!(!forge.calls().contains(&"merge"));
10771        assert_eq!(state.status, RunStatus::Blocked);
10772        let why = state.merge.as_ref().unwrap().detail.clone();
10773        assert!(why.contains("new") && why.contains("old"), "{why}");
10774    }
10775
10776    #[test]
10777    fn a_refusal_read_against_another_commits_checks_is_pending() {
10778        let mut after = seen("a", Checks::Green, "BLOCKED", false);
10779        after.rollup_head = "old".to_owned();
10780        assert_eq!(
10781            classify_refusal(Some(&after), true, "a", CiExpectation::Expected),
10782            Refused::Pending
10783        );
10784    }
10785
10786    #[tokio::test]
10787    async fn absent_ci_empty_rollup_reaches_approval_then_merges_on_the_approved_head() {
10788        let mut state = landing_state();
10789        state.config.merge.ci = crate::config::MergeCi::None;
10790        state.config.graph.land_approval = true;
10791        let forge = Scripted::new(
10792            vec![seen("a", Checks::Unknown, "CLEAN", false)],
10793            vec![(true, "")],
10794        );
10795        land_with(&mut state, URL, &forge).await.unwrap();
10796        assert!(state.parked);
10797        assert_eq!(forge.calls(), ["view"]);
10798        let store = ask::Questions::open();
10799        let mut q = store
10800            .get(&state.land_approval.as_ref().unwrap().question)
10801            .unwrap();
10802        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
10803        store.put(&mut q).unwrap();
10804
10805        land_with(&mut state, URL, &forge).await.unwrap();
10806        assert_eq!(forge.calls(), ["view", "view", "view", "merge", "view"]);
10807        assert_eq!(state.status, RunStatus::Merged);
10808        assert_eq!(
10809            value_of(&forge.argvs()[0], "--match-head-commit"),
10810            Some("a")
10811        );
10812    }
10813
10814    #[tokio::test]
10815    async fn absent_ci_ignores_failed_workflow_runs_without_rerunning_them() {
10816        let mut state = landing_state();
10817        state.config.merge.ci = crate::config::MergeCi::None;
10818        let forge = Scripted::new(vec![red("a", Some("7"))], vec![(true, "")]);
10819        land_with(&mut state, URL, &forge).await.unwrap();
10820        assert!(forge.reruns.lock().unwrap().is_empty());
10821        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10822        assert_eq!(state.status, RunStatus::Merged);
10823    }
10824
10825    #[test]
10826    fn absent_ci_still_requires_a_readable_matching_head_and_resolved_comments() {
10827        let shown = BTreeSet::new();
10828        let guard = |s: Option<&Seen>| {
10829            direct_merge_is_safe(s, "a", &shown, 0, 4, Duration::ZERO, CiExpectation::Absent)
10830        };
10831        let mut fresh = seen("a", Checks::Unknown, "CLEAN", false);
10832        assert!(guard(Some(&fresh)));
10833        assert!(!guard(None));
10834        fresh.rollup_head = "old".to_owned();
10835        assert!(!guard(Some(&fresh)));
10836        fresh.rollup_head = "a".to_owned();
10837        fresh.head = "b".to_owned();
10838        assert!(!guard(Some(&fresh)));
10839        assert!(!guard(Some(&seen("a", Checks::Unknown, "CLEAN", true))));
10840        assert!(!guard(Some(&seen("a", Checks::Unknown, "DIRTY", false))));
10841    }
10842
10843    #[test]
10844    fn absent_ci_refusal_does_not_wait_for_third_party_checks() {
10845        for checks in [Checks::Unknown, Checks::Pending, Checks::Red, Checks::Green] {
10846            let after = seen("a", checks, "BLOCKED", false);
10847            assert_eq!(
10848                classify_refusal(Some(&after), false, "a", CiExpectation::Absent),
10849                Refused::Recheck
10850            );
10851            assert_eq!(
10852                classify_refusal(Some(&after), true, "a", CiExpectation::Absent),
10853                Refused::Final
10854            );
10855        }
10856    }
10857
10858    #[tokio::test]
10859    async fn a_matching_head_with_red_non_required_checks_still_merges() {
10860        let mut state = landing_state();
10861        let forge = Scripted::new(
10862            vec![seen("a", Checks::Red, "CLEAN", false)],
10863            vec![(true, "")],
10864        );
10865        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10866            .await
10867            .unwrap();
10868        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10869        assert_eq!(state.status, RunStatus::Merged);
10870    }
10871
10872    #[tokio::test]
10873    async fn a_merge_refused_because_the_head_moved_looks_again_instead_of_failing() {
10874        let mut state = landing_state();
10875        let forge = Scripted::new(
10876            vec![
10877                seen("a", Checks::Green, "CLEAN", false),
10878                seen("a", Checks::Green, "CLEAN", false),
10879                // Re-viewed after the refusal: someone pushed.
10880                seen("b", Checks::Green, "BLOCKED", false),
10881                seen("b", Checks::Green, "CLEAN", false),
10882            ],
10883            vec![(false, REFUSED), (true, "")],
10884        );
10885        land_with(&mut state, "https://github.com/o/r/pull/42", &forge)
10886            .await
10887            .unwrap();
10888        assert_eq!(
10889            forge.calls(),
10890            [
10891                "view", "view", "merge", "view", "poll", "view", "view", "merge", "view"
10892            ]
10893        );
10894        assert_eq!(state.status, RunStatus::Merged);
10895    }
10896
10897    fn merged_view(head: &str) -> Seen {
10898        let mut m = seen(head, Checks::Green, "CLEAN", false);
10899        m.pr.state = PrLifecycle::Merged;
10900        m
10901    }
10902
10903    fn has(argv: &[String], flag: &str) -> bool {
10904        argv.iter().any(|a| a == flag)
10905    }
10906
10907    fn value_of<'a>(argv: &'a [String], flag: &str) -> Option<&'a str> {
10908        let at = argv.iter().position(|a| a == flag)?;
10909        argv.get(at + 1).map(String::as_str)
10910    }
10911
10912    const URL: &str = "https://github.com/o/r/pull/42";
10913
10914    #[tokio::test]
10915    async fn the_merge_step_merges_directly_on_the_observed_head_and_never_arms() {
10916        let mut state = landing_state();
10917        let forge = Scripted::new(
10918            vec![
10919                seen("abc", Checks::Green, "CLEAN", false),
10920                seen("abc", Checks::Green, "CLEAN", false),
10921            ],
10922            vec![(true, "")],
10923        );
10924        land_with(&mut state, URL, &forge).await.unwrap();
10925        assert_eq!(forge.calls(), ["view", "view", "merge", "view"]);
10926        let argv = &forge.argvs()[0];
10927        assert!(has(argv, "--squash") && has(argv, "--subject"));
10928        assert!(!has(argv, "--auto") && !has(argv, "--admin"));
10929        assert_eq!(value_of(argv, "--match-head-commit"), Some("abc"));
10930        assert_eq!(state.status, RunStatus::Merged);
10931        assert!(state.land_armed_head.is_none());
10932    }
10933
10934    #[tokio::test]
10935    async fn a_resume_disables_an_arm_left_by_an_older_build_before_merging() {
10936        let mut state = landing_state();
10937        state.land_armed_head = Some("a".to_owned());
10938        let forge = Scripted::new(
10939            vec![seen("a", Checks::Green, "CLEAN", false)],
10940            vec![(true, ""), (true, "")],
10941        );
10942        land_with(&mut state, URL, &forge).await.unwrap();
10943        let argvs = forge.argvs();
10944        assert!(has(&argvs[0], "--disable-auto"));
10945        assert!(!has(&argvs[1], "--auto"));
10946        assert_eq!(value_of(&argvs[1], "--match-head-commit"), Some("a"));
10947        assert_eq!(state.status, RunStatus::Merged);
10948        assert!(state.land_armed_head.is_none());
10949    }
10950
10951    #[tokio::test]
10952    async fn an_approval_never_carries_over_to_a_new_head() {
10953        crate::run::pin_test_home();
10954        let mut state = run_state();
10955        state.config.graph.land_approval = true;
10956        let pr = green_pr();
10957        let store = ask::Questions::open();
10958
10959        approval_gate(&mut state, &pr, "feat: x", None, "aaa")
10960            .await
10961            .unwrap();
10962        let mut q = store
10963            .list()
10964            .into_iter()
10965            .find(|q| q.run == state.id)
10966            .unwrap();
10967        q.answer(ask::Answer::Choice(APPROVE.to_owned())).unwrap();
10968        store.put(&mut q).unwrap();
10969        assert_eq!(
10970            approval_gate(&mut state, &pr, "feat: x", None, "AAA")
10971                .await
10972                .unwrap(),
10973            ApprovalGate::Approved,
10974            "the same head keeps its approval"
10975        );
10976
10977        // A new head is a new question, not the old word.
10978        assert_eq!(
10979            approval_gate(&mut state, &pr, "feat: x", None, "bbb")
10980                .await
10981                .unwrap(),
10982            ApprovalGate::Pending
10983        );
10984        let all: Vec<_> = store
10985            .list()
10986            .into_iter()
10987            .filter(|q| q.run == state.id)
10988            .collect();
10989        assert_eq!(all.len(), 2);
10990
10991        // A question recorded before heads were tracked is not reused either.
10992        state.land_approval = None;
10993        assert_eq!(
10994            approval_gate(&mut state, &pr, "feat: x", None, "bbb")
10995                .await
10996                .unwrap(),
10997            ApprovalGate::Pending
10998        );
10999        let open = store
11000            .list()
11001            .into_iter()
11002            .filter(|q| q.run == state.id && q.status.open())
11003            .count();
11004        assert_eq!(open, 1, "the superseded question was retired");
11005    }
11006
11007    #[tokio::test]
11008    async fn the_merge_is_bound_to_the_head_it_was_decided_on() {
11009        let mut state = landing_state();
11010        let forge = Scripted::new(
11011            vec![
11012                seen("a", Checks::Green, "CLEAN", false),
11013                // The fresh read before the merge: someone pushed.
11014                seen("b", Checks::Green, "CLEAN", false),
11015            ],
11016            vec![(true, "")],
11017        );
11018        land_with(&mut state, URL, &forge).await.unwrap();
11019        let argvs = forge.argvs();
11020        assert_eq!(argvs.len(), 1, "no merge was tried on the moved head");
11021        assert!(!has(&argvs[0], "--auto"));
11022        assert_eq!(value_of(&argvs[0], "--match-head-commit"), Some("b"));
11023        assert_eq!(state.status, RunStatus::Merged);
11024    }
11025
11026    fn passing(label: &str) -> CheckInfo {
11027        CheckInfo {
11028            label: label.to_owned(),
11029            verdict: Verdict::Pass,
11030            required: Some(false),
11031            run: None,
11032        }
11033    }
11034
11035    fn failing(label: &str, run: Option<&str>) -> (String, Option<String>) {
11036        (label.to_owned(), run.map(str::to_owned))
11037    }
11038
11039    fn reran(head: &str, runs: &[(&str, i64)]) -> LandReruns {
11040        LandReruns {
11041            head: head.to_owned(),
11042            runs: runs.iter().map(|(r, at)| ((*r).to_owned(), *at)).collect(),
11043        }
11044    }
11045
11046    #[test]
11047    fn a_failed_run_is_rerun_once_then_waited_on_then_left_to_the_fixer() {
11048        let f = [failing("test (macos)", Some("7"))];
11049        assert_eq!(
11050            rerun_step(&f, None, "h", 100),
11051            RerunStep::Rerun(vec!["7".to_owned()])
11052        );
11053        let rec = reran("h", &[("7", 100)]);
11054        let grace = crate::release_watch::RERUN_GRACE;
11055        assert_eq!(
11056            rerun_step(&f, Some(&rec), "h", 100 + grace - 1),
11057            RerunStep::Grace
11058        );
11059        assert_eq!(rerun_step(&f, Some(&rec), "h", 100 + grace), RerunStep::Fix);
11060    }
11061
11062    #[test]
11063    fn a_failure_without_a_run_id_goes_to_the_fixer() {
11064        let f = [failing("a", Some("7")), failing("ci/external", None)];
11065        assert_eq!(rerun_step(&f, None, "h", 0), RerunStep::Fix);
11066        assert_eq!(rerun_step(&[], None, "h", 0), RerunStep::Fix);
11067    }
11068
11069    #[test]
11070    fn a_moved_head_forgets_the_reruns() {
11071        let f = [failing("a", Some("7"))];
11072        let rec = reran("old", &[("7", 100)]);
11073        assert_eq!(
11074            rerun_step(&f, Some(&rec), "new", 101),
11075            RerunStep::Rerun(vec!["7".to_owned()])
11076        );
11077    }
11078
11079    #[test]
11080    fn only_unrerun_runs_are_rerun_and_duplicates_collapse() {
11081        let f = [
11082            failing("a", Some("7")),
11083            failing("b", Some("7")),
11084            failing("c", Some("8")),
11085        ];
11086        assert_eq!(
11087            rerun_step(&f, None, "h", 0),
11088            RerunStep::Rerun(vec!["7".to_owned(), "8".to_owned()])
11089        );
11090        let rec = reran("h", &[("7", 0)]);
11091        assert_eq!(
11092            rerun_step(&f, Some(&rec), "h", 1),
11093            RerunStep::Rerun(vec!["8".to_owned()])
11094        );
11095    }
11096
11097    #[test]
11098    fn only_blocking_failures_are_candidates_for_a_rerun() {
11099        let check = |label: &str, verdict, required, run: &str| CheckInfo {
11100            label: label.to_owned(),
11101            verdict,
11102            required,
11103            run: Some(run.to_owned()),
11104        };
11105        let got = rerunnable(&[
11106            check("passed", Verdict::Pass, Some(true), "1"),
11107            check("optional", Verdict::Fail, Some(false), "2"),
11108            check("required", Verdict::Fail, Some(true), "3"),
11109            check("unknown", Verdict::Fail, None, "4"),
11110        ]);
11111        let labels: Vec<_> = got.iter().map(|(l, _)| l.as_str()).collect();
11112        assert_eq!(labels, ["required", "unknown"]);
11113    }
11114
11115    fn unrelated_ci_fixture() -> CiEvidence {
11116        let failure = CiFailure {
11117            path: "tests/web_render.rs".into(),
11118            start_line: 42,
11119            end_line: 42,
11120            title: "question_identity_disclosure_copy_and_live_updates".into(),
11121            message: "assertion failed".into(),
11122        };
11123        CiEvidence {
11124            head: "a".into(),
11125            base: "base-sha".into(),
11126            changed: vec![
11127                "AGENTS.md".into(),
11128                "src/talk.rs".into(),
11129                "tests/consult_investigation.rs".into(),
11130            ],
11131            checks: vec![CiCheckEvidence {
11132                label: "coverage".into(),
11133                head_check: 70,
11134                base_check: 60,
11135                app: 1,
11136                run: "7".into(),
11137                base_run: "6".into(),
11138                head_failures: vec![failure.clone()],
11139                base_failures: vec![failure],
11140                rerun_exhausted: true,
11141            }],
11142        }
11143    }
11144
11145    #[test]
11146    fn unrelated_ci_requires_complete_structural_evidence_for_every_failure() {
11147        let good = unrelated_ci_fixture();
11148        let red = vec!["coverage".into()];
11149        assert!(good.unrelated("a", &red));
11150        assert!(!good.unrelated("another-head", &red));
11151        assert!(!good.unrelated("a", &["coverage".into(), "test".into()]));
11152        assert!(!good.unrelated("a", &[]));
11153        for mutation in 0..8 {
11154            let mut bad = good.clone();
11155            match mutation {
11156                0 => bad.checks[0].rerun_exhausted = false,
11157                1 => bad.checks[0].base_failures.clear(),
11158                2 => bad.checks[0].head_failures.clear(),
11159                3 => bad.changed.push("tests/web_render.rs".into()),
11160                4 => bad.changed.push(".github/workflows/ci.yml".into()),
11161                5 => bad.checks[0].base_failures[0].message = "different failure".into(),
11162                6 => bad.checks.push(bad.checks[0].clone()),
11163                _ => bad.base.clear(),
11164            }
11165            assert!(!bad.unrelated("a", &red), "mutation {mutation}");
11166        }
11167    }
11168
11169    #[test]
11170    fn red_unknown_merge_state_waits_before_repair_but_never_implies_merge() {
11171        let pr = seen("a", Checks::Red, "UNKNOWN", false).pr;
11172        assert_eq!(decide(&pr, 0, 2, Duration::ZERO), Step::Wait);
11173        assert!(matches!(decide(&pr, 0, 2, CHECKS_GRACE), Step::Fix { .. }));
11174        assert!(matches!(
11175            decide(&pr, 2, 2, CHECKS_GRACE),
11176            Step::GiveUp { .. }
11177        ));
11178        let optional = CheckInfo {
11179            label: "coverage".into(),
11180            verdict: Verdict::Fail,
11181            required: Some(false),
11182            run: Some("7".into()),
11183        };
11184        assert!(rerunnable_with(std::slice::from_ref(&optional), false).is_empty());
11185        assert_eq!(
11186            rerunnable_with(&[optional], true),
11187            vec![("coverage".into(), Some("7".into()))]
11188        );
11189    }
11190
11191    #[tokio::test]
11192    async fn unrelated_ci_after_a_comment_round_does_not_charge_a_no_commit_stop() {
11193        let mut state = landing_state();
11194        let mut red = coverage_unknown();
11195        red.pr = seen("a", Checks::Red, "BLOCKED", true).pr;
11196        red.pr.failing = vec!["coverage".into()];
11197        let forge = Scripted::new(vec![red], vec![]);
11198        *forge.evidence.lock().unwrap() = Some(unrelated_ci_fixture());
11199        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11200        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11201        assert!(forge.calls().contains(&"fix"));
11202        assert!(state.land_unrelated.is_some());
11203        assert!(state.parked);
11204        assert!(
11205            !state
11206                .events
11207                .iter()
11208                .any(|e| e.message.contains("fixer produced no commit"))
11209        );
11210    }
11211
11212    fn coverage_unknown() -> Seen {
11213        let mut s = red("a", Some("7"));
11214        s.pr.blocking = Blocking::Unsaid;
11215        s.merge_state = "UNKNOWN".into();
11216        s.pr.failing = vec!["coverage".into()];
11217        s.contexts[0].label = "coverage".into();
11218        s.contexts[0].required = Some(false);
11219        s
11220    }
11221
11222    #[tokio::test]
11223    async fn run_196c_unknown_then_unstable_does_not_spend_a_fix_round() {
11224        let mut state = landing_state();
11225        let unknown = coverage_unknown();
11226        let mut unstable = unknown.clone();
11227        unstable.pr.blocking = Blocking::of("UNSTABLE");
11228        unstable.merge_state = "UNSTABLE".into();
11229        let forge = Scripted::new(vec![unknown, unstable], vec![(true, "")]);
11230        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11231        assert!(!forge.calls().contains(&"fix"));
11232        assert!(!forge.calls().contains(&"rerun"));
11233        assert_eq!(state.status, RunStatus::Merged);
11234        assert_eq!(state.pr.unwrap().round, 0);
11235    }
11236
11237    #[tokio::test]
11238    async fn run_196c_persistent_unknown_reruns_optional_once_then_parks_with_evidence() {
11239        let mut state = landing_state();
11240        let forge = Scripted::new(vec![coverage_unknown()], vec![]);
11241        *forge.evidence.lock().unwrap() = Some(unrelated_ci_fixture());
11242        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11243        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11244        assert!(!forge.calls().contains(&"fix"));
11245        assert!(state.parked);
11246        assert_eq!(state.status, RunStatus::Landing);
11247        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11248        let hold = state.land_unrelated.as_ref().unwrap();
11249        let q = ask::Questions::open().get(&hold.question).unwrap();
11250        assert!(
11251            q.actions
11252                .values()
11253                .any(|a| matches!(a, ask::ChoiceAction::Resume { .. }))
11254        );
11255        assert!(
11256            state
11257                .events
11258                .iter()
11259                .any(|e| e.message.contains("[ci-unrelated]") && e.message.contains("base-sha"))
11260        );
11261        let first = state.land_unsaid.clone();
11262        // A resume on this head neither extends UNKNOWN grace nor reruns 7.
11263        state.parked = false;
11264        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11265        assert_eq!(state.land_unsaid, first);
11266        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11267    }
11268
11269    fn red(head: &str, run: Option<&str>) -> Seen {
11270        let mut s = seen(head, Checks::Red, "BLOCKED", false);
11271        s.pr.failing = vec!["test (macos)".to_owned()];
11272        s.contexts = vec![CheckInfo {
11273            label: "test (macos)".to_owned(),
11274            verdict: Verdict::Fail,
11275            required: Some(true),
11276            run: run.map(str::to_owned),
11277        }];
11278        s
11279    }
11280
11281    const RERUN_PR: &str = "https://github.com/o/r/pull/42";
11282
11283    #[tokio::test]
11284    async fn a_flaky_red_check_is_rerun_without_a_fix_round_and_then_merges() {
11285        let mut state = landing_state();
11286        let forge = Scripted::new(
11287            vec![
11288                red("a", Some("7")),
11289                seen("a", Checks::Pending, "BLOCKED", false),
11290                seen("a", Checks::Green, "CLEAN", false),
11291            ],
11292            vec![(true, "")],
11293        );
11294        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11295        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11296        assert!(!forge.calls().contains(&"fix"));
11297        assert_eq!(state.status, RunStatus::Merged);
11298        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11299        let argvs = forge.argvs();
11300        assert_eq!(value_of(&argvs[0], "--match-head-commit"), Some("a"));
11301        assert!(
11302            state
11303                .events
11304                .iter()
11305                .any(|e| e.message.contains("test (macos)") && e.message.contains("run 7"))
11306        );
11307    }
11308
11309    #[tokio::test]
11310    async fn still_red_after_the_grace_goes_to_the_fixer_and_a_run_is_not_rerun_twice() {
11311        let mut state = landing_state();
11312        let forge = Scripted::new(
11313            vec![
11314                red("a", Some("7")),
11315                seen("a", Checks::Green, "CLEAN", false),
11316            ],
11317            vec![(true, "")],
11318        );
11319        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11320        // The red view repeats for the grace, then the fixer is asked once.
11321        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11322        assert_eq!(forge.reruns.lock().unwrap().len(), 1);
11323        let calls = forge.calls();
11324        let rerun_at = calls.iter().position(|c| *c == "rerun").unwrap();
11325        let fix_at = calls.iter().position(|c| *c == "fix");
11326        assert!(fix_at.is_none_or(|f| f > rerun_at));
11327    }
11328
11329    #[tokio::test]
11330    async fn a_failed_run_is_rerun_while_another_run_is_still_pending() {
11331        let mut state = landing_state();
11332        let mut v = red("a", Some("7"));
11333        v.pr.checks = Checks::Pending;
11334        v.contexts.push(CheckInfo {
11335            label: "slow".to_owned(),
11336            verdict: Verdict::Pending,
11337            required: Some(true),
11338            run: Some("8".to_owned()),
11339        });
11340        let forge = Scripted::new(
11341            vec![v, seen("a", Checks::Green, "CLEAN", false)],
11342            vec![(true, "")],
11343        );
11344        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11345        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11346        assert_eq!(state.status, RunStatus::Merged);
11347    }
11348
11349    #[test]
11350    fn a_run_with_a_job_still_going_is_not_rerun_yet() {
11351        let mut v = red("a", Some("7"));
11352        v.contexts.push(CheckInfo {
11353            label: "same run, still going".to_owned(),
11354            verdict: Verdict::Pending,
11355            required: Some(true),
11356            run: Some("7".to_owned()),
11357        });
11358        assert!(rerunnable(&v.contexts).is_empty());
11359    }
11360
11361    #[tokio::test]
11362    async fn the_rerun_is_made_even_when_the_fix_budget_is_spent() {
11363        let mut state = landing_state();
11364        state.config.graph.land_rounds = 0;
11365        let forge = Scripted::new(
11366            vec![
11367                red("a", Some("7")),
11368                seen("a", Checks::Green, "CLEAN", false),
11369            ],
11370            vec![(true, "")],
11371        );
11372        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11373        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11374        assert_eq!(state.status, RunStatus::Merged);
11375        assert!(!forge.calls().contains(&"fix"));
11376        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11377    }
11378
11379    #[tokio::test]
11380    async fn a_deferred_landing_fix_keeps_its_round_for_resume() {
11381        let mut state = landing_state();
11382        state.config.graph.land_rounds = 1;
11383        let forge = Scripted::new(vec![seen("a", Checks::Green, "CLEAN", true)], vec![]);
11384        *forge.fix.lock().unwrap() = Some(Fixed::Deferred);
11385        let pr = land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11386        assert_eq!(pr.state, PrLifecycle::Open);
11387        assert_eq!(state.status, RunStatus::Blocked);
11388        assert_eq!(state.pr.as_ref().unwrap().round, 0);
11389        assert!(
11390            state.merge_decision.is_none(),
11391            "no ordinary failure handoff"
11392        );
11393        assert!(forge.argvs().is_empty(), "no merge on outage");
11394
11395        let recovered = Scripted::new(
11396            vec![
11397                seen("a", Checks::Green, "CLEAN", true),
11398                seen("b", Checks::Green, "CLEAN", false),
11399            ],
11400            vec![(true, "")],
11401        );
11402        *recovered.fix.lock().unwrap() = Some(Fixed::Committed { head: "b".into() });
11403        land_with(&mut state, RERUN_PR, &recovered).await.unwrap();
11404        assert_eq!(state.status, RunStatus::Merged);
11405        assert_eq!(state.pr.as_ref().unwrap().round, 1);
11406        assert_eq!(recovered.calls().iter().filter(|c| **c == "fix").count(), 1);
11407    }
11408
11409    #[tokio::test]
11410    async fn the_last_fix_rounds_new_head_gets_its_rerun() {
11411        let mut state = landing_state();
11412        state.config.graph.land_rounds = 1;
11413        let forge = Scripted::new(
11414            vec![
11415                seen("a", Checks::Green, "CLEAN", true),
11416                red("b", Some("7")),
11417                seen("b", Checks::Green, "CLEAN", false),
11418            ],
11419            vec![(true, "")],
11420        );
11421        *forge.fix.lock().unwrap() = Some(Fixed::Committed {
11422            head: "b".to_owned(),
11423        });
11424        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11425        assert_eq!(*forge.reruns.lock().unwrap(), ["7"]);
11426        assert_eq!(forge.calls().iter().filter(|c| **c == "fix").count(), 1);
11427        assert_eq!(state.pr.as_ref().unwrap().round, 1);
11428        assert_eq!(state.status, RunStatus::Merged);
11429        assert_eq!(state.land_reruns.as_ref().unwrap().head, "b");
11430        assert_eq!(
11431            value_of(&forge.argvs()[0], "--match-head-commit"),
11432            Some("b")
11433        );
11434    }
11435
11436    #[tokio::test]
11437    async fn a_failed_rerun_call_falls_through_to_the_fix_in_the_same_lap() {
11438        let mut state = landing_state();
11439        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11440        *forge.rerun_fails.lock().unwrap() = true;
11441        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11442        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11443        assert_eq!(forge.reruns.lock().unwrap().len(), 1, "never retried");
11444        assert_eq!(
11445            forge.calls().iter().filter(|c| **c == "fix").count(),
11446            1,
11447            "{:?}",
11448            forge.calls()
11449        );
11450    }
11451
11452    #[tokio::test]
11453    async fn a_saved_rerun_record_stops_a_restart_from_rerunning() {
11454        let mut state = landing_state();
11455        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11456        // The record was written just before the previous pass died.
11457        state.land_reruns = Some(reran("a", &[("7", *forge.clock.lock().unwrap())]));
11458        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11459        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11460        assert!(forge.reruns.lock().unwrap().is_empty());
11461    }
11462
11463    #[tokio::test]
11464    async fn the_switch_off_and_a_missing_run_id_go_straight_to_the_fixer() {
11465        let mut state = landing_state();
11466        state.config.graph.rerun_flaky_checks = false;
11467        let forge = Scripted::new(vec![red("a", Some("7"))], vec![]);
11468        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11469        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11470        assert!(forge.reruns.lock().unwrap().is_empty());
11471        assert!(forge.calls().contains(&"fix"));
11472
11473        let mut state = landing_state();
11474        let forge = Scripted::new(vec![red("a", None)], vec![]);
11475        *forge.fix.lock().unwrap() = Some(Fixed::Declined);
11476        land_with(&mut state, RERUN_PR, &forge).await.unwrap();
11477        assert!(forge.reruns.lock().unwrap().is_empty());
11478        assert!(forge.calls().contains(&"fix"));
11479    }
11480
11481    fn names(xs: &[&str]) -> BTreeSet<String> {
11482        xs.iter().map(|x| (*x).to_owned()).collect()
11483    }
11484
11485    #[test]
11486    fn a_required_check_the_rollup_never_listed_is_named() {
11487        let req = names(&["build"]);
11488        let why = waiting_on("BLOCKED", &[passing("review")], Some(&req));
11489        assert!(why.contains("never reported: build"), "{why}");
11490        assert!(!why.contains("probably waiting for a review"), "{why}");
11491    }
11492
11493    #[test]
11494    fn an_unreadable_required_list_is_not_read_as_a_review_wait() {
11495        let why = waiting_on("BLOCKED", &[passing("review")], None);
11496        assert!(why.contains("could not be read"), "{why}");
11497        assert!(!why.contains("probably waiting for a review"), "{why}");
11498    }
11499
11500    #[test]
11501    fn all_required_reported_keeps_the_review_guess() {
11502        let req = names(&["build"]);
11503        let why = waiting_on("BLOCKED", &[passing("build")], Some(&req));
11504        assert!(why.contains("probably waiting for a review"), "{why}");
11505        assert!(!why.contains("never reported"), "{why}");
11506    }
11507
11508    #[test]
11509    fn required_names_match_the_rollup_ignoring_case_only() {
11510        let req = names(&["Build"]);
11511        let why = waiting_on("BLOCKED", &[passing("build")], Some(&req));
11512        assert!(!why.contains("never reported"), "{why}");
11513    }
11514
11515    #[test]
11516    fn required_contexts_are_read_from_protection_and_rulesets() {
11517        let classic = r#"{"contexts":["build"],"checks":[{"context":"lint","app_id":1}]}"#;
11518        assert_eq!(
11519            parse_classic_required(classic),
11520            Some(names(&["build", "lint"]))
11521        );
11522        let rules = r#"[{"type":"pull_request","parameters":{}},
11523            {"type":"required_status_checks","parameters":{"required_status_checks":[{"context":"test"}]}}]"#;
11524        assert_eq!(parse_ruleset_required(rules), Some(names(&["test"])));
11525        assert_eq!(parse_ruleset_required("nope"), None);
11526        assert_eq!(encode_path_segment("release/1.x"), "release%2F1.x");
11527    }
11528
11529    #[test]
11530    fn the_direct_merge_guard_needs_the_approved_head_bound_to_its_checks() {
11531        let shown = BTreeSet::new();
11532        let ok = seen("a", Checks::Green, "CLEAN", false);
11533        let guard = |s: Option<&Seen>| {
11534            direct_merge_is_safe(
11535                s,
11536                "A",
11537                &shown,
11538                0,
11539                4,
11540                Duration::ZERO,
11541                CiExpectation::Expected,
11542            )
11543        };
11544        assert!(guard(Some(&ok)));
11545        assert!(!guard(None));
11546        assert!(!guard(Some(&seen("b", Checks::Green, "CLEAN", false))));
11547        let mut stale = ok.clone();
11548        stale.rollup_head = "old".to_owned();
11549        assert!(!guard(Some(&stale)));
11550        assert!(!guard(Some(&seen("a", Checks::Pending, "BLOCKED", false))));
11551        assert!(!guard(Some(&merged_view("a"))));
11552    }
11553
11554    #[test]
11555    fn the_rollup_node_carries_whether_each_check_is_required() {
11556        let node = node_json("new", "SUCCESS", false)
11557            .replace(r#""name":"ci","#, r#""name":"ci","isRequired":true,"#);
11558        let s = seen_from(&view_json("new"), Some(&node)).unwrap();
11559        assert_eq!(s.contexts.len(), 1);
11560        assert_eq!(s.contexts[0].required, Some(true));
11561        let s = seen_from(&view_json("new"), Some(&node_json("new", "SUCCESS", false))).unwrap();
11562        assert_eq!(s.contexts[0].required, None);
11563    }
11564
11565    #[tokio::test]
11566    async fn a_resume_that_cannot_disable_a_recorded_arm_stops_and_keeps_the_record() {
11567        let mut state = landing_state();
11568        state.land_armed_head = Some("a".to_owned());
11569        let forge = Scripted::new(
11570            vec![seen("a", Checks::Green, "CLEAN", true)],
11571            vec![(false, "disable exploded")],
11572        );
11573        land_with(&mut state, URL, &forge).await.unwrap();
11574        assert!(!forge.calls().contains(&"fix"));
11575        assert_eq!(state.status, RunStatus::Blocked);
11576        assert_eq!(state.land_armed_head.as_deref(), Some("a"));
11577        let why = state.merge.as_ref().unwrap().detail.clone();
11578        assert!(why.contains("disable exploded"), "{why}");
11579    }
11580}