From 8a426a3bd4716b6975f569e12978154892cd1f81 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 16:17:13 +0100 Subject: [PATCH 01/17] feat(work): reserve durable board leases and attempts atomically (#1017) --- oxa/docs/work.md | 12 +- oxa/oxa-work/src/board.rs | 3 + oxa/oxa-work/src/board/claims.rs | 206 +++++++++++++++++++++++++++++ oxa/oxa-work/tests/board_claims.rs | 169 +++++++++++++++++++++++ 4 files changed, 387 insertions(+), 3 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims.rs create mode 100644 oxa/oxa-work/tests/board_claims.rs diff --git a/oxa/docs/work.md b/oxa/docs/work.md index 1d6f6791c..230e8a422 100644 --- a/oxa/docs/work.md +++ b/oxa/docs/work.md @@ -10,9 +10,15 @@ Active leases and a per-PR UTC daily attempt cap make entries ineligible without hiding them. Snapshot adapters must supply the complete open set, current-head required checks, unresolved findings, source-removal facts and review-policy approval for the PR's own diff. Callers -own durable state and must reserve attempts and leases atomically before acting; -this read-only core neither claims work nor writes to GitHub. CLI/shadow polling -is a separate adapter. +select private repository-scoped claim storage outside worker-writable binds. +`Claims::open(root).snapshot()` supplies durable state for `Board::read`. +Before dispatch, `claim(entry, policy, holder, now, ttl)` atomically reserves a +lease and an attempt under a kernel file lock, then syncs state before returning. +The default daily cap is three; a crash after reservation consumes an attempt. +`release(number, lease)` fences stale workers and never refunds attempts. Active +leases survive UTC midnight; corrupt/missing established state fails closed. +Execution, fresh-head validation and CLI polling remain in the adapter; core +claim storage never spawns workers or writes to GitHub. `oxa work tasks.json` opts into sequential tasks in separate git worktrees. Run it inside the project repository. The JSON file is an array: diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 00a93c3f3..9c98e6402 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -2,6 +2,9 @@ use serde::{Deserialize, Serialize}; use std::collections::{BTreeMap, BTreeSet}; +mod claims; +pub use claims::Claims; + #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] #[serde(rename_all = "snake_case")] pub enum Action { diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs new file mode 100644 index 000000000..5acbfb00c --- /dev/null +++ b/oxa/oxa-work/src/board/claims.rs @@ -0,0 +1,206 @@ +//! Durable reservations only; execution and GitHub writes are outside this API. +use super::{Action, AttemptState, Entry, Lease, Policy}; +use crate::Result; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::fs::{self, File, OpenOptions}; +use std::io::Read; +use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; +use std::path::{Path, PathBuf}; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Saved { + version: u8, + number: u64, + state: AttemptState, +} + +fn io(value: std::io::Result) -> Result { + value.map_err(|e| format!("board claim storage: {:?}", e.kind())) +} + +/// One repository's user-selected private directory, outside worker-writable binds. +/// The caller creates it; opening a store never starts work or contacts GitHub. +#[derive(Clone)] +pub struct Claims { + root: PathBuf, + uid: u32, +} + +impl Claims { + pub fn open(root: &Path) -> Result { + let metadata = io(fs::symlink_metadata(root))?; + if !metadata.is_dir() || metadata.mode() & 0o077 != 0 || io(root.canonicalize())? != root { + return Err("board claims require a canonical private directory".into()); + } + Ok(Self { + root: root.into(), + uid: metadata.uid(), + }) + } + + fn path(&self, number: u64) -> PathBuf { + self.root.join(format!("{number}.board-claim.json")) + } + + fn private(&self, path: &Path) -> Result<()> { + let metadata = io(fs::symlink_metadata(path))?; + if !metadata.is_file() || metadata.mode() & 0o077 != 0 || metadata.uid() != self.uid { + return Err("board claim file is not private".into()); + } + Ok(()) + } + + fn lock(&self, number: u64) -> Result<(File, bool)> { + if Self::open(&self.root)?.uid != self.uid || number == 0 { + return Err("invalid board claim directory or PR".into()); + } + let path = self.root.join(format!("{number}.board-claim.lock")); + let (file, fresh) = match OpenOptions::new() + .write(true) + .create_new(true) + .mode(0o600) + .open(&path) + { + Ok(file) => (file, true), + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => { + self.private(&path)?; + (io(OpenOptions::new().read(true).write(true).open(&path))?, false) + } + Err(e) => return io(Err(e)), + }; + self.private(&path)?; + io(file.lock())?; + Ok((file, fresh)) + } + + fn load(&self, number: u64, fresh: bool) -> Result { + let path = self.path(number); + match fs::symlink_metadata(&path) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound && fresh => return Ok(AttemptState::default()), + Err(e) => return io(Err(e)), + Ok(_) => self.private(&path)?, + } + let mut bytes = vec![]; + io(io(File::open(&path))?.take(4097).read_to_end(&mut bytes))?; + if bytes.len() > 4096 { + return Err("board claim file exceeds capacity".into()); + } + let saved: Saved = serde_json::from_slice(&bytes).map_err(|_| "invalid board claim state")?; + if saved.version != 1 + || saved.number != number + || saved.state.lease.as_ref().is_some_and(|l| { + saved.state.attempts == 0 || !crate::valid_task_id(&l.holder) || l.expires_at == 0 + }) + { + return Err("invalid board claim identity or lease".into()); + } + Ok(saved.state) + } + + fn save(&self, number: u64, state: AttemptState, fresh: bool) -> Result<()> { + let bytes = serde_json::to_vec(&Saved { + version: 1, + number, + state, + }) + .map_err(|_| "cannot encode board claim state")?; + crate::checkpoint::write_atomic(&self.path(number), &bytes, !fresh) + .map_err(|_| "cannot durably reserve board claim".into()) + } + + /// Atomic replacements permit a coherent per-PR read without taking execution leases. + pub fn snapshot(&self) -> Result> { + Self::open(&self.root)?; + let mut states = BTreeMap::new(); + for entry in io(fs::read_dir(&self.root))? { + let name = io(entry)?.file_name(); + let Some(id) = name.to_str().and_then(|s| { + s.strip_suffix(".board-claim.json") + .or_else(|| s.strip_suffix(".board-claim.lock")) + }) else { + continue; + }; + let number = id.parse::().map_err(|_| "invalid board claim filename")?; + if number == 0 || id != number.to_string() { + return Err("invalid board claim filename".into()); + } + states.insert(number, self.load(number, false)?); + } + Ok(states) + } + + /// Reserve before dispatch. A crash after reservation consumes an attempt conservatively. + /// The caller must use a fresh GitHub entry and revalidate its head before external effects. + pub fn claim( + &self, + entry: &Entry, + policy: &Policy, + holder: &str, + now: u64, + ttl: u64, + ) -> Result> { + if !policy.enabled + || policy.max_attempts_per_day == 0 + || !entry.eligible + || matches!( + entry.action, + Action::WaitReview | Action::WaitRequiredCi | Action::WaitMergeability + ) + { + return Ok(None); + } + let expires_at = now + .checked_add(ttl) + .filter(|_| ttl > 0) + .ok_or("invalid board lease duration")?; + if entry.number == 0 || entry.head.is_empty() || !crate::valid_task_id(holder) { + return Err("invalid board claim request".into()); + } + let (_lock, fresh) = self.lock(entry.number)?; + let mut state = self.load(entry.number, fresh)?; + let day = now / 86_400; + if state.utc_day > day { + return Err("board claim clock moved backwards".into()); + } + if state.lease.as_ref().is_some_and(|l| l.expires_at > now) { + return Ok(None); + } + if state.utc_day < day { + state.utc_day = day; + state.attempts = 0; + } + if state.attempts >= policy.max_attempts_per_day { + return Ok(None); + } + state.attempts = state + .attempts + .checked_add(1) + .ok_or("board attempt count exhausted")?; + let lease = Lease { + holder: holder.into(), + expires_at, + }; + state.lease = Some(lease.clone()); + self.save(entry.number, state, fresh)?; + Ok(Some(lease)) + } + + /// An old worker cannot release a replacement lease. Attempts are never refunded. + pub fn release(&self, number: u64, lease: &Lease) -> Result { + match fs::symlink_metadata(self.path(number)) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(false), + Err(e) => return io(Err(e)), + Ok(_) => {} + } + let (_lock, _) = self.lock(number)?; + let mut state = self.load(number, false)?; + if state.lease.as_ref() != Some(lease) { + return Ok(false); + } + state.lease = None; + self.save(number, state, false)?; + Ok(true) + } +} diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs new file mode 100644 index 000000000..d0dffbc5b --- /dev/null +++ b/oxa/oxa-work/tests/board_claims.rs @@ -0,0 +1,169 @@ +use oxa_work::board::*; +use std::{collections::BTreeMap, fs, os::unix::fs::DirBuilderExt, path::PathBuf, process::Command}; + +struct Fixture(PathBuf); +impl Fixture { + fn new() -> Self { + static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); + let path = std::env::temp_dir().join(format!( + "oxa-board-claims-{}-{}", + std::process::id(), + NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + )); + fs::DirBuilder::new().mode(0o700).create(&path).unwrap(); + Self(path.canonicalize().unwrap()) + } + fn store(&self) -> Claims { + Claims::open(&self.0).unwrap() + } +} +impl Drop for Fixture { + fn drop(&mut self) { + fs::remove_dir_all(&self.0).unwrap(); + } +} +struct FakeGitHub; +impl GitHub for FakeGitHub { + fn open_pull_requests(&mut self) -> oxa_work::Result> { + Ok(vec![PullRequest { + number: 1, + head: "synthetic-head".into(), + release_pinned: true, + findings: true, + required_ci: RequiredCi::Passed, + mergeability: Mergeability::Mergeable, + body: String::new(), + removes_source: false, + draft: false, + reviewed: false, + }]) + } +} +fn policy() -> Policy { + Policy { + enabled: true, + ..Policy::default() + } +} +fn entry() -> Entry { + Board::read(&mut FakeGitHub, &policy(), &BTreeMap::new(), 0) + .unwrap() + .entries + .remove(0) +} + +#[test] +fn disabled_and_zero_cap_do_not_create_claim_files() { + let fixture = Fixture::new(); + let store = fixture.store(); + for policy in [ + Policy::default(), + Policy { + enabled: true, + max_attempts_per_day: 0, + }, + ] { + assert!(store + .claim(&entry(), &policy, "worker-a", 10, 10) + .unwrap() + .is_none()); + } + assert!(store.snapshot().unwrap().is_empty()); + assert_eq!(fs::read_dir(&fixture.0).unwrap().count(), 0); +} + +#[test] +fn durable_daily_cap_and_stale_release_fencing() { + let fixture = Fixture::new(); + let store = fixture.store(); + let first = store + .claim(&entry(), &policy(), "worker-a", 10, 10) + .unwrap() + .unwrap(); + assert!(fixture + .store() + .claim(&entry(), &policy(), "worker-b", 19, 10) + .unwrap() + .is_none()); + let second = fixture + .store() + .claim(&entry(), &policy(), "worker-b", 20, 10) + .unwrap() + .unwrap(); + assert!(!store.release(1, &first).unwrap()); + assert!(store.release(1, &second).unwrap()); + let third = store + .claim(&entry(), &policy(), "worker-c", 21, 10) + .unwrap() + .unwrap(); + assert!(store.release(1, &third).unwrap()); + assert!(fixture + .store() + .claim(&entry(), &policy(), "worker-d", 22, 10) + .unwrap() + .is_none()); + assert_eq!(store.snapshot().unwrap()[&1].attempts, 3); + assert!(store + .claim(&entry(), &policy(), "worker-e", 86_400, 10) + .unwrap() + .is_some()); + assert_eq!(fixture.store().snapshot().unwrap()[&1].attempts, 1); +} + +#[test] +fn midnight_does_not_revoke_a_lease_and_clock_rollback_refuses() { + let fixture = Fixture::new(); + let store = fixture.store(); + store + .claim(&entry(), &policy(), "worker-a", 86_399, 5) + .unwrap() + .unwrap(); + assert!(store + .claim(&entry(), &policy(), "worker-b", 86_400, 5) + .unwrap() + .is_none()); + assert!(store + .claim(&entry(), &policy(), "worker-b", 86_404, 5) + .unwrap() + .is_some()); + assert!(store.claim(&entry(), &policy(), "worker-c", 0, 5).is_err()); +} + +#[test] +fn claim_child() { + let Some(root) = std::env::var_os("OXA_BOARD_CLAIM_TEST_ROOT") else { + return; + }; + let store = Claims::open(&PathBuf::from(root)).unwrap(); + if store + .claim(&entry(), &policy(), "worker-child", 10, 10) + .unwrap() + .is_some() + { + println!("BOARD_CLAIMED"); + } +} + +#[test] +fn concurrent_processes_reserve_exactly_one_attempt() { + let fixture = Fixture::new(); + let children: Vec<_> = (0..6) + .map(|_| { + Command::new(std::env::current_exe().unwrap()) + .args(["--exact", "claim_child", "--nocapture"]) + .env_clear() + .env("OXA_BOARD_CLAIM_TEST_ROOT", &fixture.0) + .stdout(std::process::Stdio::piped()) + .spawn() + .unwrap() + }) + .collect(); + let mut winners = 0; + for child in children { + let out = child.wait_with_output().unwrap(); + assert!(out.status.success()); + winners += usize::from(String::from_utf8(out.stdout).unwrap().contains("BOARD_CLAIMED")); + } + assert_eq!(winners, 1); + assert_eq!(fixture.store().snapshot().unwrap()[&1].attempts, 1); +} From ba694005492dadc80ca3795f842f9104143bc48d Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 16:18:57 +0100 Subject: [PATCH 02/17] test(work): cover poisoned claims and serialize first reservation (#1017) --- oxa/oxa-work/src/board/claims.rs | 8 ++- oxa/oxa-work/tests/board_claims.rs | 78 +++++++++++++++--------------- 2 files changed, 45 insertions(+), 41 deletions(-) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 5acbfb00c..c2eeada12 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -56,6 +56,10 @@ impl Claims { if Self::open(&self.root)?.uid != self.uid || number == 0 { return Err("invalid board claim directory or PR".into()); } + // Lock the existing directory inode before creating any per-PR marker. + // Otherwise a contender could lock a new marker before its creator does. + let lock = io(File::open(&self.root))?; + io(lock.lock())?; let path = self.root.join(format!("{number}.board-claim.lock")); let (file, fresh) = match OpenOptions::new() .write(true) @@ -71,8 +75,8 @@ impl Claims { Err(e) => return io(Err(e)), }; self.private(&path)?; - io(file.lock())?; - Ok((file, fresh)) + drop(file); + Ok((lock, fresh)) } fn load(&self, number: u64, fresh: bool) -> Result { diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index d0dffbc5b..ea09a7cfa 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -16,6 +16,11 @@ impl Fixture { fn store(&self) -> Claims { Claims::open(&self.0).unwrap() } + fn claim(&self, now: u64, ttl: u64) -> Option { + self.store() + .claim(&entry(), &policy(), "worker", now, ttl) + .unwrap() + } } impl Drop for Fixture { fn drop(&mut self) { @@ -76,37 +81,16 @@ fn disabled_and_zero_cap_do_not_create_claim_files() { fn durable_daily_cap_and_stale_release_fencing() { let fixture = Fixture::new(); let store = fixture.store(); - let first = store - .claim(&entry(), &policy(), "worker-a", 10, 10) - .unwrap() - .unwrap(); - assert!(fixture - .store() - .claim(&entry(), &policy(), "worker-b", 19, 10) - .unwrap() - .is_none()); - let second = fixture - .store() - .claim(&entry(), &policy(), "worker-b", 20, 10) - .unwrap() - .unwrap(); + let first = fixture.claim(10, 10).unwrap(); + assert!(fixture.claim(19, 10).is_none()); + let second = fixture.claim(20, 10).unwrap(); assert!(!store.release(1, &first).unwrap()); assert!(store.release(1, &second).unwrap()); - let third = store - .claim(&entry(), &policy(), "worker-c", 21, 10) - .unwrap() - .unwrap(); + let third = fixture.claim(21, 10).unwrap(); assert!(store.release(1, &third).unwrap()); - assert!(fixture - .store() - .claim(&entry(), &policy(), "worker-d", 22, 10) - .unwrap() - .is_none()); + assert!(fixture.claim(22, 10).is_none()); assert_eq!(store.snapshot().unwrap()[&1].attempts, 3); - assert!(store - .claim(&entry(), &policy(), "worker-e", 86_400, 10) - .unwrap() - .is_some()); + assert!(fixture.claim(86_400, 10).is_some()); assert_eq!(fixture.store().snapshot().unwrap()[&1].attempts, 1); } @@ -114,21 +98,37 @@ fn durable_daily_cap_and_stale_release_fencing() { fn midnight_does_not_revoke_a_lease_and_clock_rollback_refuses() { let fixture = Fixture::new(); let store = fixture.store(); - store - .claim(&entry(), &policy(), "worker-a", 86_399, 5) - .unwrap() - .unwrap(); - assert!(store - .claim(&entry(), &policy(), "worker-b", 86_400, 5) - .unwrap() - .is_none()); - assert!(store - .claim(&entry(), &policy(), "worker-b", 86_404, 5) - .unwrap() - .is_some()); + fixture.claim(86_399, 5).unwrap(); + assert!(fixture.claim(86_400, 5).is_none()); + assert!(fixture.claim(86_404, 5).is_some()); assert!(store.claim(&entry(), &policy(), "worker-c", 0, 5).is_err()); } +#[test] +fn missing_corrupt_symlinked_or_public_state_never_resets_the_cap() { + use std::os::unix::fs::{symlink, PermissionsExt}; + for poison in ["missing", "corrupt", "symlink", "public"] { + let fixture = Fixture::new(); + fixture.claim(10, 10).unwrap(); + let path = fixture.0.join("1.board-claim.json"); + match poison { + "missing" => fs::remove_file(&path).unwrap(), + "corrupt" => fs::write(&path, b"not valid state").unwrap(), + "symlink" => { + fs::rename(&path, fixture.0.join("outside")).unwrap(); + symlink(fixture.0.join("outside"), &path).unwrap(); + } + _ => fs::set_permissions(&path, fs::Permissions::from_mode(0o644)).unwrap(), + } + let store = fixture.store(); + assert!(store.snapshot().is_err(), "{poison}"); + assert!( + store.claim(&entry(), &policy(), "worker", 30, 10).is_err(), + "{poison}" + ); + } +} + #[test] fn claim_child() { let Some(root) = std::env::var_os("OXA_BOARD_CLAIM_TEST_ROOT") else { From 3cdd364f83ebdf5470febf0339fff728544ebebf Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 16:33:40 +0100 Subject: [PATCH 03/17] test(work): reproduce repeated lease identity and concurrent snapshots (#1017) --- oxa/oxa-work/tests/board_claims.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index ea09a7cfa..6bf7cc7e0 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -83,7 +83,8 @@ fn durable_daily_cap_and_stale_release_fencing() { let store = fixture.store(); let first = fixture.claim(10, 10).unwrap(); assert!(fixture.claim(19, 10).is_none()); - let second = fixture.claim(20, 10).unwrap(); + assert!(store.release(1, &first).unwrap()); + let second = fixture.claim(10, 10).unwrap(); assert!(!store.release(1, &first).unwrap()); assert!(store.release(1, &second).unwrap()); let third = fixture.claim(21, 10).unwrap(); @@ -159,6 +160,9 @@ fn concurrent_processes_reserve_exactly_one_attempt() { }) .collect(); let mut winners = 0; + for _ in 0..256 { + fixture.store().snapshot().unwrap(); + } for child in children { let out = child.wait_with_output().unwrap(); assert!(out.status.success()); From e6a2185222ff5612f05017beec50b751a77b59ed Mon Sep 17 00:00:00 2001 From: Oscar Nordstrom <13300531+n0rpan@users.noreply.github.com> Date: Tue, 17 Nov 2026 16:34:31 +0100 Subject: [PATCH 04/17] fix(work): never let a per-PR marker decide the claim write mode (#1017) The per-PR marker was created inside `lock`, so "first access" was really "marker file missing". The only thing named `.lock`, a marker is the file an operator or a cleanup step would delete. Losing it made every later `claim` take the create-only branch, which fails on the intact, authoritative state file: that PR's claims were permanently bricked although its attempts were still on disk and had to be counted. Creation now keys on the authoritative state file itself, so a missing marker can never block a reservation. Whether a PR has ever been reserved is a separate, explicit fact: a private `.board-claim.created` marker written only after the state file is durable, so it can only under-claim, never hide a cap. First access is unaffected; a state file lost after that marker still fails closed, so a deleted reservation cannot reset the daily cap. Also drops the now-unused `fresh` return value and reads private markers with an explicit read-only open, and documents the rule in oxa/docs/work.md. Tests: board_claims::lost_marker_keeps_the_cap_but_lost_state_still_fails_closed covers both directions; the existing poisoned-state and concurrent-process cases still pin fail-closed first access and single reservation. --- oxa/docs/work.md | 6 +-- oxa/oxa-work/src/board/claims.rs | 79 +++++++++++++++++++++++------- oxa/oxa-work/tests/board_claims.rs | 21 ++++++++ 3 files changed, 86 insertions(+), 20 deletions(-) diff --git a/oxa/docs/work.md b/oxa/docs/work.md index 230e8a422..8c317783d 100644 --- a/oxa/docs/work.md +++ b/oxa/docs/work.md @@ -16,9 +16,9 @@ Before dispatch, `claim(entry, policy, holder, now, ttl)` atomically reserves a lease and an attempt under a kernel file lock, then syncs state before returning. The default daily cap is three; a crash after reservation consumes an attempt. `release(number, lease)` fences stale workers and never refunds attempts. Active -leases survive UTC midnight; corrupt/missing established state fails closed. -Execution, fresh-head validation and CLI polling remain in the adapter; core -claim storage never spawns workers or writes to GitHub. +leases survive UTC midnight; corrupt state, or state that vanished after a PR's +first reservation, fails closed. Execution, fresh-head validation and CLI polling +remain in the adapter; core claim storage never spawns workers or writes to GitHub. `oxa work tasks.json` opts into sequential tasks in separate git worktrees. Run it inside the project repository. The JSON file is an array: diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index c2eeada12..59b1be479 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -4,7 +4,7 @@ use crate::Result; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use std::fs::{self, File, OpenOptions}; -use std::io::Read; +use std::io::{Read, Write}; use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; use std::path::{Path, PathBuf}; @@ -52,7 +52,9 @@ impl Claims { Ok(()) } - fn lock(&self, number: u64) -> Result<(File, bool)> { + /// Take the store lock and make sure this PR's marker exists. A marker is created + /// only under the lock, so it never records a reservation that was not attempted. + fn lock(&self, number: u64) -> Result { if Self::open(&self.root)?.uid != self.uid || number == 0 { return Err("invalid board claim directory or PR".into()); } @@ -61,28 +63,36 @@ impl Claims { let lock = io(File::open(&self.root))?; io(lock.lock())?; let path = self.root.join(format!("{number}.board-claim.lock")); - let (file, fresh) = match OpenOptions::new() + let file = match OpenOptions::new() .write(true) .create_new(true) .mode(0o600) .open(&path) { - Ok(file) => (file, true), + Ok(file) => file, Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => { - self.private(&path)?; - (io(OpenOptions::new().read(true).write(true).open(&path))?, false) + io(OpenOptions::new().read(true).write(true).open(&path))? } Err(e) => return io(Err(e)), }; - self.private(&path)?; drop(file); - Ok((lock, fresh)) + self.private(&path)?; + Ok(lock) } - fn load(&self, number: u64, fresh: bool) -> Result { + /// First access to a PR counts. A state file lost after a marker exists is still + /// corruption, so a vanished marker must not reset the cap by faking a first access. + fn load(&self, number: u64) -> Result { let path = self.path(number); + let created = self.root.join(format!("{number}.board-claim.created")); match fs::symlink_metadata(&path) { - Err(e) if e.kind() == std::io::ErrorKind::NotFound && fresh => return Ok(AttemptState::default()), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => { + return match fs::symlink_metadata(&created) { + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(AttemptState::default()), + Ok(_) => Err("board claim state is missing; recovery is required".into()), + Err(e) => io(Err(e)), + }; + } Err(e) => return io(Err(e)), Ok(_) => self.private(&path)?, } @@ -103,17 +113,28 @@ impl Claims { Ok(saved.state) } - fn save(&self, number: u64, state: AttemptState, fresh: bool) -> Result<()> { + fn save(&self, number: u64, state: AttemptState, replacing: bool) -> Result<()> { let bytes = serde_json::to_vec(&Saved { version: 1, number, state, }) .map_err(|_| "cannot encode board claim state")?; - crate::checkpoint::write_atomic(&self.path(number), &bytes, !fresh) + crate::checkpoint::write_atomic(&self.path(number), &bytes, replacing) .map_err(|_| "cannot durably reserve board claim".into()) } + /// Whether the authoritative state file is already on disk. The per-PR marker only + /// records that a reservation started, so it must never decide create-versus-replace: + /// losing a marker may not brick a PR whose attempts still have to be counted. + fn established(&self, number: u64) -> Result { + match fs::symlink_metadata(self.path(number)) { + Ok(_) => Ok(true), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false), + Err(e) => io(Err(e)), + } + } + /// Atomic replacements permit a coherent per-PR read without taking execution leases. pub fn snapshot(&self) -> Result> { Self::open(&self.root)?; @@ -130,7 +151,7 @@ impl Claims { if number == 0 || id != number.to_string() { return Err("invalid board claim filename".into()); } - states.insert(number, self.load(number, false)?); + states.insert(number, self.load(number)?); } Ok(states) } @@ -162,8 +183,8 @@ impl Claims { if entry.number == 0 || entry.head.is_empty() || !crate::valid_task_id(holder) { return Err("invalid board claim request".into()); } - let (_lock, fresh) = self.lock(entry.number)?; - let mut state = self.load(entry.number, fresh)?; + let _lock = self.lock(entry.number)?; + let mut state = self.load(entry.number)?; let day = now / 86_400; if state.utc_day > day { return Err("board claim clock moved backwards".into()); @@ -187,10 +208,34 @@ impl Claims { expires_at, }; state.lease = Some(lease.clone()); - self.save(entry.number, state, fresh)?; + let replacing = self.established(entry.number)?; + self.save(entry.number, state, replacing)?; + if !replacing { + self.mark(entry.number)?; + } Ok(Some(lease)) } + /// Record that this PR has established state. Written only after the state file is + /// durable, so a marker can only ever claim too little, never hide a lost cap. + fn mark(&self, number: u64) -> Result<()> { + let path = self.root.join(format!("{number}.board-claim.created")); + match OpenOptions::new() + .write(true) + .create_new(true) + .mode(0o600) + .open(&path) + { + Ok(mut file) => { + io(io(file.write_all(b"1\n"))?.sync_all())?; + io(File::open(&self.root)?.sync_all())?; + Ok(()) + } + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(()), + Err(e) => io(Err(e)), + } + } + /// An old worker cannot release a replacement lease. Attempts are never refunded. pub fn release(&self, number: u64, lease: &Lease) -> Result { match fs::symlink_metadata(self.path(number)) { @@ -199,7 +244,7 @@ impl Claims { Ok(_) => {} } let (_lock, _) = self.lock(number)?; - let mut state = self.load(number, false)?; + let mut state = self.load(number)?; if state.lease.as_ref() != Some(lease) { return Ok(false); } diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index ea09a7cfa..43d903f80 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -129,6 +129,27 @@ fn missing_corrupt_symlinked_or_public_state_never_resets_the_cap() { } } +#[test] +fn lost_marker_keeps_the_cap_but_lost_state_still_fails_closed() { + let fixture = Fixture::new(); + let store = fixture.store(); + assert!(fixture.claim(10, 10).is_some()); + // A disposable-looking marker must not decide whether the attempts on disk count. + fs::remove_file(fixture.0.join("1.board-claim.lock")).unwrap(); + assert!(fixture.claim(20, 10).is_some()); + assert_eq!(fixture.store().snapshot().unwrap()[&1].attempts, 2); + // The reverse is corruption: attempts whose state file vanished are never reset. + let vanished = Fixture::new(); + assert!(vanished.claim(10, 10).is_some()); + fs::remove_file(vanished.0.join("1.board-claim.json")).unwrap(); + fs::remove_file(vanished.0.join("1.board-claim.lock")).unwrap(); + assert!(vanished.store().snapshot().is_err()); + assert!(vanished + .store() + .claim(&entry(), &policy(), "worker", 20, 10) + .is_err()); +} + #[test] fn claim_child() { let Some(root) = std::env::var_os("OXA_BOARD_CLAIM_TEST_ROOT") else { From e9118cfa458501a772160d27505549e039b66e06 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 16:47:13 +0100 Subject: [PATCH 05/17] fix(work): retain helper claim delta and repair its compile errors (#1017) --- oxa/oxa-work/src/board/claims.rs | 6 +++--- oxa/oxa-work/tests/board_claims.rs | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 59b1be479..489b8191a 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -227,8 +227,8 @@ impl Claims { .open(&path) { Ok(mut file) => { - io(io(file.write_all(b"1\n"))?.sync_all())?; - io(File::open(&self.root)?.sync_all())?; + io(file.write_all(b"1\n").and_then(|()| file.sync_all()))?; + io(io(File::open(&self.root))?.sync_all())?; Ok(()) } Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(()), @@ -243,7 +243,7 @@ impl Claims { Err(e) => return io(Err(e)), Ok(_) => {} } - let (_lock, _) = self.lock(number)?; + let _lock = self.lock(number)?; let mut state = self.load(number)?; if state.lease.as_ref() != Some(lease) { return Ok(false); diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index 2073464ee..6644872c4 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -138,7 +138,7 @@ fn lost_marker_keeps_the_cap_but_lost_state_still_fails_closed() { // A disposable-looking marker must not decide whether the attempts on disk count. fs::remove_file(fixture.0.join("1.board-claim.lock")).unwrap(); assert!(fixture.claim(20, 10).is_some()); - assert_eq!(fixture.store().snapshot().unwrap()[&1].attempts, 2); + assert_eq!(store.snapshot().unwrap()[&1].attempts, 2); // The reverse is corruption: attempts whose state file vanished are never reset. let vanished = Fixture::new(); assert!(vanished.claim(10, 10).is_some()); From 266f37e7dba95e26e895cea2248655ccce0c509c Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 17:26:42 +0100 Subject: [PATCH 06/17] fix(work): serialize claim snapshots and replace release state (#1017) --- oxa/oxa-work/src/board/claims.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 489b8191a..fabd3bd78 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -138,12 +138,15 @@ impl Claims { /// Atomic replacements permit a coherent per-PR read without taking execution leases. pub fn snapshot(&self) -> Result> { Self::open(&self.root)?; + let lock = io(File::open(&self.root))?; + io(lock.lock())?; let mut states = BTreeMap::new(); for entry in io(fs::read_dir(&self.root))? { let name = io(entry)?.file_name(); let Some(id) = name.to_str().and_then(|s| { s.strip_suffix(".board-claim.json") .or_else(|| s.strip_suffix(".board-claim.lock")) + .or_else(|| s.strip_suffix(".board-claim.created")) }) else { continue; }; @@ -249,7 +252,7 @@ impl Claims { return Ok(false); } state.lease = None; - self.save(number, state, false)?; + self.save(number, state, true)?; Ok(true) } } From b4d8ce4e0db3e88e791d7f9b9305f72d280ad953 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 17:43:32 +0100 Subject: [PATCH 07/17] fix(work): fence repeated reservations and accept canonical worker IDs (#1017) --- oxa/oxa-work/src/board.rs | 9 +++++++++ oxa/oxa-work/src/board/claims.rs | 21 +++++++++++++-------- oxa/oxa-work/tests/board.rs | 2 ++ oxa/oxa-work/tests/board_claims.rs | 2 +- 4 files changed, 25 insertions(+), 9 deletions(-) diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 9c98e6402..c5729c3b0 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -60,6 +60,15 @@ pub trait GitHub { pub struct Lease { pub holder: String, pub expires_at: u64, + #[serde(default)] + pub claimed_at: Option, + /// UTC admission day and its non-refunded attempt ordinal identify this reservation. + #[serde(default)] + pub generation: (u64, u32), +} + +pub fn valid_worker_id(id: &str) -> bool { + !id.is_empty() && id.len() <= 128 && id.split([':', '/']).all(crate::valid_task_id) } #[derive(Clone, Debug, Default, Deserialize, Serialize)] diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index fabd3bd78..e6205af5e 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -1,5 +1,5 @@ //! Durable reservations only; execution and GitHub writes are outside this API. -use super::{Action, AttemptState, Entry, Lease, Policy}; +use super::{valid_worker_id, Action, AttemptState, Entry, Lease, Policy}; use crate::Result; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -71,7 +71,8 @@ impl Claims { { Ok(file) => file, Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => { - io(OpenOptions::new().read(true).write(true).open(&path))? + self.private(&path)?; + io(File::open(&path))? } Err(e) => return io(Err(e)), }; @@ -105,7 +106,11 @@ impl Claims { if saved.version != 1 || saved.number != number || saved.state.lease.as_ref().is_some_and(|l| { - saved.state.attempts == 0 || !crate::valid_task_id(&l.holder) || l.expires_at == 0 + saved.state.attempts == 0 + || !valid_worker_id(&l.holder) + || l.expires_at == 0 + || l.generation != (saved.state.utc_day, saved.state.attempts) + || l.claimed_at.is_none_or(|at| at >= l.expires_at) }) { return Err("invalid board claim identity or lease".into()); @@ -183,7 +188,7 @@ impl Claims { .checked_add(ttl) .filter(|_| ttl > 0) .ok_or("invalid board lease duration")?; - if entry.number == 0 || entry.head.is_empty() || !crate::valid_task_id(holder) { + if entry.number == 0 || entry.head.is_empty() || !valid_worker_id(holder) { return Err("invalid board claim request".into()); } let _lock = self.lock(entry.number)?; @@ -209,13 +214,13 @@ impl Claims { let lease = Lease { holder: holder.into(), expires_at, + claimed_at: Some(now), + generation: (day, state.attempts), }; state.lease = Some(lease.clone()); let replacing = self.established(entry.number)?; self.save(entry.number, state, replacing)?; - if !replacing { - self.mark(entry.number)?; - } + self.mark(entry.number)?; Ok(Some(lease)) } @@ -234,7 +239,7 @@ impl Claims { io(io(File::open(&self.root))?.sync_all())?; Ok(()) } - Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(()), + Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => self.private(&path), Err(e) => io(Err(e)), } } diff --git a/oxa/oxa-work/tests/board.rs b/oxa/oxa-work/tests/board.rs index f617dcca9..0819cc998 100644 --- a/oxa/oxa-work/tests/board.rs +++ b/oxa/oxa-work/tests/board.rs @@ -98,6 +98,8 @@ fn release_priority_lease_expiry_and_daily_attempt_cap() { lease: Some(Lease { holder: "worker-a".into(), expires_at: 86_410, + claimed_at: Some(86_400), + generation: (1, 2), }), }, )]); diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index 6644872c4..174823527 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -18,7 +18,7 @@ impl Fixture { } fn claim(&self, now: u64, ttl: u64) -> Option { self.store() - .claim(&entry(), &policy(), "worker", now, ttl) + .claim(&entry(), &policy(), "codex:node/slot-1", now, ttl) .unwrap() } } From ef3931860635b399220c43e7f93d73babb22204a Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:12:02 +0100 Subject: [PATCH 08/17] test(work): expose creation-witness gap on refused claims (#1017) --- oxa/oxa-work/tests/board_claims.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/oxa/oxa-work/tests/board_claims.rs b/oxa/oxa-work/tests/board_claims.rs index 174823527..5bf1889ff 100644 --- a/oxa/oxa-work/tests/board_claims.rs +++ b/oxa/oxa-work/tests/board_claims.rs @@ -166,6 +166,28 @@ fn claim_child() { } } +#[test] +fn active_and_capped_claims_repair_the_missing_creation_witness() { + for now in [11, 21] { + let fixture = Fixture::new(); + fixture.claim(10, 10).unwrap(); + fs::remove_file(fixture.0.join("1.board-claim.created")).unwrap(); + let capped = Policy { + enabled: true, + max_attempts_per_day: 1, + }; + assert!(fixture + .store() + .claim(&entry(), &capped, "worker", now, 10) + .unwrap() + .is_none()); + assert!(fixture.0.join("1.board-claim.created").exists()); + fs::remove_file(fixture.0.join("1.board-claim.json")).unwrap(); + fs::remove_file(fixture.0.join("1.board-claim.lock")).unwrap(); + assert!(fixture.store().snapshot().is_err()); + } +} + #[test] fn concurrent_processes_reserve_exactly_one_attempt() { let fixture = Fixture::new(); From 98f47ec7b470e7b48de0fd7ea62bdff26aa1fde4 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:22:48 +0100 Subject: [PATCH 09/17] fix(work): repair claim witnesses before admission refusal (#1017) --- oxa/oxa-work/src/board/claims.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index e6205af5e..da7ca42fb 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -193,6 +193,9 @@ impl Claims { } let _lock = self.lock(entry.number)?; let mut state = self.load(entry.number)?; + if self.established(entry.number)? { + self.mark(entry.number)?; + } let day = now / 86_400; if state.utc_day > day { return Err("board claim clock moved backwards".into()); From ba7718e6bd7467b061f886335ed3446088ece09f Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:29:18 +0100 Subject: [PATCH 10/17] feat(work): persist assignment controls in atomic claim records (#1017) --- oxa/oxa-work/src/board.rs | 2 +- oxa/oxa-work/src/board/claims.rs | 73 +++++++--- oxa/oxa-work/src/board/claims/controls.rs | 150 +++++++++++++++++++ oxa/oxa-work/tests/board_controls.rs | 168 ++++++++++++++++++++++ 4 files changed, 375 insertions(+), 18 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/controls.rs create mode 100644 oxa/oxa-work/tests/board_controls.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 95b09fd5d..1e501c006 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize}; use std::collections::{BTreeMap, BTreeSet}; mod claims; -pub use claims::Claims; +pub use claims::{Assignment, AssignmentBoard, AssignmentData, Claims}; pub mod assignment; #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index e6205af5e..0c10004bb 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -8,12 +8,17 @@ use std::io::{Read, Write}; use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; use std::path::{Path, PathBuf}; +mod controls; +pub use controls::{Assignment, AssignmentBoard, AssignmentData}; + #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct Saved { version: u8, number: u64, state: AttemptState, + #[serde(default)] + data: AssignmentData, } fn io(value: std::io::Result) -> Result { @@ -83,13 +88,18 @@ impl Claims { /// First access to a PR counts. A state file lost after a marker exists is still /// corruption, so a vanished marker must not reset the cap by faking a first access. - fn load(&self, number: u64) -> Result { + fn load(&self, number: u64) -> Result { let path = self.path(number); let created = self.root.join(format!("{number}.board-claim.created")); match fs::symlink_metadata(&path) { Err(e) if e.kind() == std::io::ErrorKind::NotFound => { return match fs::symlink_metadata(&created) { - Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(AttemptState::default()), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Saved { + version: 1, + number, + state: AttemptState::default(), + data: AssignmentData::default(), + }), Ok(_) => Err("board claim state is missing; recovery is required".into()), Err(e) => io(Err(e)), }; @@ -115,16 +125,19 @@ impl Claims { { return Err("invalid board claim identity or lease".into()); } - Ok(saved.state) + Ok(saved) } - fn save(&self, number: u64, state: AttemptState, replacing: bool) -> Result<()> { - let bytes = serde_json::to_vec(&Saved { - version: 1, - number, - state, - }) - .map_err(|_| "cannot encode board claim state")?; + fn save(&self, number: u64, mut saved: Saved, replacing: bool) -> Result<()> { + saved.data.revision = saved + .data + .revision + .checked_add(1) + .ok_or("assignment revision exhausted")?; + let bytes = serde_json::to_vec(&saved).map_err(|_| "cannot encode board claim state")?; + if bytes.len() > 4096 { + return Err("board claim file exceeds capacity".into()); + } crate::checkpoint::write_atomic(&self.path(number), &bytes, replacing) .map_err(|_| "cannot durably reserve board claim".into()) } @@ -141,7 +154,7 @@ impl Claims { } /// Atomic replacements permit a coherent per-PR read without taking execution leases. - pub fn snapshot(&self) -> Result> { + fn rows(&self) -> Result> { Self::open(&self.root)?; let lock = io(File::open(&self.root))?; io(lock.lock())?; @@ -164,6 +177,14 @@ impl Claims { Ok(states) } + pub fn snapshot(&self) -> Result> { + Ok(self + .rows()? + .into_iter() + .map(|(number, row)| (number, row.state)) + .collect()) + } + /// Reserve before dispatch. A crash after reservation consumes an attempt conservatively. /// The caller must use a fresh GitHub entry and revalidate its head before external effects. pub fn claim( @@ -174,6 +195,20 @@ impl Claims { now: u64, ttl: u64, ) -> Result> { + self.claim_checked(entry, policy, holder, (now, ttl), |row| { + Ok(row.data.policy.is_none()) + }) + } + + fn claim_checked( + &self, + entry: &Entry, + policy: &Policy, + holder: &str, + timing: (u64, u64), + authorize: impl FnOnce(&mut Saved) -> Result, + ) -> Result> { + let (now, ttl) = timing; if !policy.enabled || policy.max_attempts_per_day == 0 || !entry.eligible @@ -192,7 +227,11 @@ impl Claims { return Err("invalid board claim request".into()); } let _lock = self.lock(entry.number)?; - let mut state = self.load(entry.number)?; + let mut row = self.load(entry.number)?; + if !authorize(&mut row)? { + return Ok(None); + } + let state = &mut row.state; let day = now / 86_400; if state.utc_day > day { return Err("board claim clock moved backwards".into()); @@ -219,7 +258,7 @@ impl Claims { }; state.lease = Some(lease.clone()); let replacing = self.established(entry.number)?; - self.save(entry.number, state, replacing)?; + self.save(entry.number, row, replacing)?; self.mark(entry.number)?; Ok(Some(lease)) } @@ -252,12 +291,12 @@ impl Claims { Ok(_) => {} } let _lock = self.lock(number)?; - let mut state = self.load(number)?; - if state.lease.as_ref() != Some(lease) { + let mut row = self.load(number)?; + if row.state.lease.as_ref() != Some(lease) { return Ok(false); } - state.lease = None; - self.save(number, state, true)?; + row.state.lease = None; + self.save(number, row, true)?; Ok(true) } } diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs new file mode 100644 index 000000000..591dcb5c9 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -0,0 +1,150 @@ +//! Authenticated controls share the exact record and lock used by claim admission. +use super::*; +use crate::board::assignment::{AssignmentPolicy, Control, ManualAuthority, Worker}; +use crate::board::{Board, GitHub}; + +#[derive(Clone, Default, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AssignmentData { + pub revision: u64, + pub policy: Option, +} + +#[derive(Clone, Deserialize, Serialize)] +pub struct Assignment { + pub number: u64, + pub state: AttemptState, + pub data: AssignmentData, +} + +impl Assignment { + pub fn assignee(&self, now: u64) -> Option<&str> { + self.state + .lease + .as_ref() + .filter(|lease| lease.expires_at > now) + .map(|lease| lease.holder.as_str()) + } +} + +#[derive(Clone, Serialize)] +pub struct AssignmentBoard { + pub board: Board, + pub assignments: BTreeMap, + pub workers: Vec, +} + +impl AssignmentBoard { + pub fn candidates(&self, worker_id: &str) -> Result> { + let worker = self + .workers + .iter() + .find(|worker| worker.id == worker_id) + .ok_or("unknown registered worker")?; + let mut ranked = vec![]; + for entry in &self.board.entries { + let policy = self + .assignments + .get(&entry.number) + .and_then(|row| row.data.policy.as_ref()) + .cloned() + .unwrap_or_default(); + if let Some(rank) = policy.rank(worker, entry) { + ranked.push((rank, entry.number)); + } + } + ranked.sort_by_key(|(rank, _)| *rank); + Ok(ranked.into_iter().map(|(_, number)| number).collect()) + } +} + +impl Claims { + /// The catalog comes from existing authenticated host registration, never GitHub labels. + /// One complete GitHub read serves every worker in this immutable query result. + pub fn assignment_board( + &self, + github: &mut impl GitHub, + policy: &Policy, + workers: &[Worker], + now: u64, + ) -> Result { + let assignments = if policy.enabled { + self.assignments()? + } else { + BTreeMap::new() + }; + let states = assignments + .iter() + .map(|(number, row)| (*number, row.state.clone())) + .collect(); + let mut ids = std::collections::BTreeSet::new(); + if workers + .iter() + .any(|worker| !valid_worker_id(&worker.id) || !ids.insert(&worker.id)) + { + return Err("invalid or duplicate worker catalog".into()); + } + Ok(AssignmentBoard { + board: Board::read(github, policy, &states, now)?, + assignments, + workers: workers.to_vec(), + }) + } + /// Full private query projection, not a second facts database. + pub fn assignments(&self) -> Result> { + Ok(self + .rows()? + .into_iter() + .map(|(number, row)| { + ( + number, + Assignment { + number, + state: row.state, + data: row.data, + }, + ) + }) + .collect()) + } + + /// The authority is supplied by trusted user/lead authentication, not request JSON. + pub fn control( + &self, + number: u64, + authority: Option, + expected_revision: u64, + change: Control, + ) -> Result<()> { + if authority.is_none() { + return Err("owner or lead control required".into()); + } + let _lock = self.lock(number)?; + let mut row = self.load(number)?; + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + let mut policy = row.data.policy.take().unwrap_or_default(); + policy.control(authority, change)?; + row.data.policy = Some(policy); + let replacing = self.established(number)?; + self.save(number, row, replacing)?; + self.mark(number) + } + + /// Worker declarations come from the authenticated registration frontend. + /// Manual state is reread under the reservation lock; stale caller snapshots cannot bypass it. + pub fn claim_for( + &self, + entry: &Entry, + policy: &Policy, + worker: &Worker, + now: u64, + ttl: u64, + ) -> Result> { + self.claim_checked(entry, policy, &worker.id, (now, ttl), |row| { + let controls = row.data.policy.get_or_insert_with(AssignmentPolicy::default); + Ok(controls.allows(worker, entry.action)) + }) + } +} diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs new file mode 100644 index 000000000..b43225f26 --- /dev/null +++ b/oxa/oxa-work/tests/board_controls.rs @@ -0,0 +1,168 @@ +use oxa_work::board::assignment::{Control, ManualAuthority, Pin, Role, Worker, WorkerKind}; +use oxa_work::board::*; +use std::{collections::BTreeMap, fs, os::unix::fs::DirBuilderExt, path::PathBuf}; + +struct Fixture(PathBuf); +impl Fixture { + fn new() -> Self { + static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); + let path = std::env::temp_dir().join(format!( + "oxa-board-controls-{}-{}", + std::process::id(), + NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + )); + fs::DirBuilder::new().mode(0o700).create(&path).unwrap(); + Self(path.canonicalize().unwrap()) + } + fn store(&self) -> Claims { + Claims::open(&self.0).unwrap() + } +} +impl Drop for Fixture { + fn drop(&mut self) { + fs::remove_dir_all(&self.0).unwrap(); + } +} +struct FakeGitHub(usize); +impl GitHub for FakeGitHub { + fn open_pull_requests(&mut self) -> oxa_work::Result> { + self.0 += 1; + Ok((1..=3) + .map(|number| PullRequest { + number, + head: "synthetic-head".into(), + release_pinned: number == 3, + findings: true, + required_ci: RequiredCi::Passed, + mergeability: Mergeability::Mergeable, + body: String::new(), + removes_source: false, + draft: false, + reviewed: false, + }) + .collect()) + } +} +fn policy() -> Policy { + Policy { + enabled: true, + ..Policy::default() + } +} +fn worker(slot: &str) -> Worker { + Worker { + id: format!("codex:node/{slot}"), + kind: WorkerKind::Codex, + skills: Default::default(), + roles: [Role::Builder].into(), + } +} +fn entry() -> Entry { + Board::read(&mut FakeGitHub(0), &policy(), &BTreeMap::new(), 0) + .unwrap() + .entries + .remove(0) +} + +#[test] +fn controls_require_authority_and_compare_revision_after_reopen() { + let fixture = Fixture::new(); + assert!(fixture + .store() + .control(3, None, 0, Control::OwnerOnly(true)) + .is_err()); + assert_eq!(fs::read_dir(&fixture.0).unwrap().count(), 0); + fixture + .store() + .control(3, Some(ManualAuthority::Lead), 0, Control::OwnerOnly(true)) + .unwrap(); + assert!(fixture + .store() + .control(3, Some(ManualAuthority::Owner), 0, Control::OwnerOnly(false)) + .is_err()); + let rows = fixture.store().assignments().unwrap(); + assert_eq!(rows[&3].data.revision, 1); + assert!(rows[&3].data.policy.as_ref().unwrap().owner_only); + assert_eq!(rows[&3].state.attempts, 0); + assert_eq!(rows[&3].assignee(10), None); +} + +#[test] +fn stale_entries_and_legacy_claims_cannot_bypass_persistent_controls() { + let fixture = Fixture::new(); + let store = fixture.store(); + let entry = entry(); + let worker = worker("slot-1"); + store + .control( + 3, + Some(ManualAuthority::Owner), + 0, + Control::Pin(Pin::Worker(worker.id.clone())), + ) + .unwrap(); + assert!(store + .claim_for(&entry, &policy(), &crate::worker("slot-2"), 10, 10) + .unwrap() + .is_none()); + assert!(store + .claim(&entry, &policy(), &worker.id, 10, 10) + .unwrap() + .is_none()); + let lease = store + .claim_for(&entry, &policy(), &worker, 10, 10) + .unwrap() + .unwrap(); + store + .control(3, Some(ManualAuthority::Lead), 2, Control::OwnerOnly(true)) + .unwrap(); + assert_eq!( + store.assignments().unwrap()[&3].assignee(19), + Some(worker.id.as_str()) + ); + assert_eq!(store.assignments().unwrap()[&3].assignee(20), None); + assert!(store.release(3, &lease).unwrap()); + assert!(store + .claim_for(&entry, &policy(), &worker, 21, 10) + .unwrap() + .is_none()); + let owner = Worker { + roles: [Role::Owner].into(), + ..worker + }; + assert!(store + .claim_for(&entry, &policy(), &owner, 21, 10) + .unwrap() + .is_some()); + assert_eq!(store.snapshot().unwrap()[&3].attempts, 2); +} + +#[test] +fn one_snapshot_serves_all_workers_with_release_and_manual_pin_priority() { + let fixture = Fixture::new(); + let store = fixture.store(); + let first = worker("slot-1"); + let second = worker("slot-2"); + store + .control( + 2, + Some(ManualAuthority::Owner), + 0, + Control::Pin(Pin::Worker(first.id.clone())), + ) + .unwrap(); + let mut github = FakeGitHub(0); + let board = store + .assignment_board(&mut github, &policy(), &[first.clone(), second.clone()], 10) + .unwrap(); + assert_eq!(board.candidates(&first.id).unwrap(), [3, 2, 1]); + assert_eq!(board.candidates(&second.id).unwrap(), [3, 1]); + assert!(board.candidates("unknown").is_err()); + assert_eq!(github.0, 1); + let disabled = store + .assignment_board(&mut github, &Policy::default(), &[first], 10) + .unwrap(); + assert!(disabled.board.entries.is_empty()); + assert!(disabled.assignments.is_empty()); + assert_eq!(github.0, 1); +} From 08fe3016e49b56c63517aea7bd820dbde76d68e3 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:37:07 +0100 Subject: [PATCH 11/17] feat(work): add authenticated manual leases and reasoned releases (#1017) --- oxa/oxa-work/src/board.rs | 2 +- oxa/oxa-work/src/board/claims.rs | 5 +- oxa/oxa-work/src/board/claims/controls.rs | 5 + .../src/board/claims/controls/leases.rs | 106 ++++++++++ oxa/oxa-work/tests/board_controls.rs | 182 +++++++++++++++++- 5 files changed, 297 insertions(+), 3 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/controls/leases.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 1e501c006..206502262 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize}; use std::collections::{BTreeMap, BTreeSet}; mod claims; -pub use claims::{Assignment, AssignmentBoard, AssignmentData, Claims}; +pub use claims::{Assignment, AssignmentBoard, AssignmentData, Claims, ReleaseRecord}; pub mod assignment; #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index d44565b71..dcc3795a0 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -9,7 +9,7 @@ use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; use std::path::{Path, PathBuf}; mod controls; -pub use controls::{Assignment, AssignmentBoard, AssignmentData}; +pub use controls::{Assignment, AssignmentBoard, AssignmentData, ReleaseRecord}; #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] @@ -295,6 +295,9 @@ impl Claims { } let _lock = self.lock(number)?; let mut row = self.load(number)?; + if row.data.policy.is_some() { + return Err("configured assignments require authenticated release with a reason".into()); + } if row.state.lease.as_ref() != Some(lease) { return Ok(false); } diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs index 591dcb5c9..157ef91a1 100644 --- a/oxa/oxa-work/src/board/claims/controls.rs +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -3,11 +3,16 @@ use super::*; use crate::board::assignment::{AssignmentPolicy, Control, ManualAuthority, Worker}; use crate::board::{Board, GitHub}; +mod leases; +pub use leases::ReleaseRecord; + #[derive(Clone, Default, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct AssignmentData { pub revision: u64, pub policy: Option, + #[serde(default)] + pub last_release: Option, } #[derive(Clone, Deserialize, Serialize)] diff --git a/oxa/oxa-work/src/board/claims/controls/leases.rs b/oxa/oxa-work/src/board/claims/controls/leases.rs new file mode 100644 index 000000000..9b04394c4 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/controls/leases.rs @@ -0,0 +1,106 @@ +//! Lease changes use the same admission accounting, revision and private record as controls. +use super::*; + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct ReleaseRecord { + pub holder: String, + pub released_at: u64, + pub reason: String, +} + +impl Claims { + /// Manual assignment cannot bypass a pin, role requirement, live lease or attempt cap. + pub fn assign( + &self, + entry: &Entry, + policy: &Policy, + authority: Option, + expected_revision: u64, + worker: &Worker, + now: u64, + ttl: u64, + ) -> Result> { + if authority.is_none() { + return Err("owner or lead assignment required".into()); + } + self.claim_checked(entry, policy, &worker.id, (now, ttl), |row| { + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + Ok(row + .data + .policy + .get_or_insert_with(AssignmentPolicy::default) + .allows(worker, entry.action)) + }) + } + + /// The trusted worker frontend supplies identity; knowing a lease is not authority to release it. + pub fn release_for( + &self, + number: u64, + worker_id: &str, + lease: &Lease, + now: u64, + reason: &str, + ) -> Result { + if !valid_worker_id(worker_id) || worker_id != lease.holder { + return Err("lease holder authentication required".into()); + } + self.end_lease(number, now, reason, |row| { + Ok(row.state.lease.as_ref() == Some(lease)) + }) + } + + pub fn unassign( + &self, + number: u64, + authority: Option, + expected_revision: u64, + now: u64, + reason: &str, + ) -> Result { + if authority.is_none() { + return Err("owner or lead unassignment required".into()); + } + self.end_lease(number, now, reason, |row| { + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + Ok(true) + }) + } + + fn end_lease( + &self, + number: u64, + now: u64, + reason: &str, + authorize: impl FnOnce(&super::super::Saved) -> Result, + ) -> Result { + let reason = reason.trim(); + if reason.is_empty() || reason.len() > 512 || reason.chars().any(char::is_control) { + return Err("release requires a bounded single-line reason".into()); + } + let _lock = self.lock(number)?; + let mut row = self.load(number)?; + if !authorize(&row)? { + return Ok(false); + } + let Some(lease) = row.state.lease.take() else { + return Ok(false); + }; + if lease.claimed_at.is_none_or(|at| at > now) { + return Err("board release clock moved backwards".into()); + } + row.data.last_release = Some(ReleaseRecord { + holder: lease.holder, + released_at: now, + reason: reason.into(), + }); + self.save(number, row, true)?; + self.mark(number)?; + Ok(true) + } +} diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index b43225f26..732484990 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -121,7 +121,7 @@ fn stale_entries_and_legacy_claims_cannot_bypass_persistent_controls() { Some(worker.id.as_str()) ); assert_eq!(store.assignments().unwrap()[&3].assignee(20), None); - assert!(store.release(3, &lease).unwrap()); + assert!(store.release_for(3, &worker.id, &lease, 20, "completed").unwrap()); assert!(store .claim_for(&entry, &policy(), &worker, 21, 10) .unwrap() @@ -166,3 +166,183 @@ fn one_snapshot_serves_all_workers_with_release_and_manual_pin_priority() { assert!(disabled.assignments.is_empty()); assert_eq!(github.0, 1); } + +#[test] +fn manual_assignment_and_unassignment_share_revision_fencing_and_attempts() { + let fixture = Fixture::new(); + let store = fixture.store(); + let first = worker("slot-1"); + let second = worker("slot-2"); + let entry = entry(); + assert!(store.assign(&entry, &policy(), None, 0, &first, 10, 10).is_err()); + assert_eq!(fs::read_dir(&fixture.0).unwrap().count(), 0); + assert!(store + .assign( + &entry, + &Policy::default(), + Some(ManualAuthority::Owner), + 0, + &first, + 10, + 10 + ) + .unwrap() + .is_none()); + assert_eq!(fs::read_dir(&fixture.0).unwrap().count(), 0); + let lease = store + .assign(&entry, &policy(), Some(ManualAuthority::Lead), 0, &first, 10, 10) + .unwrap() + .unwrap(); + assert!(store + .assign( + &entry, + &policy(), + Some(ManualAuthority::Owner), + 1, + &second, + 11, + 10 + ) + .unwrap() + .is_none()); + assert!(store.unassign(3, None, 1, 11, "reassign").is_err()); + assert!(store + .unassign(3, Some(ManualAuthority::Lead), 0, 11, "reassign") + .is_err()); + assert!(store + .unassign(3, Some(ManualAuthority::Lead), 1, 11, "reassign") + .unwrap()); + let next = store + .assign( + &entry, + &policy(), + Some(ManualAuthority::Owner), + 2, + &second, + 11, + 10, + ) + .unwrap() + .unwrap(); + assert_ne!(lease.generation, next.generation); + assert!(!store + .release_for(3, &first.id, &lease, 12, "stale completion") + .unwrap()); + assert!(store + .release_for(3, &first.id, &next, 12, "wrong worker") + .is_err()); + assert!(store.release(3, &next).is_err()); + assert!(store + .release_for(3, &second.id, &next, 12, " completed ") + .unwrap()); + let rows = fixture.store().assignments().unwrap(); + assert_eq!(rows[&3].data.revision, 4); + assert_eq!(rows[&3].state.attempts, 2); + assert_eq!(rows[&3].assignee(12), None); + let ended = rows[&3].data.last_release.as_ref().unwrap(); + assert_eq!(ended.holder, second.id); + assert_eq!(ended.released_at, 12); + assert_eq!(ended.reason, "completed"); +} + +#[test] +fn manual_assignment_never_bypasses_pins_or_the_three_attempt_cap() { + let fixture = Fixture::new(); + let store = fixture.store(); + let worker = worker("slot-1"); + let entry = entry(); + store + .control( + 3, + Some(ManualAuthority::Owner), + 0, + Control::Pin(Pin::Worker(worker.id.clone())), + ) + .unwrap(); + assert!(store + .assign( + &entry, + &policy(), + Some(ManualAuthority::Owner), + 1, + &crate::worker("slot-2"), + 10, + 10 + ) + .unwrap() + .is_none()); + for attempt in 0..3 { + let revision = 1 + attempt * 2; + let lease = store + .assign( + &entry, + &policy(), + Some(ManualAuthority::Owner), + revision, + &worker, + 10, + 10, + ) + .unwrap() + .unwrap(); + assert_eq!(lease.generation.1, attempt as u32 + 1); + assert!(store + .unassign(3, Some(ManualAuthority::Owner), revision + 1, 10, "retry needed") + .unwrap()); + } + assert!(store + .assign( + &entry, + &policy(), + Some(ManualAuthority::Owner), + 7, + &worker, + 10, + 10 + ) + .unwrap() + .is_none()); + let rows = store.assignments().unwrap(); + assert_eq!(rows[&3].state.attempts, 3); + assert_eq!( + rows[&3].data.policy.as_ref().unwrap().pin, + Some(Pin::Worker(worker.id)) + ); +} + +#[test] +fn releases_validate_reasons_and_repair_witnesses_without_refunding() { + let fixture = Fixture::new(); + let store = fixture.store(); + let worker = worker("slot-1"); + let lease = store + .claim_for(&entry(), &policy(), &worker, 10, 10) + .unwrap() + .unwrap(); + for reason in ["", "line\nline", "control\0text", &"x".repeat(513)] { + assert!(store.release_for(3, &worker.id, &lease, 11, reason).is_err()); + } + assert!(store.release_for(3, &worker.id, &lease, 9, "backwards").is_err()); + fs::remove_file(fixture.0.join("3.board-claim.created")).unwrap(); + assert!(store.release_for(3, &worker.id, &lease, 11, "finished").unwrap()); + assert_eq!(store.snapshot().unwrap()[&3].attempts, 1); + fs::remove_file(fixture.0.join("3.board-claim.json")).unwrap(); + fs::remove_file(fixture.0.join("3.board-claim.lock")).unwrap(); + assert!(store.snapshot().is_err()); +} + +#[test] +fn records_without_release_metadata_remain_readable() { + let fixture = Fixture::new(); + let store = fixture.store(); + store + .claim_for(&entry(), &policy(), &worker("slot-1"), 10, 10) + .unwrap(); + let path = fixture.0.join("3.board-claim.json"); + let mut saved: serde_json::Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap(); + saved["data"].as_object_mut().unwrap().remove("last_release"); + fs::write(path, serde_json::to_vec(&saved).unwrap()).unwrap(); + let rows = store.assignments().unwrap(); + assert_eq!(rows[&3].state.attempts, 1); + assert!(rows[&3].data.last_release.is_none()); +} From 0db017d1861512e2badc9842328192608b078bdd Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:45:18 +0100 Subject: [PATCH 12/17] feat(work): add typed issue intake and conservative claim import (#1017) --- oxa/oxa-work/src/board.rs | 64 +++++--- oxa/oxa-work/src/board/assignment.rs | 8 +- oxa/oxa-work/src/board/claims.rs | 6 +- oxa/oxa-work/src/board/claims/controls.rs | 13 +- oxa/oxa-work/src/board/claims/imports.rs | 80 ++++++++++ oxa/oxa-work/src/board/intake.rs | 55 +++++++ oxa/oxa-work/tests/board_controls.rs | 174 ++++++++++++++++++++++ 7 files changed, 375 insertions(+), 25 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/imports.rs create mode 100644 oxa/oxa-work/src/board/intake.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 1e501c006..2cebce53b 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -5,6 +5,8 @@ use std::collections::{BTreeMap, BTreeSet}; mod claims; pub use claims::{Assignment, AssignmentBoard, AssignmentData, Claims}; pub mod assignment; +mod intake; +pub use intake::{ImportState, Issue, Snapshot}; #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] #[serde(rename_all = "snake_case")] @@ -13,11 +15,13 @@ pub enum Action { FixRequiredCi, ResolveConflict, AddRemoves, + BuildIssue, PromoteDraft, Ready, WaitRequiredCi, WaitMergeability, WaitReview, + WaitIssue, } #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)] @@ -71,7 +75,16 @@ impl std::fmt::Debug for PullRequest { /// The adapter must return the complete open-PR snapshot or fail, never a partial page. pub trait GitHub { - fn open_pull_requests(&mut self) -> crate::Result>; + fn open_pull_requests(&mut self) -> crate::Result> { + Err("adapter must implement a complete board snapshot".into()) + } + /// One complete, caller-partitioned PR AND issue intake. Legacy PR adapters remain valid. + fn snapshot(&mut self) -> crate::Result { + Ok(Snapshot { + pull_requests: self.open_pull_requests()?, + issues: vec![], + }) + } } #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] @@ -89,7 +102,7 @@ pub fn valid_worker_id(id: &str) -> bool { !id.is_empty() && id.len() <= 128 && id.split([':', '/']).all(crate::valid_task_id) } -#[derive(Clone, Debug, Default, Deserialize, Serialize)] +#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)] pub struct AttemptState { pub utc_day: u64, pub attempts: u32, @@ -114,6 +127,7 @@ impl Default for Policy { #[derive(Clone, Debug, Deserialize, Serialize)] pub struct Entry { pub number: u64, + /// PR head, or frozen issue-source revision for BuildIssue/WaitIssue. Never a fabricated PR. pub head: String, pub release_pinned: bool, pub action: Action, @@ -145,7 +159,8 @@ impl Board { return Ok(board); } let mut seen = BTreeSet::new(); - for pr in github.open_pull_requests()? { + let snapshot = github.snapshot()?; + for pr in snapshot.pull_requests { if pr.number == 0 || pr.head.is_empty() || !seen.insert(pr.number) { return Err("invalid or duplicate pull request in board snapshot".into()); } @@ -174,25 +189,34 @@ impl Board { } else { Action::WaitReview }; - let saved = state.get(&pr.number); - let attempts_today = saved - .filter(|s| s.utc_day >= now / 86_400) - .map_or(0, |s| s.attempts); - let lease = saved.and_then(|s| s.lease.clone()); - let eligible = !matches!( + board.entries.push(intake::entry( + pr.number, + pr.head, + pr.release_pinned, action, - Action::WaitReview | Action::WaitRequiredCi | Action::WaitMergeability - ) && attempts_today < policy.max_attempts_per_day - && lease.as_ref().is_none_or(|l| l.expires_at <= now); - board.entries.push(Entry { - number: pr.number, - head: pr.head, - release_pinned: pr.release_pinned, + state.get(&pr.number), + policy, + now, + )); + } + for issue in snapshot.issues { + if issue.number == 0 || issue.revision.is_empty() || !seen.insert(issue.number) { + return Err("invalid or duplicate issue in board snapshot".into()); + } + let action = if issue.approved && !issue.has_open_pull_request { + Action::BuildIssue + } else { + Action::WaitIssue + }; + board.entries.push(intake::entry( + issue.number, + issue.revision, + issue.release_pinned, action, - lease, - attempts_today, - eligible, - }); + state.get(&issue.number), + policy, + now, + )); } board .entries diff --git a/oxa/oxa-work/src/board/assignment.rs b/oxa/oxa-work/src/board/assignment.rs index 515c8f4d8..caeedec12 100644 --- a/oxa/oxa-work/src/board/assignment.rs +++ b/oxa/oxa-work/src/board/assignment.rs @@ -101,9 +101,11 @@ impl AssignmentPolicy { /// A manual pin narrows eligibility; it cannot bypass skills or action authority. pub fn allows(&self, worker: &Worker, action: Action) -> bool { let base_role = match action { - Action::FixFindings | Action::FixRequiredCi | Action::ResolveConflict | Action::AddRemoves => { - Role::Builder - } + Action::FixFindings + | Action::FixRequiredCi + | Action::ResolveConflict + | Action::AddRemoves + | Action::BuildIssue => Role::Builder, Action::PromoteDraft | Action::Ready => Role::Orchestrator, _ => return false, }; diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index d44565b71..ecf19e058 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -10,6 +10,7 @@ use std::path::{Path, PathBuf}; mod controls; pub use controls::{Assignment, AssignmentBoard, AssignmentData}; +mod imports; #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] @@ -214,7 +215,7 @@ impl Claims { || !entry.eligible || matches!( entry.action, - Action::WaitReview | Action::WaitRequiredCi | Action::WaitMergeability + Action::WaitReview | Action::WaitRequiredCi | Action::WaitMergeability | Action::WaitIssue ) { return Ok(None); @@ -231,6 +232,9 @@ impl Claims { if self.established(entry.number)? { self.mark(entry.number)?; } + if row.data.import_hold { + return Ok(None); + } if !authorize(&mut row)? { return Ok(None); } diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs index 591dcb5c9..d20e7390d 100644 --- a/oxa/oxa-work/src/board/claims/controls.rs +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -8,6 +8,8 @@ use crate::board::{Board, GitHub}; pub struct AssignmentData { pub revision: u64, pub policy: Option, + #[serde(default)] + pub import_hold: bool, } #[derive(Clone, Deserialize, Serialize)] @@ -84,8 +86,17 @@ impl Claims { { return Err("invalid or duplicate worker catalog".into()); } + let mut board = Board::read(github, policy, &states, now)?; + for entry in &mut board.entries { + if assignments + .get(&entry.number) + .is_some_and(|row| row.data.import_hold) + { + entry.eligible = false; + } + } Ok(AssignmentBoard { - board: Board::read(github, policy, &states, now)?, + board, assignments, workers: workers.to_vec(), }) diff --git a/oxa/oxa-work/src/board/claims/imports.rs b/oxa/oxa-work/src/board/claims/imports.rs new file mode 100644 index 000000000..d9e073fa5 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/imports.rs @@ -0,0 +1,80 @@ +//! Bootstrap is restartable, refuses conflicting native facts, and never refunds attempts. +use super::*; +use crate::board::{assignment::ManualAuthority, ImportState}; + +impl Claims { + /// Caller keeps activation OFF until the entire authoritative batch is imported and verified. + /// A partial I/O failure can be retried; an established, differing state is never overwritten. + pub fn import_snapshot( + &self, + authority: Option, + incoming: &BTreeMap, + now: u64, + ) -> Result<()> { + if authority.is_none() { + return Err("owner or lead import required".into()); + } + for (number, item) in incoming { + let state = &item.state; + if *number == 0 + || state.utc_day > now / 86_400 + || state.lease.as_ref().is_some_and(|l| { + state.attempts == 0 + || !valid_worker_id(&l.holder) + || l.generation != (state.utc_day, state.attempts) + || l.claimed_at.is_none_or(|at| at > now || at >= l.expires_at) + }) + { + return Err("invalid imported claim state".into()); + } + } + if Self::open(&self.root)?.uid != self.uid { + return Err("invalid import directory".into()); + } + let lock = io(File::open(&self.root))?; + io(lock.lock())?; + let mut prepared = vec![]; + for (number, item) in incoming { + let mut row = self.load(*number)?; + let exists = self.established(*number)?; + if exists && row.state != item.state { + return Err("import conflicts with established claims; reconciliation required".into()); + } + let held = item.excluded || item.state.lease.as_ref().is_some_and(|l| l.expires_at > now); + let changed = !exists || (held && !row.data.import_hold); + row.state = item.state.clone(); + row.data.import_hold |= held; + prepared.push((*number, row, exists, changed)); + } + for (number, row, exists, changed) in prepared { + if changed { + self.save(number, row, exists)?; + } + self.mark(number)?; + } + Ok(()) + } + + /// Only after the trusted frontend verifies preserved queued/active work has ended. + pub fn clear_import_hold( + &self, + number: u64, + authority: Option, + expected_revision: u64, + ) -> Result<()> { + if authority.is_none() { + return Err("owner or lead reconciliation required".into()); + } + let _lock = self.lock(number)?; + let mut row = self.load(number)?; + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + if !row.data.import_hold { + return Ok(()); + } + row.data.import_hold = false; + self.save(number, row, true)?; + self.mark(number) + } +} diff --git a/oxa/oxa-work/src/board/intake.rs b/oxa/oxa-work/src/board/intake.rs new file mode 100644 index 000000000..75e7317a0 --- /dev/null +++ b/oxa/oxa-work/src/board/intake.rs @@ -0,0 +1,55 @@ +//! Typed intake and conservative bootstrap data; no acquisition, partitioner or second store. +use super::*; + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct Issue { + pub number: u64, + pub revision: String, + pub release_pinned: bool, + /// Trusted intake approval, never inferred from arbitrary issue text. + pub approved: bool, + pub has_open_pull_request: bool, +} + +#[derive(Clone, Debug, Default, Deserialize, Serialize)] +pub struct Snapshot { + pub pull_requests: Vec, + pub issues: Vec, +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct ImportState { + pub state: AttemptState, + /// Queued OR active legacy work excludes native admission until explicitly reconciled. + pub excluded: bool, +} + +pub(super) fn entry( + number: u64, + head: String, + release_pinned: bool, + action: Action, + saved: Option<&AttemptState>, + policy: &Policy, + now: u64, +) -> Entry { + let attempts_today = saved + .filter(|s| s.utc_day >= now / 86_400) + .map_or(0, |s| s.attempts); + let lease = saved.and_then(|s| s.lease.clone()); + let eligible = !matches!( + action, + Action::WaitReview | Action::WaitRequiredCi | Action::WaitMergeability | Action::WaitIssue + ) && attempts_today < policy.max_attempts_per_day + && lease.as_ref().is_none_or(|l| l.expires_at <= now); + Entry { + number, + head, + release_pinned, + action, + lease, + attempts_today, + eligible, + } +} diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index b43225f26..4f387e595 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -1,5 +1,6 @@ use oxa_work::board::assignment::{Control, ManualAuthority, Pin, Role, Worker, WorkerKind}; use oxa_work::board::*; +use std::slice::from_ref; use std::{collections::BTreeMap, fs, os::unix::fs::DirBuilderExt, path::PathBuf}; struct Fixture(PathBuf); @@ -166,3 +167,176 @@ fn one_snapshot_serves_all_workers_with_release_and_manual_pin_priority() { assert!(disabled.assignments.is_empty()); assert_eq!(github.0, 1); } + +struct Intake(Snapshot, usize); +impl GitHub for Intake { + fn snapshot(&mut self) -> oxa_work::Result { + self.1 += 1; + Ok(self.0.clone()) + } +} + +#[test] +fn typed_issue_intake_uses_one_snapshot_and_builder_authority() { + let fixture = Fixture::new(); + let worker = worker("slot-1"); + let mut source = Intake( + Snapshot { + pull_requests: FakeGitHub(0).open_pull_requests().unwrap(), + issues: (4..=6) + .map(|number| Issue { + number, + revision: "source-revision".into(), + release_pinned: true, + approved: number != 5, + has_open_pull_request: number == 6, + }) + .collect(), + }, + 0, + ); + let store = fixture.store(); + let disabled = store + .assignment_board(&mut source, &Policy::default(), from_ref(&worker), 10) + .unwrap(); + assert!(disabled.board.entries.is_empty()); + assert_eq!(source.1, 0); + let board = store + .assignment_board(&mut source, &policy(), from_ref(&worker), 10) + .unwrap(); + assert_eq!(source.1, 1); + assert_eq!(board.candidates(&worker.id).unwrap(), [3, 4, 1, 2]); + let issue = board.board.entries.iter().find(|e| e.number == 4).unwrap(); + assert_eq!(issue.action, Action::BuildIssue); + assert_eq!(issue.head, "source-revision"); + assert!(store + .claim_for(issue, &policy(), &worker, 10, 10) + .unwrap() + .is_some()); + for number in [5, 6] { + let waiting = board.board.entries.iter().find(|e| e.number == number).unwrap(); + assert_eq!(waiting.action, Action::WaitIssue); + assert!(!waiting.eligible); + assert!(store + .claim_for(waiting, &policy(), &worker, 10, 10) + .unwrap() + .is_none()); + } + source.0.issues[0].number = 3; + assert!(Board::read(&mut source, &policy(), &BTreeMap::new(), 10).is_err()); +} + +#[test] +fn import_resumes_without_resetting_attempts_or_admitting_preserved_jobs() { + let fixture = Fixture::new(); + let store = fixture.store(); + let worker = worker("slot-1"); + let incoming: BTreeMap<_, _> = [ + ( + 3, + ImportState { + state: AttemptState { + utc_day: 0, + attempts: 1, + lease: Some(Lease { + holder: worker.id.clone(), + claimed_at: Some(10), + expires_at: 20, + generation: (0, 1), + }), + }, + excluded: false, + }, + ), + ( + 4, + ImportState { + state: AttemptState { + attempts: 2, + ..Default::default() + }, + excluded: true, + }, + ), + ] + .into(); + assert!(store.import_snapshot(None, &incoming, 11).is_err()); + assert_eq!(fs::read_dir(&fixture.0).unwrap().count(), 0); + let first = [(3, incoming[&3].clone())].into(); + store + .import_snapshot(Some(ManualAuthority::Owner), &first, 11) + .unwrap(); + store + .import_snapshot(Some(ManualAuthority::Owner), &incoming, 11) + .unwrap(); + store + .import_snapshot(Some(ManualAuthority::Owner), &incoming, 11) + .unwrap(); + let rows = store.assignments().unwrap(); + for number in [3, 4] { + assert_eq!(rows[&number].state, incoming[&number].state); + assert_eq!(rows[&number].data.revision, 1); + assert!(rows[&number].data.import_hold); + } + let mut issue = entry(); + issue.number = 4; + issue.action = Action::BuildIssue; + assert!(store + .claim_for(&issue, &policy(), &worker, 21, 10) + .unwrap() + .is_none()); + assert!(store + .claim(&entry(), &policy(), &worker.id, 21, 10) + .unwrap() + .is_none()); + let board = store + .assignment_board(&mut FakeGitHub(0), &policy(), from_ref(&worker), 21) + .unwrap(); + assert!(!board.candidates(&worker.id).unwrap().contains(&3)); + assert!(store.clear_import_hold(4, None, 1).is_err()); + assert!(store + .clear_import_hold(4, Some(ManualAuthority::Lead), 0) + .is_err()); + store + .clear_import_hold(4, Some(ManualAuthority::Lead), 1) + .unwrap(); + assert!(store + .claim_for(&issue, &policy(), &worker, 21, 10) + .unwrap() + .is_some()); + assert!(store + .import_snapshot(Some(ManualAuthority::Owner), &incoming, 21) + .is_err()); + assert_eq!(store.snapshot().unwrap()[&4].attempts, 3); +} + +#[test] +fn invalid_or_conflicting_import_is_preflighted_before_any_state_write() { + let fixture = Fixture::new(); + let store = fixture.store(); + store + .claim(&entry(), &policy(), "codex:node/slot-1", 10, 10) + .unwrap(); + let mut incoming: BTreeMap<_, _> = [2, 3] + .map(|number| { + ( + number, + ImportState { + state: AttemptState::default(), + excluded: true, + }, + ) + }) + .into(); + assert!(store + .import_snapshot(Some(ManualAuthority::Owner), &incoming, 11) + .is_err()); + assert!(!fixture.0.join("2.board-claim.json").exists()); + incoming.remove(&3); + incoming.get_mut(&2).unwrap().state.utc_day = 1; + assert!(store + .import_snapshot(Some(ManualAuthority::Owner), &incoming, 11) + .is_err()); + assert!(!fixture.0.join("2.board-claim.json").exists()); + assert_eq!(store.snapshot().unwrap()[&3].attempts, 1); +} From 3c4288a09c41a8cacaf1164eaa87571c7afc8610 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 18:45:57 +0100 Subject: [PATCH 13/17] fix(work): label typed issue actions in the existing board projection (#1017) --- oxa/oxa-cli/src/lead_page.rs | 2 ++ oxa/oxa-work/src/board/intake.rs | 2 -- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/oxa/oxa-cli/src/lead_page.rs b/oxa/oxa-cli/src/lead_page.rs index 80cbb8b85..21d56abfd 100644 --- a/oxa/oxa-cli/src/lead_page.rs +++ b/oxa/oxa-cli/src/lead_page.rs @@ -32,11 +32,13 @@ fn action(value: Action) -> &'static str { Action::FixRequiredCi => "Fix required CI", Action::ResolveConflict => "Resolve conflict", Action::AddRemoves => "Add removal rationale", + Action::BuildIssue => "Build approved issue", Action::PromoteDraft => "Promote green draft", Action::Ready => "Ready to land", Action::WaitRequiredCi => "Wait for required CI", Action::WaitMergeability => "Wait for mergeability", Action::WaitReview => "Wait for review", + Action::WaitIssue => "Wait for issue intake", } } fn subject(value: &Subject) -> String { diff --git a/oxa/oxa-work/src/board/intake.rs b/oxa/oxa-work/src/board/intake.rs index 75e7317a0..b72af76a2 100644 --- a/oxa/oxa-work/src/board/intake.rs +++ b/oxa/oxa-work/src/board/intake.rs @@ -11,13 +11,11 @@ pub struct Issue { pub approved: bool, pub has_open_pull_request: bool, } - #[derive(Clone, Debug, Default, Deserialize, Serialize)] pub struct Snapshot { pub pull_requests: Vec, pub issues: Vec, } - #[derive(Clone, Debug, Deserialize, Serialize)] pub struct ImportState { pub state: AttemptState, From 99bfa5452fbdea6cbf6ecd85f3495aaaca238c39 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 19:20:36 +0100 Subject: [PATCH 14/17] test(work): expose witness loss on stale control updates (#1017) --- oxa/oxa-work/tests/board_controls.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index b43225f26..009647ed4 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -76,15 +76,21 @@ fn controls_require_authority_and_compare_revision_after_reopen() { .store() .control(3, Some(ManualAuthority::Lead), 0, Control::OwnerOnly(true)) .unwrap(); + let witness = fixture.0.join("3.board-claim.created"); + fs::remove_file(&witness).unwrap(); assert!(fixture .store() .control(3, Some(ManualAuthority::Owner), 0, Control::OwnerOnly(false)) .is_err()); + assert!(witness.exists()); let rows = fixture.store().assignments().unwrap(); assert_eq!(rows[&3].data.revision, 1); assert!(rows[&3].data.policy.as_ref().unwrap().owner_only); assert_eq!(rows[&3].state.attempts, 0); assert_eq!(rows[&3].assignee(10), None); + fs::remove_file(fixture.0.join("3.board-claim.json")).unwrap(); + fs::remove_file(fixture.0.join("3.board-claim.lock")).unwrap(); + assert!(fixture.store().assignments().is_err()); } #[test] From 0a8306488e33025f998638a023806d09d3e4dd94 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 19:29:29 +0100 Subject: [PATCH 15/17] fix(work): restore witnesses before returning established claim state (#1017) --- oxa/oxa-work/src/board/claims.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index d44565b71..e6caf3bc4 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -125,6 +125,7 @@ impl Claims { { return Err("invalid board claim identity or lease".into()); } + self.mark(number)?; Ok(saved) } From 8715e59703aa1c547af0bc57466696f56c202d90 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 19:51:15 +0100 Subject: [PATCH 16/17] test(work): reject reviewer issue leases through the legacy claim API (#1017) --- oxa/oxa-work/src/board/claims/imports.rs | 2 -- oxa/oxa-work/src/board/intake.rs | 2 -- oxa/oxa-work/tests/board_controls.rs | 12 +++++++----- 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/oxa/oxa-work/src/board/claims/imports.rs b/oxa/oxa-work/src/board/claims/imports.rs index d9e073fa5..aae524413 100644 --- a/oxa/oxa-work/src/board/claims/imports.rs +++ b/oxa/oxa-work/src/board/claims/imports.rs @@ -1,7 +1,6 @@ //! Bootstrap is restartable, refuses conflicting native facts, and never refunds attempts. use super::*; use crate::board::{assignment::ManualAuthority, ImportState}; - impl Claims { /// Caller keeps activation OFF until the entire authoritative batch is imported and verified. /// A partial I/O failure can be retried; an established, differing state is never overwritten. @@ -54,7 +53,6 @@ impl Claims { } Ok(()) } - /// Only after the trusted frontend verifies preserved queued/active work has ended. pub fn clear_import_hold( &self, diff --git a/oxa/oxa-work/src/board/intake.rs b/oxa/oxa-work/src/board/intake.rs index b72af76a2..6887ce825 100644 --- a/oxa/oxa-work/src/board/intake.rs +++ b/oxa/oxa-work/src/board/intake.rs @@ -1,6 +1,5 @@ //! Typed intake and conservative bootstrap data; no acquisition, partitioner or second store. use super::*; - #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct Issue { @@ -22,7 +21,6 @@ pub struct ImportState { /// Queued OR active legacy work excludes native admission until explicitly reconciled. pub excluded: bool, } - pub(super) fn entry( number: u64, head: String, diff --git a/oxa/oxa-work/tests/board_controls.rs b/oxa/oxa-work/tests/board_controls.rs index 7623a6283..0c52d6a78 100644 --- a/oxa/oxa-work/tests/board_controls.rs +++ b/oxa/oxa-work/tests/board_controls.rs @@ -173,7 +173,6 @@ fn one_snapshot_serves_all_workers_with_release_and_manual_pin_priority() { assert!(disabled.assignments.is_empty()); assert_eq!(github.0, 1); } - struct Intake(Snapshot, usize); impl GitHub for Intake { fn snapshot(&mut self) -> oxa_work::Result { @@ -181,11 +180,10 @@ impl GitHub for Intake { Ok(self.0.clone()) } } - #[test] fn typed_issue_intake_uses_one_snapshot_and_builder_authority() { let fixture = Fixture::new(); - let worker = worker("slot-1"); + let mut worker = worker("slot-1"); let mut source = Intake( Snapshot { pull_requests: FakeGitHub(0).open_pull_requests().unwrap(), @@ -215,6 +213,12 @@ fn typed_issue_intake_uses_one_snapshot_and_builder_authority() { let issue = board.board.entries.iter().find(|e| e.number == 4).unwrap(); assert_eq!(issue.action, Action::BuildIssue); assert_eq!(issue.head, "source-revision"); + worker.roles = [Role::Reviewer].into(); + let denied = store.claim_for(issue, &policy(), &worker, 10, 10).unwrap(); + assert!(denied.is_none()); + let legacy = store.claim(issue, &policy(), &worker.id, 10, 10).unwrap(); + assert!(legacy.is_none()); + worker.roles = [Role::Builder].into(); assert!(store .claim_for(issue, &policy(), &worker, 10, 10) .unwrap() @@ -231,7 +235,6 @@ fn typed_issue_intake_uses_one_snapshot_and_builder_authority() { source.0.issues[0].number = 3; assert!(Board::read(&mut source, &policy(), &BTreeMap::new(), 10).is_err()); } - #[test] fn import_resumes_without_resetting_attempts_or_admitting_preserved_jobs() { let fixture = Fixture::new(); @@ -315,7 +318,6 @@ fn import_resumes_without_resetting_attempts_or_admitting_preserved_jobs() { .is_err()); assert_eq!(store.snapshot().unwrap()[&4].attempts, 3); } - #[test] fn invalid_or_conflicting_import_is_preflighted_before_any_state_write() { let fixture = Fixture::new(); From d6c94a7c4790b9ede76c684b3660043c942f74a6 Mon Sep 17 00:00:00 2001 From: oxstack-agent Date: Tue, 17 Nov 2026 20:04:14 +0100 Subject: [PATCH 17/17] fix(work): require role-aware admission for issue builds (#1017) --- oxa/oxa-work/src/board/claims.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index bab212e8a..686395df7 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -198,7 +198,7 @@ impl Claims { ttl: u64, ) -> Result> { self.claim_checked(entry, policy, holder, (now, ttl), |row| { - Ok(row.data.policy.is_none()) + Ok(entry.action != Action::BuildIssue && row.data.policy.is_none()) }) }