From 14d6e1e51146298111824bbe2b6dfdc8c9d49cb9 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 20:52:20 +0100 Subject: [PATCH 01/16] feat(work): plan board review policy decisions (#307 auto-approve) --- oxa/oxa-work/src/board.rs | 9 +- oxa/oxa-work/src/board/review.rs | 198 +++++++++++++++++++++++++++++ oxa/oxa-work/tests/board_review.rs | 183 ++++++++++++++++++++++++++ 3 files changed, 383 insertions(+), 7 deletions(-) create mode 100644 oxa/oxa-work/src/board/review.rs create mode 100644 oxa/oxa-work/tests/board_review.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 5279a154..1fe84bd5 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -7,6 +7,7 @@ pub use claims::{Assignment, AssignmentBoard, AssignmentData, Claims, ReleaseRec pub mod assignment; mod intake; pub use intake::{ImportState, Issue, Snapshot}; +pub mod review; #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] #[serde(rename_all = "snake_case")] @@ -170,13 +171,7 @@ impl Board { Action::FixRequiredCi } else if pr.mergeability == Mergeability::Conflicting { Action::ResolveConflict - } else if pr.removes_source - && !pr.body.lines().any(|line| { - line.trim() - .strip_prefix("Removes:") - .is_some_and(|note| !note.trim().is_empty()) - }) - { + } else if pr.removes_source && !review::has_removes_note(&pr.body) { Action::AddRemoves } else if pr.required_ci != RequiredCi::Passed { Action::WaitRequiredCi diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs new file mode 100644 index 00000000..1da80b04 --- /dev/null +++ b/oxa/oxa-work/src/board/review.rs @@ -0,0 +1,198 @@ +//! Read-only decisions for the #307 auto-approve row. The runner supplies complete +//! diff facts and authenticated receipts. This module cannot post or approve reviews. + +use super::RequiredCi; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub enum Tier { + DocsAndTests, + Product, + Core, + Protected, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Reviewer { + Codex, + Security, + Owner, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ChangeKind { + Documentation, + Test, + Source, + Other, +} + +pub struct Change<'a> { + pub path: &'a str, + pub previous_path: Option<&'a str>, + pub kind: ChangeKind, + pub deleted_lines: u64, + pub deleted_file: bool, +} + +pub struct RequestReceipt<'a> { + pub reviewer: Reviewer, + pub patch_id: &'a str, +} + +pub struct Approval<'a> { + pub reviewer: Reviewer, + pub head: &'a str, + pub patch_id: &'a str, +} + +pub struct Facts<'a> { + pub changes: &'a [Change<'a>], + pub two_review: bool, + pub required_ci: RequiredCi, + pub draft: bool, + /// Known same-repo author or an explicit maintainer admission. + pub review_admitted: bool, + pub unresolved_findings: bool, + pub body: &'a str, + pub head: &'a str, + /// Stable patch ID of the complete own diff. Missing evidence fails closed. + pub patch_id: Option<&'a str>, + /// Heads proven to reach this head through pure main merges only. + pub main_merge_predecessors: &'a [&'a str], + pub requested: &'a [RequestReceipt<'a>], + pub approvals: &'a [Approval<'a>], +} + +#[derive(Debug, PartialEq, Eq)] +pub enum Decision { + Disabled, + ResolveFindings, + AddRemoves, + Wait, + Review { + tier: Tier, + request: Vec, + outstanding: Vec, + }, +} + +/// Match an exact repo-relative path or a whole directory prefix. +pub struct PathRule<'a> { + pub path: &'a str, + pub tier: Tier, +} + +/// Construct this policy from owner-controlled rules, never from the PR. +#[derive(Default)] +pub struct Policy<'a> { + pub enabled: bool, + pub paths: &'a [PathRule<'a>], +} + +impl Policy<'_> { + pub fn decide(&self, facts: &Facts<'_>) -> Decision { + if !self.enabled { + return Decision::Disabled; + } + if facts.unresolved_findings { + return Decision::ResolveFindings; + } + let source_deletions = facts + .changes + .iter() + .filter(|change| change.kind == ChangeKind::Source) + .fold(0_u64, |total, change| total.saturating_add(change.deleted_lines)); + if (source_deletions > 60 || facts.changes.iter().any(|change| change.deleted_file)) + && !has_removes_note(facts.body) + { + return Decision::AddRemoves; + } + let Some(patch_id) = facts.patch_id.filter(|id| !id.is_empty()) else { + return Decision::Wait; + }; + if facts.required_ci != RequiredCi::Passed + || facts.draft + || !facts.review_admitted + || facts.head.is_empty() + || facts.changes.is_empty() + { + return Decision::Wait; + } + let tier = facts + .changes + .iter() + .map(|change| { + let path_tier = self + .paths + .iter() + .filter(|rule| { + [Some(change.path), change.previous_path] + .into_iter() + .flatten() + .any(|path| { + path == rule.path + || path + .strip_prefix(rule.path) + .is_some_and(|rest| rest.starts_with('/')) + }) + }) + .map(|rule| rule.tier) + .max() + .unwrap_or(Tier::DocsAndTests); + match change.kind { + _ if path_tier == Tier::Protected => Tier::Protected, + ChangeKind::Documentation | ChangeKind::Test => Tier::DocsAndTests, + ChangeKind::Source | ChangeKind::Other => path_tier.max(Tier::Product), + } + }) + .max() + .unwrap_or(Tier::DocsAndTests); + let tier = if facts.two_review { + tier.max(Tier::Core) + } else { + tier + }; + let required: &[Reviewer] = match tier { + Tier::DocsAndTests => &[], + Tier::Product => &[Reviewer::Codex], + Tier::Core => &[Reviewer::Codex, Reviewer::Security], + Tier::Protected => &[Reviewer::Codex, Reviewer::Security, Reviewer::Owner], + }; + let outstanding: Vec<_> = required + .iter() + .copied() + .filter(|reviewer| { + !facts.approvals.iter().any(|approval| { + approval.reviewer == *reviewer + && approval.patch_id == patch_id + && (approval.head == facts.head + || facts.main_merge_predecessors.contains(&approval.head)) + }) + }) + .collect(); + let request = outstanding + .iter() + .copied() + .filter(|reviewer| { + *reviewer != Reviewer::Owner + && !facts + .requested + .iter() + .any(|receipt| receipt.reviewer == *reviewer && receipt.patch_id == patch_id) + }) + .collect(); + Decision::Review { + tier, + request, + outstanding, + } + } +} + +pub(super) fn has_removes_note(body: &str) -> bool { + body.lines().any(|line| { + line.trim() + .strip_prefix("Removes:") + .is_some_and(|note| !note.trim().is_empty()) + }) +} diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs new file mode 100644 index 00000000..1705170d --- /dev/null +++ b/oxa/oxa-work/tests/board_review.rs @@ -0,0 +1,183 @@ +use oxa_work::board::{RequiredCi, review::*}; + +const PATHS: &[PathRule<'_>] = &[ + PathRule { + path: "engine", + tier: Tier::Core, + }, + PathRule { + path: "engine/src/sandbox.rs", + tier: Tier::Protected, + }, +]; + +const SOURCE: Change<'static> = Change { + path: "oxa/src/main.rs", + previous_path: None, + kind: ChangeKind::Source, + deleted_lines: 0, + deleted_file: false, +}; + +fn facts(changes: &[Change<'static>]) -> Facts<'_> { + Facts { + changes, + two_review: false, + required_ci: RequiredCi::Passed, + draft: false, + review_admitted: true, + unresolved_findings: false, + body: "", + head: "new-head", + patch_id: Some("own-patch"), + main_merge_predecessors: &[], + requested: &[], + approvals: &[], + } +} + +fn decide(facts: &Facts<'_>) -> Decision { + Policy { + enabled: true, + paths: PATHS, + } + .decide(facts) +} + +#[test] +fn requires_opt_in_green_required_ci_and_review_admission() { + let mut input = facts(&[SOURCE]); + assert_eq!(Policy::default().decide(&input), Decision::Disabled); + for ci in [RequiredCi::Pending, RequiredCi::Failed] { + input.required_ci = ci; + assert_eq!(decide(&input), Decision::Wait); + } + input.required_ci = RequiredCi::Passed; + input.review_admitted = false; + assert_eq!(decide(&input), Decision::Wait); + input.review_admitted = true; + input.patch_id = None; + assert_eq!(decide(&input), Decision::Wait); +} + +#[test] +fn path_tiers_ignore_routine_tests_and_include_both_paths_of_renames() { + let tests = [Change { + path: "engine/tests/behavior.rs", + kind: ChangeKind::Test, + ..SOURCE + }]; + let mut input = facts(&tests); + assert_eq!( + decide(&input), + Decision::Review { + tier: Tier::DocsAndTests, + request: vec![], + outstanding: vec![], + } + ); + input.two_review = true; + assert_eq!( + decide(&input), + Decision::Review { + tier: Tier::Core, + request: vec![Reviewer::Codex, Reviewer::Security], + outstanding: vec![Reviewer::Codex, Reviewer::Security], + } + ); + let renamed = [Change { + path: "engine-copy/src/sandbox.rs", + previous_path: Some("engine/src/sandbox.rs"), + ..SOURCE + }]; + assert_eq!( + decide(&facts(&renamed)), + Decision::Review { + tier: Tier::Protected, + request: vec![Reviewer::Codex, Reviewer::Security], + outstanding: vec![Reviewer::Codex, Reviewer::Security, Reviewer::Owner], + } + ); +} + +#[test] +fn request_receipts_deduplicate_and_only_pure_merges_carry_approvals() { + let changes = [Change { + path: "engine/src/sandbox.rs", + ..SOURCE + }]; + let mut input = facts(&changes); + input.requested = &[RequestReceipt { + reviewer: Reviewer::Codex, + patch_id: "own-patch", + }]; + input.approvals = &[ + Approval { + reviewer: Reviewer::Codex, + head: "old-head", + patch_id: "own-patch", + }, + Approval { + reviewer: Reviewer::Security, + head: "old-head", + patch_id: "different-patch", + }, + ]; + input.main_merge_predecessors = &["old-head"]; + assert_eq!( + decide(&input), + Decision::Review { + tier: Tier::Protected, + request: vec![Reviewer::Security], + outstanding: vec![Reviewer::Security, Reviewer::Owner], + } + ); + input.main_merge_predecessors = &[]; + assert_eq!( + decide(&input), + Decision::Review { + tier: Tier::Protected, + request: vec![Reviewer::Security], + outstanding: vec![Reviewer::Codex, Reviewer::Security, Reviewer::Owner], + } + ); + input.patch_id = Some("next-own-patch"); + assert!(matches!( + decide(&input), + Decision::Review { request, .. } if request == [Reviewer::Codex, Reviewer::Security] + )); +} + +#[test] +fn removals_count_source_lines_in_aggregate_and_any_deleted_file() { + let changes = [ + Change { + deleted_lines: 30, + ..SOURCE + }, + Change { + deleted_lines: 31, + ..SOURCE + }, + ]; + let mut input = facts(&changes); + assert_eq!(decide(&input), Decision::AddRemoves); + input.body = "Removes: "; + assert_eq!(decide(&input), Decision::AddRemoves); + input.body = "Removes: stale local fallback"; + assert!(matches!(decide(&input), Decision::Review { .. })); + input.unresolved_findings = true; + assert_eq!(decide(&input), Decision::ResolveFindings); + + let exactly_sixty = [Change { + deleted_lines: 60, + ..SOURCE + }]; + assert!(matches!(decide(&facts(&exactly_sixty)), Decision::Review { .. })); + let deleted_doc = [Change { + kind: ChangeKind::Documentation, + deleted_file: true, + ..SOURCE + }]; + assert_eq!(decide(&facts(&deleted_doc)), Decision::AddRemoves); +} From 82862ba592c7bb21e136d703ddf8295f74d54b44 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 20:55:04 +0100 Subject: [PATCH 02/16] fix(work): apply workspace formatting to review policy tests --- oxa/oxa-work/tests/board_review.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs index 1705170d..99e258c7 100644 --- a/oxa/oxa-work/tests/board_review.rs +++ b/oxa/oxa-work/tests/board_review.rs @@ -1,4 +1,4 @@ -use oxa_work::board::{RequiredCi, review::*}; +use oxa_work::board::{review::*, RequiredCi}; const PATHS: &[PathRule<'_>] = &[ PathRule { From dad68e497e9ae920989a44f082e84fc7c14f3def Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 20:57:15 +0100 Subject: [PATCH 03/16] feat(work): feed opted-in review plans into board decisions --- oxa/oxa-work/src/board.rs | 64 ++++++++++++++++++++++-- oxa/oxa-work/src/board/review.rs | 3 ++ oxa/oxa-work/tests/board_review.rs | 80 ++++++++++++++++++++++++++++++ 3 files changed, 142 insertions(+), 5 deletions(-) diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 1fe84bd5..d3fd7985 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -152,12 +152,35 @@ impl Board { state: &BTreeMap, now: u64, ) -> crate::Result { + Self::read_with_review_policy( + github, + policy, + state, + now, + &review::Policy::default(), + &BTreeMap::new(), + ) + .map(|(board, _)| board) + } + + /// The caller supplies trusted evidence for this repository, keyed by PR number. + /// Evidence from a different head cannot qualify a PR or produce a review request. + /// The returned plans are read-only. Dispatch requires a durable request reservation. + pub fn read_with_review_policy( + github: &mut impl GitHub, + policy: &Policy, + state: &BTreeMap, + now: u64, + review_policy: &review::Policy<'_>, + evidence: &BTreeMap>, + ) -> crate::Result<(Self, BTreeMap)> { let mut board = Self { observed_at: now, entries: vec![], }; + let mut review_plans = BTreeMap::new(); if !policy.enabled { - return Ok(board); + return Ok((board, review_plans)); } let mut seen = BTreeSet::new(); let snapshot = github.snapshot()?; @@ -165,25 +188,56 @@ impl Board { if pr.number == 0 || pr.head.is_empty() || !seen.insert(pr.number) { return Err("invalid or duplicate pull request in board snapshot".into()); } + let facts = evidence.get(&pr.number).filter(|facts| facts.head == pr.head); + let review = review_policy.enabled.then(|| { + let Some(facts) = facts else { + return review::Decision::Wait; + }; + let mut decision = review_policy.decide(&review::Facts { + required_ci: pr.required_ci, + draft: pr.draft, + unresolved_findings: pr.findings, + body: &pr.body, + ..*facts + }); + if pr.mergeability != Mergeability::Mergeable { + if let review::Decision::Review { request, .. } = &mut decision { + request.clear(); + } + } + decision + }); let action = if pr.findings { Action::FixFindings } else if pr.required_ci == RequiredCi::Failed { Action::FixRequiredCi } else if pr.mergeability == Mergeability::Conflicting { Action::ResolveConflict - } else if pr.removes_source && !review::has_removes_note(&pr.body) { + } else if matches!(review, Some(review::Decision::AddRemoves)) + || (review.is_none() && pr.removes_source && !review::has_removes_note(&pr.body)) + { Action::AddRemoves } else if pr.required_ci != RequiredCi::Passed { Action::WaitRequiredCi } else if pr.mergeability == Mergeability::Unknown { Action::WaitMergeability - } else if pr.draft { + } else if pr.draft + && (!review_policy.enabled + || facts.is_some_and(|facts| { + !facts.changes.is_empty() && facts.patch_id.is_some_and(|id| !id.is_empty()) + })) + { Action::PromoteDraft - } else if pr.reviewed { + } else if matches!(&review, Some(review::Decision::Review { outstanding, .. }) if outstanding.is_empty()) + || (review.is_none() && pr.reviewed) + { Action::Ready } else { Action::WaitReview }; + if let Some(decision) = review { + review_plans.insert(pr.number, decision); + } board.entries.push(intake::entry( pr.number, pr.head, @@ -216,6 +270,6 @@ impl Board { board .entries .sort_by_key(|e| (!e.release_pinned, e.action, e.number)); - Ok(board) + Ok((board, review_plans)) } } diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 1da80b04..9e656c9a 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -29,6 +29,8 @@ pub enum ChangeKind { pub struct Change<'a> { pub path: &'a str, pub previous_path: Option<&'a str>, + /// For a rename, Source if either side is source and Other if either side + /// is unclassified. Filter as documentation or test only if both sides qualify. pub kind: ChangeKind, pub deleted_lines: u64, pub deleted_file: bool, @@ -45,6 +47,7 @@ pub struct Approval<'a> { pub patch_id: &'a str, } +#[derive(Clone, Copy)] pub struct Facts<'a> { pub changes: &'a [Change<'a>], pub two_review: bool, diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs index 99e258c7..10dd0b4a 100644 --- a/oxa/oxa-work/tests/board_review.rs +++ b/oxa/oxa-work/tests/board_review.rs @@ -181,3 +181,83 @@ fn removals_count_source_lines_in_aggregate_and_any_deleted_file() { }]; assert_eq!(decide(&facts(&deleted_doc)), Decision::AddRemoves); } + +#[test] +fn board_holds_stale_evidence_and_uses_current_pull_request_facts() { + use oxa_work::board::{Action, Board, GitHub, Mergeability, PullRequest}; + use std::collections::BTreeMap; + + struct Snapshot(PullRequest); + impl GitHub for Snapshot { + fn open_pull_requests(&mut self) -> oxa_work::Result> { + Ok(vec![self.0.clone()]) + } + } + + let changes = [Change { + deleted_lines: 61, + ..SOURCE + }]; + let mut evidence = facts(&changes); + let mut github = Snapshot(PullRequest { + number: 23, + head: "new-head".into(), + release_pinned: false, + findings: false, + required_ci: RequiredCi::Passed, + mergeability: Mergeability::Mergeable, + body: String::new(), + removes_source: false, + draft: false, + reviewed: true, + }); + let read = |github: &mut Snapshot, evidence| { + let (board, plans) = Board::read_with_review_policy( + github, + &oxa_work::board::Policy { + enabled: true, + ..Default::default() + }, + &BTreeMap::new(), + 0, + &Policy { + enabled: true, + paths: PATHS, + }, + &BTreeMap::from([(23, evidence)]), + ) + .unwrap(); + (board.entries[0].action, plans.into_values().next().unwrap()) + }; + + assert_eq!( + read(&mut github, evidence), + (Action::AddRemoves, Decision::AddRemoves) + ); + github.0.body = "Removes: obsolete fallback".into(); + github.0.required_ci = RequiredCi::Pending; + assert_eq!( + read(&mut github, evidence), + (Action::WaitRequiredCi, Decision::Wait) + ); + github.0.required_ci = RequiredCi::Passed; + evidence.head = "old-head"; + assert_eq!(read(&mut github, evidence), (Action::WaitReview, Decision::Wait)); + evidence.head = "new-head"; + evidence.approvals = &[Approval { + reviewer: Reviewer::Codex, + head: "new-head", + patch_id: "own-patch", + }]; + assert_eq!( + read(&mut github, evidence), + ( + Action::Ready, + Decision::Review { + tier: Tier::Product, + request: vec![], + outstanding: vec![], + } + ) + ); +} From 248e133ec1cfcb35e10c85b1a4472f6de0e6c27c Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:02:37 +0100 Subject: [PATCH 04/16] feat(work): verify own-diff and main merge review evidence from Git --- oxa/oxa-cli/tests/work_shadow_log.rs | 67 +++++++++++ oxa/oxa-work/src/board/review.rs | 3 + oxa/oxa-work/src/board/review/git.rs | 161 +++++++++++++++++++++++++++ 3 files changed, 231 insertions(+) create mode 100644 oxa/oxa-work/src/board/review/git.rs diff --git a/oxa/oxa-cli/tests/work_shadow_log.rs b/oxa/oxa-cli/tests/work_shadow_log.rs index 6028f607..e278a0c6 100644 --- a/oxa/oxa-cli/tests/work_shadow_log.rs +++ b/oxa/oxa-cli/tests/work_shadow_log.rs @@ -64,3 +64,70 @@ fn sampling_appends_and_waits_five_minutes_and_stops_on_read_error() { fs::set_permissions(&path, fs::Permissions::from_mode(0o644)).unwrap(); assert!(oxa_work::shadow::open_log(&path).is_err()); } + +#[test] +fn review_git_evidence_keeps_an_unchanged_main_merge_and_rejects_a_changed_patch() { + use oxa_work::{board::review::GitDiff, RunPolicy}; + use std::process::Command; + + let env = TestEnv::new(); + let repo = env.work(); + let git = |args: &[&str]| { + let out = Command::new("git") + .current_dir(&repo) + .env_clear() + .envs(env.envs("http://127.0.0.1:1")) + .env("GIT_AUTHOR_NAME", "Test") + .env("GIT_COMMITTER_NAME", "Test") + .env("GIT_AUTHOR_EMAIL", "test@example.invalid") + .env("GIT_COMMITTER_EMAIL", "test@example.invalid") + .args(args) + .output() + .unwrap(); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + String::from_utf8(out.stdout).unwrap().trim().to_owned() + }; + git(&["init", "-b", "main"]); + git(&["commit", "--allow-empty", "-m", "initial"]); + let old_main = git(&["rev-parse", "HEAD"]); + git(&["switch", "-c", "review"]); + env.write("work/protected.rs", "fn check() {}\n"); + git(&["add", "protected.rs"]); + git(&["commit", "-m", "reviewed change"]); + let reviewed = git(&["rev-parse", "HEAD"]); + git(&["switch", "main"]); + env.write("work/README.md", "new base\n"); + git(&["add", "README.md"]); + git(&["commit", "-m", "unrelated main change"]); + let main = git(&["rev-parse", "HEAD"]); + git(&["switch", "review"]); + git(&["merge", "--no-edit", "main"]); + let merged = git(&["rev-parse", "HEAD"]); + + let host_path = std::env::var_os("PATH").unwrap(); + let git_binary = std::env::split_paths(&host_path) + .map(|directory| directory.join("git")) + .find(|path| path.is_absolute() && path.is_file()) + .unwrap(); + let policy = RunPolicy { + git_binary, + host_path, + offline: true, + terminate_binary: None, + storage: env.tmp(), + }; + let read = |base: &str, head: &str| GitDiff::read(&policy, &repo, base, head).unwrap().unwrap(); + let original = read(&old_main, &reviewed); + let carried = read(&main, &merged); + assert_eq!(carried.patch_id, original.patch_id); + assert_eq!(carried.main_merge_predecessors, [reviewed]); + + env.write("work/protected.rs", "fn check() { }\n"); + git(&["add", "protected.rs"]); + git(&["commit", "-m", "adjust protected change"]); + let edited = git(&["rev-parse", "HEAD"]); + let current = read(&main, &edited); + assert_ne!(current.patch_id, carried.patch_id); + assert!(current.main_merge_predecessors.is_empty()); + assert!(GitDiff::read(&policy, &repo, &main, "HEAD").is_err()); +} diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 9e656c9a..ca953288 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -3,6 +3,9 @@ use super::RequiredCi; +mod git; +pub use git::GitDiff; + #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum Tier { DocsAndTests, diff --git a/oxa/oxa-work/src/board/review/git.rs b/oxa/oxa-work/src/board/review/git.rs new file mode 100644 index 00000000..04ab9689 --- /dev/null +++ b/oxa/oxa-work/src/board/review/git.rs @@ -0,0 +1,161 @@ +use crate::{git, output, Result, RunPolicy}; +use std::io::{Read, Write}; +use std::path::Path; +use std::process::{Command, Stdio}; + +const MAX_DIFF_BYTES: u64 = 2 * 1024 * 1024; +const MAX_MAIN_MERGES: usize = 16; + +/// Own-diff evidence from already available Git objects. The caller supplies the +/// trusted base and the GitHub snapshot's exact head, never PR-provided refs. +pub struct GitDiff { + pub patch_id: String, + pub main_merge_predecessors: Vec, +} + +impl GitDiff { + pub fn read(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Result> { + if !object_id(base) || !object_id(head) { + return Err("review evidence requires full Git object IDs".into()); + } + let Some(patch_id) = own_patch_id(policy, repo, base, head)? else { + return Ok(None); + }; + let mut current = head.to_owned(); + let mut main_merge_predecessors = Vec::new(); + for _ in 0..MAX_MAIN_MERGES { + let parents = git_line( + policy, + repo, + &["rev-list", "--parents", "--max-count=1", ¤t, "--"], + )?; + let fields: Vec<_> = parents.split_ascii_whitespace().collect(); + let [_, previous, main] = fields.as_slice() else { + break; + }; + if !is_ancestor(policy, repo, main, base)? + || is_ancestor(policy, repo, main, previous)? + || own_patch_id(policy, repo, base, previous)?.as_ref() != Some(&patch_id) + { + break; + } + current = (*previous).to_owned(); + main_merge_predecessors.push(current.clone()); + } + Ok(Some(Self { + patch_id, + main_merge_predecessors, + })) + } +} + +fn object_id(id: &str) -> bool { + matches!(id.len(), 40 | 64) && id.bytes().all(|b| b.is_ascii_digit() || matches!(b, b'a'..=b'f')) +} + +fn git_line(policy: &RunPolicy, repo: &Path, args: &[&str]) -> Result { + let mut command = git(policy, repo, args); + command.stderr(Stdio::null()); + let out = output(command)?; + if !out.status.success() { + return Err("cannot read Git review evidence".into()); + } + String::from_utf8(out.stdout) + .map(|line| line.trim().to_owned()) + .map_err(|_| "invalid Git review evidence".into()) +} + +fn is_ancestor(policy: &RunPolicy, repo: &Path, ancestor: &str, descendant: &str) -> Result { + let mut command = git( + policy, + repo, + &["merge-base", "--is-ancestor", ancestor, descendant], + ); + command.stdout(Stdio::null()).stderr(Stdio::null()); + match output(command)?.status.code() { + Some(0) => Ok(true), + Some(1) => Ok(false), + _ => Err("cannot verify Git main ancestry".into()), + } +} + +fn own_patch_id(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Result> { + let start = git_line(policy, repo, &["merge-base", "--all", base, head])?; + if !object_id(&start) { + return Err("review evidence requires one Git merge base".into()); + } + let diff = git( + policy, + repo, + &[ + "diff", + "--binary", + "--full-index", + "--no-renames", + "--no-ext-diff", + "--no-textconv", + "--no-color", + "--no-relative", + "--no-indent-heuristic", + "--diff-algorithm=myers", + "--src-prefix=a/", + "--dst-prefix=b/", + "--ignore-submodules=none", + "--submodule=short", + &start, + head, + "--", + ], + ); + let patch = read_diff(diff)?; + if patch.is_empty() { + return Ok(None); + } + let mut child = git(policy, repo, &["patch-id", "--verbatim"]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::null()) + .spawn() + .map_err(|_| "cannot start Git patch identity calculation")?; + let written = child.stdin.take().expect("piped stdin").write_all(&patch); + let out = child + .wait_with_output() + .map_err(|_| "cannot finish Git patch identity calculation")?; + if written.is_err() || !out.status.success() { + return Err("cannot calculate Git patch identity".into()); + } + let receipt = std::str::from_utf8(&out.stdout).map_err(|_| "invalid Git patch identity")?; + let fields: Vec<_> = receipt.split_ascii_whitespace().collect(); + match fields.as_slice() { + [patch_id, commit] if object_id(patch_id) && object_id(commit) => Ok(Some((*patch_id).to_owned())), + _ => Err("invalid Git patch identity".into()), + } +} + +fn read_diff(mut command: Command) -> Result> { + let mut child = command + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::null()) + .spawn() + .map_err(|_| "cannot start Git review diff")?; + let mut patch = Vec::new(); + let read = child + .stdout + .take() + .expect("piped stdout") + .take(MAX_DIFF_BYTES + 1) + .read_to_end(&mut patch); + let oversized = patch.len() as u64 > MAX_DIFF_BYTES; + if oversized || read.is_err() { + let _ = child.kill(); + } + let status = child.wait().map_err(|_| "cannot finish Git review diff")?; + if oversized { + return Err("Git review diff exceeds the evidence limit".into()); + } + if read.is_err() || !status.success() { + return Err("cannot read Git review diff".into()); + } + Ok(patch) +} From 177dc8c2522e7a8d308bb1c9f85f0cbca8faada7 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:03:41 +0100 Subject: [PATCH 05/16] fix(work): enforce review admission when promoting drafts --- oxa/oxa-work/src/board.rs | 4 +++- oxa/oxa-work/tests/board_review.rs | 11 ++++++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index d3fd7985..47e861d9 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -224,7 +224,9 @@ impl Board { } else if pr.draft && (!review_policy.enabled || facts.is_some_and(|facts| { - !facts.changes.is_empty() && facts.patch_id.is_some_and(|id| !id.is_empty()) + facts.review_admitted + && !facts.changes.is_empty() + && facts.patch_id.is_some_and(|id| !id.is_empty()) })) { Action::PromoteDraft diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs index 10dd0b4a..50dbfc87 100644 --- a/oxa/oxa-work/tests/board_review.rs +++ b/oxa/oxa-work/tests/board_review.rs @@ -19,7 +19,7 @@ const SOURCE: Change<'static> = Change { deleted_file: false, }; -fn facts(changes: &[Change<'static>]) -> Facts<'_> { +fn facts<'a>(changes: &'a [Change<'static>]) -> Facts<'a> { Facts { changes, two_review: false, @@ -244,6 +244,15 @@ fn board_holds_stale_evidence_and_uses_current_pull_request_facts() { evidence.head = "old-head"; assert_eq!(read(&mut github, evidence), (Action::WaitReview, Decision::Wait)); evidence.head = "new-head"; + github.0.draft = true; + evidence.review_admitted = false; + assert_eq!(read(&mut github, evidence), (Action::WaitReview, Decision::Wait)); + evidence.review_admitted = true; + assert_eq!( + read(&mut github, evidence), + (Action::PromoteDraft, Decision::Wait) + ); + github.0.draft = false; evidence.approvals = &[Approval { reviewer: Reviewer::Codex, head: "new-head", From 33353fb2aef4370889adbc9266088ef1ee73f34b Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:06:56 +0100 Subject: [PATCH 06/16] feat(work): reserve review requests once per own-diff patch --- oxa/oxa-work/src/board.rs | 14 +++- oxa/oxa-work/src/board/claims.rs | 5 ++ oxa/oxa-work/src/board/claims/reviews.rs | 30 +++++++++ oxa/oxa-work/src/board/review.rs | 82 +++++++++++++++++++++++- oxa/oxa-work/src/board/review/git.rs | 2 +- oxa/oxa-work/tests/board_controls.rs | 77 ++++++++++++++++++++++ oxa/oxa-work/tests/board_review.rs | 20 ++++-- 7 files changed, 217 insertions(+), 13 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/reviews.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 47e861d9..7a0e78b6 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -173,7 +173,7 @@ impl Board { now: u64, review_policy: &review::Policy<'_>, evidence: &BTreeMap>, - ) -> crate::Result<(Self, BTreeMap)> { + ) -> crate::Result<(Self, BTreeMap)> { let mut board = Self { observed_at: now, entries: vec![], @@ -226,7 +226,7 @@ impl Board { || facts.is_some_and(|facts| { facts.review_admitted && !facts.changes.is_empty() - && facts.patch_id.is_some_and(|id| !id.is_empty()) + && facts.verified_patch_id().is_some() })) { Action::PromoteDraft @@ -238,7 +238,15 @@ impl Board { Action::WaitReview }; if let Some(decision) = review { - review_plans.insert(pr.number, decision); + review_plans.insert( + pr.number, + review::Plan::new( + pr.number, + &pr.head, + facts.and_then(review::Facts::verified_patch_id), + decision, + ), + ); } board.entries.push(intake::entry( pr.number, diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 686395df..45f2c44a 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -11,6 +11,7 @@ use std::path::{Path, PathBuf}; mod controls; pub use controls::{Assignment, AssignmentBoard, AssignmentData, ReleaseRecord}; mod imports; +mod reviews; #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] @@ -20,6 +21,8 @@ struct Saved { state: AttemptState, #[serde(default)] data: AssignmentData, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + review_requests: Vec, } fn io(value: std::io::Result) -> Result { @@ -100,6 +103,7 @@ impl Claims { number, state: AttemptState::default(), data: AssignmentData::default(), + review_requests: vec![], }), Ok(_) => Err("board claim state is missing; recovery is required".into()), Err(e) => io(Err(e)), @@ -116,6 +120,7 @@ impl Claims { let saved: Saved = serde_json::from_slice(&bytes).map_err(|_| "invalid board claim state")?; if saved.version != 1 || saved.number != number + || saved.review_requests.iter().any(|key| !key.valid()) || saved.state.lease.as_ref().is_some_and(|l| { saved.state.attempts == 0 || !valid_worker_id(&l.holder) diff --git a/oxa/oxa-work/src/board/claims/reviews.rs b/oxa/oxa-work/src/board/claims/reviews.rs new file mode 100644 index 00000000..ece0445b --- /dev/null +++ b/oxa/oxa-work/src/board/claims/reviews.rs @@ -0,0 +1,30 @@ +use super::*; +use crate::board::{assignment::ManualAuthority, review::Request}; + +impl Claims { + /// Atomically consume the request before dispatch. An uncertain result from + /// the external reviewer leaves the reservation in place. Head changes alone + /// never reset this reservation. + pub fn reserve_review_request( + &self, + request: &Request, + authority: Option, + ) -> Result { + if authority.is_none() { + return Err("owner or lead control required".into()); + } + if !request.key.valid() { + return Err("invalid review request key".into()); + } + let _lock = self.lock(request.number)?; + let mut row = self.load(request.number)?; + if row.data.import_hold || row.review_requests.contains(&request.key) { + return Ok(false); + } + row.review_requests.push(request.key.clone()); + let replacing = self.established(request.number)?; + self.save(request.number, row, replacing)?; + self.mark(request.number)?; + Ok(true) + } +} diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index ca953288..4db1eb5d 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -2,6 +2,7 @@ //! diff facts and authenticated receipts. This module cannot post or approve reviews. use super::RequiredCi; +use serde::{Deserialize, Serialize}; mod git; pub use git::GitDiff; @@ -14,7 +15,8 @@ pub enum Tier { Protected, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] pub enum Reviewer { Codex, Security, @@ -69,6 +71,12 @@ pub struct Facts<'a> { pub approvals: &'a [Approval<'a>], } +impl<'a> Facts<'a> { + pub(super) fn verified_patch_id(&self) -> Option<&'a str> { + self.patch_id.filter(|id| git::object_id(id)) + } +} + #[derive(Debug, PartialEq, Eq)] pub enum Decision { Disabled, @@ -82,6 +90,76 @@ pub enum Decision { }, } +#[derive(Debug)] +pub struct Plan { + pub decision: Decision, + requests: Vec, +} + +/// Only the board can produce requests. A dispatcher must revalidate the head +/// and required checks and reserve the request before causing external effects. +#[derive(Debug)] +pub struct Request { + pub(super) number: u64, + pub(super) head: String, + pub(super) key: RequestKey, +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub(super) struct RequestKey { + patch_id: String, + reviewer: Reviewer, +} + +impl RequestKey { + pub(super) fn valid(&self) -> bool { + self.reviewer != Reviewer::Owner && git::object_id(&self.patch_id) + } +} + +impl Request { + pub fn number(&self) -> u64 { + self.number + } + + pub fn head(&self) -> &str { + &self.head + } + + pub fn reviewer(&self) -> Reviewer { + self.key.reviewer + } + + pub fn patch_id(&self) -> &str { + &self.key.patch_id + } +} + +impl Plan { + pub(super) fn new(number: u64, head: &str, patch_id: Option<&str>, decision: Decision) -> Self { + let requests = match (&decision, patch_id) { + (Decision::Review { request, .. }, Some(patch_id)) => request + .iter() + .map(|&reviewer| Request { + number, + head: head.to_owned(), + key: RequestKey { + patch_id: patch_id.to_owned(), + reviewer, + }, + }) + .collect(), + _ => vec![], + }; + Self { decision, requests } + } + + pub fn requests(&self) -> &[Request] { + &self.requests + } +} + /// Match an exact repo-relative path or a whole directory prefix. pub struct PathRule<'a> { pub path: &'a str, @@ -113,7 +191,7 @@ impl Policy<'_> { { return Decision::AddRemoves; } - let Some(patch_id) = facts.patch_id.filter(|id| !id.is_empty()) else { + let Some(patch_id) = facts.verified_patch_id() else { return Decision::Wait; }; if facts.required_ci != RequiredCi::Passed diff --git a/oxa/oxa-work/src/board/review/git.rs b/oxa/oxa-work/src/board/review/git.rs index 04ab9689..4378d1ec 100644 --- a/oxa/oxa-work/src/board/review/git.rs +++ b/oxa/oxa-work/src/board/review/git.rs @@ -49,7 +49,7 @@ impl GitDiff { } } -fn object_id(id: &str) -> bool { +pub(super) fn object_id(id: &str) -> bool { matches!(id.len(), 40 | 64) && id.bytes().all(|b| b.is_ascii_digit() || matches!(b, b'a'..=b'f')) } diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index 0c52d6a7..aa3ed0a6 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -528,3 +528,80 @@ fn records_without_release_metadata_remain_readable() { assert_eq!(rows[&3].state.attempts, 1); assert!(rows[&3].data.last_release.is_none()); } + +#[test] +fn review_reservations_survive_reopening_and_head_changes() { + use oxa_work::board::review::{self, Change, ChangeKind, Facts, Plan, Reviewer}; + + struct ReviewPr(PullRequest); + impl GitHub for ReviewPr { + fn open_pull_requests(&mut self) -> oxa_work::Result> { + Ok(vec![self.0.clone()]) + } + } + + let plan = |head: &str, patch_id: &str| -> Plan { + let changes = [Change { + path: "src/main.rs", + previous_path: None, + kind: ChangeKind::Source, + deleted_lines: 0, + deleted_file: false, + }]; + let facts = Facts { + changes: &changes, + two_review: false, + required_ci: RequiredCi::Pending, + draft: false, + review_admitted: true, + unresolved_findings: false, + body: "", + head, + patch_id: Some(patch_id), + main_merge_predecessors: &[], + requested: &[], + approvals: &[], + }; + let mut pr = FakeGitHub(0).open_pull_requests().unwrap().remove(0); + pr.head = head.into(); + pr.findings = false; + let (_, mut plans) = Board::read_with_review_policy( + &mut ReviewPr(pr), + &policy(), + &BTreeMap::new(), + 0, + &review::Policy { + enabled: true, + paths: &[], + }, + &BTreeMap::from([(1, facts)]), + ) + .unwrap(); + plans.remove(&1).unwrap() + }; + + let fixture = Fixture::new(); + let claims = fixture.store(); + let patch_id = "a".repeat(40); + let original = plan("tested-head", &patch_id); + let request = &original.requests()[0]; + assert_eq!(request.reviewer(), Reviewer::Codex); + assert!(claims.reserve_review_request(request, None).is_err()); + let owner = Some(ManualAuthority::Owner); + std::thread::scope(|scope| { + let first = scope.spawn(|| claims.reserve_review_request(request, owner).unwrap()); + let second = scope.spawn(|| claims.reserve_review_request(request, owner).unwrap()); + assert_ne!(first.join().unwrap(), second.join().unwrap()); + }); + + let reopened = fixture.store(); + let merged = plan("main-merge-head", &patch_id); + assert!(!reopened + .reserve_review_request(&merged.requests()[0], owner) + .unwrap()); + let changed = plan("edited-head", &"b".repeat(40)); + assert!(reopened + .reserve_review_request(&changed.requests()[0], owner) + .unwrap()); + assert_eq!(reopened.snapshot().unwrap()[&1].attempts, 0); +} diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs index 50dbfc87..f1f500a6 100644 --- a/oxa/oxa-work/tests/board_review.rs +++ b/oxa/oxa-work/tests/board_review.rs @@ -1,5 +1,8 @@ use oxa_work::board::{review::*, RequiredCi}; +const PATCH: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; +const NEXT_PATCH: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; + const PATHS: &[PathRule<'_>] = &[ PathRule { path: "engine", @@ -29,7 +32,7 @@ fn facts<'a>(changes: &'a [Change<'static>]) -> Facts<'a> { unresolved_findings: false, body: "", head: "new-head", - patch_id: Some("own-patch"), + patch_id: Some(PATCH), main_merge_predecessors: &[], requested: &[], approvals: &[], @@ -109,18 +112,18 @@ fn request_receipts_deduplicate_and_only_pure_merges_carry_approvals() { let mut input = facts(&changes); input.requested = &[RequestReceipt { reviewer: Reviewer::Codex, - patch_id: "own-patch", + patch_id: PATCH, }]; input.approvals = &[ Approval { reviewer: Reviewer::Codex, head: "old-head", - patch_id: "own-patch", + patch_id: PATCH, }, Approval { reviewer: Reviewer::Security, head: "old-head", - patch_id: "different-patch", + patch_id: NEXT_PATCH, }, ]; input.main_merge_predecessors = &["old-head"]; @@ -141,7 +144,7 @@ fn request_receipts_deduplicate_and_only_pure_merges_carry_approvals() { outstanding: vec![Reviewer::Codex, Reviewer::Security, Reviewer::Owner], } ); - input.patch_id = Some("next-own-patch"); + input.patch_id = Some(NEXT_PATCH); assert!(matches!( decide(&input), Decision::Review { request, .. } if request == [Reviewer::Codex, Reviewer::Security] @@ -227,7 +230,10 @@ fn board_holds_stale_evidence_and_uses_current_pull_request_facts() { &BTreeMap::from([(23, evidence)]), ) .unwrap(); - (board.entries[0].action, plans.into_values().next().unwrap()) + ( + board.entries[0].action, + plans.into_values().next().unwrap().decision, + ) }; assert_eq!( @@ -256,7 +262,7 @@ fn board_holds_stale_evidence_and_uses_current_pull_request_facts() { evidence.approvals = &[Approval { reviewer: Reviewer::Codex, head: "new-head", - patch_id: "own-patch", + patch_id: PATCH, }]; assert_eq!( read(&mut github, evidence), From 156f79895ee4b65b3ca53f4754373fc23b095792 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:12:02 +0100 Subject: [PATCH 07/16] feat(work): dispatch pinned review requests through authenticated runners --- oxa/oxa-work/src/board/claims/reviews.rs | 24 ++++++++- oxa/oxa-work/src/board/review.rs | 18 +++++++ oxa/oxa-work/src/board/review/receipts.rs | 60 +++++++++++++++++++++++ oxa/oxa-work/tests/board_controls.rs | 53 +++++++++++++++++++- 4 files changed, 153 insertions(+), 2 deletions(-) create mode 100644 oxa/oxa-work/src/board/review/receipts.rs diff --git a/oxa/oxa-work/src/board/claims/reviews.rs b/oxa/oxa-work/src/board/claims/reviews.rs index ece0445b..8ed4030b 100644 --- a/oxa/oxa-work/src/board/claims/reviews.rs +++ b/oxa/oxa-work/src/board/claims/reviews.rs @@ -1,7 +1,29 @@ use super::*; -use crate::board::{assignment::ManualAuthority, review::Request}; +use crate::board::{ + assignment::ManualAuthority, + review::{Dispatch, Request, RequestRemote}, +}; impl Claims { + pub fn dispatch_review_request( + &self, + remote: &mut impl RequestRemote, + request: &Request, + authority: Option, + ) -> Result { + if authority.is_none() { + return Err("owner or lead control required".into()); + } + if !remote.current_and_admitted(request)? { + return Ok(Dispatch::Held); + } + if !self.reserve_review_request(request, authority)? { + return Ok(Dispatch::AlreadyReserved); + } + remote.send_once(request)?; + Ok(Dispatch::Sent) + } + /// Atomically consume the request before dispatch. An uncertain result from /// the external reviewer leaves the reservation in place. Head changes alone /// never reset this reservation. diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 4db1eb5d..4d9bdbfe 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -6,6 +6,8 @@ use serde::{Deserialize, Serialize}; mod git; pub use git::GitDiff; +mod receipts; +pub use receipts::GitHubRequestReceipt; #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum Tier { @@ -136,6 +138,22 @@ impl Request { } } +/// A runner with authenticated reviewer access. Both operations are scoped to +/// the immutable head and own diff on the request. The preflight must confirm +/// admission and required CI and honor authenticated prior request receipts. +pub trait RequestRemote { + fn current_and_admitted(&mut self, request: &Request) -> crate::Result; + /// One submission attempt, with no automatic retry after an uncertain response. + fn send_once(&mut self, request: &Request) -> crate::Result<()>; +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Dispatch { + Held, + AlreadyReserved, + Sent, +} + impl Plan { pub(super) fn new(number: u64, head: &str, patch_id: Option<&str>, decision: Decision) -> Self { let requests = match (&decision, patch_id) { diff --git a/oxa/oxa-work/src/board/review/receipts.rs b/oxa/oxa-work/src/board/review/receipts.rs new file mode 100644 index 00000000..9157976e --- /dev/null +++ b/oxa/oxa-work/src/board/review/receipts.rs @@ -0,0 +1,60 @@ +use super::{git, Request, RequestReceipt, Reviewer}; +use serde::{Deserialize, Serialize}; + +const PREFIX: &str = ""; + +/// A bounded GitHub marker for cross-run request deduplication. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct GitHubRequestReceipt { + reviewer: Reviewer, + sha: String, + patch_id: String, +} + +impl GitHubRequestReceipt { + /// GitHub supplies the actor login. Only the runner's configured account + /// may seed requests; a matching marker elsewhere is ordinary PR text. + pub fn from_comment(trusted_login: &str, actor: &str, body: &str) -> Option { + if trusted_login.is_empty() || !trusted_login.eq_ignore_ascii_case(actor) { + return None; + } + let mut markers = body + .lines() + .filter_map(|line| line.strip_prefix(PREFIX)?.strip_suffix(SUFFIX)); + let raw = markers.next().filter(|raw| raw.len() <= 256)?; + if markers.next().is_some() { + return None; + } + let receipt: Self = serde_json::from_str(raw).ok()?; + (receipt.reviewer != Reviewer::Owner + && git::object_id(&receipt.sha) + && git::object_id(&receipt.patch_id)) + .then_some(receipt) + } + + pub fn receipt(&self) -> RequestReceipt<'_> { + RequestReceipt { + reviewer: self.reviewer, + patch_id: &self.patch_id, + } + } +} + +impl Request { + /// The native dispatcher controls the review command and appends this marker + /// as its own line. The marker deliberately contains no PR text. + pub fn github_marker(&self) -> crate::Result { + if !git::object_id(self.head()) || !self.key.valid() { + return Err("invalid GitHub review request identity".into()); + } + let receipt = GitHubRequestReceipt { + reviewer: self.reviewer(), + sha: self.head().to_owned(), + patch_id: self.patch_id().to_owned(), + }; + let json = serde_json::to_string(&receipt).map_err(|_| "cannot encode review request")?; + Ok(format!("{PREFIX}{json}{SUFFIX}")) + } +} diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index aa3ed0a6..61c77de8 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -531,7 +531,10 @@ fn records_without_release_metadata_remain_readable() { #[test] fn review_reservations_survive_reopening_and_head_changes() { - use oxa_work::board::review::{self, Change, ChangeKind, Facts, Plan, Reviewer}; + use oxa_work::board::review::{ + self, Change, ChangeKind, Dispatch, Facts, GitHubRequestReceipt, Plan, Request, RequestRemote, + Reviewer, + }; struct ReviewPr(PullRequest); impl GitHub for ReviewPr { @@ -604,4 +607,52 @@ fn review_reservations_survive_reopening_and_head_changes() { .reserve_review_request(&changed.requests()[0], owner) .unwrap()); assert_eq!(reopened.snapshot().unwrap()[&1].attempts, 0); + + #[derive(Default)] + struct Remote { + eligible: bool, + submissions: usize, + } + impl RequestRemote for Remote { + fn current_and_admitted(&mut self, _: &Request) -> oxa_work::Result { + Ok(self.eligible) + } + fn send_once(&mut self, _: &Request) -> oxa_work::Result<()> { + self.submissions += 1; + Err("synthetic connection loss after sending".into()) + } + } + let plan = plan(&"c".repeat(40), &"d".repeat(40)); + let request = &plan.requests()[0]; + let marker = request.github_marker().unwrap(); + assert!(GitHubRequestReceipt::from_comment("review-app[bot]", "untrusted", &marker).is_none()); + let receipt = GitHubRequestReceipt::from_comment( + "review-app[bot]", + "review-app[bot]", + &format!("@codex review\n{marker}"), + ) + .unwrap(); + assert_eq!(receipt.receipt().patch_id, request.patch_id()); + assert_eq!(receipt.receipt().reviewer, Reviewer::Codex); + + let mut remote = Remote::default(); + assert_eq!( + reopened + .dispatch_review_request(&mut remote, request, owner) + .unwrap(), + Dispatch::Held + ); + assert_eq!(remote.submissions, 0); + remote.eligible = true; + assert!(reopened + .dispatch_review_request(&mut remote, request, owner) + .is_err()); + assert_eq!( + fixture + .store() + .dispatch_review_request(&mut remote, request, owner) + .unwrap(), + Dispatch::AlreadyReserved + ); + assert_eq!(remote.submissions, 1); } From 8416a9c75238bcbef65c31f5a718759d54955410 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:19:49 +0100 Subject: [PATCH 08/16] feat(work): derive review file evidence from pinned own diffs --- oxa/oxa-cli/tests/work_shadow_log.rs | 27 ++++++- oxa/oxa-work/src/board/review.rs | 2 +- oxa/oxa-work/src/board/review/git.rs | 102 +++++++++++++++++++++++++-- 3 files changed, 125 insertions(+), 6 deletions(-) diff --git a/oxa/oxa-cli/tests/work_shadow_log.rs b/oxa/oxa-cli/tests/work_shadow_log.rs index e278a0c6..7d8866cf 100644 --- a/oxa/oxa-cli/tests/work_shadow_log.rs +++ b/oxa/oxa-cli/tests/work_shadow_log.rs @@ -88,7 +88,13 @@ fn review_git_evidence_keeps_an_unchanged_main_merge_and_rejects_a_changed_patch String::from_utf8(out.stdout).unwrap().trim().to_owned() }; git(&["init", "-b", "main"]); - git(&["commit", "--allow-empty", "-m", "initial"]); + env.write( + "work/obsolete.rs", + "const FIRST: u8 = 1;\nconst SECOND: u8 = 2;\n", + ); + env.write("work/old_name.rs", "fn existing() {}\n"); + git(&["add", "obsolete.rs", "old_name.rs"]); + git(&["commit", "-m", "initial"]); let old_main = git(&["rev-parse", "HEAD"]); git(&["switch", "-c", "review"]); env.write("work/protected.rs", "fn check() {}\n"); @@ -130,4 +136,23 @@ fn review_git_evidence_keeps_an_unchanged_main_merge_and_rejects_a_changed_patch assert_ne!(current.patch_id, carried.patch_id); assert!(current.main_merge_predecessors.is_empty()); assert!(GitDiff::read(&policy, &repo, &main, "HEAD").is_err()); + + git(&["mv", "old_name.rs", "renamed.md"]); + git(&["rm", "obsolete.rs"]); + git(&["commit", "-m", "rename code and remove a file"]); + let changed = read(&main, &git(&["rev-parse", "HEAD"])); + let renamed = changed + .files + .iter() + .find(|file| file.path == "renamed.md") + .unwrap(); + assert_eq!(renamed.previous_path.as_deref(), Some("old_name.rs")); + assert!(!renamed.deleted_file); + let removed = changed + .files + .iter() + .find(|file| file.path == "obsolete.rs") + .unwrap(); + assert!(removed.deleted_file); + assert_eq!(removed.deleted_lines, 2); } diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 4d9bdbfe..305425ec 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -5,7 +5,7 @@ use super::RequiredCi; use serde::{Deserialize, Serialize}; mod git; -pub use git::GitDiff; +pub use git::{GitDiff, GitFileChange}; mod receipts; pub use receipts::GitHubRequestReceipt; diff --git a/oxa/oxa-work/src/board/review/git.rs b/oxa/oxa-work/src/board/review/git.rs index 4378d1ec..fecd8c32 100644 --- a/oxa/oxa-work/src/board/review/git.rs +++ b/oxa/oxa-work/src/board/review/git.rs @@ -11,6 +11,15 @@ const MAX_MAIN_MERGES: usize = 16; pub struct GitDiff { pub patch_id: String, pub main_merge_predecessors: Vec, + pub files: Vec, +} + +#[derive(Debug, PartialEq, Eq)] +pub struct GitFileChange { + pub path: String, + pub previous_path: Option, + pub deleted_file: bool, + pub deleted_lines: u64, } impl GitDiff { @@ -18,9 +27,11 @@ impl GitDiff { if !object_id(base) || !object_id(head) { return Err("review evidence requires full Git object IDs".into()); } - let Some(patch_id) = own_patch_id(policy, repo, base, head)? else { + let start = merge_base(policy, repo, base, head)?; + let Some(patch_id) = own_patch_id(policy, repo, &start, head)? else { return Ok(None); }; + let files = own_file_changes(policy, repo, &start, head)?; let mut current = head.to_owned(); let mut main_merge_predecessors = Vec::new(); for _ in 0..MAX_MAIN_MERGES { @@ -35,7 +46,8 @@ impl GitDiff { }; if !is_ancestor(policy, repo, main, base)? || is_ancestor(policy, repo, main, previous)? - || own_patch_id(policy, repo, base, previous)?.as_ref() != Some(&patch_id) + || own_patch_id(policy, repo, &merge_base(policy, repo, base, previous)?, previous)?.as_ref() + != Some(&patch_id) { break; } @@ -45,6 +57,7 @@ impl GitDiff { Ok(Some(Self { patch_id, main_merge_predecessors, + files, })) } } @@ -79,11 +92,15 @@ fn is_ancestor(policy: &RunPolicy, repo: &Path, ancestor: &str, descendant: &str } } -fn own_patch_id(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Result> { +fn merge_base(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Result { let start = git_line(policy, repo, &["merge-base", "--all", base, head])?; if !object_id(&start) { return Err("review evidence requires one Git merge base".into()); } + Ok(start) +} + +fn own_patch_id(policy: &RunPolicy, repo: &Path, start: &str, head: &str) -> Result> { let diff = git( policy, repo, @@ -102,7 +119,7 @@ fn own_patch_id(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Resu "--dst-prefix=b/", "--ignore-submodules=none", "--submodule=short", - &start, + start, head, "--", ], @@ -132,6 +149,83 @@ fn own_patch_id(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Resu } } +fn own_file_changes(policy: &RunPolicy, repo: &Path, start: &str, head: &str) -> Result> { + let raw = read_diff(git( + policy, + repo, + &[ + "diff", + "--raw", + "--numstat", + "-z", + "--find-renames=50%", + "--no-ext-diff", + "--no-textconv", + "--no-relative", + "--no-color", + "--ignore-submodules=none", + start, + head, + "--", + ], + ))?; + let invalid = "invalid Git review file inventory"; + let raw = std::str::from_utf8(&raw).map_err(|_| invalid)?; + let mut records = raw.strip_suffix('\0').ok_or(invalid)?.split('\0').peekable(); + let mut files = Vec::new(); + while records.peek().is_some_and(|record| record.starts_with(':')) { + let status = records + .next() + .and_then(|header| header.split_ascii_whitespace().last()) + .ok_or(invalid)?; + let first = records.next().filter(|path| !path.is_empty()).ok_or(invalid)?; + let (previous_path, path) = match status.as_bytes() { + [b'R' | b'C', similarity @ ..] + if !similarity.is_empty() && similarity.iter().all(u8::is_ascii_digit) => + { + let path = records.next().filter(|path| !path.is_empty()).ok_or(invalid)?; + (Some(first.to_owned()), path) + } + [b'A' | b'D' | b'M' | b'T'] => (None, first), + _ => return Err(invalid.into()), + }; + files.push(GitFileChange { + path: path.to_owned(), + previous_path, + deleted_file: status == "D", + deleted_lines: 0, + }); + } + for file in &mut files { + let row = records.next().ok_or(invalid)?; + let mut columns = row.splitn(3, '\t'); + let added = columns.next().ok_or(invalid)?; + let deleted = columns.next().ok_or(invalid)?; + let path = columns.next().ok_or(invalid)?; + if let Some(previous) = &file.previous_path { + if !path.is_empty() + || records.next() != Some(previous.as_str()) + || records.next() != Some(file.path.as_str()) + { + return Err(invalid.into()); + } + } else if path != file.path { + return Err(invalid.into()); + } + file.deleted_lines = match (added, deleted) { + ("-", "-") => 0, + (added, deleted) if added.parse::().is_ok() => { + deleted.parse::().map_err(|_| invalid)? + } + _ => return Err(invalid.into()), + }; + } + if files.is_empty() || records.next().is_some() { + return Err(invalid.into()); + } + Ok(files) +} + fn read_diff(mut command: Command) -> Result> { let mut child = command .stdin(Stdio::null()) From 061462793b4bb5c4fb10364ed3a1818316838fa0 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:24:54 +0100 Subject: [PATCH 09/16] feat(work): observe review policy through the opt-in GitHub shadow board --- oxa/oxa-cli/src/help.rs | 1 + oxa/oxa-cli/src/work_board.rs | 74 +++++--- oxa/oxa-cli/src/work_board/review.rs | 274 +++++++++++++++++++++++++++ oxa/oxa-cli/tests/work_shadow.rs | 64 +++++++ oxa/oxa-work/src/board/review.rs | 10 +- oxa/oxa-work/src/shadow.rs | 17 +- 6 files changed, 404 insertions(+), 36 deletions(-) create mode 100644 oxa/oxa-cli/src/work_board/review.rs diff --git a/oxa/oxa-cli/src/help.rs b/oxa/oxa-cli/src/help.rs index e581e174..060e4f77 100644 --- a/oxa/oxa-cli/src/help.rs +++ b/oxa/oxa-cli/src/help.rs @@ -178,6 +178,7 @@ const BASE: &[Entry] = &[ usage: &[ "oxa work board --shadow --repo OWNER/REPO --once", "oxa work board --shadow --repo OWNER/REPO --token-stdin [--once]", + "oxa work board --shadow --repo OWNER/REPO --once --review-policy FILE", ], example: "oxa work board --shadow --repo example/project --once", }, diff --git a/oxa/oxa-cli/src/work_board.rs b/oxa/oxa-cli/src/work_board.rs index 1ae914e2..fce661a9 100644 --- a/oxa/oxa-cli/src/work_board.rs +++ b/oxa/oxa-cli/src/work_board.rs @@ -9,6 +9,8 @@ use std::{ time::{Duration, SystemTime}, }; +mod review; + fn token_line(input: &mut dyn BufRead) -> Result { let mut line = Vec::new(); input @@ -32,6 +34,7 @@ struct Reader<'a> { path: &'a std::ffi::OsStr, repo: &'a str, token: &'a str, + review_rows: Option, } const MAX_RESPONSE: usize = 4 * 1024 * 1024; @@ -178,18 +181,23 @@ impl GitHub for Reader<'_> { }; let expected = ids(&list["pullRequests"])?; let mut details = serde_json::json!({}); + let review_fields = if self.review_rows.is_some() { + "baseRefOid isCrossRepository authorAssociation comments(first:100){totalCount nodes{body author{login}}}" + } else { + "" + }; let (mut offset, mut size, mut bytes) = (0, 15, 0usize); loop { let end = numbers.len().min(offset + size); let mut fields = LIST.to_owned(); for n in &numbers[offset..end] { fields.push_str(&format!( - r#"p{n}:pullRequest(number:{n}){{number headRefOid baseRefName state body isDraft reviewDecision mergeable mergeStateStatus + r#"p{n}:pullRequest(number:{n}){{number headRefOid baseRefName state body isDraft reviewDecision mergeable mergeStateStatus {review_fields} baseRef{{refUpdateRule{{requiredStatusCheckContexts}} rules(first:100){{totalCount nodes{{type parameters{{... on RequiredStatusChecksParameters{{requiredStatusChecks{{context}}}}}}}}}}}} labels(first:100){{totalCount nodes{{name}}}} files(first:100){{totalCount nodes{{path deletions}}}} reviewThreads(first:100){{totalCount nodes{{isResolved}}}} - latestOpinionatedReviews(first:100,writersOnly:true){{totalCount nodes{{state commit{{oid}}}}}} + latestOpinionatedReviews(first:100,writersOnly:true){{totalCount nodes{{state commit{{oid}} author{{login}}}}}} commits(last:1){{nodes{{commit{{statusCheckRollup{{contexts(first:100){{totalCount nodes{{ ... on CheckRun{{name isRequired(pullRequestNumber:{n}) status conclusion}} ... on StatusContext{{context isRequired(pullRequestNumber:{n}) state}} @@ -223,7 +231,7 @@ impl GitHub for Reader<'_> { break; } } - nodes(&list["pullRequests"])? + let rows = nodes(&list["pullRequests"])? .iter() .map(|pr| { let row = &details[format!("p{}", pr["number"])]; @@ -304,14 +312,7 @@ impl GitHub for Reader<'_> { body: row["body"].as_str().ok_or("missing PR body")?.into(), removes_source: nodes(&row["files"])?.iter().any(|f| { f["deletions"].as_u64().unwrap_or(0) > 0 - && f["path"].as_str().is_some_and(|p| { - [ - ".rs", ".py", ".go", ".ts", ".tsx", ".js", ".jsx", ".sh", ".c", ".cc", - ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx", ".inc", ".qml", - ] - .iter() - .any(|ext| p.ends_with(ext)) - }) + && f["path"].as_str().is_some_and(review::source_path) }), draft: row["isDraft"].as_bool().ok_or("missing draft state")?, reviewed: row["reviewDecision"] == "APPROVED" && { @@ -324,7 +325,11 @@ impl GitHub for Reader<'_> { }, }) }) - .collect() + .collect(); + if self.review_rows.is_some() { + self.review_rows = Some(details); + } + rows } } @@ -338,16 +343,20 @@ pub(crate) fn run( // Existing parser declaration; migrate command/flag metadata together in #1062. let (repo, options) = match args { [shadow, flag, repo, options @ ..] if shadow == "--shadow" && flag == "--repo" => (repo, options), - _ => return Err("usage: oxa work board --shadow --repo OWNER/REPO [--once] [--token-stdin]".into()), + _ => return Err("usage: oxa work board --shadow --repo OWNER/REPO [--once] [--token-stdin] [--review-policy FILE]".into()), }; - if options - .iter() - .any(|o| !matches!(o.as_str(), "--once" | "--token-stdin")) - { - return Err("invalid board option".into()); + let (mut once, mut streamed, mut review_file) = (false, false, None); + let mut options = options.iter(); + while let Some(option) = options.next() { + match option.as_str() { + "--once" => once = true, + "--token-stdin" => streamed = true, + "--review-policy" if review_file.is_none() => { + review_file = Some(options.next().ok_or("missing board review policy file")?); + } + _ => return Err("invalid board option".into()), + } } - let once = options.iter().any(|o| o == "--once"); - let streamed = options.iter().any(|o| o == "--token-stdin"); if !once && !streamed { return Err("continuous sampling requires --token-stdin; use --once with a five-minute token-refresh supervisor otherwise".into()); } @@ -368,6 +377,9 @@ pub(crate) fn run( if !crate::work_cmd::trusted(root, env, dirs)? { return Err("source project is not trusted".into()); } + let review_settings = review_file + .map(|path| review::Settings::read(Path::new(path))) + .transpose()?; let inherited = env.get("GH_TOKEN").filter(|s| !s.is_empty()); if !streamed && inherited.is_none() { return Err("shadow board requires an explicit GitHub App token".into()); @@ -388,7 +400,7 @@ pub(crate) fn run( .create(&storage) .map_err(|_| "cannot create shadow storage")?; let mut log = oxa_work::shadow::open_log(&storage.join("board-shadow.jsonl"))?; - oxa_work::shadow::run( + oxa_work::shadow::run_with_reviews( &mut log, once, || { @@ -402,20 +414,22 @@ pub(crate) fn run( path: &policy.host_path, repo, token: &token, + review_rows: review_settings.as_ref().map(|_| Value::Null), }; let now = SystemTime::now() .duration_since(SystemTime::UNIX_EPOCH) .map_err(|_| "invalid system clock")? .as_secs(); - Board::read( - &mut reader, - &Policy { - enabled: true, - ..Policy::default() - }, - &BTreeMap::new(), - now, - ) + let board_policy = Policy { + enabled: true, + ..Policy::default() + }; + if let Some(settings) = &review_settings { + review::sample(&mut reader, root, policy, &board_policy, settings, now) + } else { + Board::read(&mut reader, &board_policy, &BTreeMap::new(), now) + .map(|board| (board, BTreeMap::new())) + } }, std::thread::sleep, )?; diff --git a/oxa/oxa-cli/src/work_board/review.rs b/oxa/oxa-cli/src/work_board/review.rs new file mode 100644 index 00000000..de65c071 --- /dev/null +++ b/oxa/oxa-cli/src/work_board/review.rs @@ -0,0 +1,274 @@ +use super::{nodes, Board, GitHub, Policy, PullRequest, Reader, RequiredCi}; +use oxa_work::board::review::{ + self, Approval, Change, ChangeKind, Facts, GitDiff, GitHubRequestReceipt, PathRule, Reviewer, Tier, +}; +use serde::Deserialize; +use serde_json::Value; +use std::{collections::BTreeMap, fs::File, io::Read, path::Path}; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub(super) struct Settings { + requester: String, + codex: String, + security: String, + owner: String, + core: Vec, + protected: Vec, +} + +impl Settings { + pub(super) fn read(path: &Path) -> Result { + let mut input = Vec::new(); + File::open(path) + .and_then(|file| { + if !file.metadata()?.is_file() { + return Err(std::io::Error::other("expected regular file")); + } + file.take(16_385).read_to_end(&mut input) + }) + .map_err(|_| "cannot read board review policy")?; + if input.len() > 16_384 { + return Err("board review policy exceeds the size limit".into()); + } + let settings: Self = serde_json::from_slice(&input).map_err(|_| "invalid board review policy")?; + let roles = [&settings.codex, &settings.security, &settings.owner]; + if settings.requester.is_empty() + || roles.iter().any(|login| login.is_empty()) + || roles.iter().enumerate().any(|(index, login)| { + roles[index + 1..] + .iter() + .any(|other| other.eq_ignore_ascii_case(login)) + }) + || settings.core.iter().chain(&settings.protected).any(|prefix| { + prefix + .split('/') + .any(|component| matches!(component, "" | "." | "..")) + }) + { + return Err("invalid board review policy paths or reviewer accounts".into()); + } + Ok(settings) + } + + fn reviewer(&self, actor: &str) -> Option { + [ + (Reviewer::Codex, &self.codex), + (Reviewer::Security, &self.security), + (Reviewer::Owner, &self.owner), + ] + .into_iter() + .find_map(|(reviewer, login)| login.eq_ignore_ascii_case(actor).then_some(reviewer)) + } +} + +pub(super) fn source_path(path: &str) -> bool { + [ + ".rs", ".py", ".go", ".ts", ".tsx", ".js", ".jsx", ".sh", ".c", ".cc", ".cpp", ".cxx", ".h", ".hh", + ".hpp", ".hxx", ".inc", ".qml", + ] + .iter() + .any(|extension| path.ends_with(extension)) +} + +fn kind(path: &str) -> ChangeKind { + let name = path.rsplit('/').next().unwrap_or(path); + if path + .split('/') + .any(|part| matches!(part, "test" | "tests" | "fixtures")) + || name.ends_with("_test.go") + || name.starts_with("test_") && name.ends_with(".py") + { + ChangeKind::Test + } else if matches!(name, "README.md" | "CHANGELOG.md" | "CONTRIBUTING.md") + || (path.split('/').any(|part| part == "docs") && (path.ends_with(".md") || path.ends_with(".rst"))) + { + ChangeKind::Documentation + } else if source_path(path) { + ChangeKind::Source + } else { + ChangeKind::Other + } +} + +struct Evidence<'a> { + git: GitDiff, + head: &'a str, + two_review: bool, + admitted: bool, + approvals: Vec<(Reviewer, &'a str)>, + receipts: Vec, +} + +impl<'a> Evidence<'a> { + fn read(row: &'a Value, root: &Path, policy: &oxa_work::RunPolicy, settings: &Settings) -> Option { + if row["baseRefName"] != "main" { + return None; + } + let base = row["baseRefOid"].as_str()?; + let head = row["headRefOid"].as_str()?; + let git = GitDiff::read(policy, root, base, head).ok().flatten()?; + let labels = nodes(&row["labels"]).ok()?; + let labeled = |label| labels.iter().any(|item| item["name"].as_str() == Some(label)); + let admitted = !row["isCrossRepository"].as_bool()? + && (labeled("ok-to-review") + || matches!( + row["authorAssociation"].as_str(), + Some("OWNER" | "MEMBER" | "COLLABORATOR") + )); + let approvals = nodes(&row["latestOpinionatedReviews"]) + .ok()? + .iter() + .filter(|opinion| opinion["state"] == "APPROVED") + .filter_map(|opinion| { + Some(( + settings.reviewer(opinion["author"]["login"].as_str()?)?, + opinion["commit"]["oid"].as_str()?, + )) + }) + .collect(); + let receipts = nodes(&row["comments"]) + .ok()? + .iter() + .filter_map(|comment| { + GitHubRequestReceipt::from_comment( + &settings.requester, + comment["author"]["login"].as_str()?, + comment["body"].as_str()?, + ) + }) + .collect(); + Some(Self { + git, + head, + two_review: labeled("two-review"), + admitted, + approvals, + receipts, + }) + } +} + +struct Snapshot(Vec); + +impl GitHub for Snapshot { + fn open_pull_requests(&mut self) -> Result, String> { + Ok(std::mem::take(&mut self.0)) + } +} + +pub(super) fn sample( + reader: &mut Reader<'_>, + root: &Path, + run_policy: &oxa_work::RunPolicy, + board_policy: &Policy, + settings: &Settings, + now: u64, +) -> Result<(Board, BTreeMap), String> { + let pulls = reader.open_pull_requests()?; + let observations = reader + .review_rows + .take() + .ok_or("missing board review observations")?; + let observations: Vec<_> = pulls + .iter() + .filter_map(|pr| { + let row = &observations[format!("p{}", pr.number)]; + Some((pr.number, Evidence::read(row, root, run_policy, settings)?)) + }) + .collect(); + let inputs: Vec<_> = observations + .iter() + .map(|(number, evidence)| { + let changes: Vec<_> = evidence + .git + .files + .iter() + .map(|file| { + let current = kind(&file.path); + let previous = file.previous_path.as_deref().map(kind).unwrap_or(current); + let kind = match (current, previous) { + (ChangeKind::Source, _) | (_, ChangeKind::Source) => ChangeKind::Source, + (ChangeKind::Other, _) | (_, ChangeKind::Other) => ChangeKind::Other, + _ => current, + }; + Change { + path: &file.path, + previous_path: file.previous_path.as_deref(), + kind, + deleted_file: file.deleted_file, + deleted_lines: file.deleted_lines, + } + }) + .collect(); + let predecessors: Vec<_> = evidence + .git + .main_merge_predecessors + .iter() + .map(String::as_str) + .collect(); + let requests: Vec<_> = evidence + .receipts + .iter() + .map(GitHubRequestReceipt::receipt) + .collect(); + let approvals: Vec<_> = evidence + .approvals + .iter() + .map(|&(reviewer, head)| Approval { + reviewer, + head, + patch_id: &evidence.git.patch_id, + }) + .collect(); + (*number, evidence, changes, predecessors, requests, approvals) + }) + .collect(); + let facts = inputs + .iter() + .map( + |(number, evidence, changes, predecessors, requested, approvals)| { + ( + *number, + Facts { + changes, + two_review: evidence.two_review, + required_ci: RequiredCi::Pending, + draft: false, + review_admitted: evidence.admitted, + unresolved_findings: false, + body: "", + head: evidence.head, + patch_id: Some(&evidence.git.patch_id), + main_merge_predecessors: predecessors, + requested, + approvals, + }, + ) + }, + ) + .collect(); + let paths: Vec<_> = settings + .core + .iter() + .map(|path| PathRule { + path, + tier: Tier::Core, + }) + .chain(settings.protected.iter().map(|path| PathRule { + path, + tier: Tier::Protected, + })) + .collect(); + Board::read_with_review_policy( + &mut Snapshot(pulls), + board_policy, + &BTreeMap::new(), + now, + &review::Policy { + enabled: true, + paths: &paths, + }, + &facts, + ) +} diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index 3cd00575..a48908c9 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -444,3 +444,67 @@ fn exited_github_child_cannot_escape_the_whole_read_deadline() { || fs::metadata(log_for(&env, "example/repo")).unwrap().len() == 0 ); } + +#[test] +fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { + let (env, mut detail) = fixture(); + let git = |args: &[&str]| { + let out = Command::new("git") + .args(args) + .current_dir(env.work()) + .env_clear() + .envs(env.envs("http://127.0.0.1:1")) + .env("GIT_AUTHOR_NAME", "Test") + .env("GIT_COMMITTER_NAME", "Test") + .env("GIT_AUTHOR_EMAIL", "test@example.invalid") + .env("GIT_COMMITTER_EMAIL", "test@example.invalid") + .output() + .unwrap(); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + String::from_utf8_lossy(&out.stdout).trim().to_owned() + }; + git(&["commit", "--allow-empty", "-m", "base"]); + let base = git(&["rev-parse", "HEAD"]); + env.write("work/engine/core.rs", "fn change() {}\n"); + git(&["add", "engine/core.rs"]); + git(&["commit", "-m", "own diff"]); + let head = git(&["rev-parse", "HEAD"]); + env.write( + "home/review.json", + r#"{"requester":"review-bot","codex":"code-reviewer","security":"security-reviewer","owner":"owner-reviewer","core":["engine"],"protected":[]}"#, + ); + let row = &mut detail["data"]["repository"]["p42"]; + row["baseRefOid"] = base.into(); + row["headRefOid"] = head.clone().into(); + row["authorAssociation"] = "MEMBER".into(); + row["isCrossRepository"] = false.into(); + row["mergeable"] = "MERGEABLE".into(); + row["comments"] = serde_json::json!({ "totalCount": 0, "nodes": [] }); + row["commits"] = serde_json::json!({ "nodes": [{ "commit": {"statusCheckRollup":{"contexts": + {"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}]} + }}}] }); + row["latestOpinionatedReviews"] = serde_json::json!({ + "totalCount": 2, + "nodes": [ + {"state":"APPROVED","commit":{"oid":head},"author":{"login":"code-reviewer"}}, + {"state":"APPROVED","commit":{"oid":head},"author":{"login":"outside"}} + ] + }); + fs::write(env.work().join("detail.json"), detail.to_string()).unwrap(); + let out = invoke( + &env, + "work board --shadow --repo example/repo --once --review-policy ../home/review.json", + ); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + let log = fs::read_to_string(log_for(&env, "example/repo")).unwrap(); + let sample: serde_json::Value = serde_json::from_str(log.lines().last().unwrap()).unwrap(); + assert_eq!(sample["board"]["entries"][0]["action"], "wait_review"); + let plan = &sample["reviews"]["42"]; + assert_eq!(plan["decision"]["review"]["tier"], "core"); + assert_eq!( + plan["decision"]["review"]["outstanding"], + serde_json::json!(["security"]) + ); + assert_eq!(plan["requests"][0]["key"]["reviewer"], "security"); + assert_eq!(plan["requests"][0]["head"], head); +} diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 305425ec..4f4cf346 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -9,7 +9,8 @@ pub use git::{GitDiff, GitFileChange}; mod receipts; pub use receipts::GitHubRequestReceipt; -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Clone, Copy, Debug, Serialize, PartialEq, Eq, PartialOrd, Ord)] +#[serde(rename_all = "snake_case")] pub enum Tier { DocsAndTests, Product, @@ -79,7 +80,8 @@ impl<'a> Facts<'a> { } } -#[derive(Debug, PartialEq, Eq)] +#[derive(Debug, Serialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] pub enum Decision { Disabled, ResolveFindings, @@ -92,7 +94,7 @@ pub enum Decision { }, } -#[derive(Debug)] +#[derive(Debug, Serialize)] pub struct Plan { pub decision: Decision, requests: Vec, @@ -100,7 +102,7 @@ pub struct Plan { /// Only the board can produce requests. A dispatcher must revalidate the head /// and required checks and reserve the request before causing external effects. -#[derive(Debug)] +#[derive(Debug, Serialize)] pub struct Request { pub(super) number: u64, pub(super) head: String, diff --git a/oxa/oxa-work/src/shadow.rs b/oxa/oxa-work/src/shadow.rs index 8be29365..94f1d272 100644 --- a/oxa/oxa-work/src/shadow.rs +++ b/oxa/oxa-work/src/shadow.rs @@ -1,7 +1,8 @@ //! Read-only sampling: this runner has no executor or GitHub mutation interface. -use crate::board::{Board, Entry}; +use crate::board::{review, Board, Entry}; use crate::Result; use serde::Serialize; +use std::collections::BTreeMap; use std::fs::{File, OpenOptions}; use std::io::{Read, Seek, SeekFrom, Write}; use std::os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt}; @@ -17,6 +18,8 @@ struct Sample<'a> { observed_at: u64, board: &'a Board, would_take: Vec<&'a Entry>, + #[serde(skip_serializing_if = "BTreeMap::is_empty")] + reviews: &'a BTreeMap, } /// Refuse links, shared files and concurrent writers before consulting GitHub. @@ -154,16 +157,26 @@ pub fn run( log: &mut File, once: bool, mut snapshot: impl FnMut() -> Result, + wait: impl FnMut(Duration), +) -> Result<()> { + run_with_reviews(log, once, || Ok((snapshot()?, BTreeMap::new())), wait) +} + +pub fn run_with_reviews( + log: &mut File, + once: bool, + mut snapshot: impl FnMut() -> Result<(Board, BTreeMap)>, mut wait: impl FnMut(Duration), ) -> Result<()> { loop { let started = Instant::now(); - let board = snapshot()?; + let (board, reviews) = snapshot()?; let sample = Sample { schema_version: 1, observed_at: board.observed_at, would_take: board.entries.iter().filter(|entry| entry.eligible).collect(), board: &board, + reviews: &reviews, }; let mut line = serde_json::to_vec(&sample).map_err(|_| "cannot encode shadow board")?; line.push(b'\n'); From c3d0ab7122989bd24280de6634ec5b0e88cbe893 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:31:03 +0100 Subject: [PATCH 10/16] fix(work): parse board settings with the CLI JSON dependency --- oxa/oxa-cli/src/work_board/review.rs | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/oxa/oxa-cli/src/work_board/review.rs b/oxa/oxa-cli/src/work_board/review.rs index de65c071..6763e4ce 100644 --- a/oxa/oxa-cli/src/work_board/review.rs +++ b/oxa/oxa-cli/src/work_board/review.rs @@ -2,12 +2,9 @@ use super::{nodes, Board, GitHub, Policy, PullRequest, Reader, RequiredCi}; use oxa_work::board::review::{ self, Approval, Change, ChangeKind, Facts, GitDiff, GitHubRequestReceipt, PathRule, Reviewer, Tier, }; -use serde::Deserialize; use serde_json::Value; use std::{collections::BTreeMap, fs::File, io::Read, path::Path}; -#[derive(Deserialize)] -#[serde(deny_unknown_fields)] pub(super) struct Settings { requester: String, codex: String, @@ -31,7 +28,28 @@ impl Settings { if input.len() > 16_384 { return Err("board review policy exceeds the size limit".into()); } - let settings: Self = serde_json::from_slice(&input).map_err(|_| "invalid board review policy")?; + let invalid = "invalid board review policy"; + let raw: Value = serde_json::from_slice(&input).map_err(|_| invalid)?; + if raw.as_object().is_none_or(|fields| fields.len() != 6) { + return Err(invalid.into()); + } + let login = |field: &str| raw[field].as_str().map(str::to_owned).ok_or(invalid); + let paths = |field: &str| { + raw[field] + .as_array() + .ok_or(invalid)? + .iter() + .map(|path| path.as_str().map(str::to_owned).ok_or(invalid)) + .collect::, _>>() + }; + let settings = Self { + requester: login("requester")?, + codex: login("codex")?, + security: login("security")?, + owner: login("owner")?, + core: paths("core")?, + protected: paths("protected")?, + }; let roles = [&settings.codex, &settings.security, &settings.owner]; if settings.requester.is_empty() || roles.iter().any(|login| login.is_empty()) From 600260264c43735fb83ac9164ca23cb29b875dd8 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Tue, 17 Nov 2026 21:39:57 +0100 Subject: [PATCH 11/16] feat(work): accept commit-bound Codex review receipts on the shadow board --- oxa/oxa-cli/src/work_board.rs | 2 +- oxa/oxa-cli/src/work_board/review.rs | 41 ++++++++++++++++++-- oxa/oxa-cli/tests/work_shadow.rs | 57 ++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 4 deletions(-) diff --git a/oxa/oxa-cli/src/work_board.rs b/oxa/oxa-cli/src/work_board.rs index fce661a9..0b02d5b5 100644 --- a/oxa/oxa-cli/src/work_board.rs +++ b/oxa/oxa-cli/src/work_board.rs @@ -182,7 +182,7 @@ impl GitHub for Reader<'_> { let expected = ids(&list["pullRequests"])?; let mut details = serde_json::json!({}); let review_fields = if self.review_rows.is_some() { - "baseRefOid isCrossRepository authorAssociation comments(first:100){totalCount nodes{body author{login}}}" + "baseRefOid isCrossRepository authorAssociation comments(first:100){totalCount nodes{body author{login} lastEditedAt}} reviews(first:100){totalCount nodes{state body author{login} commit{oid} lastEditedAt}}" } else { "" }; diff --git a/oxa/oxa-cli/src/work_board/review.rs b/oxa/oxa-cli/src/work_board/review.rs index 6763e4ce..078adeb6 100644 --- a/oxa/oxa-cli/src/work_board/review.rs +++ b/oxa/oxa-cli/src/work_board/review.rs @@ -109,6 +109,28 @@ fn kind(path: &str) -> ChangeKind { } } +fn codex_clean_receipt(body: &str) -> Option<&str> { + let mut lines = body.lines().filter(|line| !line.trim().is_empty()); + if lines.next()? != "" + || !matches!( + lines.next()?, + "Codex Review: Didn't find any major issues." + | "Codex Review: Didn't find any major issues. :rocket:" + ) + { + return None; + } + let sha = lines + .next()? + .strip_prefix("**Reviewed commit:** `")? + .strip_suffix('`')?; + (matches!(sha.len(), 10..=40 | 64) + && sha + .bytes() + .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))) + .then_some(sha) +} + struct Evidence<'a> { git: GitDiff, head: &'a str, @@ -134,7 +156,7 @@ impl<'a> Evidence<'a> { row["authorAssociation"].as_str(), Some("OWNER" | "MEMBER" | "COLLABORATOR") )); - let approvals = nodes(&row["latestOpinionatedReviews"]) + let mut approvals: Vec<_> = nodes(&row["latestOpinionatedReviews"]) .ok()? .iter() .filter(|opinion| opinion["state"] == "APPROVED") @@ -145,9 +167,10 @@ impl<'a> Evidence<'a> { )) }) .collect(); - let receipts = nodes(&row["comments"]) - .ok()? + let comments = nodes(&row["comments"]).ok()?; + let receipts = comments .iter() + .filter(|comment| comment["lastEditedAt"].is_null()) .filter_map(|comment| { GitHubRequestReceipt::from_comment( &settings.requester, @@ -156,6 +179,18 @@ impl<'a> Evidence<'a> { ) }) .collect(); + if let Ok(reviews) = nodes(&row["reviews"]) { + approvals.extend(reviews.iter().filter_map(|review| { + let actor = review["author"]["login"].as_str()?; + let commit = review["commit"]["oid"].as_str()?; + let receipt = codex_clean_receipt(review["body"].as_str()?)?; + (review["state"] == "COMMENTED" + && review["lastEditedAt"].is_null() + && settings.reviewer(actor) == Some(Reviewer::Codex) + && commit.starts_with(receipt)) + .then_some((Reviewer::Codex, commit)) + })); + } Some(Self { git, head, diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index a48908c9..484bbf32 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -507,4 +507,61 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { ); assert_eq!(plan["requests"][0]["key"]["reviewer"], "security"); assert_eq!(plan["requests"][0]["head"], head); + + let receipt = format!( + "\n\nCodex Review: Didn't find any major issues. :rocket:\n\n**Reviewed commit:** `{}`", + &head[..10] + ); + for (actor, edited, attached, outstanding) in [ + ( + "outside", + serde_json::Value::Null, + true, + serde_json::json!(["codex", "security"]), + ), + ( + "code-reviewer", + serde_json::json!("2026-01-01T00:00:00Z"), + true, + serde_json::json!(["codex", "security"]), + ), + ( + "code-reviewer", + serde_json::Value::Null, + false, + serde_json::json!(["codex", "security"]), + ), + ( + "code-reviewer", + serde_json::Value::Null, + true, + serde_json::json!(["security"]), + ), + ] { + let row = &mut detail["data"]["repository"]["p42"]; + row["latestOpinionatedReviews"] = serde_json::json!({"totalCount":0,"nodes":[]}); + row["comments"] = serde_json::json!({"totalCount":1,"nodes":[{ + "body":receipt,"author":{"login":actor},"lastEditedAt":edited + }]}); + row["reviews"] = if attached { + serde_json::json!({"totalCount":1,"nodes":[{ + "state":"COMMENTED","body":receipt,"author":{"login":actor}, + "lastEditedAt":edited,"commit":{"oid":head} + }]}) + } else { + serde_json::json!({"totalCount":0,"nodes":[]}) + }; + fs::write(env.work().join("detail.json"), detail.to_string()).unwrap(); + let out = invoke( + &env, + "work board --shadow --repo example/repo --once --review-policy ../home/review.json", + ); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + let log = fs::read_to_string(log_for(&env, "example/repo")).unwrap(); + let sample: serde_json::Value = serde_json::from_str(log.lines().last().unwrap()).unwrap(); + assert_eq!( + sample["reviews"]["42"]["decision"]["review"]["outstanding"], + outstanding + ); + } } From 58a18cba2829ac1509d927327289dbcfe3ac1584 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 00:16:49 +0100 Subject: [PATCH 12/16] test(board): reproduce lost approval after docs and tests changes --- oxa/oxa-cli/tests/work_shadow.rs | 38 ++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index e200f227..ee5e7fc4 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -691,4 +691,42 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { outstanding ); } + + for (paths, outstanding) in [ + ( + &["docs/usage.md", "engine/tests/regression.rs"][..], + serde_json::json!(["security"]), + ), + (&["docs/AGENTS.md"][..], serde_json::json!(["codex", "security"])), + (&["engine/other.rs"][..], serde_json::json!(["codex", "security"])), + ] { + git(&["reset", "--hard", &head]); + for path in paths { + env.write(&format!("work/{path}"), "follow-up\n"); + git(&["add", "--", path]); + } + git(&["commit", "-m", "follow-up"]); + let new_head = git(&["rev-parse", "HEAD"]); + detail["data"]["repository"]["pullRequests"]["nodes"][0]["headRefOid"] = new_head.clone().into(); + let row = &mut detail["data"]["repository"]["p42"]; + row["headRefOid"] = new_head.into(); + row["comments"] = serde_json::json!({"totalCount":0,"nodes":[]}); + row["latestOpinionatedReviews"] = serde_json::json!({ + "totalCount":1, + "nodes":[{"state":"APPROVED","commit":{"oid":head},"author":{"login":"code-reviewer"}}] + }); + fs::write(env.work().join("first.json"), detail.to_string()).unwrap(); + fs::write(env.work().join("detail.json"), detail.to_string()).unwrap(); + let out = invoke( + &env, + "work board --shadow --repo example/repo --once --review-policy ../home/review.json", + ); + assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr)); + let log = fs::read_to_string(log_for(&env, "example/repo")).unwrap(); + let sample: serde_json::Value = serde_json::from_str(log.lines().last().unwrap()).unwrap(); + assert_eq!( + sample["reviews"]["42"]["decision"]["review"]["outstanding"], outstanding, + "{paths:?}" + ); + } } From 8e80f6f9056e4f348027df53b1f1f8745cd29f31 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 00:22:33 +0100 Subject: [PATCH 13/16] test(board): restrict approval carry regression to owner evidence --- oxa/oxa-cli/tests/work_shadow.rs | 46 +++++++++++++++++++++++++------- 1 file changed, 37 insertions(+), 9 deletions(-) diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index ee5e7fc4..be29b2f0 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -550,7 +550,7 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { let head = git(&["rev-parse", "HEAD"]); env.write( "home/review.json", - r#"{"requester":"review-bot","codex":"code-reviewer","security":"security-reviewer","owner":"owner-reviewer","core":["engine"],"protected":[]}"#, + r#"{"requester":"review-bot","codex":"code-reviewer","security":"security-reviewer","owner":"owner-reviewer","core":["engine"],"protected":["docs/protected"]}"#, ); detail["data"]["repository"]["pullRequests"]["nodes"][0]["headRefOid"] = head.clone().into(); let row = &mut detail["data"]["repository"]["p42"]; @@ -692,15 +692,39 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { ); } - for (paths, outstanding) in [ + env.write("work/docs/protected/contract.md", "protected change\n"); + git(&["add", "docs/protected/contract.md"]); + git(&["commit", "-m", "owner-reviewed change"]); + let reviewed_head = git(&["rev-parse", "HEAD"]); + + for (paths, owner_opinion, outstanding) in [ ( - &["docs/usage.md", "engine/tests/regression.rs"][..], - serde_json::json!(["security"]), + &["docs/token-usage.md", "engine/tests/regression.rs"][..], + "APPROVED", + serde_json::json!(["codex", "security"]), + ), + ( + &["docs/token-usage.md"][..], + "DISMISSED", + serde_json::json!(["codex", "security", "owner"]), + ), + ( + &["docs/AGENTS.md"][..], + "APPROVED", + serde_json::json!(["codex", "security", "owner"]), + ), + ( + &["docs/protected/guide.md"][..], + "APPROVED", + serde_json::json!(["codex", "security", "owner"]), + ), + ( + &["engine/other.rs"][..], + "APPROVED", + serde_json::json!(["codex", "security", "owner"]), ), - (&["docs/AGENTS.md"][..], serde_json::json!(["codex", "security"])), - (&["engine/other.rs"][..], serde_json::json!(["codex", "security"])), ] { - git(&["reset", "--hard", &head]); + git(&["reset", "--hard", &reviewed_head]); for path in paths { env.write(&format!("work/{path}"), "follow-up\n"); git(&["add", "--", path]); @@ -712,8 +736,12 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { row["headRefOid"] = new_head.into(); row["comments"] = serde_json::json!({"totalCount":0,"nodes":[]}); row["latestOpinionatedReviews"] = serde_json::json!({ - "totalCount":1, - "nodes":[{"state":"APPROVED","commit":{"oid":head},"author":{"login":"code-reviewer"}}] + "totalCount":3, + "nodes":[ + {"state":"APPROVED","commit":{"oid":reviewed_head},"author":{"login":"code-reviewer"}}, + {"state":"APPROVED","commit":{"oid":reviewed_head},"author":{"login":"security-reviewer"}}, + {"state":owner_opinion,"commit":{"oid":reviewed_head},"author":{"login":"owner-reviewer"}} + ] }); fs::write(env.work().join("first.json"), detail.to_string()).unwrap(); fs::write(env.work().join("detail.json"), detail.to_string()).unwrap(); From 909639775f008ebcdbb841ad0d4e9ab89738838e Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 00:32:46 +0100 Subject: [PATCH 14/16] fix(board): carry owner approval across verified docs and tests edits --- oxa/oxa-cli/src/work_board/review.rs | 84 ++++++++++++++++++++-------- oxa/oxa-cli/tests/work_shadow.rs | 3 +- oxa/oxa-cli/tests/work_shadow_log.rs | 20 ++++++- oxa/oxa-work/src/board/review.rs | 36 ++++++++---- oxa/oxa-work/src/board/review/git.rs | 79 ++++++++++++++++++++++---- oxa/oxa-work/tests/board_controls.rs | 1 + oxa/oxa-work/tests/board_review.rs | 1 + 7 files changed, 177 insertions(+), 47 deletions(-) diff --git a/oxa/oxa-cli/src/work_board/review.rs b/oxa/oxa-cli/src/work_board/review.rs index cdc6397c..2d004879 100644 --- a/oxa/oxa-cli/src/work_board/review.rs +++ b/oxa/oxa-cli/src/work_board/review.rs @@ -144,13 +144,18 @@ struct Evidence<'a> { } impl<'a> Evidence<'a> { - fn read(row: &'a Value, root: &Path, policy: &oxa_work::RunPolicy, settings: &Settings) -> Option { + fn read( + row: &'a Value, + root: &Path, + policy: &oxa_work::RunPolicy, + settings: &Settings, + review_policy: &review::Policy<'_>, + ) -> Option { if row["baseRefName"] != "main" { return None; } let base = row["baseRefOid"].as_str()?; let head = row["headRefOid"].as_str()?; - let git = GitDiff::read(policy, root, base, head).ok().flatten()?; let labels = nodes(&row["labels"]).ok()?; let labeled = |label| labels.iter().any(|item| item["name"].as_str() == Some(label)); let admitted = !row["isCrossRepository"].as_bool()? @@ -217,6 +222,20 @@ impl<'a> Evidence<'a> { .then_some((Reviewer::Codex, commit)) })); } + let candidates: Vec<_> = approvals + .iter() + .copied() + .chain( + summary_approval + .as_deref() + .map(|commit| (Reviewer::Codex, commit)), + ) + .collect(); + let git = GitDiff::read(policy, root, base, head, &candidates, |path| { + review_policy.allows_approval_carry(path, kind(path)) + }) + .ok() + .flatten()?; Some(Self { git, head, @@ -245,6 +264,22 @@ pub(super) fn sample( settings: &Settings, now: u64, ) -> Result<(Board, BTreeMap), String> { + let paths: Vec<_> = settings + .core + .iter() + .map(|path| PathRule { + path, + tier: Tier::Core, + }) + .chain(settings.protected.iter().map(|path| PathRule { + path, + tier: Tier::Protected, + })) + .collect(); + let review_policy = review::Policy { + enabled: true, + paths: &paths, + }; let pulls = reader.open_pull_requests()?; let observations = reader .review_rows @@ -254,7 +289,10 @@ pub(super) fn sample( .iter() .filter_map(|pr| { let row = &observations[format!("p{}", pr.number)]; - Some((pr.number, Evidence::read(row, root, run_policy, settings)?)) + Some(( + pr.number, + Evidence::read(row, root, run_policy, settings, &review_policy)?, + )) }) .collect(); let inputs: Vec<_> = observations @@ -281,12 +319,18 @@ pub(super) fn sample( } }) .collect(); - let predecessors: Vec<_> = evidence + let main_predecessors: Vec<_> = evidence .git .main_merge_predecessors .iter() .map(String::as_str) .collect(); + let owner_predecessors: Vec<_> = evidence + .git + .owner_approval_predecessors + .iter() + .map(String::as_str) + .collect(); let requests: Vec<_> = evidence .receipts .iter() @@ -308,13 +352,21 @@ pub(super) fn sample( patch_id: &evidence.git.patch_id, }) .collect(); - (*number, evidence, changes, predecessors, requests, approvals) + ( + *number, + evidence, + changes, + main_predecessors, + owner_predecessors, + requests, + approvals, + ) }) .collect(); let facts = inputs .iter() .map( - |(number, evidence, changes, predecessors, requested, approvals)| { + |(number, evidence, changes, main_predecessors, owner_predecessors, requested, approvals)| { ( *number, Facts { @@ -327,7 +379,8 @@ pub(super) fn sample( body: "", head: evidence.head, patch_id: Some(&evidence.git.patch_id), - main_merge_predecessors: predecessors, + main_merge_predecessors: main_predecessors, + owner_approval_predecessors: owner_predecessors, requested, approvals, }, @@ -335,27 +388,12 @@ pub(super) fn sample( }, ) .collect(); - let paths: Vec<_> = settings - .core - .iter() - .map(|path| PathRule { - path, - tier: Tier::Core, - }) - .chain(settings.protected.iter().map(|path| PathRule { - path, - tier: Tier::Protected, - })) - .collect(); Board::read_with_review_policy( &mut Snapshot(pulls), board_policy, &BTreeMap::new(), now, - &review::Policy { - enabled: true, - paths: &paths, - }, + &review_policy, &facts, ) } diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index be29b2f0..e35e439a 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -703,6 +703,7 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { "APPROVED", serde_json::json!(["codex", "security"]), ), + (&[][..], "APPROVED", serde_json::json!(["codex", "security"])), ( &["docs/token-usage.md"][..], "DISMISSED", @@ -729,7 +730,7 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { env.write(&format!("work/{path}"), "follow-up\n"); git(&["add", "--", path]); } - git(&["commit", "-m", "follow-up"]); + git(&["commit", "--allow-empty", "-m", "follow-up"]); let new_head = git(&["rev-parse", "HEAD"]); detail["data"]["repository"]["pullRequests"]["nodes"][0]["headRefOid"] = new_head.clone().into(); let row = &mut detail["data"]["repository"]["p42"]; diff --git a/oxa/oxa-cli/tests/work_shadow_log.rs b/oxa/oxa-cli/tests/work_shadow_log.rs index 7d8866cf..ae6e8fdf 100644 --- a/oxa/oxa-cli/tests/work_shadow_log.rs +++ b/oxa/oxa-cli/tests/work_shadow_log.rs @@ -122,11 +122,25 @@ fn review_git_evidence_keeps_an_unchanged_main_merge_and_rejects_a_changed_patch terminate_binary: None, storage: env.tmp(), }; - let read = |base: &str, head: &str| GitDiff::read(&policy, &repo, base, head).unwrap().unwrap(); + let read = |base: &str, head: &str| { + GitDiff::read( + &policy, + &repo, + base, + head, + &[(oxa_work::board::review::Reviewer::Codex, &reviewed)], + |_| false, + ) + .unwrap() + .unwrap() + }; let original = read(&old_main, &reviewed); let carried = read(&main, &merged); assert_eq!(carried.patch_id, original.patch_id); - assert_eq!(carried.main_merge_predecessors, [reviewed]); + assert_eq!( + carried.main_merge_predecessors.as_slice(), + std::slice::from_ref(&reviewed) + ); env.write("work/protected.rs", "fn check() { }\n"); git(&["add", "protected.rs"]); @@ -135,7 +149,7 @@ fn review_git_evidence_keeps_an_unchanged_main_merge_and_rejects_a_changed_patch let current = read(&main, &edited); assert_ne!(current.patch_id, carried.patch_id); assert!(current.main_merge_predecessors.is_empty()); - assert!(GitDiff::read(&policy, &repo, &main, "HEAD").is_err()); + assert!(GitDiff::read(&policy, &repo, &main, "HEAD", &[], |_| false).is_err()); git(&["mv", "old_name.rs", "renamed.md"]); git(&["rm", "obsolete.rs"]); diff --git a/oxa/oxa-work/src/board/review.rs b/oxa/oxa-work/src/board/review.rs index 0ed24f5c..945a1ba6 100644 --- a/oxa/oxa-work/src/board/review.rs +++ b/oxa/oxa-work/src/board/review.rs @@ -69,8 +69,11 @@ pub struct Facts<'a> { pub head: &'a str, /// Stable patch ID of the complete own diff. Missing evidence fails closed. pub patch_id: Option<&'a str>, - /// Heads proven to reach this head through pure main merges only. + /// Reviewed heads linked to this head by verified pure main merges. pub main_merge_predecessors: &'a [&'a str], + /// Owner-approved heads with only verified pure main merges and ordinary + /// documentation and test changes since approval. + pub owner_approval_predecessors: &'a [&'a str], pub requested: &'a [RequestReceipt<'a>], pub approvals: &'a [Approval<'a>], } @@ -187,6 +190,15 @@ pub struct PathRule<'a> { pub tier: Tier, } +impl PathRule<'_> { + fn matches(&self, path: &str) -> bool { + path == self.path + || path + .strip_prefix(self.path) + .is_some_and(|rest| rest.starts_with('/')) + } +} + /// Construct this policy from owner-controlled rules, never from the PR. #[derive(Default)] pub struct Policy<'a> { @@ -195,6 +207,15 @@ pub struct Policy<'a> { } impl Policy<'_> { + pub fn allows_approval_carry(&self, path: &str, kind: ChangeKind) -> bool { + matches!(kind, ChangeKind::Documentation | ChangeKind::Test) + && !agent_instruction_path(path) + && !self + .paths + .iter() + .any(|rule| rule.tier == Tier::Protected && rule.matches(path)) + } + pub fn decide(&self, facts: &Facts<'_>) -> Decision { if !self.enabled { return Decision::Disabled; @@ -231,14 +252,7 @@ impl Policy<'_> { let path_tier = self .paths .iter() - .filter(|rule| { - paths.into_iter().flatten().any(|path| { - path == rule.path - || path - .strip_prefix(rule.path) - .is_some_and(|rest| rest.starts_with('/')) - }) - }) + .filter(|rule| paths.into_iter().flatten().any(|path| rule.matches(path))) .map(|rule| rule.tier) .max() .unwrap_or(Tier::DocsAndTests); @@ -272,7 +286,9 @@ impl Policy<'_> { approval.reviewer == *reviewer && approval.patch_id == patch_id && (approval.head == facts.head - || facts.main_merge_predecessors.contains(&approval.head)) + || facts.main_merge_predecessors.contains(&approval.head) + || (*reviewer == Reviewer::Owner + && facts.owner_approval_predecessors.contains(&approval.head))) }) }) .collect(); diff --git a/oxa/oxa-work/src/board/review/git.rs b/oxa/oxa-work/src/board/review/git.rs index fecd8c32..e57f8cf0 100644 --- a/oxa/oxa-work/src/board/review/git.rs +++ b/oxa/oxa-work/src/board/review/git.rs @@ -1,16 +1,18 @@ +use super::Reviewer; use crate::{git, output, Result, RunPolicy}; use std::io::{Read, Write}; use std::path::Path; use std::process::{Command, Stdio}; const MAX_DIFF_BYTES: u64 = 2 * 1024 * 1024; -const MAX_MAIN_MERGES: usize = 16; +const MAX_APPROVAL_STEPS: usize = 16; /// Own-diff evidence from already available Git objects. The caller supplies the /// trusted base and the GitHub snapshot's exact head, never PR-provided refs. pub struct GitDiff { pub patch_id: String, pub main_merge_predecessors: Vec, + pub owner_approval_predecessors: Vec, pub files: Vec, } @@ -23,7 +25,14 @@ pub struct GitFileChange { } impl GitDiff { - pub fn read(policy: &RunPolicy, repo: &Path, base: &str, head: &str) -> Result> { + pub fn read( + policy: &RunPolicy, + repo: &Path, + base: &str, + head: &str, + approvals: &[(Reviewer, &str)], + carry_path: impl Fn(&str) -> bool, + ) -> Result> { if !object_id(base) || !object_id(head) { return Err("review evidence requires full Git object IDs".into()); } @@ -34,29 +43,76 @@ impl GitDiff { let files = own_file_changes(policy, repo, &start, head)?; let mut current = head.to_owned(); let mut main_merge_predecessors = Vec::new(); - for _ in 0..MAX_MAIN_MERGES { + let mut owner_approval_predecessors = Vec::new(); + let mut owner_only = false; + let mut candidates: Vec<_> = approvals + .iter() + .copied() + .filter(|&(_, reviewed)| reviewed != head) + .collect(); + let mut current_patch = patch_id.clone(); + for _ in 0..MAX_APPROVAL_STEPS { + if candidates.is_empty() { + break; + } let parents = git_line( policy, repo, &["rev-list", "--parents", "--max-count=1", ¤t, "--"], )?; let fields: Vec<_> = parents.split_ascii_whitespace().collect(); - let [_, previous, main] = fields.as_slice() else { + let [_, previous, rest @ ..] = fields.as_slice() else { break; }; - if !is_ancestor(policy, repo, main, base)? - || is_ancestor(policy, repo, main, previous)? - || own_patch_id(policy, repo, &merge_base(policy, repo, base, previous)?, previous)?.as_ref() - != Some(&patch_id) - { + if rest.is_empty() { + // Only an existing owner approval survives an ordinary docs/test delta. + candidates.retain(|&(reviewer, _)| reviewer == Reviewer::Owner); + if candidates.is_empty() + || !own_file_changes(policy, repo, previous, ¤t).is_ok_and(|delta| { + delta.iter().all(|file| { + carry_path(&file.path) && file.previous_path.as_deref().is_none_or(&carry_path) + }) + }) + { + break; + } + owner_only = true; + } + let previous_base = merge_base(policy, repo, base, previous)?; + if previous_base == *previous { + break; + } + let Some(previous_patch) = own_patch_id(policy, repo, &previous_base, previous)? else { + break; + }; + let can_carry = match rest { + [] => true, + [main] => { + previous_patch == current_patch + && is_ancestor(policy, repo, main, base)? + && !is_ancestor(policy, repo, main, previous)? + } + _ => false, + }; + if !can_carry { break; } current = (*previous).to_owned(); - main_merge_predecessors.push(current.clone()); + current_patch = previous_patch; + let previous_count = candidates.len(); + candidates.retain(|&(_, reviewed)| reviewed != current); + if candidates.len() != previous_count { + if owner_only { + owner_approval_predecessors.push(current.clone()); + } else { + main_merge_predecessors.push(current.clone()); + } + } } Ok(Some(Self { patch_id, main_merge_predecessors, + owner_approval_predecessors, files, })) } @@ -169,6 +225,9 @@ fn own_file_changes(policy: &RunPolicy, repo: &Path, start: &str, head: &str) -> "--", ], ))?; + if raw.is_empty() { + return Ok(Vec::new()); + } let invalid = "invalid Git review file inventory"; let raw = std::str::from_utf8(&raw).map_err(|_| invalid)?; let mut records = raw.strip_suffix('\0').ok_or(invalid)?.split('\0').peekable(); diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index 6fb95ccf..6916d264 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -579,6 +579,7 @@ fn review_reservations_survive_reopening_and_head_changes() { head, patch_id: Some(patch_id), main_merge_predecessors: &[], + owner_approval_predecessors: &[], requested: &[], approvals: &[], }; diff --git a/oxa/oxa-work/tests/board_review.rs b/oxa/oxa-work/tests/board_review.rs index 47a85f11..207ac8f7 100644 --- a/oxa/oxa-work/tests/board_review.rs +++ b/oxa/oxa-work/tests/board_review.rs @@ -35,6 +35,7 @@ fn facts<'a>(changes: &'a [Change<'static>]) -> Facts<'a> { head: "new-head", patch_id: Some(PATCH), main_merge_predecessors: &[], + owner_approval_predecessors: &[], requested: &[], approvals: &[], } From a1eb623c0a5035947de0790980bb982b4193b274 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 01:16:15 +0100 Subject: [PATCH 15/16] test(board): cover an in-progress required check retaining success --- oxa/oxa-cli/tests/work_shadow.rs | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/oxa/oxa-cli/tests/work_shadow.rs b/oxa/oxa-cli/tests/work_shadow.rs index 9e46eee1..69e02878 100644 --- a/oxa/oxa-cli/tests/work_shadow.rs +++ b/oxa/oxa-cli/tests/work_shadow.rs @@ -151,22 +151,23 @@ fn real_cli_requires_opt_in_and_offline_never_reads_github() { assert_eq!(sample["would_take"][0]["action"], "resolve_conflict"); assert_eq!(sample["board"]["entries"][0], sample["would_take"][0]); let mut actual = vec![]; - for (conclusion, head, source) in [ - ("STARTUP_FAILURE", "synthetic-head", ""), - ("STALE", "synthetic-head", ""), - ("SUCCESS", "old-head", ""), - ("SUCCESS", "synthetic-head", ""), - ("SUCCESS", "synthetic-head", "engine.c"), - ("SUCCESS", "synthetic-head", "view.qml"), - ("SUCCESS", "synthetic-head", "header.hpp"), - ("SUCCESS", "synthetic-head", "kernel.inc"), + for (status, conclusion, head, source) in [ + ("COMPLETED", "STARTUP_FAILURE", "synthetic-head", ""), + ("COMPLETED", "STALE", "synthetic-head", ""), + ("IN_PROGRESS", "SUCCESS", "synthetic-head", ""), + ("COMPLETED", "SUCCESS", "old-head", ""), + ("COMPLETED", "SUCCESS", "synthetic-head", ""), + ("COMPLETED", "SUCCESS", "synthetic-head", "engine.c"), + ("COMPLETED", "SUCCESS", "synthetic-head", "view.qml"), + ("COMPLETED", "SUCCESS", "synthetic-head", "header.hpp"), + ("COMPLETED", "SUCCESS", "synthetic-head", "kernel.inc"), ] { let row = &mut detail["data"]["repository"]["p42"]; row["mergeable"] = "MERGEABLE".into(); row["reviewDecision"] = "APPROVED".into(); row["latestOpinionatedReviews"] = serde_json::json!({"totalCount":1,"nodes":[{"state":"APPROVED","commit":{"oid":head}}]}); - row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":conclusion}]}}}}]}); + row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":status,"conclusion":conclusion}]}}}}]}); row["files"] = if source.is_empty() { serde_json::json!({"totalCount":0,"nodes":[]}) } else { @@ -193,6 +194,7 @@ fn real_cli_requires_opt_in_and_offline_never_reads_github() { vec![ "fix_required_ci", "fix_required_ci", + "wait_required_ci", "wait_review", "ready", "add_removes", @@ -243,7 +245,7 @@ fn behind_heads_wait_without_a_queue_and_keep_queue_composition() { row["reviewDecision"] = "APPROVED".into(); row["latestOpinionatedReviews"] = serde_json::json!({"totalCount":1,"nodes":[{"state":"APPROVED","commit":{"oid":"synthetic-head"}}]}); - row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}]}}}}]}); + row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":"COMPLETED","conclusion":"SUCCESS"}]}}}}]}); let mut actions = vec![]; for queued in [false, true] { let mut first = detail.clone(); @@ -316,7 +318,7 @@ fn approval_required_block_has_an_actionable_wait_reason() { row["mergeable"] = "MERGEABLE".into(); row["mergeStateStatus"] = "BLOCKED".into(); row["reviewDecision"] = "REVIEW_REQUIRED".into(); - row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}]}}}}]}); + row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":"COMPLETED","conclusion":"SUCCESS"}]}}}}]}); assert_eq!( sample(&env, &detail)["board"]["entries"][0]["action"], "wait_review" @@ -328,7 +330,7 @@ fn unreported_classic_and_ruleset_requirements_are_pending() { let (env, mut detail) = fixture(); let row = &mut detail["data"]["repository"]["p42"]; row["mergeable"] = "MERGEABLE".into(); - row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}]}}}}]}); + row["commits"] = serde_json::json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":"COMPLETED","conclusion":"SUCCESS"}]}}}}]}); for base in [ serde_json::json!({"refUpdateRule":{"requiredStatusCheckContexts":["ci","missing"]},"rules":{"totalCount":0,"nodes":[]}}), serde_json::json!({"refUpdateRule":null,"rules":{"totalCount":1,"nodes":[{"type":"REQUIRED_STATUS_CHECKS","parameters":{"requiredStatusChecks":[{"context":"ci"},{"context":"missing"}]}}]}}), @@ -706,7 +708,7 @@ fn opt_in_review_policy_observes_pinned_diff_and_authenticated_reviews() { row["mergeable"] = "MERGEABLE".into(); row["comments"] = serde_json::json!({ "totalCount": 0, "nodes": [] }); row["commits"] = serde_json::json!({ "nodes": [{ "commit": {"statusCheckRollup":{"contexts": - {"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}]} + {"totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":"COMPLETED","conclusion":"SUCCESS"}]} }}}] }); row["latestOpinionatedReviews"] = serde_json::json!({ "totalCount": 2, @@ -990,7 +992,7 @@ fn landing_shadow_holds_an_approved_head_on_unresolved_older_review() { row["latestOpinionatedReviews"] = json!({"totalCount":1,"nodes":[{"state":"APPROVED","commit":{"oid":head}}]}); row["commits"] = json!({"nodes":[{"commit":{"statusCheckRollup":{"contexts":{ - "totalCount":1,"nodes":[{"name":"ci","isRequired":true,"conclusion":"SUCCESS"}] + "totalCount":1,"nodes":[{"name":"ci","isRequired":true,"status":"COMPLETED","conclusion":"SUCCESS"}] }}}}]}); detail["data"]["repository"]["pullRequests"]["nodes"][0]["headRefOid"] = head.into(); fs::write(env.work().join("first.json"), detail.to_string()).unwrap(); From 402f6d156da35e12b938e965d8161211263a9d23 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 01:16:40 +0100 Subject: [PATCH 16/16] fix(board): wait for required check completion before reading its conclusion --- oxa/oxa-cli/src/work_board.rs | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/oxa/oxa-cli/src/work_board.rs b/oxa/oxa-cli/src/work_board.rs index 869b20f1..cc74a24f 100644 --- a/oxa/oxa-cli/src/work_board.rs +++ b/oxa/oxa-cli/src/work_board.rs @@ -296,6 +296,15 @@ fn nodes(value: &Value) -> Result<&Vec, String> { Ok(rows) } +fn check_outcome(check: &Value) -> Option<&str> { + match check["status"].as_str() { + Some("COMPLETED") => check["conclusion"].as_str(), + // GitHub can retain a prior conclusion while the check is active. + Some(_) => None, + None => check["state"].as_str(), + } +} + fn required_contexts(base: &Value) -> Result, String> { if !base.is_object() { return Err("missing PR base requirements".into()); @@ -419,7 +428,7 @@ impl Reader<'_> { }; let required_ci = if checks.iter().any(|c| { matches!( - c["state"].as_str().or(c["conclusion"].as_str()), + check_outcome(c), Some( "FAILURE" | "ERROR" @@ -438,12 +447,9 @@ impl Reader<'_> { .iter() .any(|c| c["name"].as_str().or(c["context"].as_str()) == Some(*name)) }) - || checks.iter().any(|c| { - !matches!( - c["state"].as_str().or(c["conclusion"].as_str()), - Some("SUCCESS" | "NEUTRAL" | "SKIPPED") - ) - }) + || checks + .iter() + .any(|c| !matches!(check_outcome(c), Some("SUCCESS" | "NEUTRAL" | "SKIPPED"))) { RequiredCi::Pending } else {