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