From 213de7bae4a9ab68fe0d6e4fd6ab42449dc1e1d2 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 06:16:19 +0100 Subject: [PATCH 1/6] Record host-bound lease activity without treating heartbeats as work --- oxa/oxa-work/src/board.rs | 4 +- oxa/oxa-work/src/board/claims.rs | 8 + oxa/oxa-work/src/board/claims/activity.rs | 169 ++++++++++++++++ .../src/board/claims/activity/tests.rs | 188 ++++++++++++++++++ oxa/oxa-work/src/board/claims/controls.rs | 2 + oxa/oxa-work/src/board/claims/ownership.rs | 2 +- 6 files changed, 370 insertions(+), 3 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/activity.rs create mode 100644 oxa/oxa-work/src/board/claims/activity/tests.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index 84c5cce6a..f81d24855 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -4,8 +4,8 @@ use std::collections::{BTreeMap, BTreeSet}; mod claims; pub use claims::{ - Assignment, AssignmentBoard, AssignmentData, Claims, ExistingWork, ItemLease, ItemOwner, NativeBinding, - ReleaseRecord, + Assignment, AssignmentBoard, AssignmentData, Claims, ExistingWork, ItemLease, ItemOwner, LeaseActivity, + LeaseSignal, NativeBinding, ReleaseRecord, VerifiedMilestone, }; pub mod assignment; mod intake; diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 64132ab6a..7a0cb2f11 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -8,7 +8,9 @@ use std::io::{Read, Write}; use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; use std::path::{Path, PathBuf}; +mod activity; mod controls; +pub use activity::{LeaseActivity, LeaseSignal, VerifiedMilestone}; pub use controls::{Assignment, AssignmentBoard, AssignmentData, ReleaseRecord}; mod imports; mod native; @@ -141,6 +143,11 @@ impl Claims { .is_some_and(|lease| lease != &binding.lease) }) || saved.review_requests.iter().any(|key| !key.valid()) + || saved + .data + .lease_activity + .as_ref() + .is_some_and(|activity| saved.data.item_owner.is_none() || !activity.valid(&saved.state)) || saved.data.item_owner.as_ref().is_some_and(|owner| { !valid_worker_id(&owner.host_id) || owner.expires_at == 0 @@ -321,6 +328,7 @@ impl Claims { expires_at, }); row.data.native_binding = None; + row.data.lease_activity = None; let replacing = self.established(entry.number)?; self.save(entry.number, row, replacing)?; self.mark(entry.number)?; diff --git a/oxa/oxa-work/src/board/claims/activity.rs b/oxa/oxa-work/src/board/claims/activity.rs new file mode 100644 index 000000000..aaf2a9f45 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/activity.rs @@ -0,0 +1,169 @@ +//! Trusted per-lease observations; silence never releases ownership or establishes liveness. +use super::*; +use crate::{CheckpointKind, Record, Step}; + +pub enum LeaseSignal<'a> { + /// A trusted frontend observed its exact managed child, not worker-provided output. + Heartbeat, + /// The existing observer supplies a synced record without reacquiring task/checkpoint locks. + Milestone(&'a Record), +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub struct VerifiedMilestone { + pub revision: u64, + pub at_ms: u64, +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub struct LeaseActivity { + pub generation: (u64, u32), + pub heartbeat_at: Option, + pub last_action: Option, +} + +impl LeaseActivity { + pub(super) fn valid(&self, state: &AttemptState) -> bool { + self.generation == (state.utc_day, state.attempts) + && self.generation.1 > 0 + && self + .last_action + .as_ref() + .is_none_or(|action| action.revision > 0 && action.at_ms > 0) + && state.lease.as_ref().is_none_or(|lease| { + lease.claimed_at.is_some_and(|start| { + self.heartbeat_at.is_none_or(|at| at >= start) + && self + .last_action + .as_ref() + .is_none_or(|action| action.at_ms / 1000 >= start) + }) + }) + } +} + +impl Assignment { + /// Timeout is opt-in. Heartbeat and observation time never reset the action deadline. + /// A true result is an assessment, not permission to bypass verified expiry/gone reclaim. + pub fn stalled(&self, now: u64, silence: Option) -> Result { + let Some(silence) = silence else { return Ok(false) }; + if silence == 0 { + return Err("silence timeout must be positive".into()); + } + let Some(lease) = self + .state + .lease + .as_ref() + .filter(|_| self.data.item_owner.is_some()) + else { + return Ok(false); + }; + let last = self + .data + .lease_activity + .as_ref() + .and_then(|activity| activity.last_action.as_ref()) + .map(|action| action.at_ms) + .or_else(|| lease.claimed_at.and_then(|at| at.checked_mul(1000))) + .ok_or("item has no action clock")?; + if now < last / 1000 { + return Err("item action clock moved backwards".into()); + } + let deadline = silence + .checked_mul(1000) + .and_then(|timeout| last.checked_add(timeout)) + .ok_or("silence deadline overflow")?; + Ok(now.checked_mul(1000).ok_or("item action clock overflow")? >= deadline) + } +} + +impl Claims { + /// Only the authenticated runtime observer may supply signals. The current receipt, + /// original binding and host are checked under the existing Claims lock. No callbacks + /// or task/checkpoint lock acquisition occur here; callers must not invert those locks. + pub fn observe_item_for( + &self, + worker_id: &str, + host_id: &str, + binding: &NativeBinding, + receipt: &ItemLease, + now: u64, + signal: LeaseSignal<'_>, + ) -> Result { + binding.validate()?; + if !valid_worker_id(host_id) + || worker_id != binding.lease.holder + || receipt.host_id != host_id + || receipt.lease != binding.lease + { + return Err("authenticated item observer and original binding required".into()); + } + let _lock = self.lock(binding.number)?; + let mut row = self.load(binding.number)?; + if row.item_lease().as_ref() != Some(receipt) + || row.data.native_binding.as_ref() != Some(binding) + || now >= receipt.expires_at + { + return Ok(false); + } + if receipt.lease.claimed_at.is_none_or(|start| now < start) { + return Err("item observation clock moved backwards".into()); + } + let activity = row.data.lease_activity.get_or_insert_with(|| LeaseActivity { + generation: receipt.lease.generation, + heartbeat_at: None, + last_action: None, + }); + match signal { + LeaseSignal::Heartbeat => { + if activity.heartbeat_at.is_some_and(|at| now < at) { + return Err("item heartbeat clock moved backwards".into()); + } + if activity.heartbeat_at == Some(now) { + return Ok(false); + } + activity.heartbeat_at = Some(now); + } + LeaseSignal::Milestone(record) => { + if record.id != binding.native_task_id + || record.branch != binding.branch + || record.checkpoint_kind != CheckpointKind::WorkerFinished + || !matches!(record.step, Step::Acceptance | Step::Recheck) + || record.worker.is_none() + || record.checkpoint_revision == 0 + { + return Ok(false); + } + if activity + .last_action + .as_ref() + .is_some_and(|last| record.checkpoint_revision <= last.revision) + { + return Ok(false); + } + if record.checkpoint_at_ms == 0 + || record.checkpoint_at_ms / 1000 > now + || record.checkpoint_at_ms / 1000 < receipt.lease.claimed_at.unwrap() + || activity + .last_action + .as_ref() + .is_some_and(|last| record.checkpoint_at_ms < last.at_ms) + { + return Err("invalid durable action clock".into()); + } + activity.last_action = Some(VerifiedMilestone { + revision: record.checkpoint_revision, + at_ms: record.checkpoint_at_ms, + }); + } + } + self.save(binding.number, row, true)?; + self.mark(binding.number)?; + Ok(true) + } +} + +#[cfg(test)] +mod tests; diff --git a/oxa/oxa-work/src/board/claims/activity/tests.rs b/oxa/oxa-work/src/board/claims/activity/tests.rs new file mode 100644 index 000000000..efd7a3d17 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/activity/tests.rs @@ -0,0 +1,188 @@ +use super::*; +use crate::board::assignment::{ManualAuthority, Role, Worker, WorkerKind}; +use crate::test_dir::PrivateDir; +use crate::{blocked_record, Task, WorkerOutcome, WorkerResult}; + +fn fixture() -> (PrivateDir, Claims, ItemLease, NativeBinding) { + let dir = PrivateDir::new("lease-activity"); + let claims = Claims::open(dir.path()).unwrap(); + let receipt = reserve(&claims, 10); + let binding = NativeBinding::new(1, &"a".repeat(64), &receipt.lease, "agent/fixture").unwrap(); + assert!(claims.bind_native("worker-a", &binding).unwrap()); + (dir, claims, receipt, binding) +} + +fn reserve(claims: &Claims, now: u64) -> ItemLease { + let entry = Entry { + number: 1, + head: "synthetic-source".into(), + release_pinned: false, + action: Action::BuildIssue, + lease: None, + attempts_today: 0, + eligible: true, + }; + let worker = Worker { + id: "worker-a".into(), + kind: WorkerKind::Codex, + skills: Default::default(), + roles: [Role::Builder].into(), + }; + let policy = Policy { + enabled: true, + ..Policy::default() + }; + claims + .claim_item_for(&entry, &policy, &worker, "host-a", (now, 100), |_| Ok(None)) + .unwrap() + .unwrap() +} + +fn milestone(binding: &NativeBinding) -> Record { + let task: Task = serde_json::from_value(serde_json::json!({ + "id":binding.native_task_id,"model":"fixture","branch":binding.branch,"prompt":"Synthetic task" + })) + .unwrap(); + let mut record = blocked_record(&task, "synthetic private detail".into()); + record.checkpoint_revision = 7; + record.checkpoint_at_ms = 12_999; + record.checkpoint_kind = CheckpointKind::WorkerFinished; + record.step = Step::Acceptance; + record.worker = Some(WorkerResult { + outcome: WorkerOutcome::Done, + exit_code: 0, + error_class: None, + interruption: None, + tokens: None, + }); + record +} + +#[test] +fn heartbeat_never_masks_silence_and_recovery_cannot_refresh_action_time() { + let (dir, claims, receipt, binding) = fixture(); + let observe = |now, signal: LeaseSignal<'_>| { + claims.observe_item_for("worker-a", "host-a", &binding, &receipt, now, signal) + }; + assert!(observe(11, LeaseSignal::Heartbeat).unwrap()); + assert!(!observe(11, LeaseSignal::Heartbeat).unwrap()); + let mut record = milestone(&binding); + assert!(observe(13, LeaseSignal::Milestone(&record)).unwrap()); + assert!(observe(30, LeaseSignal::Heartbeat).unwrap()); + assert!(observe(29, LeaseSignal::Heartbeat).is_err()); + assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + record.checkpoint_revision = 8; + record.checkpoint_at_ms = 36_000; + assert!(observe(35, LeaseSignal::Milestone(&record)).is_err()); + record.checkpoint_at_ms = 35_000; + record.checkpoint_kind = CheckpointKind::TaskTransition; + assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + record.checkpoint_kind = CheckpointKind::WorkerFinished; + record.id = "foreign-attempt".into(); + assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + let rows = Claims::open(dir.path()).unwrap().assignments().unwrap(); + let row = &rows[&1]; + let activity = row.data.lease_activity.as_ref().unwrap(); + assert_eq!(activity.heartbeat_at, Some(30)); + assert_eq!( + activity.last_action, + Some(VerifiedMilestone { + revision: 7, + at_ms: 12_999 + }) + ); + assert!(!row.stalled(22, Some(10)).unwrap()); + assert!(row.stalled(23, Some(10)).unwrap()); + assert!(!row.stalled(100, None).unwrap()); + assert!(row.stalled(23, Some(0)).is_err()); + assert!(row.stalled(11, Some(10)).is_err()); + assert!(row.stalled(23, Some(u64::MAX)).is_err()); + assert!(!serde_json::to_string(activity) + .unwrap() + .contains("synthetic private detail")); + assert!( + claims + .native_binding(&binding.native_task_id, &binding.branch) + .unwrap() + == Some(binding) + ); +} + +#[test] +fn renewal_release_and_reassignment_fence_the_original_observer_receipt() { + let (dir, claims, receipt, binding) = fixture(); + let heartbeat = |worker: &str, host: &str, receipt: &ItemLease, now| { + claims.observe_item_for(worker, host, &binding, receipt, now, LeaseSignal::Heartbeat) + }; + assert!(heartbeat("worker-b", "host-a", &receipt, 11).is_err()); + assert!(heartbeat("worker-a", "host-b", &receipt, 11).is_err()); + let mut different = binding.clone(); + different.reviewed_head = Some("b".repeat(40)); + assert!(!claims + .observe_item_for( + "worker-a", + "host-a", + &different, + &receipt, + 11, + LeaseSignal::Heartbeat + ) + .unwrap()); + let renewed = claims + .renew_item_for(1, "worker-a", "host-a", &receipt, 20, 200) + .unwrap() + .unwrap(); + assert!(!heartbeat("worker-a", "host-a", &receipt, 21).unwrap()); + assert!(heartbeat("worker-a", "host-a", &renewed, 21).unwrap()); + assert!(claims + .release_for(1, "worker-a", &receipt.lease, 22, "finished") + .unwrap()); + assert!(!heartbeat("worker-a", "host-a", &renewed, 23).unwrap()); + let data = claims.assignments().unwrap().remove(&1).unwrap().data; + assert!(data.lease_activity.is_some()); + let next = reserve(&claims, 23); + assert_ne!(next.lease.generation, receipt.lease.generation); + assert!(Claims::open(dir.path()).unwrap().assignments().unwrap()[&1] + .data + .lease_activity + .is_none()); + assert!(!heartbeat("worker-a", "host-a", &renewed, 24).unwrap()); +} + +#[test] +fn stalled_is_not_gone_and_the_existing_verified_reclaim_is_still_required() { + let (_dir, claims, receipt, binding) = fixture(); + assert!(claims.assignments().unwrap()[&1].stalled(30, Some(10)).unwrap()); + let heartbeat = |now| { + claims.observe_item_for( + "worker-a", + "host-a", + &binding, + &receipt, + now, + LeaseSignal::Heartbeat, + ) + }; + assert!(heartbeat(11).unwrap()); + assert!(claims.assignments().unwrap()[&1].stalled(30, Some(10)).unwrap()); + assert!(!claims + .reclaim_item(1, Some(ManualAuthority::Lead), &receipt, 30, |_| panic!( + "not expired" + )) + .unwrap()); + assert!(!heartbeat(110).unwrap()); + assert!(!claims + .reclaim_item(1, Some(ManualAuthority::Lead), &receipt, 110, |_| Ok(false)) + .unwrap()); + assert!(claims.assignments().unwrap()[&1].state.lease.is_some()); + assert!(claims + .reclaim_item(1, Some(ManualAuthority::Lead), &receipt, 111, |_| Ok(true)) + .unwrap()); + assert!(claims.assignments().unwrap()[&1].state.lease.is_none()); + assert!( + claims + .native_binding(&binding.native_task_id, &binding.branch) + .unwrap() + == Some(binding) + ); +} diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs index 14e767542..87d519f9e 100644 --- a/oxa/oxa-work/src/board/claims/controls.rs +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -19,6 +19,8 @@ pub struct AssignmentData { pub native_binding: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub item_owner: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub lease_activity: Option, } #[derive(Clone, Deserialize, Serialize)] diff --git a/oxa/oxa-work/src/board/claims/ownership.rs b/oxa/oxa-work/src/board/claims/ownership.rs index 528c4cd4d..bc5594ce4 100644 --- a/oxa/oxa-work/src/board/claims/ownership.rs +++ b/oxa/oxa-work/src/board/claims/ownership.rs @@ -23,7 +23,7 @@ pub struct ItemOwner { } impl Saved { - fn item_lease(&self) -> Option { + pub(super) fn item_lease(&self) -> Option { let owner = self.data.item_owner.as_ref()?; Some(ItemLease { lease: self.state.lease.clone()?, From c5f004af51a109d86dc13da4f42e4807657bd61c Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 06:25:48 +0100 Subject: [PATCH 2/6] Fence action observations with the original worker launch revision --- oxa/oxa-work/src/board/claims/activity.rs | 26 ++++++++++--------- .../src/board/claims/activity/tests.rs | 21 +++++++++++---- 2 files changed, 30 insertions(+), 17 deletions(-) diff --git a/oxa/oxa-work/src/board/claims/activity.rs b/oxa/oxa-work/src/board/claims/activity.rs index aaf2a9f45..b984af8cd 100644 --- a/oxa/oxa-work/src/board/claims/activity.rs +++ b/oxa/oxa-work/src/board/claims/activity.rs @@ -5,13 +5,14 @@ use crate::{CheckpointKind, Record, Step}; pub enum LeaseSignal<'a> { /// A trusted frontend observed its exact managed child, not worker-provided output. Heartbeat, - /// The existing observer supplies a synced record without reacquiring task/checkpoint locks. - Milestone(&'a Record), + /// Synced result and its runner-owned original launch revision, never a child-provided ID. + Milestone(&'a Record, u64), } #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] pub struct VerifiedMilestone { + pub launch_revision: u64, pub revision: u64, pub at_ms: u64, } @@ -28,10 +29,9 @@ impl LeaseActivity { pub(super) fn valid(&self, state: &AttemptState) -> bool { self.generation == (state.utc_day, state.attempts) && self.generation.1 > 0 - && self - .last_action - .as_ref() - .is_none_or(|action| action.revision > 0 && action.at_ms > 0) + && self.last_action.as_ref().is_none_or(|action| { + action.launch_revision > 0 && action.launch_revision < action.revision && action.at_ms > 0 + }) && state.lease.as_ref().is_none_or(|lease| { lease.claimed_at.is_some_and(|start| { self.heartbeat_at.is_none_or(|at| at >= start) @@ -126,7 +126,7 @@ impl Claims { } activity.heartbeat_at = Some(now); } - LeaseSignal::Milestone(record) => { + LeaseSignal::Milestone(record, launch_revision) => { if record.id != binding.native_task_id || record.branch != binding.branch || record.checkpoint_kind != CheckpointKind::WorkerFinished @@ -136,11 +136,12 @@ impl Claims { { return Ok(false); } - if activity - .last_action - .as_ref() - .is_some_and(|last| record.checkpoint_revision <= last.revision) - { + if launch_revision == 0 || launch_revision >= record.checkpoint_revision { + return Err("invalid original process launch revision".into()); + } + if activity.last_action.as_ref().is_some_and(|last| { + record.checkpoint_revision <= last.revision || launch_revision <= last.revision + }) { return Ok(false); } if record.checkpoint_at_ms == 0 @@ -154,6 +155,7 @@ impl Claims { return Err("invalid durable action clock".into()); } activity.last_action = Some(VerifiedMilestone { + launch_revision, revision: record.checkpoint_revision, at_ms: record.checkpoint_at_ms, }); diff --git a/oxa/oxa-work/src/board/claims/activity/tests.rs b/oxa/oxa-work/src/board/claims/activity/tests.rs index efd7a3d17..8d510b87f 100644 --- a/oxa/oxa-work/src/board/claims/activity/tests.rs +++ b/oxa/oxa-work/src/board/claims/activity/tests.rs @@ -67,19 +67,24 @@ fn heartbeat_never_masks_silence_and_recovery_cannot_refresh_action_time() { assert!(observe(11, LeaseSignal::Heartbeat).unwrap()); assert!(!observe(11, LeaseSignal::Heartbeat).unwrap()); let mut record = milestone(&binding); - assert!(observe(13, LeaseSignal::Milestone(&record)).unwrap()); + assert!(observe(13, LeaseSignal::Milestone(&record, 0)).is_err()); + assert!(observe(13, LeaseSignal::Milestone(&record, 7)).is_err()); + assert!(observe(13, LeaseSignal::Milestone(&record, 5)).unwrap()); assert!(observe(30, LeaseSignal::Heartbeat).unwrap()); assert!(observe(29, LeaseSignal::Heartbeat).is_err()); - assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + assert!(!observe(35, LeaseSignal::Milestone(&record, 5)).unwrap()); record.checkpoint_revision = 8; + record.checkpoint_at_ms = 35_000; + assert!(!observe(35, LeaseSignal::Milestone(&record, 5)).unwrap()); + record.checkpoint_revision = 10; record.checkpoint_at_ms = 36_000; - assert!(observe(35, LeaseSignal::Milestone(&record)).is_err()); + assert!(observe(35, LeaseSignal::Milestone(&record, 9)).is_err()); record.checkpoint_at_ms = 35_000; record.checkpoint_kind = CheckpointKind::TaskTransition; - assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + assert!(!observe(35, LeaseSignal::Milestone(&record, 9)).unwrap()); record.checkpoint_kind = CheckpointKind::WorkerFinished; record.id = "foreign-attempt".into(); - assert!(!observe(35, LeaseSignal::Milestone(&record)).unwrap()); + assert!(!observe(35, LeaseSignal::Milestone(&record, 9)).unwrap()); let rows = Claims::open(dir.path()).unwrap().assignments().unwrap(); let row = &rows[&1]; let activity = row.data.lease_activity.as_ref().unwrap(); @@ -87,6 +92,7 @@ fn heartbeat_never_masks_silence_and_recovery_cannot_refresh_action_time() { assert_eq!( activity.last_action, Some(VerifiedMilestone { + launch_revision: 5, revision: 7, at_ms: 12_999 }) @@ -100,6 +106,11 @@ fn heartbeat_never_masks_silence_and_recovery_cannot_refresh_action_time() { assert!(!serde_json::to_string(activity) .unwrap() .contains("synthetic private detail")); + record.id.clone_from(&binding.native_task_id); + record.checkpoint_revision = 12; + record.checkpoint_at_ms = 40_000; + assert!(observe(40, LeaseSignal::Milestone(&record, 11)).unwrap()); + assert!(!claims.assignments().unwrap()[&1].stalled(49, Some(10)).unwrap()); assert!( claims .native_binding(&binding.native_task_id, &binding.branch) From fd60d278b5c0a0089cc1497589572bc09e2116a8 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 06:48:24 +0100 Subject: [PATCH 3/6] Persist typed dependency waits in the existing item lease row --- oxa/oxa-work/src/board.rs | 1 + oxa/oxa-work/src/board/claims.rs | 12 ++ oxa/oxa-work/src/board/claims/activity.rs | 25 +-- .../src/board/claims/activity/tests.rs | 4 +- oxa/oxa-work/src/board/claims/controls.rs | 2 + oxa/oxa-work/src/board/claims/dependencies.rs | 69 ++++++++ .../src/board/claims/dependencies/tests.rs | 148 ++++++++++++++++++ oxa/oxa-work/src/board/claims/ownership.rs | 31 ++++ 8 files changed, 271 insertions(+), 21 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/dependencies.rs create mode 100644 oxa/oxa-work/src/board/claims/dependencies/tests.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index f81d24855..fa4038467 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -8,6 +8,7 @@ pub use claims::{ LeaseSignal, NativeBinding, ReleaseRecord, VerifiedMilestone, }; pub mod assignment; +pub use claims::{Dependency, DependencyWait}; mod intake; pub mod landing; pub mod queue; diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 7a0cb2f11..7a007f6a8 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -10,8 +10,10 @@ use std::path::{Path, PathBuf}; mod activity; mod controls; +mod dependencies; pub use activity::{LeaseActivity, LeaseSignal, VerifiedMilestone}; pub use controls::{Assignment, AssignmentBoard, AssignmentData, ReleaseRecord}; +pub use dependencies::{Dependency, DependencyWait}; mod imports; mod native; pub use native::NativeBinding; @@ -143,6 +145,15 @@ impl Claims { .is_some_and(|lease| lease != &binding.lease) }) || saved.review_requests.iter().any(|key| !key.valid()) + || saved.data.dependency.as_ref().is_some_and(|wait| { + !wait.valid(number) + || saved.data.item_owner.is_none() + || saved + .data + .native_binding + .as_ref() + .is_none_or(|binding| binding.lease.claimed_at.is_none_or(|at| wait.deadline <= at)) + }) || saved .data .lease_activity @@ -329,6 +340,7 @@ impl Claims { }); row.data.native_binding = None; row.data.lease_activity = None; + row.data.dependency = None; let replacing = self.established(entry.number)?; self.save(entry.number, row, replacing)?; self.mark(entry.number)?; diff --git a/oxa/oxa-work/src/board/claims/activity.rs b/oxa/oxa-work/src/board/claims/activity.rs index b984af8cd..33c320fda 100644 --- a/oxa/oxa-work/src/board/claims/activity.rs +++ b/oxa/oxa-work/src/board/claims/activity.rs @@ -71,6 +71,9 @@ impl Assignment { if now < last / 1000 { return Err("item action clock moved backwards".into()); } + if let Some(wait) = &self.data.dependency { + return Ok(now >= wait.deadline); + } let deadline = silence .checked_mul(1000) .and_then(|timeout| last.checked_add(timeout)) @@ -92,25 +95,9 @@ impl Claims { now: u64, signal: LeaseSignal<'_>, ) -> Result { - binding.validate()?; - if !valid_worker_id(host_id) - || worker_id != binding.lease.holder - || receipt.host_id != host_id - || receipt.lease != binding.lease - { - return Err("authenticated item observer and original binding required".into()); - } - let _lock = self.lock(binding.number)?; - let mut row = self.load(binding.number)?; - if row.item_lease().as_ref() != Some(receipt) - || row.data.native_binding.as_ref() != Some(binding) - || now >= receipt.expires_at - { + let Some((_lock, mut row)) = self.active_item_for(worker_id, host_id, binding, receipt, now)? else { return Ok(false); - } - if receipt.lease.claimed_at.is_none_or(|start| now < start) { - return Err("item observation clock moved backwards".into()); - } + }; let activity = row.data.lease_activity.get_or_insert_with(|| LeaseActivity { generation: receipt.lease.generation, heartbeat_at: None, @@ -168,4 +155,4 @@ impl Claims { } #[cfg(test)] -mod tests; +pub(super) mod tests; diff --git a/oxa/oxa-work/src/board/claims/activity/tests.rs b/oxa/oxa-work/src/board/claims/activity/tests.rs index 8d510b87f..3756595f3 100644 --- a/oxa/oxa-work/src/board/claims/activity/tests.rs +++ b/oxa/oxa-work/src/board/claims/activity/tests.rs @@ -3,7 +3,7 @@ use crate::board::assignment::{ManualAuthority, Role, Worker, WorkerKind}; use crate::test_dir::PrivateDir; use crate::{blocked_record, Task, WorkerOutcome, WorkerResult}; -fn fixture() -> (PrivateDir, Claims, ItemLease, NativeBinding) { +pub(in crate::board::claims) fn fixture() -> (PrivateDir, Claims, ItemLease, NativeBinding) { let dir = PrivateDir::new("lease-activity"); let claims = Claims::open(dir.path()).unwrap(); let receipt = reserve(&claims, 10); @@ -12,7 +12,7 @@ fn fixture() -> (PrivateDir, Claims, ItemLease, NativeBinding) { (dir, claims, receipt, binding) } -fn reserve(claims: &Claims, now: u64) -> ItemLease { +pub(in crate::board::claims) fn reserve(claims: &Claims, now: u64) -> ItemLease { let entry = Entry { number: 1, head: "synthetic-source".into(), diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs index 87d519f9e..b4b5838ed 100644 --- a/oxa/oxa-work/src/board/claims/controls.rs +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -21,6 +21,8 @@ pub struct AssignmentData { pub item_owner: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub lease_activity: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub dependency: Option, } #[derive(Clone, Deserialize, Serialize)] diff --git a/oxa/oxa-work/src/board/claims/dependencies.rs b/oxa/oxa-work/src/board/claims/dependencies.rs new file mode 100644 index 000000000..69c58baec --- /dev/null +++ b/oxa/oxa-work/src/board/claims/dependencies.rs @@ -0,0 +1,69 @@ +//! Parked work retains item ownership; a deadline wakes a decision, never proves clearance. +use super::*; + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case", deny_unknown_fields)] +pub enum Dependency { + RequiredCi(u64), + ReviewedHead { number: u64, head: String }, + WorkItem(u64), + OwnerRead(String), +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub struct DependencyWait { + pub dependency: Dependency, + pub deadline: u64, +} + +impl DependencyWait { + pub(super) fn valid(&self, number: u64) -> bool { + self.deadline > 0 + && match &self.dependency { + Dependency::RequiredCi(run) => *run > 0, + Dependency::ReviewedHead { number, head } => { + *number > 0 && super::super::queue::is_object_id(head) + } + Dependency::WorkItem(item) => *item > 0 && *item != number, + Dependency::OwnerRead(id) => crate::valid_task_id(id), + } + } +} + +impl Claims { + /// The trusted observer verifies the exact dependency and safe quiescence before parking. + /// It runs under Claims: never acquire task/repository + /// locks or call Claims inside it. Heartbeat, worker text and a deadline are not proof. + pub fn wait_for_dependency( + &self, + worker_id: &str, + host_id: &str, + binding: &NativeBinding, + receipt: &ItemLease, + now: u64, + expected_revision: u64, + wait: &DependencyWait, + verify: impl FnOnce(&DependencyWait) -> Result, + ) -> Result { + let Some((_lock, mut row)) = self.active_item_for(worker_id, host_id, binding, receipt, now)? else { + return Ok(false); + }; + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + if !wait.valid(binding.number) || wait.deadline <= now { + return Err("invalid dependency or future wake deadline required".into()); + } + if row.data.dependency.as_ref() == Some(wait) || !verify(wait)? { + return Ok(false); + } + row.data.dependency = Some(wait.clone()); + self.save(binding.number, row, true)?; + self.mark(binding.number)?; + Ok(true) + } +} + +#[cfg(test)] +mod tests; diff --git a/oxa/oxa-work/src/board/claims/dependencies/tests.rs b/oxa/oxa-work/src/board/claims/dependencies/tests.rs new file mode 100644 index 000000000..61628e4b4 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/dependencies/tests.rs @@ -0,0 +1,148 @@ +use super::*; +use crate::board::claims::activity::tests::{fixture, reserve}; + +fn wait() -> DependencyWait { + DependencyWait { + dependency: Dependency::WorkItem(3), + deadline: 40, + } +} + +fn park( + claims: &Claims, + binding: &NativeBinding, + receipt: &ItemLease, + wait: &DependencyWait, + proof: Result, +) -> Result { + let revision = claims.assignments()?[&binding.number].data.revision; + claims.wait_for_dependency("worker-a", "host-a", binding, receipt, 25, revision, wait, |_| { + proof + }) +} + +#[test] +fn dependency_wait_survives_reopening_and_deadline_is_not_release_or_progress() { + let (dir, claims, receipt, binding) = fixture(); + let wait = wait(); + assert!( + serde_json::to_value(claims.assignments().unwrap()[&1].data.clone()) + .unwrap() + .get("dependency") + .is_none() + ); + assert!(!park(&claims, &binding, &receipt, &wait, Ok(false)).unwrap()); + assert!(park(&claims, &binding, &receipt, &wait, Ok(true)).unwrap()); + let claims = Claims::open(dir.path()).unwrap(); + let revision = claims.assignments().unwrap()[&1].data.revision; + assert!(!park(&claims, &binding, &receipt, &wait, Ok(true)).unwrap()); + assert_eq!(claims.assignments().unwrap()[&1].data.revision, revision); + assert!(claims + .observe_item_for( + "worker-a", + "host-a", + &binding, + &receipt, + 30, + LeaseSignal::Heartbeat + ) + .unwrap()); + let row = claims.assignments().unwrap().remove(&1).unwrap(); + assert_eq!(row.data.dependency, Some(wait)); + assert!(!row.stalled(39, Some(5)).unwrap()); + assert!(row.stalled(40, Some(5)).unwrap()); + assert!(row.stalled(100, Some(5)).unwrap()); + assert_eq!(row.state.lease, Some(receipt.lease)); + assert_eq!(row.state.attempts, 1); + assert!(row.data.native_binding == Some(binding)); +} + +#[test] +fn invalid_unknown_and_stale_waits_cannot_change_the_current_assignment() { + let (_dir, claims, receipt, binding) = fixture(); + let wait = wait(); + let revision = claims.assignments().unwrap()[&1].data.revision; + assert!(park(&claims, &binding, &receipt, &wait, Err("unavailable".into())).is_err()); + for dependency in [ + Dependency::RequiredCi(0), + Dependency::WorkItem(1), + Dependency::ReviewedHead { + number: 2, + head: "short".into(), + }, + Dependency::OwnerRead("free text".into()), + ] { + let invalid = DependencyWait { + dependency, + deadline: 40, + }; + assert!(park(&claims, &binding, &receipt, &invalid, Ok(true)).is_err()); + } + let expired = DependencyWait { + deadline: 25, + ..wait.clone() + }; + assert!(park(&claims, &binding, &receipt, &expired, Ok(true)).is_err()); + assert!(claims + .wait_for_dependency( + "worker-a", + "host-a", + &binding, + &receipt, + 25, + 0, + &wait, + |_| panic!("stale revision") + ) + .is_err()); + assert_eq!(claims.assignments().unwrap()[&1].data.revision, revision); + assert!(claims.assignments().unwrap()[&1].data.dependency.is_none()); +} + +#[test] +fn wait_uses_latest_full_receipt_and_new_admission_clears_its_old_generation() { + let (_dir, claims, receipt, binding) = fixture(); + let wait = wait(); + assert!(park(&claims, &binding, &receipt, &wait, Ok(true)).unwrap()); + let renewed = claims + .renew_item_for(1, "worker-a", "host-a", &receipt, 30, 200) + .unwrap() + .unwrap(); + let next = DependencyWait { + dependency: Dependency::OwnerRead("read-1".into()), + deadline: 50, + }; + assert!(!park(&claims, &binding, &receipt, &next, Ok(true)).unwrap()); + let revision = claims.assignments().unwrap()[&1].data.revision; + assert!(claims + .wait_for_dependency( + "worker-a", + "host-b", + &binding, + &renewed, + 31, + revision, + &next, + |_| Ok(true) + ) + .is_err()); + assert!(claims + .wait_for_dependency( + "worker-a", + "host-a", + &binding, + &renewed, + 31, + revision, + &next, + |_| Ok(true) + ) + .unwrap()); + claims + .release_for(1, "worker-a", &receipt.lease, 32, "finished") + .unwrap(); + assert!(claims.assignments().unwrap()[&1].data.dependency.is_some()); + reserve(&claims, 33); + assert!(claims.assignments().unwrap()[&1].data.dependency.is_none()); + assert!(!park(&claims, &binding, &renewed, &next, Ok(true)).unwrap()); +} diff --git a/oxa/oxa-work/src/board/claims/ownership.rs b/oxa/oxa-work/src/board/claims/ownership.rs index bc5594ce4..9e37d1cf5 100644 --- a/oxa/oxa-work/src/board/claims/ownership.rs +++ b/oxa/oxa-work/src/board/claims/ownership.rs @@ -43,6 +43,37 @@ impl Saved { } impl Claims { + /// Retain the same directory lock across each authenticated active-item update. + pub(super) fn active_item_for( + &self, + worker_id: &str, + host_id: &str, + binding: &NativeBinding, + receipt: &ItemLease, + now: u64, + ) -> Result> { + binding.validate()?; + if !valid_worker_id(host_id) + || worker_id != binding.lease.holder + || receipt.host_id != host_id + || receipt.lease != binding.lease + { + return Err("authenticated item observer and original binding required".into()); + } + let lock = self.lock(binding.number)?; + let row = self.load(binding.number)?; + if row.item_lease().as_ref() != Some(receipt) + || row.data.native_binding.as_ref() != Some(binding) + || now >= receipt.expires_at + { + return Ok(None); + } + if receipt.lease.claimed_at.is_none_or(|start| now < start) { + return Err("item observation clock moved backwards".into()); + } + Ok(Some((lock, row))) + } + /// Hosted automatic admission retains the existing atomic idle/bootstrap fence. /// Its observer receives the current retained binding under that same lock, /// so a replacement packet can check the prior branch as well as its new branch. From 7d8b30eed397fb3662263d300be6e132af552b16 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 07:04:15 +0100 Subject: [PATCH 4/6] Resume dependency waits with atomic worker exclusion and bounded wakes --- oxa/oxa-work/src/board.rs | 1 + oxa/oxa-work/src/board/claims.rs | 2 + oxa/oxa-work/src/board/claims/controls.rs | 14 +- oxa/oxa-work/src/board/claims/dependencies.rs | 46 +++++ .../board/claims/dependencies/resume_tests.rs | 191 ++++++++++++++++++ oxa/oxa-work/src/board/claims/timing.rs | 68 +++++++ 6 files changed, 314 insertions(+), 8 deletions(-) create mode 100644 oxa/oxa-work/src/board/claims/dependencies/resume_tests.rs create mode 100644 oxa/oxa-work/src/board/claims/timing.rs diff --git a/oxa/oxa-work/src/board.rs b/oxa/oxa-work/src/board.rs index fa4038467..f06b4fb77 100644 --- a/oxa/oxa-work/src/board.rs +++ b/oxa/oxa-work/src/board.rs @@ -8,6 +8,7 @@ pub use claims::{ LeaseSignal, NativeBinding, ReleaseRecord, VerifiedMilestone, }; pub mod assignment; +pub use claims::ActivityTiming; pub use claims::{Dependency, DependencyWait}; mod intake; pub mod landing; diff --git a/oxa/oxa-work/src/board/claims.rs b/oxa/oxa-work/src/board/claims.rs index 7a007f6a8..818cc7d73 100644 --- a/oxa/oxa-work/src/board/claims.rs +++ b/oxa/oxa-work/src/board/claims.rs @@ -19,7 +19,9 @@ mod native; pub use native::NativeBinding; mod ownership; mod reviews; +mod timing; pub use ownership::{ExistingWork, ItemLease, ItemOwner}; +pub use timing::ActivityTiming; #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] diff --git a/oxa/oxa-work/src/board/claims/controls.rs b/oxa/oxa-work/src/board/claims/controls.rs index b4b5838ed..cd994a50c 100644 --- a/oxa/oxa-work/src/board/claims/controls.rs +++ b/oxa/oxa-work/src/board/claims/controls.rs @@ -173,7 +173,8 @@ impl Claims { /// Helper admission checks idleness and reserves under the SAME directory lock. /// The target must have validated Saved state; transient lock markers are not bootstrap facts. - /// Every outstanding target/worker lease, including expired work, requires fenced completion. + /// Every target and unparked worker lease needs fenced completion, including expired work. + /// Verified dependency waits retain item ownership while permitting other eligible work. /// Worker identity and roles must come from the trusted frontend, as with `claim_for`. /// Generic manual reservations retain their separate `assign`/`claim_for` semantics. pub fn claim_idle_for( @@ -196,12 +197,9 @@ impl Claims { pub(super) fn idle_for(&self, number: u64, worker_id: &str, row: &Saved) -> Result { Ok(self.established(number)? && row.state.lease.is_none() - && !self.rows_locked()?.values().any(|saved| { - saved - .state - .lease - .as_ref() - .is_some_and(|lease| lease.holder == worker_id) - })) + && !self + .rows_locked()? + .values() + .any(|saved| saved.busy_for(worker_id))) } } diff --git a/oxa/oxa-work/src/board/claims/dependencies.rs b/oxa/oxa-work/src/board/claims/dependencies.rs index 69c58baec..c2802b024 100644 --- a/oxa/oxa-work/src/board/claims/dependencies.rs +++ b/oxa/oxa-work/src/board/claims/dependencies.rs @@ -31,7 +31,51 @@ impl DependencyWait { } } +impl Saved { + pub(super) fn busy_for(&self, worker_id: &str) -> bool { + self.state.lease.as_ref().is_some_and(|lease| { + lease.holder == worker_id && (self.data.import_hold || self.data.dependency.is_none()) + }) + } +} + impl Claims { + /// Fresh verified clearance resumes only this exact wait, receipt and revision. + /// Verification runs under Claims and must not acquire task/repository locks or call Claims. + /// Expired unfinished work and imported holds remain fences; a deadline is not clearance. + pub fn resume_dependency_for( + &self, + worker_id: &str, + host_id: &str, + binding: &NativeBinding, + receipt: &ItemLease, + now: u64, + expected_revision: u64, + wait: &DependencyWait, + verify: impl FnOnce(&DependencyWait) -> Result, + ) -> Result { + let Some((_lock, mut row)) = self.active_item_for(worker_id, host_id, binding, receipt, now)? else { + return Ok(false); + }; + if row.data.revision != expected_revision { + return Err("assignment changed; refresh it".into()); + } + if row.data.import_hold + || row.data.dependency.as_ref() != Some(wait) + || self + .rows_locked()? + .iter() + .any(|(number, other)| *number != binding.number && other.busy_for(worker_id)) + || !verify(wait)? + { + return Ok(false); + } + row.data.dependency = None; + self.save(binding.number, row, true)?; + self.mark(binding.number)?; + Ok(true) + } + /// The trusted observer verifies the exact dependency and safe quiescence before parking. /// It runs under Claims: never acquire task/repository /// locks or call Claims inside it. Heartbeat, worker text and a deadline are not proof. @@ -65,5 +109,7 @@ impl Claims { } } +#[cfg(test)] +mod resume_tests; #[cfg(test)] mod tests; diff --git a/oxa/oxa-work/src/board/claims/dependencies/resume_tests.rs b/oxa/oxa-work/src/board/claims/dependencies/resume_tests.rs new file mode 100644 index 000000000..5c0ff14d9 --- /dev/null +++ b/oxa/oxa-work/src/board/claims/dependencies/resume_tests.rs @@ -0,0 +1,191 @@ +use super::*; +use crate::board::assignment::{Control, ManualAuthority, Role, Worker, WorkerKind}; +use crate::board::claims::activity::tests::fixture; +use crate::board::ImportState; + +fn wait() -> DependencyWait { + DependencyWait { + dependency: Dependency::WorkItem(3), + deadline: 40, + } +} + +fn park(claims: &Claims, binding: &NativeBinding, receipt: &ItemLease, now: u64, wait: &DependencyWait) { + let revision = claims.assignments().unwrap()[&binding.number].data.revision; + assert!(claims + .wait_for_dependency( + "worker-a", + "host-a", + binding, + receipt, + now, + revision, + wait, + |_| Ok(true) + ) + .unwrap()); +} + +fn resume( + claims: &Claims, + binding: &NativeBinding, + receipt: &ItemLease, + now: u64, + wait: &DependencyWait, + proof: bool, +) -> bool { + let revision = claims.assignments().unwrap()[&binding.number].data.revision; + claims + .resume_dependency_for( + "worker-a", + "host-a", + binding, + receipt, + now, + revision, + wait, + |_| Ok(proof), + ) + .unwrap() +} + +fn pick(claims: &Claims, now: u64) -> Option { + let entry = Entry { + number: 2, + head: "synthetic-source".into(), + release_pinned: false, + action: Action::BuildIssue, + lease: None, + attempts_today: 0, + eligible: true, + }; + let worker = Worker { + id: "worker-a".into(), + kind: WorkerKind::Codex, + skills: Default::default(), + roles: [Role::Builder].into(), + }; + claims + .claim_idle_item_for( + &entry, + &Policy { + enabled: true, + ..Policy::default() + }, + &worker, + "host-a", + (now, 100), + |_, _| Ok(None), + ) + .unwrap() +} + +#[test] +fn parked_worker_takes_next_item_and_only_fresh_clearance_resumes_original_attempt() { + let (dir, claims, receipt, binding) = fixture(); + claims + .control(2, Some(ManualAuthority::Lead), 0, Control::OwnerOnly(false)) + .unwrap(); + assert!(pick(&claims, 11).is_none()); + let wait = wait(); + park(&claims, &binding, &receipt, 12, &wait); + let claims = Claims::open(dir.path()).unwrap(); + let other = pick(&claims, 20).expect("verified parking permits actual next-item admission"); + assert!(!resume(&claims, &binding, &receipt, 22, &wait, true)); + claims + .release_for(2, "worker-a", &other.lease, 23, "finished") + .unwrap(); + assert!(!resume(&claims, &binding, &receipt, 41, &wait, false)); + let wrong = DependencyWait { + deadline: 50, + ..wait.clone() + }; + assert!(!resume(&claims, &binding, &receipt, 41, &wrong, true)); + assert!(resume(&claims, &binding, &receipt, 42, &wait, true)); + assert!(pick(&claims, 43).is_none()); + let row = claims.assignments().unwrap().remove(&1).unwrap(); + assert_eq!(row.state.lease, Some(receipt.lease)); + assert_eq!(row.state.attempts, 1); + assert!(row.data.native_binding == Some(binding)); + assert!(row.data.dependency.is_none()); +} + +#[test] +fn concurrent_clearance_cannot_resume_two_running_items_for_the_same_worker() { + let (_dir, claims, receipt, binding) = fixture(); + let wait = wait(); + park(&claims, &binding, &receipt, 12, &wait); + claims + .control(2, Some(ManualAuthority::Lead), 0, Control::OwnerOnly(false)) + .unwrap(); + let other = pick(&claims, 20).unwrap(); + let other_binding = NativeBinding::new(2, &"b".repeat(64), &other.lease, "agent/other").unwrap(); + assert!(claims.bind_native("worker-a", &other_binding).unwrap()); + park(&claims, &other_binding, &other, 21, &wait); + let outcomes = std::thread::scope(|scope| { + let first = scope.spawn(|| resume(&claims, &binding, &receipt, 30, &wait, true)); + let second = scope.spawn(|| resume(&claims, &other_binding, &other, 30, &wait, true)); + [first.join().unwrap(), second.join().unwrap()] + }); + assert_eq!(outcomes.into_iter().filter(|running| *running).count(), 1); + let rows = claims.assignments().unwrap(); + assert_eq!( + rows.values().filter(|row| row.data.dependency.is_some()).count(), + 1 + ); + assert!(rows + .values() + .all(|row| row.state.lease.is_some() && row.state.attempts == 1)); +} + +#[test] +fn imported_holds_and_stale_observations_still_block_yield_and_resume() { + let (_dir, claims, receipt, binding) = fixture(); + let wait = wait(); + park(&claims, &binding, &receipt, 12, &wait); + let old_revision = claims.assignments().unwrap()[&1].data.revision; + let state = claims.snapshot().unwrap().remove(&1).unwrap(); + claims + .import_snapshot( + Some(ManualAuthority::Lead), + &BTreeMap::from([( + 1, + ImportState { + state, + excluded: true, + }, + )]), + 13, + ) + .unwrap(); + claims + .control(2, Some(ManualAuthority::Lead), 0, Control::OwnerOnly(false)) + .unwrap(); + assert!(pick(&claims, 20).is_none()); + assert!(claims + .resume_dependency_for( + "worker-a", + "host-a", + &binding, + &receipt, + 20, + old_revision, + &wait, + |_| panic!("stale revision") + ) + .is_err()); + let revision = claims.assignments().unwrap()[&1].data.revision; + assert!(!claims + .resume_dependency_for( + "worker-a", + "host-a", + &binding, + &receipt, + 20, + revision, + &wait, + |_| panic!("import hold is not cleared by a dependency") + ) + .unwrap()); + assert!(claims.assignments().unwrap()[&1].state.lease.is_some()); +} diff --git a/oxa/oxa-work/src/board/claims/timing.rs b/oxa/oxa-work/src/board/claims/timing.rs new file mode 100644 index 000000000..f21e3f23e --- /dev/null +++ b/oxa/oxa-work/src/board/claims/timing.rs @@ -0,0 +1,68 @@ +//! Owner-selected sampling bounds; no policy starts work or grants action credit. +use super::*; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct ActivityTiming { + pub heartbeat_interval_secs: u64, + pub silence_secs: u64, +} + +impl ActivityTiming { + pub fn validate(&self) -> Result<()> { + if self.heartbeat_interval_secs == 0 + || self.silence_secs == 0 + || self.silence_secs.checked_mul(1000).is_none() + { + return Err("positive representable activity timing required".into()); + } + Ok(()) + } + + /// Assess already-due work first. Past deadlines never create a busy wake loop. + /// A future dependency deadline can shorten sampling; only verified evidence can resume. + pub fn next_wake(&self, now: u64, dependency_deadline: Option) -> Result { + self.validate()?; + let next = now + .checked_add(self.heartbeat_interval_secs) + .ok_or("activity wake overflow")?; + Ok(dependency_deadline + .filter(|deadline| *deadline > now) + .map_or(next, |deadline| next.min(deadline))) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn bounded_wake_observes_deadlines_without_inventing_progress_or_spinning() { + let timing = ActivityTiming { + heartbeat_interval_secs: 15, + silence_secs: 30, + }; + assert_eq!(timing.next_wake(100, None).unwrap(), 115); + assert_eq!(timing.next_wake(100, Some(108)).unwrap(), 108); + assert_eq!(timing.next_wake(100, Some(90)).unwrap(), 115); + assert!(timing.next_wake(u64::MAX, None).is_err()); + assert!(ActivityTiming { + heartbeat_interval_secs: 0, + ..timing + } + .validate() + .is_err()); + assert!(ActivityTiming { + silence_secs: 0, + ..timing + } + .validate() + .is_err()); + assert!(ActivityTiming { + silence_secs: u64::MAX, + ..timing + } + .validate() + .is_err()); + } +} From 9b47bbcad01e848c919e2f60ec018cd62ce3f37a Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 07:17:45 +0100 Subject: [PATCH 5/6] Require original clock overflow refusals while waiting on dependencies --- oxa/oxa-work/src/board/claims/dependencies/tests.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/oxa/oxa-work/src/board/claims/dependencies/tests.rs b/oxa/oxa-work/src/board/claims/dependencies/tests.rs index 61628e4b4..bcdb4050a 100644 --- a/oxa/oxa-work/src/board/claims/dependencies/tests.rs +++ b/oxa/oxa-work/src/board/claims/dependencies/tests.rs @@ -50,6 +50,8 @@ fn dependency_wait_survives_reopening_and_deadline_is_not_release_or_progress() let row = claims.assignments().unwrap().remove(&1).unwrap(); assert_eq!(row.data.dependency, Some(wait)); assert!(!row.stalled(39, Some(5)).unwrap()); + assert!(row.stalled(39, Some(u64::MAX)).is_err()); + assert!(row.stalled(u64::MAX, Some(5)).is_err()); assert!(row.stalled(40, Some(5)).unwrap()); assert!(row.stalled(100, Some(5)).unwrap()); assert_eq!(row.state.lease, Some(receipt.lease)); From 781f27ff2f99bc7e51eac12b942ccfb1dd540490 Mon Sep 17 00:00:00 2001 From: oxa-agent Date: Wed, 18 Nov 2026 07:27:26 +0100 Subject: [PATCH 6/6] Validate activity clocks before applying dependency deadlines --- oxa/oxa-work/src/board/claims/activity.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/oxa/oxa-work/src/board/claims/activity.rs b/oxa/oxa-work/src/board/claims/activity.rs index 33c320fda..deaed23a3 100644 --- a/oxa/oxa-work/src/board/claims/activity.rs +++ b/oxa/oxa-work/src/board/claims/activity.rs @@ -71,14 +71,15 @@ impl Assignment { if now < last / 1000 { return Err("item action clock moved backwards".into()); } - if let Some(wait) = &self.data.dependency { - return Ok(now >= wait.deadline); - } let deadline = silence .checked_mul(1000) .and_then(|timeout| last.checked_add(timeout)) .ok_or("silence deadline overflow")?; - Ok(now.checked_mul(1000).ok_or("item action clock overflow")? >= deadline) + let now_ms = now.checked_mul(1000).ok_or("item action clock overflow")?; + if let Some(wait) = &self.data.dependency { + return Ok(now >= wait.deadline); + } + Ok(now_ms >= deadline) } }