1use 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
61pub const POLL: Duration = Duration::from_secs(30);
67
68pub const WAIT_CEILING: Duration = Duration::from_secs(45 * 60);
74
75pub const CHECKS_GRACE: Duration = Duration::from_secs(3 * 60);
87
88const LOG_TAIL: usize = 4_000;
91
92const MAX_LOGS: usize = 3;
95
96pub const MARKER: &str = "<!-- magi:land -->";
102
103const NOT_A_REVIEW: [&str; 3] = [
112 "skip review by coderabbit.ai",
113 "summarize by coderabbit.ai",
114 "<!-- tips_start -->",
115];
116
117#[derive(Debug, Clone, Copy, PartialEq, Eq)]
119pub enum PrLifecycle {
120 Open,
122 Merged,
124 Closed,
126}
127
128#[derive(Debug, Clone, Copy, PartialEq, Eq)]
130pub enum Checks {
131 Pending,
133 Green,
136 Red,
138 Unknown,
140}
141
142impl PrLifecycle {
143 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 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#[derive(Debug, Clone, PartialEq, Eq)]
167pub struct ReviewComment {
168 pub author: String,
170 pub path: Option<String>,
172 pub line: Option<u64>,
174 pub body: String,
176}
177
178#[derive(Debug, Clone, PartialEq, Eq)]
180pub struct PrState {
181 pub url: String,
183 pub number: u64,
185 pub state: PrLifecycle,
187 pub checks: Checks,
189 pub failing: Vec<String>,
191 pub review_comments: Vec<ReviewComment>,
193 pub blocking: Blocking,
195}
196
197#[derive(Debug, Clone, Copy, PartialEq, Eq)]
210pub enum Blocking {
211 No,
213 Yes,
215 Conflict,
217 Behind,
219 Unsaid,
223}
224
225impl Blocking {
226 fn of(raw: &str) -> Self {
228 match raw.to_ascii_uppercase().as_str() {
229 "CLEAN" | "UNSTABLE" | "HAS_HOOKS" => Self::No,
232 "DIRTY" => Self::Conflict,
233 "BEHIND" => Self::Behind,
234 "" | "UNKNOWN" => Self::Unsaid,
235 _ => Self::Yes,
237 }
238 }
239
240 #[must_use]
242 pub fn stops_a_merge(self) -> bool {
243 !matches!(self, Self::No)
244 }
245}
246
247#[derive(Debug, Clone, PartialEq, Eq)]
249pub enum Step {
250 Wait,
252 Rebase,
260 Fix {
262 reason: String,
264 },
265 Merge,
267 Done {
269 merged: bool,
271 },
272 GiveUp {
274 reason: String,
276 },
277}
278
279pub(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
320pub fn decide(pr: &PrState, round: usize, budget: usize, waited: Duration) -> Step {
340 decide_with(pr, round, budget, waited, CiExpectation::Expected)
341}
342
343#[derive(Debug, Clone, Copy, PartialEq, Eq)]
345pub enum CiExpectation {
346 Expected,
349 Absent,
352}
353
354pub 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 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 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
435fn 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
446pub 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
461pub 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
473pub 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
483fn 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
514fn 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 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
597pub 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
616pub const APPROVE: &str = "merge";
618
619pub const HOLD: &str = "hold";
621
622pub const REPAIR: &str = "fix findings and re-review";
624
625pub 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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
638pub enum ApprovalReason {
639 EveryMerge,
641 OpenBlockingFindings,
643 FinalReject,
645 ExistingDecision,
647 AfterRepair,
649}
650
651pub 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
679fn 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
691fn 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
914pub 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
933pub 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 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
980pub const APPROVAL_NODE: &str = "land-approval";
986
987pub const DIFF_MAX_LINES: usize = 400;
995
996#[derive(Debug, Clone, Copy, PartialEq, Eq)]
998pub enum Approval {
999 Merge,
1001 Repair,
1003 Hold,
1005}
1006
1007pub 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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1024enum ApprovalGate {
1025 Approved,
1027 Repair,
1029 Held,
1032 Pending,
1034}
1035
1036fn 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("&"),
1050 '<' => out.push_str("<"),
1051 '>' => out.push_str(">"),
1052 '"' => out.push_str("""),
1053 '\'' => out.push_str("'"),
1054 _ => out.push(c),
1055 }
1056 }
1057 out
1058}
1059
1060#[derive(Debug, Clone, PartialEq, Eq)]
1062struct StatRow {
1063 path: String,
1064 added: Option<u64>,
1066 removed: Option<u64>,
1067}
1068
1069impl StatRow {
1070 fn churn(&self) -> u64 {
1073 self.added.unwrap_or(0) + self.removed.unwrap_or(0)
1074 }
1075}
1076
1077fn 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 rows.sort_by(|a, b| b.churn().cmp(&a.churn()).then_with(|| a.path.cmp(&b.path)));
1103 rows
1104}
1105
1106fn 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
1130struct 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 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 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 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 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 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
1325fn words(language: &str) -> &'static Words {
1328 if crate::lang::is_japanese(language) {
1329 &JA
1330 } else {
1331 &EN
1332 }
1333}
1334
1335pub 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 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 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 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 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 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 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 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 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 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
1631fn 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
1641pub 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
1698fn 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
1720async 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 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 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 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 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 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 ask::QuestionStatus::Abandoned => ApprovalGate::Held,
1940 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
1973fn 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
2001pub 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#[derive(Debug, Clone, PartialEq, Eq)]
2051pub(crate) struct CheckView {
2052 pub name: String,
2053 pub verdict: Verdict,
2054 pub run: Option<String>,
2056 pub url: Option<String>,
2057}
2058
2059#[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
2071pub(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
2100pub 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 Ok(parse_pr(&view.1)?.state)
2128}
2129
2130#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
2134pub struct ExternalMerge {
2135 pub url: String,
2137 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
2150fn 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#[derive(Debug, Clone, PartialEq, Eq)]
2195pub enum OpenPr {
2196 None,
2198 One {
2200 url: String,
2202 title: String,
2204 },
2205 Many(Vec<String>),
2207}
2208
2209#[derive(Debug, Deserialize)]
2210#[serde(rename_all = "camelCase")]
2211struct GhOpenPr {
2212 url: String,
2216 #[serde(default)]
2217 title: String,
2218 base_ref_name: String,
2219 #[serde(default)]
2222 is_cross_repository: bool,
2223}
2224
2225pub 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
2250pub 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 is_cross_repository: bool,
2285 head_ref_oid: String,
2288}
2289
2290#[derive(Debug, Clone, PartialEq, Eq)]
2292pub struct Refusal {
2293 pub retry: bool,
2296 pub why: String,
2298}
2299
2300impl Refusal {
2301 fn final_(why: String) -> Self {
2302 Self { retry: false, why }
2303 }
2304}
2305
2306pub 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 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
2360async 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
2378fn forge_unavailable(message: &str) -> bool {
2381 message.contains("known GitHub host") || message.contains("spawn gh")
2382}
2383
2384pub 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
2407pub 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 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 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
2494pub 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
2502pub async fn set_pr_title_verbatim(repo: &Path, url: &str, title: &str) -> Result<()> {
2506 edit_pr_title(repo, url, title).await
2507}
2508
2509pub 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 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
2551pub 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
2588pub 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
2611fn 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
2627pub(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
2646fn 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
2660pub(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
2692async 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
2726pub 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
2788pub(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
2805fn 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
2826fn 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
2882pub(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
2906pub(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
2931pub(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
2939pub 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 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 if state.status == RunStatus::Merged {
2997 crate::followup::after_merge(state, url).await;
2998 }
2999 state.save()?;
3000 Ok((before, state.status))
3001}
3002
3003pub 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
3027fn 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
3042pub 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
3075fn 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 None => return out,
3095 }
3096 }
3097}
3098
3099fn 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
3108fn 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
3121fn 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
3128fn 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
3144fn 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
3162fn 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
3191fn 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
3207fn 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
3222async 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 crate::notices::raise_with(
3237 crate::notices::merged_red(&state.id, &summary),
3238 &state.config.notify,
3239 );
3240}
3241
3242pub async fn land(state: &mut RunState, pr_url: &str) -> Result<PrState> {
3249 land_with(state, pr_url, &GhForge).await
3250}
3251
3252trait 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 async fn rerun(&self, repo: &Path, run: &str) -> Result<()>;
3281 fn now(&self) -> i64;
3283 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
3345fn 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
3358async 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 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
3397fn 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
3418fn 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
3436fn awaiting_new_head(awaiting: Option<&str>, observed: &str) -> bool {
3444 awaiting.is_some_and(|want| !observed.eq_ignore_ascii_case(want))
3445}
3446
3447fn 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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3472enum Refused {
3473 Behind,
3475 Pending,
3477 Recheck,
3481 Final,
3484}
3485
3486fn 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 return Refused::Pending;
3497 };
3498 if after.pr.state != PrLifecycle::Open {
3499 return Refused::Final;
3500 }
3501 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 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
3528async 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
3556async 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
3578fn 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
3591async 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 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
3729fn 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
3753async 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 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
3901async 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 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 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 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 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
4033async 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 state.pr_pushed_head = Some(observed.to_owned());
4064 state.save()?;
4065 restore_landing_worktree(state).await?;
4066 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
4111async 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 let mut shown: BTreeSet<String> = BTreeSet::new();
4173 let mut awaiting_head: Option<String> = state.pr_pushed_head.clone();
4175 let mut rechecked = false;
4177
4178 state.status = RunStatus::Landing;
4186 state.event("land", format!("watching {pr_url}"));
4187 state.save()?;
4188
4189 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 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 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 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 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 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 continue;
4330 }
4331
4332 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 if awaiting_head.take().is_some() {
4379 waited = Duration::ZERO;
4382 }
4383 }
4384
4385 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 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 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 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 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 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 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 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 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 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 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 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 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 let observed_head = seen.head.clone();
4696 {
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(¤t.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, ¤t)?
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 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 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 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 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 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 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 Fixed::Declined => state.event(
4992 "land",
4993 format!("round {round}: fixer declined the comments, nothing committed"),
4994 ),
4995 Fixed::Deferred => {
4996 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
5014pub const CI_HOLD_NODE: &str = "land-ci-unrelated";
5016
5017#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
5019pub struct CiHold {
5020 pub head: String,
5022 pub question: String,
5024 pub evidence: CiEvidence,
5026}
5027
5028#[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#[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 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 !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 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 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 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#[derive(Clone)]
5317struct Seen {
5318 pr: PrState,
5319 title: String,
5320 failing_urls: Vec<(String, String)>,
5321 head: String,
5323 rollup_head: String,
5326 merge_state: String,
5329 contexts: Vec<CheckInfo>,
5331 base: String,
5333}
5334
5335#[derive(Clone)]
5337struct CheckInfo {
5338 label: String,
5339 verdict: Verdict,
5340 required: Option<bool>,
5341 run: Option<String>,
5343}
5344
5345#[derive(Debug, Clone, PartialEq, Eq)]
5347enum RerunStep {
5348 Rerun(Vec<String>),
5350 Grace,
5352 Fix,
5354}
5355
5356#[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 .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
5384fn rerun_step(
5386 failing: &[(String, Option<String>)],
5387 record: Option<&LandReruns>,
5388 head: &str,
5389 now: i64,
5390) -> RerunStep {
5391 if failing.is_empty() || failing.iter().any(|(_, run)| run.is_none()) {
5394 return RerunStep::Fix;
5395 }
5396 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
5420async 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 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
5464fn 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
5516fn 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 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
5542async 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#[doc(hidden)]
5574#[derive(Debug, PartialEq)]
5575pub enum Fixed {
5576 Committed {
5578 head: String,
5580 },
5581 Declined,
5583 Deferred,
5585 Failed(String),
5587}
5588
5589#[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 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 let before = git::rev_parse(&winner.worktree, "HEAD").await?;
5635 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 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 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
5804pub(crate) fn seat_of(state: &mut RunState, key: &str, agent: &str) -> SeatState {
5806 crate::fixer::seat_for(state, key, agent)
5807}
5808
5809pub(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 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
5864fn 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 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
5945async 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 (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
5979fn 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
5987pub(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
5994fn 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
6004async 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
6042pub(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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6079pub(crate) enum Verdict {
6080 Pass,
6081 Fail,
6082 Pending,
6083 Unknown,
6084}
6085
6086impl Verdict {
6087 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 #[serde(default)]
6118 merge_state_status: String,
6119 #[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#[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 #[serde(default)]
6156 is_required: Option<bool>,
6157}
6158
6159impl GhCheck {
6160 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Open)).is_none());
7101 assert!(merged_after_all(&argv, jj, Some(PrLifecycle::Closed)).is_none());
7102 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 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 state.config.disk.min_free_bytes = 0;
7211 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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/<b>&"x"'.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 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 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 <evidence>"));
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 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 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 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 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 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 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 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 assert!(ja.contains("src/a.rs"), "the diffstat is not prose");
9644 assert!(ja.contains("feat: x"), "nor is the merge subject");
9645
9646 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 #[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 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 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 #[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 #[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 #[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 #[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 #[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 #[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 pr_run(
9869 h,
9870 "20261004-100200-cccc",
9871 "/repo/r",
9872 RunStatus::Landing,
9873 PR,
9874 "open",
9875 );
9876 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 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 assert_eq!(recorded(h, "20261004-100500-ffff"), "open");
9915 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 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 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 use std::collections::VecDeque;
10018 use std::sync::Mutex;
10019
10020 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 merged: Mutex<bool>,
10034 queued: Mutex<bool>,
10035 unreadable_after_merge: Mutex<bool>,
10037 reruns: Mutex<Vec<String>>,
10039 rerun_fails: Mutex<bool>,
10040 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(¤t.pr, 0, 4, Duration::ZERO, CiExpectation::Expected),
10247 Step::Rebase
10248 );
10249 assert_ne!(
10250 classify_refusal(Some(¤t), 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(¤t), true, "a", CiExpectation::Expected),
10258 Refused::Behind
10259 );
10260 assert_eq!(
10261 classify_refusal(Some(¤t), true, "other", CiExpectation::Expected),
10262 Refused::Pending
10263 );
10264 current.pr.state = PrLifecycle::Closed;
10265 assert_eq!(
10266 classify_refusal(Some(¤t), 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 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 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 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 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 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 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 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 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 assert_eq!(bound_head("old", "old", Some("new")), None);
10676 assert_eq!(bound_head("new", "old", Some("new")), None);
10678 assert_eq!(bound_head("new", "old", None), None);
10679 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 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 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 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 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 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 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 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 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 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}