From 32ce137ec7cc058417351ad1a2d8b1336a91796e Mon Sep 17 00:00:00 2001 From: Oscar Nordstrom <13300531+n0rpan@users.noreply.github.com> Date: Tue, 17 Nov 2026 21:35:09 +0100 Subject: [PATCH 1/2] test(lead): follow native goal status across saved sessions --- oxa/Cargo.lock | 1 + oxa/oxa-cli/Cargo.toml | 3 ++ oxa/oxa-cli/src/lead_preset.rs | 91 +++++++++++++++++++++++++++++++++- 3 files changed, 94 insertions(+), 1 deletion(-) diff --git a/oxa/Cargo.lock b/oxa/Cargo.lock index bca2abf8..85a2486e 100644 --- a/oxa/Cargo.lock +++ b/oxa/Cargo.lock @@ -1164,6 +1164,7 @@ dependencies = [ "oxa-fake", "oxa-interactive", "oxa-mcp", + "oxa-orchestrator", "oxa-perm", "oxa-proto", "oxa-resources", diff --git a/oxa/oxa-cli/Cargo.toml b/oxa/oxa-cli/Cargo.toml index da65be48..82204384 100644 --- a/oxa/oxa-cli/Cargo.toml +++ b/oxa/oxa-cli/Cargo.toml @@ -52,5 +52,8 @@ pulldown-cmark = { version = "0.13.6", default-features = false } [dev-dependencies] oxa-fake.workspace = true +[target.'cfg(target_os = "linux")'.dev-dependencies] +oxa-orchestrator = { path = "../oxa-orchestrator", features = ["a2a"] } + [lints] workspace = true diff --git a/oxa/oxa-cli/src/lead_preset.rs b/oxa/oxa-cli/src/lead_preset.rs index 2c892e1e..ccc3c66c 100644 --- a/oxa/oxa-cli/src/lead_preset.rs +++ b/oxa/oxa-cli/src/lead_preset.rs @@ -109,7 +109,7 @@ mod tests { fn session( env: &oxa_fake::TestEnv, - store: Arc, + store: Arc, hooks: Vec>, how: oxa_core::Open, ) -> Result { @@ -194,4 +194,93 @@ mod tests { assert_eq!(error.code, codes::USAGE); assert!(lead.goal().is_none()); } + + #[cfg(target_os = "linux")] + #[test] + fn follow_observes_the_saved_goal_and_does_not_keep_it_after_a_session_switch() { + use oxa_orchestrator::follow::publisher::Publisher; + use oxa_session::{FsStore, Goal, GoalStatus}; + use serde_json::{json, Value}; + + let env = oxa_fake::TestEnv::new(); + let directory = env.root().join("sessions"); + let open = |how| { + session( + &env, + Arc::new(FsStore::new(directory.clone())), + vec![Arc::new(NoHooks)], + how, + ) + .unwrap() + }; + let (mut ui, mut sink) = (oxa_proto::HeadlessUi::default(), oxa_proto::VecSink::default()); + let publisher = Publisher::default(); + let refresh = |owner: &oxa_core::Session| { + let state = owner.state(); + let goal = owner + .goal() + .map_or(Value::Null, |goal| json!({"status": goal.status.as_str()})); + publisher + .bind_session( + &state.session_id, + &state.model, + state.mode.as_str(), + state.is_streaming, + ) + .unwrap(); + assert_eq!( + publisher.publish("goal_status", goal.clone(), None, None), + Ok(None) + ); + assert_eq!( + publisher.latest().unwrap(), + json!({ + "goal": goal, "kind": "goal_status", "tasks": null, + "session": {"id": state.session_id, "model": state.model, + "mode": state.mode.as_str(), "busy": state.is_streaming} + }) + ); + }; + + let mut owner = open(oxa_core::Open::New); + let saved = owner.inner().sref.clone(); + let mut goal = Goal::new("Synthetic private goal".into(), Default::default(), 1).unwrap(); + owner.set_goal(Some(goal.clone()), &mut sink).unwrap(); + refresh(&owner); + assert_eq!(publisher.latest().unwrap()["goal"], json!({"status": "pursuing"})); + assert_eq!(publisher.page(0).unwrap().latest, 0); + + goal.finish(GoalStatus::Blocked, "Synthetic private evidence".into()) + .unwrap(); + owner.set_goal(Some(goal), &mut sink).unwrap(); + refresh(&owner); + let approved_goal = publisher.latest().unwrap()["goal"].clone(); + assert_eq!(approved_goal, json!({"status": "blocked"})); + assert_eq!( + publisher.publish("goal_observed", approved_goal, None, None), + Ok(Some(1)) + ); + owner.shutdown(&mut ui); + drop(owner); + + let mut owner = open(oxa_core::Open::Resume(saved.clone())); + refresh(&owner); + let resumed = publisher.latest().unwrap(); + assert_eq!(resumed["session"]["id"], saved.id.as_str()); + assert_eq!(resumed["goal"], json!({"status": "blocked"})); + assert_eq!(publisher.page(1).unwrap().latest, 1); + + owner.switch(oxa_core::Open::New, &mut sink, &mut ui).unwrap(); + let new_id = owner.state().session_id; + assert_ne!(new_id, saved.id); + refresh(&owner); + let current = publisher.latest().unwrap(); + assert_eq!(current["session"]["id"], new_id.as_str()); + assert!(current["goal"].is_null()); + let history = publisher.page(0).unwrap(); + assert_eq!(history.latest, 1); + assert_eq!(history.events[0].1["session"]["id"], saved.id.as_str()); + assert_eq!(history.events[0].1["goal"], json!({"status": "blocked"})); + owner.shutdown(&mut ui); + } } From ebe979ee98e5684476f42450c79661a161dc2b43 Mon Sep 17 00:00:00 2001 From: Oscar Nordstrom <13300531+n0rpan@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:31:39 +0100 Subject: [PATCH 2/2] Derive bounded lead digest from verified runner facts --- oxa/oxa-work/src/events.rs | 10 +++- oxa/oxa-work/src/events/digest.rs | 94 +++++++++++++++++++++++++++++++ oxa/oxa-work/src/events/tests.rs | 77 +++++++++++++++++++++++++ 3 files changed, 179 insertions(+), 2 deletions(-) create mode 100644 oxa/oxa-work/src/events/digest.rs diff --git a/oxa/oxa-work/src/events.rs b/oxa/oxa-work/src/events.rs index 8d480a0d..c5ce9496 100644 --- a/oxa/oxa-work/src/events.rs +++ b/oxa/oxa-work/src/events.rs @@ -8,6 +8,9 @@ use serde::{Deserialize, Serialize}; use serde_json::Value; use std::path::Path; +mod digest; +pub use digest::{Digest, DigestChanges, DigestGap}; + const CURRENT: &str = "events.jsonl"; const PREVIOUS: &str = "events.previous.jsonl"; const STATE: &str = "facts.json"; @@ -300,11 +303,14 @@ impl Facts { self.recover().map(|(_, snapshot, _)| snapshot) } pub fn events_after(&self, after: u64, limit: usize) -> Result { + self.read_window(after, limit).map(|(_, page)| page) + } + fn read_window(&self, after: u64, limit: usize) -> Result<(Snapshot, EventPage)> { if !(1..=64).contains(&limit) { return Err("event page limit must be between 1 and 64".into()); } let _lock = self.root.lock(LOCK)?; - let (state, _, journal) = self.recover()?; + let (state, snapshot, journal) = self.recover()?; if after > state.last_seq { return Err("event cursor is ahead of the journal".into()); } @@ -343,7 +349,7 @@ impl Facts { page.events.push(event); } page.to_json().map_err(|error| error.to_string())?; - Ok(page) + Ok((snapshot, page)) } fn journal(&self, pending: bool) -> Result { // The only allowed missing current file is an interrupted, durably reserved rotation. diff --git a/oxa/oxa-work/src/events/digest.rs b/oxa/oxa-work/src/events/digest.rs new file mode 100644 index 00000000..d30f0247 --- /dev/null +++ b/oxa/oxa-work/src/events/digest.rs @@ -0,0 +1,94 @@ +//! A bounded, deterministic digest of facts observed since an owner's cursor. +use super::{Facts, Result}; +use oxa_proto::work::{Blocked, Fact, Incident, IncidentKind, Landed, Snapshot, Subject}; + +#[derive(Debug, PartialEq, Eq)] +pub enum Digest { + Quiet { through: u64 }, + Changes(DigestChanges), + SnapshotOnly { snapshot: Snapshot, reason: DigestGap }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum DigestGap { + Retention, + PageLimit, +} + +#[derive(Debug, PartialEq, Eq)] +pub struct DigestChanges { + pub after: u64, + pub through: u64, + pub merged: Vec, + pub blocked: Vec, + pub cleared: Vec, + /// These events establish an observed stall, not that a worker is still stalled. + pub observed_stalls: Vec, + pub asks_waiting: usize, +} + +impl Facts { + /// Read one coherent bounded window. Callers can show the fresh snapshot when + /// the complete interval is unavailable, without representing it as a delta. + pub fn digest_since(&self, after: u64) -> Result { + let (snapshot, page) = self.read_window(after, 64)?; + if page.gap || page.next != snapshot.as_of_seq { + return Ok(Digest::SnapshotOnly { + reason: if page.gap { + DigestGap::Retention + } else { + DigestGap::PageLimit + }, + snapshot, + }); + } + let mut changes = DigestChanges { + after, + through: page.next, + merged: Vec::new(), + blocked: Vec::new(), + cleared: Vec::new(), + observed_stalls: Vec::new(), + asks_waiting: snapshot.asks.len(), + }; + let mut asks_changed = false; + for event in page.events { + match event.fact { + Fact::PrMerged(landed) => { + changes.merged.retain(|prior| prior.pr.number != landed.pr.number); + changes.merged.push(landed); + } + Fact::Blocked(block) => { + changes.cleared.retain(|subject| *subject != block.subject); + changes.blocked.retain(|prior| prior.subject != block.subject); + changes.blocked.push(block); + } + Fact::Unblocked(subject) => { + changes.blocked.retain(|prior| prior.subject != subject); + changes.cleared.retain(|prior| *prior != subject); + changes.cleared.push(subject); + } + Fact::AskOpened(_) | Fact::AskClosed(_) => asks_changed = true, + Fact::StandingChanged(standing) => { + asks_changed |= standing.ask_opened.is_some() || standing.ask_closed.is_some(); + } + Fact::Incident(incident) if incident.kind == IncidentKind::WorkerStalled => { + changes + .observed_stalls + .retain(|prior| prior.subject != incident.subject); + changes.observed_stalls.push(incident); + } + _ => {} + } + } + if changes.merged.is_empty() + && changes.blocked.is_empty() + && changes.cleared.is_empty() + && changes.observed_stalls.is_empty() + && !asks_changed + { + return Ok(Digest::Quiet { through: page.next }); + } + Ok(Digest::Changes(changes)) + } +} diff --git a/oxa/oxa-work/src/events/tests.rs b/oxa/oxa-work/src/events/tests.rs index 145e9afd..402732f7 100644 --- a/oxa/oxa-work/src/events/tests.rs +++ b/oxa/oxa-work/src/events/tests.rs @@ -834,3 +834,80 @@ fn artifacts_are_private_and_source_capacity_does_not_consume_a_sequence() { assert!(facts.append(checkpoint("too-many", 1), 0, mechanical()).is_err()); assert_eq!(facts.situation().unwrap().as_of_seq, MAX_SOURCES as u64); } + +#[test] +fn digest_uses_durable_changes_and_the_current_ask_count() { + let fixture = Fixture::new(); + let facts = fixture.facts(); + let pr = PullRequest { + number: 3, + head: "a".repeat(40), + }; + let subject = Subject::PullRequest(pr.number); + let merged = Landed { + pr, + merge_commit: "b".repeat(40), + merged_at_ms: 4, + }; + let observations = [ + mechanical(), + Fact::Blocked(Blocked { + subject: subject.clone(), + code: "waiting".into(), + ask_id: None, + }), + Fact::Unblocked(subject.clone()), + Fact::PrMerged(merged.clone()), + Fact::AskOpened(Ask { + id: "fixture-ask".into(), + subject: Subject::Repository, + question: "Choose one option".into(), + }), + ]; + for (index, fact) in observations.into_iter().enumerate() { + let revision = index as u64 + 1; + facts + .append(checkpoint("digest", revision), revision, fact) + .unwrap(); + } + let reopened = Facts::open(&fixture.root()).unwrap(); + let Digest::Changes(changes) = reopened.digest_since(1).unwrap() else { + panic!("complete retained interval must produce a digest"); + }; + assert_eq!(changes.after, 1); + assert_eq!(changes.through, 5); + assert_eq!(changes.merged, [merged]); + assert!(changes.blocked.is_empty()); + assert_eq!(changes.cleared, [subject]); + assert_eq!(changes.asks_waiting, 1); + facts.append(checkpoint("digest", 6), 6, mechanical()).unwrap(); + assert_eq!(reopened.digest_since(5).unwrap(), Digest::Quiet { through: 6 }); +} + +#[test] +fn digest_reports_a_fresh_snapshot_for_incomplete_intervals() { + let fixture = Fixture::new(); + let mut facts = fixture.facts(); + for revision in 1..=65 { + facts + .append(checkpoint("digest", revision), revision, mechanical()) + .unwrap(); + } + assert!(matches!( + facts.digest_since(0).unwrap(), + Digest::SnapshotOnly { snapshot, reason: DigestGap::PageLimit } if snapshot.as_of_seq == 65 + )); + + let fixture = Fixture::new(); + facts = fixture.facts(); + facts.journal_bytes = 512; + for revision in 1..=20 { + facts + .append(checkpoint("digest", revision), revision, mechanical()) + .unwrap(); + } + assert!(matches!( + facts.digest_since(0).unwrap(), + Digest::SnapshotOnly { snapshot, reason: DigestGap::Retention } if snapshot.as_of_seq == 20 + )); +}