From bd9c893146d0c82a35a72e82c8097cc9af5d14a0 Mon Sep 17 00:00:00 2001 From: Lee Faus Date: Mon, 7 Sep 2026 15:25:03 -0400 Subject: [PATCH 01/15] fix turn orchestrator --- atomic-agent/src/turn/session.rs | 78 ++++++++++++++++++++++++++++---- 1 file changed, 68 insertions(+), 10 deletions(-) diff --git a/atomic-agent/src/turn/session.rs b/atomic-agent/src/turn/session.rs index 275a8513..781c654c 100644 --- a/atomic-agent/src/turn/session.rs +++ b/atomic-agent/src/turn/session.rs @@ -54,6 +54,7 @@ use std::fmt; use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicU64, Ordering}; use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; @@ -442,6 +443,8 @@ impl super::phase::SessionState for AgentSession { // SessionStore +static SESSION_TMP_SEQUENCE: AtomicU64 = AtomicU64::new(0); + /// Persistent storage for agent session state files. /// /// Sessions are stored as `{session_id}.json` files in the sessions directory @@ -522,7 +525,7 @@ impl SessionStore { validate_session_id(&session.session_id)?; let path = self.session_path(&session.session_id); - let tmp_path = path.with_extension("json.tmp"); + let tmp_path = self.temp_session_path(&session.session_id); let data = serde_json::to_string_pretty(session).map_err(|e| AgentError::SessionSaveFailed { @@ -530,17 +533,25 @@ impl SessionStore { reason: format!("JSON serialize error: {}", e), })?; - // Write to temp file - std::fs::write(&tmp_path, data.as_bytes()).map_err(|e| AgentError::SessionSaveFailed { - session_id: session.session_id.clone(), - reason: format!("write temp file: {}", e), - })?; + // Each writer needs its own same-directory temp file. Concurrent hook + // processes can save the same session, and threads within one process + // must not collide either. + if let Err(e) = std::fs::write(&tmp_path, data.as_bytes()) { + let _ = std::fs::remove_file(&tmp_path); + return Err(AgentError::SessionSaveFailed { + session_id: session.session_id.clone(), + reason: format!("write temp file: {}", e), + }); + } // Atomic rename - std::fs::rename(&tmp_path, &path).map_err(|e| AgentError::SessionSaveFailed { - session_id: session.session_id.clone(), - reason: format!("rename temp file: {}", e), - })?; + if let Err(e) = std::fs::rename(&tmp_path, &path) { + let _ = std::fs::remove_file(&tmp_path); + return Err(AgentError::SessionSaveFailed { + session_id: session.session_id.clone(), + reason: format!("rename temp file: {}", e), + }); + } Ok(()) } @@ -626,6 +637,16 @@ impl SessionStore { self.sessions_dir.join(format!("{}.json", session_id)) } + fn temp_session_path(&self, session_id: &str) -> PathBuf { + let sequence = SESSION_TMP_SEQUENCE.fetch_add(1, Ordering::Relaxed); + self.sessions_dir.join(format!( + ".{}.json.{}.{}.tmp", + session_id, + std::process::id(), + sequence + )) + } + /// Returns the sessions directory path. pub fn sessions_dir(&self) -> &Path { &self.sessions_dir @@ -1117,6 +1138,43 @@ mod tests { assert_eq!(loaded.agent_name, "claude-code"); } + #[test] + fn test_store_concurrent_saves_do_not_share_temp_files() { + use std::sync::{Arc, Barrier}; + + const WRITERS: usize = 32; + + let (_dir, store) = make_store(); + let store = Arc::new(store); + let barrier = Arc::new(Barrier::new(WRITERS)); + let mut writers = Vec::with_capacity(WRITERS); + + for turn_count in 0..WRITERS { + let store = Arc::clone(&store); + let barrier = Arc::clone(&barrier); + writers.push(std::thread::spawn(move || { + let mut session = make_session(); + session.turn_count = turn_count as u32; + barrier.wait(); + store.save(&session) + })); + } + + for writer in writers { + writer.join().unwrap().unwrap(); + } + + let loaded = store.load("sess-abc-123").unwrap().unwrap(); + assert!(loaded.turn_count < WRITERS as u32); + + let remaining_files: Vec<_> = std::fs::read_dir(store.sessions_dir()) + .unwrap() + .map(|entry| entry.unwrap().file_name()) + .collect(); + assert_eq!(remaining_files.len(), 1); + assert_eq!(remaining_files[0], "sess-abc-123.json"); + } + #[test] fn test_store_load_nonexistent() { let (_dir, store) = make_store(); From 96009342c4c032d657178df18c68b5d7c9fdd4d8 Mon Sep 17 00:00:00 2001 From: Lee Faus Date: Tue, 8 Sep 2026 11:24:39 -0400 Subject: [PATCH 02/15] fix logs in opencode --- atomic-cli/src/commands/agent/lifecycle.rs | 94 ++++++++++++------- .../src/record/workflow/assembly/mod.rs | 51 ++++------ .../src/record/workflow/globalize/hunk.rs | 24 ++--- atomic-repository/src/apply/mod.rs | 14 +-- atomic-repository/src/repository/status.rs | 30 ++---- 5 files changed, 96 insertions(+), 117 deletions(-) diff --git a/atomic-cli/src/commands/agent/lifecycle.rs b/atomic-cli/src/commands/agent/lifecycle.rs index c86a2552..71fdf31c 100644 --- a/atomic-cli/src/commands/agent/lifecycle.rs +++ b/atomic-cli/src/commands/agent/lifecycle.rs @@ -11,7 +11,8 @@ //! sandbox pointer) so sandbox hooks see project-root lifecycles. //! //! `expires_at` is crash protection, not a session limit: a dead -//! orchestrator's lease expires on its own and is cleaned up lazily. +//! orchestrator's lease expires on its own, stops governing hooks, and remains +//! visible as stale until `lifecycle end` harvests and removes it. use std::fs; use std::path::{Path, PathBuf}; @@ -210,7 +211,9 @@ struct LifecycleEndResult { #[derive(Debug, Serialize)] struct LifecycleStatus { active: bool, + interrupted: bool, lifecycles: Vec, + stale_lifecycles: Vec, } impl Command for Lifecycle { @@ -237,7 +240,6 @@ impl Begin { let now = now_secs(); let dir = lifecycle_dir(&dot_dir); - cleanup_expired(&dir, now); // Idempotent begin: the same owner+session renews its existing run // (noname retries begin on reconnect) instead of minting a new id. @@ -344,26 +346,42 @@ impl Status { fn run(&self) -> CliResult<()> { let dot_dir = resolve_dot_dir()?; let dir = lifecycle_dir(&dot_dir); - let lifecycles = list_active(&dir, now_secs()); + let (lifecycles, stale_lifecycles) = list_by_state(&dir, now_secs()); if self.json { let status = LifecycleStatus { active: !lifecycles.is_empty(), + interrupted: !stale_lifecycles.is_empty(), lifecycles, + stale_lifecycles, }; println!("{}", serde_json::to_string(&status).unwrap()); - } else if lifecycles.is_empty() { - println!("No active managed lifecycles."); } else { - for l in lifecycles { + if lifecycles.is_empty() { + println!("No active managed lifecycles."); + } else { + for l in lifecycles { + println!( + "Managed run {}: owner={} session={} view={} workdir={} expires_at={}", + l.run_id, + l.owner_agent, + l.owner_session_id, + l.view.as_deref().unwrap_or("-"), + l.workdir.display(), + l.expires_at, + ); + } + } + for l in stale_lifecycles { println!( - "Managed run {}: owner={} session={} view={} workdir={} expires_at={}", + "Interrupted managed run {}: owner={} session={} view={} workdir={} lease_expired_at={} (run lifecycle end --run-id {} to harvest and remove)", l.run_id, l.owner_agent, l.owner_session_id, l.view.as_deref().unwrap_or("-"), l.workdir.display(), l.expires_at, + l.run_id, ); } } @@ -436,13 +454,13 @@ fn current_dir_canonical() -> CliResult { Ok(canonicalize_lenient(&cwd)) } -fn list_active(dir: &Path, now: i64) -> Vec { +fn list_lifecycles(dir: &Path) -> Vec { let entries = match fs::read_dir(dir) { Ok(entries) => entries, Err(_) => return Vec::new(), }; - let mut active = Vec::new(); + let mut lifecycles = Vec::new(); for entry in entries.flatten() { let path = entry.path(); if path.extension().and_then(|e| e.to_str()) != Some("json") { @@ -455,32 +473,19 @@ fn list_active(dir: &Path, now: i64) -> Vec { log::warn!("skipping unparseable lifecycle file {}", path.display()); continue; }; - if !lifecycle.is_expired(now) { - active.push(lifecycle); - } + lifecycles.push(lifecycle); } - active + lifecycles } -fn cleanup_expired(dir: &Path, now: i64) { - let entries = match fs::read_dir(dir) { - Ok(entries) => entries, - Err(_) => return, - }; - for entry in entries.flatten() { - let path = entry.path(); - if path.extension().and_then(|e| e.to_str()) != Some("json") { - continue; - } - let expired = fs::read_to_string(&path) - .ok() - .and_then(|data| serde_json::from_str::(&data).ok()) - .map(|l| l.is_expired(now)) - .unwrap_or(false); - if expired { - let _ = fs::remove_file(&path); - } - } +fn list_by_state(dir: &Path, now: i64) -> (Vec, Vec) { + list_lifecycles(dir) + .into_iter() + .partition(|lifecycle| !lifecycle.is_expired(now)) +} + +fn list_active(dir: &Path, now: i64) -> Vec { + list_by_state(dir, now).0 } fn load_lifecycle(dir: &Path, run_id: &str) -> CliResult> { @@ -626,7 +631,7 @@ mod tests { } #[test] - fn expired_lifecycles_are_ignored_and_cleaned() { + fn expired_lifecycles_are_ignored_but_retained_for_interruption_detection() { let temp = TempDir::new().unwrap(); let dir = temp.path().join(LIFECYCLE_DIR); let now = now_secs(); @@ -634,15 +639,32 @@ mod tests { save_lifecycle(&dir, &lifecycle("run-old", "sherpa", temp.path(), now - 1)).unwrap(); save_lifecycle(&dir, &lifecycle("run-new", "sherpa", temp.path(), now + 60)).unwrap(); - let active = list_active(&dir, now); + let (active, stale) = list_by_state(&dir, now); assert_eq!(active.len(), 1); assert_eq!(active[0].run_id, "run-new"); + assert_eq!(stale.len(), 1); + assert_eq!(stale[0].run_id, "run-old"); - cleanup_expired(&dir, now); - assert!(!lifecycle_path(&dir, "run-old").exists()); + assert!(lifecycle_path(&dir, "run-old").exists()); assert!(lifecycle_path(&dir, "run-new").exists()); } + #[test] + fn lifecycle_status_reports_interrupted_stale_runs() { + let temp = TempDir::new().unwrap(); + let status = LifecycleStatus { + active: false, + interrupted: true, + lifecycles: Vec::new(), + stale_lifecycles: vec![lifecycle("run-old", "sherpa", temp.path(), 1)], + }; + + let json = serde_json::to_value(status).unwrap(); + assert_eq!(json["active"], false); + assert_eq!(json["interrupted"], true); + assert_eq!(json["stale_lifecycles"][0]["run_id"], "run-old"); + } + #[test] fn governs_requires_cwd_inside_workdir() { let temp = TempDir::new().unwrap(); diff --git a/atomic-core/src/record/workflow/assembly/mod.rs b/atomic-core/src/record/workflow/assembly/mod.rs index c3231248..7f8c4f24 100644 --- a/atomic-core/src/record/workflow/assembly/mod.rs +++ b/atomic-core/src/record/workflow/assembly/mod.rs @@ -440,14 +440,14 @@ where } } let glob_ms = glob_start.elapsed().as_millis(); - if glob_ms > 100 { - eprintln!( - "[assemble] pre-globalized '{}' {}ms ({} hunks)", - file.path(), - glob_ms, - pre_ops.len(), - ); - } + log::debug!( + "assemble_change: pre-globalized file {}/{} '{}' in {}ms ({} hunks)", + file_idx + 1, + total_files, + file.path(), + glob_ms, + pre_ops.len(), + ); stats.record_file(); continue; } @@ -495,32 +495,15 @@ where ctx.add_hunk(graph_op.clone()); } - if glob_ms > 100 { - eprintln!( - "[assemble] SLOW '{}' {}ms ({} hunks)", - file.path(), - glob_ms, - hunk_count, - ); - log::warn!( - "assemble_change: SLOW file {}/{} '{}' took {}ms ({} hunks, {} bytes added)", - file_idx + 1, - total_files, - file.path(), - glob_ms, - hunk_count, - globalized.bytes_added(), - ); - } else { - log::debug!( - "assemble_change: file {}/{} '{}' globalized in {}ms ({} hunks)", - file_idx + 1, - total_files, - file.path(), - glob_ms, - hunk_count, - ); - } + log::debug!( + "assemble_change: file {}/{} '{}' globalized in {}ms ({} hunks, {} bytes added)", + file_idx + 1, + total_files, + file.path(), + glob_ms, + hunk_count, + globalized.bytes_added(), + ); stats.add_content_bytes(globalized.bytes_added()); globalized_files.push(globalized); diff --git a/atomic-core/src/record/workflow/globalize/hunk.rs b/atomic-core/src/record/workflow/globalize/hunk.rs index 9f20aff8..5a44ea4a 100644 --- a/atomic-core/src/record/workflow/globalize/hunk.rs +++ b/atomic-core/src/record/workflow/globalize/hunk.rs @@ -945,23 +945,13 @@ where } let elapsed_ms = step.elapsed().as_millis(); - if elapsed_ms > 50 { - log::warn!( - "find_content_vertices_inode: inode={:?} took {}ms ({} content vertices, {} visited)", - inode, - elapsed_ms, - content_vertices.len(), - visited.len(), - ); - } else { - log::debug!( - "find_content_vertices_inode: inode={:?} took {}ms ({} content vertices, {} visited)", - inode, - elapsed_ms, - content_vertices.len(), - visited.len(), - ); - } + log::debug!( + "find_content_vertices_inode: inode={:?} took {}ms ({} content vertices, {} visited)", + inode, + elapsed_ms, + content_vertices.len(), + visited.len(), + ); Ok(content_vertices) } diff --git a/atomic-repository/src/apply/mod.rs b/atomic-repository/src/apply/mod.rs index 480c7cda..2b9fed2a 100644 --- a/atomic-repository/src/apply/mod.rs +++ b/atomic-repository/src/apply/mod.rs @@ -330,15 +330,11 @@ pub fn write_change_to_graph( crdt_start.elapsed() ); } - if crdt_ms > 50 { - log::warn!( - "write_change_to_graph: SLOW apply_file_ops took {}ms ({} FileOps)", - crdt_ms, - file_ops_count - ); - } else { - log::debug!("write_change_to_graph: apply_file_ops took {}ms", crdt_ms); - } + log::debug!( + "write_change_to_graph: apply_file_ops took {}ms ({} FileOps)", + crdt_ms, + file_ops_count + ); } else { log::debug!("write_change_to_graph: no FileOps to apply"); } diff --git a/atomic-repository/src/repository/status.rs b/atomic-repository/src/repository/status.rs index 19c72e2b..b7eab48c 100644 --- a/atomic-repository/src/repository/status.rs +++ b/atomic-repository/src/repository/status.rs @@ -545,27 +545,15 @@ impl Repository { let untracked_ms = untracked_start.elapsed().as_millis(); let total_ms = overall_start.elapsed().as_millis(); - if total_ms > 100 { - log::warn!( - "status: total={}ms (view_filter={}ms tree_scan={}ms index_load={}ms classify={}ms untracked={}ms)", - total_ms, - phase1_ms, - tree_ms, - index_ms, - classify_ms, - untracked_ms - ); - } else { - log::debug!( - "status: total={}ms (view_filter={}ms tree_scan={}ms index_load={}ms classify={}ms untracked={}ms)", - total_ms, - phase1_ms, - tree_ms, - index_ms, - classify_ms, - untracked_ms - ); - } + log::debug!( + "status: total={}ms (view_filter={}ms tree_scan={}ms index_load={}ms classify={}ms untracked={}ms)", + total_ms, + phase1_ms, + tree_ms, + index_ms, + classify_ms, + untracked_ms + ); Ok(status) } From 4087391bf11f8dfa68a04b8211cee107f58b8e93 Mon Sep 17 00:00:00 2001 From: Lee Faus Date: Tue, 8 Sep 2026 12:06:25 -0400 Subject: [PATCH 03/15] update redb to 4.2.0 --- Cargo.lock | 14 +++- Cargo.toml | 3 +- .../src/turn/orchestrator/provenance.rs | 80 +++++-------------- atomic-agent/src/turn/orchestrator/tests.rs | 38 +++++++++ atomic-agent/src/turn/orchestrator/turn.rs | 11 +-- atomic-core/Cargo.toml | 2 + atomic-core/src/pristine/txn/pristine.rs | 73 +++++++++++++++-- .../src/redb_change_store/mod.rs | 2 +- .../src/redb_change_store/queries.rs | 1 + 9 files changed, 145 insertions(+), 79 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7d268a1f..15383c7e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -241,7 +241,8 @@ dependencies = [ "quickcheck", "quickcheck_macros", "rayon", - "redb", + "redb 2.6.3", + "redb 4.2.0", "serde", "serde_json", "similar", @@ -335,7 +336,7 @@ dependencies = [ "postcard", "rand 0.8.7", "rayon", - "redb", + "redb 4.2.0", "reflink-copy", "reqwest", "serde", @@ -2271,6 +2272,15 @@ dependencies = [ "libc", ] +[[package]] +name = "redb" +version = "4.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de6c3b63e007e90ce536ec2ae4690826136a20ec8dbbbb400daef1bb999d2e36" +dependencies = [ + "libc", +] + [[package]] name = "redox_syscall" version = "0.5.18" diff --git a/Cargo.toml b/Cargo.toml index 4819b9ee..9948c3fe 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -59,7 +59,8 @@ rand = "0.8" zstd = "0.13" # Database -redb = "2.1" +redb = "4.2.0" +redb_2_6 = { package = "redb", version = "=2.6.3" } # Read-only access to OpenCode's session store (transcript recovery); # bundled so no system SQLite is required. rusqlite = { version = "0.32", features = ["bundled"] } diff --git a/atomic-agent/src/turn/orchestrator/provenance.rs b/atomic-agent/src/turn/orchestrator/provenance.rs index 8eec2f71..95133d96 100644 --- a/atomic-agent/src/turn/orchestrator/provenance.rs +++ b/atomic-agent/src/turn/orchestrator/provenance.rs @@ -49,7 +49,8 @@ impl TurnOrchestrator { /// lock is released. If `f` returns `false`, the accumulator is /// discarded (read-only access). /// - /// Best-effort: returns `None` if the lock or load fails. + /// Best-effort: waits for concurrent updates and returns `None` if the lock + /// or load fails. fn with_accumulator(&self, session_id: &str, f: F) -> Option where F: FnOnce(&mut ProvenanceAccumulator) -> bool, @@ -79,15 +80,8 @@ impl TurnOrchestrator { } }; - if let Err(e) = lock_file.try_lock_exclusive() { - if super::is_lock_contended(&e) { - log::warn!( - "Provenance accumulator for session {} is already locked; skipping best-effort provenance update", - session_id, - ); - } else { - log::warn!("Failed to acquire lock for session {}: {}", session_id, e,); - } + if let Err(e) = lock_file.lock_exclusive() { + log::warn!("Failed to acquire lock for session {}: {}", session_id, e,); return None; } @@ -125,59 +119,21 @@ impl TurnOrchestrator { Some(acc) } - /// Load the provenance accumulator for a session (read-only, locked). + /// Mutate and save a session's provenance accumulator under one lock. /// - /// Best-effort: returns `None` on failure (logged, never fatal). - pub(crate) fn load_accumulator(&self, session_id: &str) -> Option { - self.with_accumulator(session_id, |_| false) - } - - /// Save the provenance accumulator for a session. - /// - /// Best-effort: failures are logged but never fatal. - pub(crate) fn save_accumulator(&self, session_id: &str, acc: &ProvenanceAccumulator) { - // We can't reuse with_accumulator here because we already have - // the accumulator in hand. Acquire the lock, write, release. - use fs2::FileExt; - - let dir = self.session_graph_dir(session_id); - let _ = std::fs::create_dir_all(&dir); - let lock_path = dir.join(LOCK_FILENAME); - - let lock_file = match std::fs::OpenOptions::new() - .create(true) - .write(true) - .truncate(false) - .open(&lock_path) - { - Ok(f) => f, - Err(e) => { - log::warn!("Failed to open lock file for session {}: {}", session_id, e); - return; - } - }; - - if let Err(e) = lock_file.try_lock_exclusive() { - if super::is_lock_contended(&e) { - log::warn!( - "Provenance accumulator for session {} is already locked; skipping save", - session_id, - ); - } else { - log::warn!("Failed to acquire lock for session {}: {}", session_id, e); - } - return; - } - - if let Err(e) = acc.save(&dir) { - log::warn!( - "Failed to save provenance accumulator for {}: {}", - session_id, - e, - ); - } - - let _ = lock_file.unlock(); + /// Concurrent hook processes wait their turn rather than dropping an update. + pub(super) fn update_accumulator( + &self, + session_id: &str, + update: F, + ) -> Option + where + F: FnOnce(&mut ProvenanceAccumulator), + { + self.with_accumulator(session_id, |acc| { + update(acc); + true + }) } /// Inject reasoning/thinking blocks from the stop event into the diff --git a/atomic-agent/src/turn/orchestrator/tests.rs b/atomic-agent/src/turn/orchestrator/tests.rs index ea2f277a..d918d921 100644 --- a/atomic-agent/src/turn/orchestrator/tests.rs +++ b/atomic-agent/src/turn/orchestrator/tests.rs @@ -39,6 +39,44 @@ fn session_end_event(session_id: &str) -> TurnEvent { TurnEvent::new(session_id, HookType::SessionEnd) } +#[test] +fn concurrent_provenance_updates_are_serialized() { + use crate::provenance::accumulator::ProvenanceAccumulator; + use std::sync::{Arc, Barrier}; + + const WRITERS: usize = 16; + const SESSION_ID: &str = "concurrent-provenance"; + + let dir = TempDir::new().unwrap(); + let root = dir.path().to_path_buf(); + fs::create_dir_all(root.join(".atomic/sessions")).unwrap(); + let barrier = Arc::new(Barrier::new(WRITERS)); + + std::thread::scope(|scope| { + for writer in 0..WRITERS { + let root = root.clone(); + let barrier = Arc::clone(&barrier); + scope.spawn(move || { + let session_store = SessionStore::for_repo(&root).unwrap(); + let watcher = FallbackWatcher::new(WatcherConfig::new(&root)); + let orchestrator = + TurnOrchestrator::with_watcher(&root, session_store, Box::new(watcher)); + + barrier.wait(); + orchestrator + .update_accumulator(SESSION_ID, |acc| { + acc.append_goal(&format!("goal-{writer}"), writer as i64); + }) + .unwrap(); + }); + } + }); + + let graph_dir = root.join(".atomic/sessions").join(SESSION_ID); + let accumulator = ProvenanceAccumulator::load_or_create(&graph_dir, SESSION_ID).unwrap(); + assert_eq!(accumulator.nodes.len(), WRITERS); +} + // DispatchResult tests #[test] diff --git a/atomic-agent/src/turn/orchestrator/turn.rs b/atomic-agent/src/turn/orchestrator/turn.rs index 289b4c8f..e81ef563 100644 --- a/atomic-agent/src/turn/orchestrator/turn.rs +++ b/atomic-agent/src/turn/orchestrator/turn.rs @@ -105,10 +105,9 @@ impl TurnOrchestrator { // Best-effort — failures are logged but never block the session. if let Some(ref prompt) = event.prompt { if !prompt.is_empty() { - if let Some(mut acc) = self.load_accumulator(session_id) { + self.update_accumulator(session_id, |acc| { acc.append_goal(prompt, event.timestamp.timestamp()); - self.save_accumulator(session_id, &acc); - } + }); } } @@ -394,7 +393,7 @@ impl TurnOrchestrator { // The classifier uses tool name + input + output to determine // the node kind (Exploration, Commitment, Verification, etc.). if event.event_type == HookType::PostToolUse { - if let Some(mut acc) = self.load_accumulator(session_id) { + self.update_accumulator(session_id, |acc| { let tool_name = event.tool_name.as_deref().unwrap_or("unknown"); let tool_call_id = event.tool_use_id.as_deref(); @@ -444,9 +443,7 @@ impl TurnOrchestrator { duration_ms, event.timestamp.timestamp(), ); - - self.save_accumulator(session_id, &acc); - } + }); } Ok(DispatchResult::new(session_id, session.phase)) diff --git a/atomic-core/Cargo.toml b/atomic-core/Cargo.toml index 8a96a4be..d0f43dbd 100644 --- a/atomic-core/Cargo.toml +++ b/atomic-core/Cargo.toml @@ -29,6 +29,8 @@ zstd.workspace = true # Database redb.workspace = true +# Compatibility reader used only to upgrade legacy v2 database files to v3. +redb_2_6.workspace = true # Time chrono.workspace = true diff --git a/atomic-core/src/pristine/txn/pristine.rs b/atomic-core/src/pristine/txn/pristine.rs index 52bfd08d..9d49f1f9 100644 --- a/atomic-core/src/pristine/txn/pristine.rs +++ b/atomic-core/src/pristine/txn/pristine.rs @@ -22,7 +22,7 @@ use std::path::Path; use std::sync::atomic::{AtomicU64, Ordering}; -use redb::{Builder, Database, ReadableTable}; +use redb::{Builder, Database, ReadableDatabase, ReadableTable}; use crate::pristine::error::{PristineError, PristineResult}; use crate::pristine::tables::*; @@ -36,6 +36,39 @@ fn next_id(max_id: u64) -> PristineResult { max_id.checked_add(1).ok_or(PristineError::IdSpaceExhausted) } +fn legacy_upgrade_error(error: impl std::fmt::Display) -> PristineError { + PristineError::Io(std::io::Error::other(format!( + "failed to upgrade legacy redb database: {error}" + ))) +} + +fn upgrade_legacy_database(path: &Path) -> PristineResult<()> { + let mut legacy = redb_2_6::Database::open(path).map_err(legacy_upgrade_error)?; + legacy.upgrade().map_err(legacy_upgrade_error)?; + Ok(()) +} + +fn open_database(path: &Path, create: bool, cache_bytes: usize) -> PristineResult { + let open = || { + let mut builder = Builder::new(); + builder.set_cache_size(cache_bytes); + if create { + builder.create(path) + } else { + builder.open(path) + } + }; + + match open() { + Ok(database) => Ok(database), + Err(redb::DatabaseError::UpgradeRequired(_)) => { + upgrade_legacy_database(path)?; + Ok(open()?) + } + Err(error) => Err(error.into()), + } +} + /// The pristine database handle /// /// This is the main entry point for all database operations. It wraps a redb @@ -74,7 +107,7 @@ impl Pristine { // redb cache is 1 GB which causes excessive page eviction when // the GRAPH table grows beyond that during large imports. let cache_bytes = 8 * 1024 * 1024 * 1024; // 8 GiB - let db = Builder::new().set_cache_size(cache_bytes).create(path)?; + let db = open_database(path.as_ref(), true, cache_bytes)?; // Initialize all tables let write_txn = db.begin_write()?; @@ -199,7 +232,7 @@ impl Pristine { /// or the ID-scan read transaction fails. pub fn open_existing>(path: P) -> PristineResult { let cache_bytes = 8 * 1024 * 1024 * 1024; // 8 GiB - let db = Builder::new().set_cache_size(cache_bytes).open(path)?; + let db = open_database(path.as_ref(), false, cache_bytes)?; Self::scan_ids(db) } @@ -227,7 +260,7 @@ impl Pristine { // Open database without creating (read-only mode) // Use the same 8 GiB cache as open() for consistent performance. let cache_bytes = 8 * 1024 * 1024 * 1024; // 8 GiB - let db = Builder::new().set_cache_size(cache_bytes).open(path)?; + let db = open_database(path.as_ref(), false, cache_bytes)?; Self::scan_ids(db) } @@ -293,8 +326,7 @@ impl Pristine { /// must be explicitly committed with `commit()` or it will be rolled back /// when dropped. pub fn write_txn(&self) -> PristineResult> { - let mut txn = self.db.begin_write()?; - txn.set_durability(redb::Durability::Eventual); + let txn = self.db.begin_write()?; Ok(WriteTxn::new( txn, &self.next_node_id, @@ -332,6 +364,35 @@ mod tests { let _write = pristine.write_txn().unwrap(); } + #[test] + fn test_open_upgrades_legacy_v2_database() { + use redb_2_6::Database as LegacyDatabase; + + const LEGACY_EXTERNAL: redb_2_6::TableDefinition = + redb_2_6::TableDefinition::new("external"); + + let dir = tempdir().unwrap(); + let db_path = dir.path().join("pristine"); + let expected_hash = [42u8; 32]; + + { + let legacy = LegacyDatabase::create(&db_path).unwrap(); + let txn = legacy.begin_write().unwrap(); + { + let mut external = txn.open_table(LEGACY_EXTERNAL).unwrap(); + external.insert(7, &expected_hash).unwrap(); + } + txn.commit().unwrap(); + } + + let pristine = Pristine::open(&db_path).unwrap(); + assert_eq!(pristine.peek_next_node_id(), 8); + + let txn = pristine.read_txn().unwrap(); + let external = txn.txn.open_table(EXTERNAL).unwrap(); + assert_eq!(external.get(7).unwrap().unwrap().value(), &expected_hash); + } + #[test] fn test_pristine_reopen() { let dir = tempdir().unwrap(); diff --git a/atomic-repository/src/redb_change_store/mod.rs b/atomic-repository/src/redb_change_store/mod.rs index 934daad2..a0ba6064 100644 --- a/atomic-repository/src/redb_change_store/mod.rs +++ b/atomic-repository/src/redb_change_store/mod.rs @@ -18,7 +18,7 @@ pub use queries::{StoreStats, StoredContentChunk}; use atomic_core::change::format_v3::{self, ChangeReader, FormatError, SectionType}; use atomic_core::change::{Change, ChangeHeader}; use atomic_core::pristine::tables; -use redb::{Database, ReadableTable, TableDefinition}; +use redb::{Database, ReadableDatabase, ReadableTable, TableDefinition}; use std::fmt; use std::io::Cursor; use std::path::Path; diff --git a/atomic-repository/src/redb_change_store/queries.rs b/atomic-repository/src/redb_change_store/queries.rs index 034c7901..2527a8ea 100644 --- a/atomic-repository/src/redb_change_store/queries.rs +++ b/atomic-repository/src/redb_change_store/queries.rs @@ -5,6 +5,7 @@ use atomic_core::change::format_v3::{ }; use atomic_core::change::Change; use atomic_core::pristine::tables; +use redb::ReadableDatabase; use std::fmt; use std::io::Cursor; use std::path::Path; From fc7231cc042ceadda0fc5cc3b289e5a4fed1b843 Mon Sep 17 00:00:00 2001 From: Lee Faus Date: Tue, 8 Sep 2026 22:12:19 -0400 Subject: [PATCH 04/15] provenance recording directly to redb --- Cargo.lock | 1 + README.md | 39 + atomic-agent/src/error.rs | 9 + atomic-agent/src/event.rs | 382 +++++ atomic-agent/src/lib.rs | 12 +- .../src/provenance/accumulator/convert.rs | 118 +- .../src/provenance/accumulator/journal.rs | 671 ++++++++ .../src/provenance/accumulator/mod.rs | 25 +- .../src/provenance/accumulator/tests.rs | 25 + atomic-agent/src/provenance/mod.rs | 23 +- atomic-agent/src/provenance/types.rs | 8 +- atomic-agent/src/transcript/opencode.rs | 20 +- atomic-agent/src/turn/mod.rs | 6 +- atomic-agent/src/turn/orchestrator/mod.rs | 164 +- .../src/turn/orchestrator/provenance.rs | 1239 ++++++++------- .../src/turn/orchestrator/session_end.rs | 28 +- atomic-agent/src/turn/orchestrator/tests.rs | 166 +- atomic-agent/src/turn/orchestrator/turn.rs | 119 +- atomic-cli/Cargo.toml | 1 + atomic-cli/src/commands/agent/hooks.rs | 3 + atomic-cli/src/commands/agent/lifecycle.rs | 405 ++++- atomic-cli/src/commands/agent/mod.rs | 6 + atomic-cli/src/commands/agent/owner.rs | 1377 +++++++++++++++++ .../tests/database_owner_integration_test.rs | 992 ++++++++++++ atomic-core/src/change/session.rs | 9 +- atomic-core/src/pristine/tables.rs | 13 + atomic-core/src/pristine/txn/write/mod.rs | 94 ++ .../src/redb_change_store/mod.rs | 66 +- .../src/redb_change_store/provenance.rs | 1034 +++++++++++++ .../src/redb_change_store/tests.rs | 468 ++++++ atomic-repository/src/repository/changes.rs | 66 + atomic-repository/src/repository/mod.rs | 33 +- .../src/repository/tests/init_tests.rs | 39 + .../tests/provenance_checkpoint_test.rs | 214 +++ packages/opencode-atomic-hooks/README.md | 13 +- .../src/handlers/compaction.ts | 23 +- tests/harness/25_agent_provenance.sh | 65 +- 37 files changed, 7104 insertions(+), 872 deletions(-) create mode 100644 atomic-agent/src/provenance/accumulator/journal.rs create mode 100644 atomic-cli/src/commands/agent/owner.rs create mode 100644 atomic-cli/tests/database_owner_integration_test.rs create mode 100644 atomic-repository/src/redb_change_store/provenance.rs create mode 100644 atomic-repository/tests/provenance_checkpoint_test.rs diff --git a/Cargo.lock b/Cargo.lock index 15383c7e..d9680c01 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -195,6 +195,7 @@ dependencies = [ "dialoguer", "dirs", "env_logger", + "fs2", "git2", "indicatif", "log", diff --git a/README.md b/README.md index e6198870..81439c64 100644 --- a/README.md +++ b/README.md @@ -41,6 +41,45 @@ atomic agent enable # - Provenance graph (why the agent made each decision) ``` +### Repository owner locks and connection recovery + +Agent hooks are short-lived processes, while redb permits only one writable process to open a database. Atomic therefore starts one long-lived **database owner per canonical repository**. Hooks send committed provenance requests to that owner instead of opening the repository's redb change store directly. + +Each repository has an independent ownership namespace: + +| Resource | Location | Purpose | +|---|---|---| +| redb change store | `.atomic/changes.redb` | Mutable provenance journal and checkpoint state | +| owner election lock | `.atomic/changes-owner.lock` | OS-backed authority deciding which process may own that database | +| Unix endpoint | `/tmp/atomic-owner-.sock` | Local IPC transport on macOS and Linux | +| Windows endpoint | `\\.\pipe\atomic-owner-` | Local IPC transport on Windows | + +The endpoint digest is derived from the canonical `.atomic` path and uses 96 bits of BLAKE3 output. Different project paths therefore get different owners, locks, databases, and endpoints. Multiple agents working in one project intentionally share that project's owner; agents working in other projects use different owners and proceed independently. Agent sandboxes and symlinked paths resolve back to the canonical repository, so they share its owner rather than creating competing databases. A clone at a different path gets its own owner. + +```text +Agent A ─┐ Agent C ─┐ +Agent B ─┴─> Project 1 owner Agent D ─┴─> Project 2 owner + │ │ + v v + Project 1 changes.redb Project 2 changes.redb +``` + +The **lock is the authority; the socket or named pipe is only transport**. The lock file may remain on disk after normal operation, but an unlocked file does not block a new owner. If an owner crashes, the OS releases its lock automatically. Recovery then proceeds as follows: + +1. A hook cannot reach the old endpoint and starts or reconnects to an owner. +2. Owner candidates race for that repository's `changes-owner.lock`. +3. Only the lock winner may open `changes.redb`. +4. On Unix, the winner removes any stale socket left by the dead owner and binds a fresh endpoint. +5. The hook retries with the same request/event ID, so a request committed before the crash is acknowledged once rather than applied twice. + +Within one repository, redb write transactions are serialized by design, while reads and independent repositories can proceed concurrently. Startup, reconnect, and retry loops are bounded so a broken owner fails instead of hanging hooks indefinitely. Checkpoint attempts, event cutoffs, and fencing generations let interrupted turns resume without rewriting completed session turns. + +Current operational considerations: + +- Owners remain alive until explicitly shut down; an idle timeout or user-level owner registry is a future resource-management improvement for machines that touch many repositories. +- Unix endpoints use `/tmp` to stay below macOS Unix-socket path limits. A future hardening step should move them into a user-private runtime directory where available, enforce restrictive socket permissions, and validate peer credentials. +- A 96-bit endpoint digest makes accidental cross-project collisions extraordinarily unlikely, but the repository-local lock remains the final ownership check. + ### Provenance Graphs Every agent session builds a causal decision DAG. Not just *what* changed, but *why*: diff --git a/atomic-agent/src/error.rs b/atomic-agent/src/error.rs index 34d5d5bf..f932f16a 100644 --- a/atomic-agent/src/error.rs +++ b/atomic-agent/src/error.rs @@ -167,6 +167,15 @@ pub enum AgentError { session_id: String, }, + /// The repository owner rejected or failed a provenance journal operation. + #[error("Provenance journal operation failed for session '{session_id}': {reason}")] + ProvenanceJournalFailed { + /// The session whose journal could not be committed. + session_id: String, + /// Owner transport, fencing, or storage failure. + reason: String, + }, + /// Multiple concurrent sessions detected that may conflict. #[error( "Concurrent session conflict: session '{existing}' is already active in this workspace" diff --git a/atomic-agent/src/event.rs b/atomic-agent/src/event.rs index a9c22116..e57a37cd 100644 --- a/atomic-agent/src/event.rs +++ b/atomic-agent/src/event.rs @@ -436,6 +436,388 @@ impl fmt::Display for TurnEvent { } } +// ProvenanceJournalEnvelope + +/// Current wire and storage version for provenance journal envelopes. +pub const PROVENANCE_JOURNAL_VERSION: u16 = 1; + +/// Whether a tool event describes invocation or its completed result. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ProvenanceToolPhase { + Before, + After, +} + +/// Lossless semantic payload for one provenance journal event. +/// +/// Typed variants retain the source fields needed to rebuild graph semantics. +/// `GraphDelta` is the compatibility escape hatch for existing or external +/// provenance nodes whose schema is richer than the normalized variants. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "snake_case")] +pub enum ProvenanceJournalEvent { + Goal { + prompt: String, + }, + Tool { + phase: ProvenanceToolPhase, + tool_name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + tool_call_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + input: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + output: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + status: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + duration_ms: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + raw: Option, + }, + ToolEnrichment { + tool_call_id: String, + tool_name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + input: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + output: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + status: Option, + }, + Reasoning { + text: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + duration_ms: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + signature: Option, + }, + Response { + text: String, + }, + Todo { + todo: atomic_core::change::session::SessionTodo, + }, + HumanGate { + reason: String, + }, + HumanGateResolution { + gate_event_id: String, + resolution: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + detail: Option, + }, + PatchProposal { + change_hash: String, + files: Vec, + }, + Terminal { + hook_type: HookType, + #[serde(default, skip_serializing_if = "Option::is_none")] + reason: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + payload: Option, + }, + GraphDelta { + nodes: Vec, + edges: Vec, + }, + LegacyGraphImport { + nodes: Vec, + edges: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + previous_provenance: Option, + }, +} + +/// Versioned, idempotent event stored in the pending provenance journal. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProvenanceJournalEnvelope { + #[serde(alias = "version")] + pub schema_version: u16, + pub event_id: String, + pub session_id: String, + pub turn_number: u32, + #[serde(default = "default_provenance_generation")] + pub generation: u64, + pub timestamp_ms: i64, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub causal_parent_ids: Vec, + pub event: ProvenanceJournalEvent, +} + +const fn default_provenance_generation() -> u64 { + 1 +} + +/// Validation or replay ordering failure for provenance journal envelopes. +#[derive(Debug, thiserror::Error)] +pub enum ProvenanceJournalError { + #[error("unsupported provenance journal schema version {0}")] + UnsupportedVersion(u16), + #[error("provenance journal event id cannot be empty")] + EmptyEventId, + #[error("provenance journal session id cannot be empty")] + EmptySessionId, + #[error("provenance journal generation must be at least one")] + InvalidGeneration, + #[error("conflicting provenance journal event id '{0}'")] + ConflictingEventId(String), + #[error("provenance event '{event_id}' references missing causal parent '{parent_id}'")] + MissingCausalParent { event_id: String, parent_id: String }, + #[error("provenance journal contains a causal cycle")] + CausalCycle, + #[error("provenance journal mixes session or turn identities")] + MixedTurnIdentity, + #[error("invalid provenance journal JSON: {0}")] + Json(#[from] serde_json::Error), + #[error("provenance graph delta conflicts for node '{0}'")] + ConflictingGraphNode(String), + #[error("human gate event '{0}' has no replayed graph node")] + MissingHumanGate(String), +} + +impl ProvenanceJournalEnvelope { + pub fn new( + event_id: impl Into, + session_id: impl Into, + turn_number: u32, + generation: u64, + timestamp_ms: i64, + event: ProvenanceJournalEvent, + ) -> Self { + Self { + schema_version: PROVENANCE_JOURNAL_VERSION, + event_id: event_id.into(), + session_id: session_id.into(), + turn_number, + generation, + timestamp_ms, + causal_parent_ids: Vec::new(), + event, + } + } + + #[must_use] + pub fn with_causal_parents(mut self, parents: I) -> Self + where + I: IntoIterator, + S: Into, + { + self.causal_parent_ids = parents.into_iter().map(Into::into).collect(); + self.causal_parent_ids.sort(); + self.causal_parent_ids.dedup(); + self + } + + /// Derive a retry-stable ID from turn identity and the complete event body. + pub fn deterministic_id( + session_id: &str, + turn_number: u32, + generation: u64, + timestamp_ms: i64, + event: &ProvenanceJournalEvent, + ) -> Result { + let bytes = + serde_json::to_vec(&(session_id, turn_number, generation, timestamp_ms, event))?; + let digest = blake3::hash(&bytes).to_hex().to_string(); + Ok(format!("pj-{}", &digest[..32])) + } + + pub fn validate(&self) -> Result<(), ProvenanceJournalError> { + if self.schema_version != PROVENANCE_JOURNAL_VERSION { + return Err(ProvenanceJournalError::UnsupportedVersion( + self.schema_version, + )); + } + if self.event_id.trim().is_empty() { + return Err(ProvenanceJournalError::EmptyEventId); + } + if self.session_id.trim().is_empty() { + return Err(ProvenanceJournalError::EmptySessionId); + } + if self.generation == 0 { + return Err(ProvenanceJournalError::InvalidGeneration); + } + Ok(()) + } + + pub fn to_json_bytes(&self) -> Result, ProvenanceJournalError> { + self.validate()?; + Ok(serde_json::to_vec(self)?) + } + + pub fn from_json_bytes(bytes: &[u8]) -> Result { + let envelope: Self = serde_json::from_slice(bytes)?; + envelope.validate()?; + Ok(envelope) + } + + /// Adapt a normalized hook event without discarding its raw payload. + /// + /// Turn starts become goals, tool hooks retain before/after phase and full + /// input/output JSON, and lifecycle boundaries remain terminal events. + pub fn from_turn_event( + event_id: impl Into, + turn_number: u32, + generation: u64, + event: &TurnEvent, + ) -> Self { + let raw = event.raw_json.clone(); + let journal_event = match event.event_type { + HookType::TurnStart if event.prompt.is_some() => ProvenanceJournalEvent::Goal { + prompt: event.prompt.clone().unwrap_or_default(), + }, + HookType::PreToolUse | HookType::PostToolUse => { + let input = raw.as_ref().and_then(|value| { + value + .get("tool_input") + .or_else(|| value.get("input")) + .or_else(|| value.get("arguments")) + .cloned() + }); + let output = raw.as_ref().and_then(|value| { + value + .get("tool_output") + .or_else(|| value.get("output")) + .or_else(|| value.get("result")) + .cloned() + }); + let status = raw + .as_ref() + .and_then(|value| value.get("status")) + .and_then(serde_json::Value::as_str) + .map(ToOwned::to_owned); + let duration_ms = raw + .as_ref() + .and_then(|value| value.get("duration_ms").or_else(|| value.get("duration"))) + .and_then(serde_json::Value::as_u64); + ProvenanceJournalEvent::Tool { + phase: if event.event_type == HookType::PreToolUse { + ProvenanceToolPhase::Before + } else { + ProvenanceToolPhase::After + }, + tool_name: event.tool_name.clone().unwrap_or_default(), + tool_call_id: event.tool_use_id.clone(), + input, + output, + status, + duration_ms, + raw, + } + } + _ => ProvenanceJournalEvent::Terminal { + hook_type: event.event_type, + reason: raw + .as_ref() + .and_then(|value| value.get("reason")) + .and_then(serde_json::Value::as_str) + .map(ToOwned::to_owned), + payload: raw, + }, + }; + Self::new( + event_id, + &event.session_id, + turn_number, + generation, + event.timestamp.timestamp_millis(), + journal_event, + ) + } +} + +/// Deduplicate and causally order a complete turn journal. +/// +/// Ready events are ordered by generation, timestamp, then stable event ID, so +/// process arrival order cannot affect replay. Causal parents always precede +/// children even when clocks are tied or skewed. +pub fn canonicalize_provenance_journal( + envelopes: Vec, +) -> Result, ProvenanceJournalError> { + use std::collections::{BTreeMap, BTreeSet}; + + let mut by_id = BTreeMap::::new(); + for mut envelope in envelopes { + envelope.validate()?; + envelope.causal_parent_ids.sort(); + envelope.causal_parent_ids.dedup(); + match by_id.get(&envelope.event_id) { + Some(existing) if existing == &envelope => continue, + Some(_) => { + return Err(ProvenanceJournalError::ConflictingEventId( + envelope.event_id, + )) + } + None => { + by_id.insert(envelope.event_id.clone(), envelope); + } + } + } + let Some(first) = by_id.values().next() else { + return Ok(Vec::new()); + }; + if by_id + .values() + .any(|event| event.session_id != first.session_id || event.turn_number != first.turn_number) + { + return Err(ProvenanceJournalError::MixedTurnIdentity); + } + + let mut indegree = BTreeMap::::new(); + let mut children = BTreeMap::>::new(); + for envelope in by_id.values() { + indegree.insert(envelope.event_id.clone(), envelope.causal_parent_ids.len()); + for parent in &envelope.causal_parent_ids { + if !by_id.contains_key(parent) { + return Err(ProvenanceJournalError::MissingCausalParent { + event_id: envelope.event_id.clone(), + parent_id: parent.clone(), + }); + } + children + .entry(parent.clone()) + .or_default() + .push(envelope.event_id.clone()); + } + } + + let mut ready = BTreeSet::<(u64, i64, String)>::new(); + for envelope in by_id.values() { + if indegree[&envelope.event_id] == 0 { + ready.insert(( + envelope.generation, + envelope.timestamp_ms, + envelope.event_id.clone(), + )); + } + } + + let mut ordered = Vec::with_capacity(by_id.len()); + while let Some(key) = ready.pop_first() { + let event_id = key.2; + let envelope = by_id[&event_id].clone(); + ordered.push(envelope); + if let Some(next_events) = children.get(&event_id) { + for child_id in next_events { + let degree = indegree.get_mut(child_id).expect("known journal child"); + *degree -= 1; + if *degree == 0 { + let child = &by_id[child_id]; + ready.insert((child.generation, child.timestamp_ms, child.event_id.clone())); + } + } + } + } + + if ordered.len() != by_id.len() { + return Err(ProvenanceJournalError::CausalCycle); + } + Ok(ordered) +} + // TurnChanges /// Files that changed during a single agent turn. diff --git a/atomic-agent/src/lib.rs b/atomic-agent/src/lib.rs index 6f25e9ed..78c4b00a 100644 --- a/atomic-agent/src/lib.rs +++ b/atomic-agent/src/lib.rs @@ -100,14 +100,20 @@ pub mod watcher; // Re-export primary types for convenience pub use envelope::SessionEnvelope; pub use error::{AgentError, AgentResult}; -pub use event::{HookType, TurnChanges, TurnEvent}; +pub use event::{ + canonicalize_provenance_journal, HookType, ProvenanceJournalEnvelope, ProvenanceJournalError, + ProvenanceJournalEvent, ProvenanceToolPhase, TurnChanges, TurnEvent, +}; pub use hooks::{AgentHook, AgentRegistry}; pub use provenance::{ - EdgeKind, GraphEdge, GraphNode, GraphStats, NodeKind, ProvenanceAccumulator, SerializedGraph, + EdgeKind, GraphEdge, GraphNode, GraphStats, NodeKind, PreparedProvenanceGraph, + ProvenanceAccumulator, SerializedGraph, }; pub use record::{record_turn, TurnRecordOptions, TurnRecordOutcome}; pub use turn::{ - apply_common_actions, transition, Action, AgentSession, Event, Phase, SessionStore, + apply_common_actions, transition, Action, AgentSession, Event, JournalAppendAck, + JournalCheckpointAttempt, JournalCheckpointSource, JournalStopCause, JournalTurnLifecycle, + JournalTurnReservation, JournalTurnStatus, Phase, ProvenanceJournalSink, SessionStore, TransitionContext, TransitionResult, }; diff --git a/atomic-agent/src/provenance/accumulator/convert.rs b/atomic-agent/src/provenance/accumulator/convert.rs index 86f62f1a..0767c4dc 100644 --- a/atomic-agent/src/provenance/accumulator/convert.rs +++ b/atomic-agent/src/provenance/accumulator/convert.rs @@ -4,7 +4,7 @@ use atomic_core::change::provenance_graph as pg; use atomic_core::types::{Base32, Hash}; use super::helpers::{convert_edge_kind, convert_node_kind}; -use super::{ProvenanceAccumulator, GRAPH_FILENAME}; +use super::{PreparedProvenanceGraph, ProvenanceAccumulator, GRAPH_FILENAME}; use crate::error::{AgentError, AgentResult}; use crate::provenance::types::{GraphNode, NodeKind, SerializedGraph}; @@ -53,75 +53,101 @@ impl ProvenanceAccumulator { agent_vendor: &str, changes_explained: &[Hash], ) -> pg::ProvenanceGraph { + let prepared = self.prepare_provenance_graph( + agent_name, + agent_display_name, + agent_vendor, + changes_explained, + ); + self.nodes_saved_count = prepared.nodes_end; + self.edges_saved_count = prepared.edges_end; + prepared.graph + } + + /// Build the next per-turn graph without advancing durable accumulator cursors. + pub fn prepare_provenance_graph( + &self, + agent_name: &str, + agent_display_name: &str, + agent_vendor: &str, + changes_explained: &[Hash], + ) -> PreparedProvenanceGraph { let previous = self .last_provenance_hash .as_ref() .and_then(|s| Hash::from_base32(s.as_bytes())); - - // Only export nodes/edges added since the last save (per-turn delta). let new_nodes = &self.nodes[self.nodes_saved_count..]; let new_edges = &self.edges[self.edges_saved_count..]; - - // Collect IDs of new nodes for edge filtering let new_node_ids: std::collections::HashSet<&str> = - new_nodes.iter().map(|n| n.id.as_str()).collect(); - - // Only include edges where BOTH endpoints are in the new node set. - // Cross-turn edges (e.g., goal from turn 1 → exploration in turn 2) - // are dropped — each turn's graph is self-contained. + new_nodes.iter().map(|node| node.id.as_str()).collect(); let relevant_edges: Vec<&super::super::types::GraphEdge> = new_edges .iter() - .filter(|e| { - new_node_ids.contains(e.from.as_str()) || new_node_ids.contains(e.to.as_str()) + .filter(|edge| { + new_node_ids.contains(edge.from.as_str()) || new_node_ids.contains(edge.to.as_str()) }) .collect(); - - let nodes: Vec = new_nodes + let nodes = new_nodes .iter() - .map(|n| pg::ProvenanceNode { - id: n.id.clone(), - kind: convert_node_kind(n.kind), - timestamp: n.timestamp, - summary: n.summary.clone(), - detail: n.detail.as_ref().map(|d| d.to_string()), - change_hash: n + .map(|node| pg::ProvenanceNode { + id: node.id.clone(), + kind: convert_node_kind(node.kind), + timestamp: node.timestamp, + summary: node.summary.clone(), + detail: node.detail.as_ref().map(ToString::to_string), + change_hash: node .change_hash .as_ref() - .and_then(|s| Hash::from_base32(s.as_bytes())), - tool_name: n.tool_name.clone(), - tool_call_id: n.tool_call_id.clone(), - duration_ms: n.duration_ms, - classified: n.classified, - confidence: n.confidence, - consolidated_from: n.consolidated_from.clone(), + .and_then(|hash| Hash::from_base32(hash.as_bytes())), + tool_name: node.tool_name.clone(), + tool_call_id: node.tool_call_id.clone(), + duration_ms: node.duration_ms, + classified: node.classified, + confidence: node.confidence, + consolidated_from: node.consolidated_from.clone(), }) .collect(); - - let edges: Vec = relevant_edges + let edges = relevant_edges .iter() - .map(|e| pg::ProvenanceEdge { - from: e.from.clone(), - to: e.to.clone(), - kind: convert_edge_kind(e.kind), + .map(|edge| pg::ProvenanceEdge { + from: edge.from.clone(), + to: edge.to.clone(), + kind: convert_edge_kind(edge.kind), }) .collect(); - - // Mark the save point so the next call only exports new nodes - self.nodes_saved_count = self.nodes.len(); - self.edges_saved_count = self.edges.len(); - + let timestamp = new_nodes + .iter() + .map(|node| node.timestamp) + .max() + .unwrap_or(0); let mut builder = pg::ProvenanceGraph::builder(&self.session_id, agent_name) .agent_display_name(agent_display_name) .agent_vendor(agent_vendor) .nodes(nodes) .edges(edges) - .changes_explained(changes_explained.to_vec()); - - if let Some(prev) = previous { - builder = builder.previous(prev); + .changes_explained(changes_explained.to_vec()) + .timestamp(timestamp); + if let Some(previous) = previous { + builder = builder.previous(previous); + } + PreparedProvenanceGraph { + graph: builder.build(), + nodes_end: self.nodes.len(), + edges_end: self.edges.len(), } + } + + /// Advance cursors only after the prepared graph and session head publish. + pub fn acknowledge_prepared_graph(&mut self, prepared: &PreparedProvenanceGraph, hash: Hash) { + self.nodes_saved_count = self.nodes_saved_count.max(prepared.nodes_end); + self.edges_saved_count = self.edges_saved_count.max(prepared.edges_end); + self.last_provenance_hash = Some(hash.to_base32()); + } - builder.build() + /// Advance all current cursors after an externally prepared graph publishes. + pub fn acknowledge_published_graph(&mut self, hash: Hash) { + self.nodes_saved_count = self.nodes.len(); + self.edges_saved_count = self.edges.len(); + self.last_provenance_hash = Some(hash.to_base32()); } /// Record the hash of a saved ProvenanceGraph artifact so subsequent @@ -137,9 +163,9 @@ impl ProvenanceAccumulator { // Serialization // ========================================================================= - /// Persist the graph to disk at `{session_dir}/graph.json`. + /// Write the legacy graph encoding for migration tooling and fixtures. /// - /// Uses atomic write (temp file + rename) to prevent corruption. + /// Production hook dispatch never calls this after the redb cutover. pub fn save(&self, session_dir: &Path) -> AgentResult<()> { // Ensure the session directory exists std::fs::create_dir_all(session_dir).map_err(|e| AgentError::SessionSaveFailed { diff --git a/atomic-agent/src/provenance/accumulator/journal.rs b/atomic-agent/src/provenance/accumulator/journal.rs new file mode 100644 index 00000000..54ce454d --- /dev/null +++ b/atomic-agent/src/provenance/accumulator/journal.rs @@ -0,0 +1,671 @@ +use std::collections::BTreeMap; + +use crate::event::{ + canonicalize_provenance_journal, ProvenanceJournalEnvelope, ProvenanceJournalError, + ProvenanceJournalEvent, ProvenanceToolPhase, +}; +use crate::provenance::accumulator::helpers::build_tool_detail; +use crate::provenance::classify::{classify_tool_call, summarize_tool_call}; +use crate::provenance::types::{GraphEdge, GraphStats, NodeKind}; + +use super::ProvenanceAccumulator; + +impl ProvenanceAccumulator { + /// Replay a complete turn journal into deterministic graph semantics. + /// + /// Arrival order is discarded by `canonicalize_provenance_journal`; causal + /// parents and the stable ordering key determine all accumulator mutations. + pub fn replay_provenance_journal( + envelopes: Vec, + ) -> Result { + let ordered = canonicalize_provenance_journal(envelopes)?; + let Some(first) = ordered.first() else { + return Ok(Self::new("")); + }; + let mut accumulator = Self::new(&first.session_id); + let mut event_nodes = BTreeMap::::new(); + + for envelope in ordered { + let timestamp = envelope.timestamp_ms; + let node_id = + match envelope.event { + ProvenanceJournalEvent::Goal { prompt } => { + Some(accumulator.append_goal(&prompt, timestamp)) + } + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::Before, + .. + } => None, + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::After, + tool_name, + tool_call_id, + input, + output, + status, + duration_ms, + .. + } => { + let output_text = output.as_ref().map(json_value_as_text); + Some(accumulator.append_tool_call( + &tool_name, + tool_call_id.as_deref(), + input.as_ref(), + output_text.as_deref(), + status.as_deref(), + duration_ms, + timestamp, + )) + } + ProvenanceJournalEvent::ToolEnrichment { + tool_call_id, + tool_name, + input, + output, + status, + } => { + let kind = classify_tool_call( + &tool_name, + input.as_ref(), + output.as_deref(), + status.as_deref(), + ); + let summary = summarize_tool_call( + &tool_name, + kind, + input.as_ref(), + output.as_deref(), + status.as_deref(), + ); + if let Some(node) = accumulator.nodes.iter_mut().find(|node| { + node.tool_call_id.as_deref() == Some(tool_call_id.as_str()) + }) { + node.kind = kind; + node.summary = summary; + node.tool_name = Some(tool_name.clone()); + node.detail = build_tool_detail( + kind, + &tool_name, + input.as_ref(), + output.as_deref(), + status.as_deref(), + ); + None + } else { + Some(accumulator.append_tool_call( + &tool_name, + Some(&tool_call_id), + input.as_ref(), + output.as_deref(), + status.as_deref(), + None, + timestamp, + )) + } + } + ProvenanceJournalEvent::Reasoning { + text, + duration_ms, + signature, + } => Some(accumulator.append_reasoning( + &text, + duration_ms, + signature.as_deref(), + timestamp, + )), + ProvenanceJournalEvent::Response { text } => { + Some(accumulator.append_llm_response(&text, timestamp)) + } + ProvenanceJournalEvent::Todo { todo } => { + Some(accumulator.append_todo_snapshot(&todo, timestamp)) + } + ProvenanceJournalEvent::HumanGate { reason } => { + Some(accumulator.append_human_gate(&reason, timestamp)) + } + ProvenanceJournalEvent::HumanGateResolution { + gate_event_id, + resolution: _, + detail: _, + } => { + let gate_node = event_nodes + .get(&gate_event_id) + .ok_or(ProvenanceJournalError::MissingHumanGate(gate_event_id))?; + accumulator.resolve_human_gate(gate_node); + None + } + ProvenanceJournalEvent::PatchProposal { change_hash, files } => { + Some(accumulator.append_patch_proposal(&change_hash, &files, timestamp)) + } + ProvenanceJournalEvent::Terminal { .. } => None, + ProvenanceJournalEvent::GraphDelta { nodes, edges } + | ProvenanceJournalEvent::LegacyGraphImport { nodes, edges, .. } => { + accumulator.apply_graph_delta(nodes, edges)?; + None + } + }; + if let Some(node_id) = node_id { + event_nodes.insert(envelope.event_id, node_id); + } + } + + accumulator.rebuild_replay_state(); + Ok(accumulator) + } + + /// Return only graph state not acknowledged by a prior publication. + pub fn pending_graph_delta(&self) -> Option { + let nodes = self.nodes.get(self.nodes_saved_count..)?.to_vec(); + let pending_ids: std::collections::HashSet<_> = + nodes.iter().map(|node| node.id.as_str()).collect(); + let edges = self + .edges + .get(self.edges_saved_count..)? + .iter() + .filter(|edge| { + pending_ids.contains(edge.from.as_str()) || pending_ids.contains(edge.to.as_str()) + }) + .cloned() + .collect::>(); + if nodes.is_empty() && edges.is_empty() { + None + } else { + Some(ProvenanceJournalEvent::LegacyGraphImport { + nodes, + edges, + previous_provenance: self.last_provenance_hash.clone(), + }) + } + } + + /// Capture the current graph as one lossless compatibility envelope. + /// + /// New producers should prefer typed journal events so raw tool and model + /// data remain available. This adapter exists to migrate existing graphs + /// without changing any node or edge semantics. + pub fn to_journal_snapshot( + &self, + turn_number: u32, + generation: u64, + timestamp_ms: i64, + ) -> Result { + let event = ProvenanceJournalEvent::GraphDelta { + nodes: self.nodes.clone(), + edges: self.edges.clone(), + }; + let event_id = ProvenanceJournalEnvelope::deterministic_id( + &self.session_id, + turn_number, + generation, + timestamp_ms, + &event, + )?; + Ok(ProvenanceJournalEnvelope::new( + event_id, + &self.session_id, + turn_number, + generation, + timestamp_ms, + event, + )) + } + + fn apply_graph_delta( + &mut self, + nodes: Vec, + edges: Vec, + ) -> Result<(), ProvenanceJournalError> { + for node in nodes { + match self.nodes.iter().find(|existing| existing.id == node.id) { + Some(existing) if existing == &node => {} + Some(_) => { + return Err(ProvenanceJournalError::ConflictingGraphNode(node.id)); + } + None => self.nodes.push(node), + } + } + for edge in edges { + if !self.edges.contains(&edge) { + self.edges.push(edge); + } + } + Ok(()) + } + + fn rebuild_replay_state(&mut self) { + self.stats = GraphStats::default(); + for node in &self.nodes { + self.stats.increment(node.kind); + } + self.stats.edge_count = self.edges.len() as u32; + self.counter = self + .nodes + .iter() + .filter_map(|node| node.id.rsplit('-').next()?.parse::().ok()) + .max() + .unwrap_or(self.nodes.len() as u64); + self.last_node = self.nodes.last().map(|node| node.id.clone()); + self.current_goal = self + .nodes + .iter() + .rev() + .find(|node| node.kind == NodeKind::Goal) + .map(|node| node.id.clone()); + self.last_commitment = self + .nodes + .iter() + .rev() + .find(|node| node.kind == NodeKind::Commitment) + .map(|node| node.id.clone()); + self.pending_human_gate = self + .nodes + .iter() + .rev() + .find(|node| { + node.kind == NodeKind::HumanGate + && node + .detail + .as_ref() + .and_then(|detail| detail.get("resolved")) + .and_then(serde_json::Value::as_bool) + != Some(true) + }) + .map(|node| node.id.clone()); + + self.pending_explorations.clear(); + for node in self.nodes.iter().rev() { + if matches!(node.kind, NodeKind::Goal | NodeKind::Commitment) { + break; + } + if node.kind == NodeKind::Exploration { + self.pending_explorations.push(node.id.clone()); + } + } + self.pending_explorations.reverse(); + + self.commitments_since_last_patch.clear(); + for node in self.nodes.iter().rev() { + if node.kind == NodeKind::PatchProposal { + break; + } + if node.kind == NodeKind::Commitment { + self.commitments_since_last_patch.push(node.id.clone()); + } + } + self.commitments_since_last_patch.reverse(); + self.nodes_saved_count = 0; + self.edges_saved_count = 0; + } +} + +fn json_value_as_text(value: &serde_json::Value) -> String { + match value { + serde_json::Value::String(text) => text.clone(), + other => other.to_string(), + } +} + +#[cfg(test)] +mod tests { + use atomic_core::change::session::SessionTodo; + use chrono::{TimeZone, Utc}; + use serde_json::json; + + use super::*; + use crate::event::{HookType, ProvenanceToolPhase, TurnEvent}; + use crate::provenance::types::{GraphNode, NodeKind}; + + fn envelope( + id: &str, + timestamp_ms: i64, + parents: &[&str], + event: ProvenanceJournalEvent, + ) -> ProvenanceJournalEnvelope { + ProvenanceJournalEnvelope::new(id, "session-1", 3, 2, timestamp_ms, event) + .with_causal_parents(parents.iter().copied()) + } + + #[test] + fn all_payloads_round_trip_without_loss() { + let node = GraphNode { + id: "external-9".to_string(), + kind: NodeKind::Decision, + timestamp: 17, + summary: "choose exact replay".to_string(), + detail: Some(json!({"nested": [1, true, {"raw": "value"}]})), + change_hash: Some("HASH".to_string()), + tool_name: Some("planner".to_string()), + tool_call_id: Some("call-9".to_string()), + duration_ms: Some(44), + classified: true, + confidence: Some(0.75), + consolidated_from: vec!["raw-1".to_string()], + }; + let payloads = vec![ + ProvenanceJournalEvent::Goal { + prompt: "full untruncated goal".to_string(), + }, + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::After, + tool_name: "terminal".to_string(), + tool_call_id: Some("tool-1".to_string()), + input: Some(json!({"command": "cargo test", "env": {"A": "B"}})), + output: Some(json!({"stdout": "ok", "exit": 0})), + status: Some("completed".to_string()), + duration_ms: Some(123), + raw: Some(json!({"vendor_extension": [1, 2, 3]})), + }, + ProvenanceJournalEvent::Reasoning { + text: "complete reasoning text".to_string(), + duration_ms: Some(55), + signature: Some("signature".to_string()), + }, + ProvenanceJournalEvent::Response { + text: "complete response".to_string(), + }, + ProvenanceJournalEvent::Todo { + todo: SessionTodo { + id: "todo-1".to_string(), + content: "finish replay".to_string(), + status: "in_progress".to_string(), + priority: "high".to_string(), + }, + }, + ProvenanceJournalEvent::HumanGate { + reason: "confirm migration".to_string(), + }, + ProvenanceJournalEvent::HumanGateResolution { + gate_event_id: "gate-1".to_string(), + resolution: "approved".to_string(), + detail: Some(json!({"command": "continue"})), + }, + ProvenanceJournalEvent::PatchProposal { + change_hash: "CHANGE".to_string(), + files: vec!["src/lib.rs".to_string()], + }, + ProvenanceJournalEvent::Terminal { + hook_type: HookType::TurnEnd, + reason: Some("completed".to_string()), + payload: Some(json!({"stop_reason": "end_turn"})), + }, + ProvenanceJournalEvent::GraphDelta { + nodes: vec![node.clone()], + edges: Vec::new(), + }, + ProvenanceJournalEvent::LegacyGraphImport { + nodes: vec![node], + edges: Vec::new(), + previous_provenance: Some("PREVIOUS".to_string()), + }, + ]; + + for (index, payload) in payloads.into_iter().enumerate() { + let original = envelope(&format!("event-{index}"), index as i64, &[], payload); + let bytes = original.to_json_bytes().unwrap(); + let decoded = ProvenanceJournalEnvelope::from_json_bytes(&bytes).unwrap(); + assert_eq!(decoded, original); + } + } + + #[test] + fn legacy_version_alias_and_generation_default_decode() { + let bytes = br#"{ + "version": 1, + "event_id": "legacy-1", + "session_id": "session-1", + "turn_number": 3, + "timestamp_ms": 1000, + "event": {"type": "goal", "prompt": "legacy goal"} + }"#; + let decoded = ProvenanceJournalEnvelope::from_json_bytes(bytes).unwrap(); + assert_eq!(decoded.generation, 1); + assert!(decoded.causal_parent_ids.is_empty()); + } + + #[test] + fn turn_event_adapter_preserves_tool_payload_and_timestamp() { + let timestamp = Utc.timestamp_millis_opt(1_700_000_000_123).unwrap(); + let turn_event = TurnEvent::new("session-1", HookType::PostToolUse) + .with_tool_name("terminal") + .with_tool_use_id("call-1") + .with_timestamp(timestamp) + .with_raw_json(json!({ + "tool_input": {"command": "cargo test"}, + "tool_output": {"stdout": "ok", "exit": 0}, + "status": "completed", + "duration_ms": 42, + "vendor": {"opaque": true} + })); + let envelope = ProvenanceJournalEnvelope::from_turn_event("hook-1", 3, 2, &turn_event); + assert_eq!(envelope.timestamp_ms, 1_700_000_000_123); + match envelope.event { + ProvenanceJournalEvent::Tool { + phase, + input, + output, + raw, + .. + } => { + assert_eq!(phase, ProvenanceToolPhase::After); + assert_eq!(input, Some(json!({"command": "cargo test"}))); + assert_eq!(output, Some(json!({"stdout": "ok", "exit": 0}))); + assert_eq!(raw.unwrap()["vendor"]["opaque"], true); + } + other => panic!("unexpected adapter payload: {other:?}"), + } + } + + #[test] + fn tool_enrichment_updates_the_correlated_node_without_duplication() { + let tool = envelope( + "tool", + 1, + &[], + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::After, + tool_name: "bash".to_string(), + tool_call_id: Some("call-1".to_string()), + input: None, + output: None, + status: Some("completed".to_string()), + duration_ms: None, + raw: None, + }, + ); + let enrichment = envelope( + "enrichment", + 2, + &["tool"], + ProvenanceJournalEvent::ToolEnrichment { + tool_call_id: "call-1".to_string(), + tool_name: "bash".to_string(), + input: Some(json!({"command": "cargo test"})), + output: Some("test result: ok. 12 passed".to_string()), + status: Some("completed".to_string()), + }, + ); + let replayed = + ProvenanceAccumulator::replay_provenance_journal(vec![enrichment, tool]).unwrap(); + assert_eq!(replayed.nodes().len(), 1); + let node = &replayed.nodes()[0]; + assert!(node.summary.contains("cargo test")); + assert_eq!(node.detail.as_ref().unwrap()["command"], "cargo test"); + assert!(node.detail.as_ref().unwrap()["output_summary"] + .as_str() + .unwrap() + .contains("12 passed")); + } + + #[test] + fn deterministic_id_binds_complete_turn_identity_and_body() { + let event = ProvenanceJournalEvent::Response { + text: "done".to_string(), + }; + let first = + ProvenanceJournalEnvelope::deterministic_id("session-1", 3, 2, 1000, &event).unwrap(); + let retry = + ProvenanceJournalEnvelope::deterministic_id("session-1", 3, 2, 1000, &event).unwrap(); + let next_generation = + ProvenanceJournalEnvelope::deterministic_id("session-1", 3, 3, 1000, &event).unwrap(); + assert_eq!(first, retry); + assert_ne!(first, next_generation); + } + + #[test] + fn replay_is_identical_for_all_arrival_permutations() { + let events = vec![ + envelope( + "goal", + 1000, + &[], + ProvenanceJournalEvent::Goal { + prompt: "implement deterministic replay".to_string(), + }, + ), + envelope( + "before-read", + 1001, + &["goal"], + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::Before, + tool_name: "read".to_string(), + tool_call_id: Some("read-1".to_string()), + input: Some(json!({"path": "src/lib.rs"})), + output: None, + status: None, + duration_ms: None, + raw: None, + }, + ), + envelope( + "after-read", + 1002, + &["before-read"], + ProvenanceJournalEvent::Tool { + phase: ProvenanceToolPhase::After, + tool_name: "read".to_string(), + tool_call_id: Some("read-1".to_string()), + input: Some(json!({"path": "src/lib.rs"})), + output: Some(json!("contents")), + status: Some("completed".to_string()), + duration_ms: Some(2), + raw: None, + }, + ), + envelope( + "reasoning", + 1003, + &["after-read"], + ProvenanceJournalEvent::Reasoning { + text: "choose an explicit envelope".to_string(), + duration_ms: Some(3), + signature: Some("sig".to_string()), + }, + ), + envelope( + "response", + 1004, + &["reasoning"], + ProvenanceJournalEvent::Response { + text: "implemented".to_string(), + }, + ), + envelope( + "terminal", + 1005, + &["response"], + ProvenanceJournalEvent::Terminal { + hook_type: HookType::TurnEnd, + reason: Some("complete".to_string()), + payload: Some(json!({"tokens": 10})), + }, + ), + ]; + let baseline = ProvenanceAccumulator::replay_provenance_journal(events.clone()).unwrap(); + + let mut permutations = Vec::new(); + let mut candidate = events; + collect_permutations(&mut candidate, 0, &mut permutations); + assert_eq!(permutations.len(), 720); + for permutation in permutations { + let replayed = ProvenanceAccumulator::replay_provenance_journal(permutation).unwrap(); + assert_eq!(replayed.nodes(), baseline.nodes()); + assert_eq!(replayed.edges(), baseline.edges()); + assert_eq!(replayed.stats(), baseline.stats()); + } + } + + #[test] + fn graph_snapshot_adapter_replays_exact_semantics() { + let mut original = ProvenanceAccumulator::new("session-1"); + original.append_goal("preserve graph", 1000); + original.append_tool_call( + "edit", + Some("edit-1"), + Some(&json!({"path": "src/lib.rs"})), + Some("ok"), + Some("completed"), + Some(5), + 1001, + ); + original.append_patch_proposal("HASH", &["src/lib.rs".to_string()], 1002); + + let snapshot = original.to_journal_snapshot(3, 2, 1003).unwrap(); + let replayed = ProvenanceAccumulator::replay_provenance_journal(vec![snapshot]).unwrap(); + assert_eq!(replayed.nodes(), original.nodes()); + assert_eq!(replayed.edges(), original.edges()); + assert_eq!(replayed.stats(), original.stats()); + } + + #[test] + fn replay_rejects_missing_parents_and_cycles() { + let missing = envelope( + "child", + 1, + &["missing"], + ProvenanceJournalEvent::Response { + text: "never replayed".to_string(), + }, + ); + assert!(matches!( + ProvenanceAccumulator::replay_provenance_journal(vec![missing]), + Err(ProvenanceJournalError::MissingCausalParent { .. }) + )); + + let a = envelope( + "a", + 1, + &["b"], + ProvenanceJournalEvent::Response { + text: "a".to_string(), + }, + ); + let b = envelope( + "b", + 1, + &["a"], + ProvenanceJournalEvent::Response { + text: "b".to_string(), + }, + ); + assert!(matches!( + ProvenanceAccumulator::replay_provenance_journal(vec![a, b]), + Err(ProvenanceJournalError::CausalCycle) + )); + } + + fn collect_permutations( + values: &mut [ProvenanceJournalEnvelope], + start: usize, + output: &mut Vec>, + ) { + if start == values.len() { + output.push(values.to_vec()); + return; + } + for index in start..values.len() { + values.swap(start, index); + collect_permutations(values, start + 1, output); + values.swap(start, index); + } + } +} diff --git a/atomic-agent/src/provenance/accumulator/mod.rs b/atomic-agent/src/provenance/accumulator/mod.rs index f68cb232..6891b943 100644 --- a/atomic-agent/src/provenance/accumulator/mod.rs +++ b/atomic-agent/src/provenance/accumulator/mod.rs @@ -7,17 +7,10 @@ //! converts the accumulated state to the `atomic-core` [`atomic_core::change::provenance_graph::ProvenanceGraph`] type //! (postcard-serialized, `Hash` change hashes) for content-addressed storage. //! -//! The [`ProvenanceAccumulator`] maintains the provenance graph for a single -//! agent session. It is loaded from disk at the start of each hook invocation, -//! appended to as events arrive, and saved back to disk before the process -//! exits. This design works with the "each hook is a separate process" model -//! used by `atomic agent hooks`. -//! -//! # Persistence -//! -//! The graph is stored as JSON at `.atomic/sessions/{session_id}/graph.json`. -//! Reads and writes are atomic (write to temp file, then rename) to prevent -//! corruption from process crashes. +//! The [`ProvenanceAccumulator`] is now the deterministic replay/build layer +//! over owner-journal envelopes. Its JSON codec remains only to import pending +//! state from repositories created before the redb authority cutover; hook +//! dispatch never writes `graph.json`. //! //! # Edge Inference //! @@ -69,8 +62,7 @@ mod append; mod convert; mod helpers; - -pub(crate) use helpers::build_tool_detail; +mod journal; #[cfg(test)] mod tests; @@ -104,6 +96,13 @@ const MAX_RESPONSE_TEXT_LEN: usize = 8_000; /// /// See the [module-level documentation](self) for details on edge inference /// and persistence. +/// Non-destructive provenance delta prepared for durable publication. +pub struct PreparedProvenanceGraph { + pub graph: atomic_core::change::ProvenanceGraph, + pub(crate) nodes_end: usize, + pub(crate) edges_end: usize, +} + pub struct ProvenanceAccumulator { /// The session ID this graph belongs to. pub(crate) session_id: String, diff --git a/atomic-agent/src/provenance/accumulator/tests.rs b/atomic-agent/src/provenance/accumulator/tests.rs index 61654961..ee05e598 100644 --- a/atomic-agent/src/provenance/accumulator/tests.rs +++ b/atomic-agent/src/provenance/accumulator/tests.rs @@ -620,6 +620,31 @@ fn test_to_provenance_graph_basic() { assert_eq!(graph.stats.commitment_count, 1); } +#[test] +fn prepare_provenance_graph_does_not_advance_cursors_before_acknowledgement() { + use atomic_core::types::{Base32, Hash}; + + let mut acc = ProvenanceAccumulator::new("sess-prepare"); + acc.append_goal("prepare safely", 1000); + let change_hash = Hash::of(b"source"); + + let first = acc.prepare_provenance_graph("agent", "Agent", "vendor", &[change_hash]); + let retry = acc.prepare_provenance_graph("agent", "Agent", "vendor", &[change_hash]); + let first_bytes = serde_json::to_vec(&first.graph).unwrap(); + let retry_bytes = serde_json::to_vec(&retry.graph).unwrap(); + assert_eq!(first_bytes, retry_bytes); + assert_eq!(acc.nodes_saved_count, 0); + assert_eq!(acc.edges_saved_count, 0); + assert!(acc.last_provenance_hash().is_none()); + + let hash = Hash::of(&first_bytes); + let hash_base32 = hash.to_base32(); + acc.acknowledge_prepared_graph(&first, hash); + assert_eq!(acc.nodes_saved_count, acc.nodes.len()); + assert_eq!(acc.edges_saved_count, acc.edges.len()); + assert_eq!(acc.last_provenance_hash(), Some(hash_base32.as_str())); +} + #[test] fn test_to_provenance_graph_with_chaining() { use atomic_core::types::{Base32, Hash}; diff --git a/atomic-agent/src/provenance/mod.rs b/atomic-agent/src/provenance/mod.rs index bb187545..8d99e834 100644 --- a/atomic-agent/src/provenance/mod.rs +++ b/atomic-agent/src/provenance/mod.rs @@ -5,31 +5,26 @@ //! explored (explorations), what it changed (commitments), how it validated //! its work (verifications), and where it was uncertain (human gates). //! -//! The graph is built incrementally by the [`accumulator::ProvenanceAccumulator`] -//! as hook events arrive via the [`crate::turn::TurnOrchestrator`], and persisted -//! to `.atomic/sessions/{session_id}/graph.json` between process invocations. +//! Hook events are committed to the repository-owner redb journal. The +//! [`accumulator::ProvenanceAccumulator`] deterministically replays a frozen +//! turn frontier when producing an immutable content-addressed graph. //! //! # Architecture //! //! ```text //! TurnOrchestrator::dispatch(event) //! │ -//! ├── handle_turn_start → accumulator.append_goal(prompt) -//! ├── handle_tool_use → accumulator.append_tool_call(tool, args, output) -//! │ │ -//! │ ├── classify::classify_tool_call → NodeKind -//! │ ├── classify::summarize_tool_call → summary -//! │ └── accumulator.infer_edges → causal DAG -//! │ -//! ├── handle_turn_end → accumulator.append_patch_proposal(change_hash) -//! └── handle_session_end → log stats, finalize graph +//! ├── turn/tool hooks → owner journal envelopes +//! ├── turn end → freeze committed event frontier +//! ├── replay → accumulator + causal DAG +//! └── checkpoint → immutable graph + SESSION_TURNS/head //! ``` //! //! # Modules //! //! - [`types`] — Node, edge, and graph type definitions //! - [`classify`] — Rule-based tool call classification -//! - [`accumulator`] — In-memory DAG builder with persistence +//! - [`accumulator`] — Deterministic journal replay and DAG builder //! - [`detail`] — Typed JSON payloads for Sherpa provenance nodes //! //! # Example @@ -62,7 +57,7 @@ pub mod detail; pub mod types; // Re-export primary types for convenience. -pub use accumulator::ProvenanceAccumulator; +pub use accumulator::{PreparedProvenanceGraph, ProvenanceAccumulator}; pub use classify::{classify_tool_call, summarize_tool_call}; pub use consolidate::consolidate; pub use detail::{ diff --git a/atomic-agent/src/provenance/types.rs b/atomic-agent/src/provenance/types.rs index a2960f50..5c5229e5 100644 --- a/atomic-agent/src/provenance/types.rs +++ b/atomic-agent/src/provenance/types.rs @@ -202,7 +202,7 @@ impl fmt::Display for EdgeKind { /// Each node represents a single activity in the agent's decision chain. /// Nodes are created by the accumulator as events arrive and are immutable /// once created (the graph is append-only). -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct GraphNode { /// Unique identifier within this session graph. /// @@ -561,10 +561,8 @@ fn plural_es(n: u32) -> &'static str { /// The complete serialized form of a provenance graph. /// -/// This is what gets written to `.atomic/sessions/{id}/graph.json` and -/// what the compaction hook reads from disk. It contains the full graph -/// state including the accumulator's internal counters needed to resume -/// appending after a process restart. +/// Legacy mutable graph encoding retained solely for one-time pending-state +/// import. Current hooks persist lossless envelopes in the owner redb journal. #[derive(Clone, Debug, Serialize, Deserialize)] pub struct SerializedGraph { /// Schema version. Always 1 for now. diff --git a/atomic-agent/src/transcript/opencode.rs b/atomic-agent/src/transcript/opencode.rs index b43f6c9b..4fbd881a 100644 --- a/atomic-agent/src/transcript/opencode.rs +++ b/atomic-agent/src/transcript/opencode.rs @@ -42,8 +42,6 @@ pub(crate) struct ReasoningBlock { pub duration_ms: Option, } -/// A tool part recovered from the store, keyed by the same call id the -/// plugin puts in the hook payload (`tool_call_id` on graph nodes). #[derive(Debug)] pub(crate) struct ToolPart { pub call_id: String, @@ -76,8 +74,7 @@ pub(crate) struct TurnData { pub finish_reason: Option, /// Number of model steps in the current turn. pub step_count: u32, - /// Tool parts for the session, so graph tool nodes recorded from thin - /// payloads can be enriched with their commands, files and outputs. + /// Tool data used to append immutable enrichment events before checkpointing. pub tool_parts: Vec, } @@ -336,19 +333,16 @@ fn assemble(messages: &[(String, String)], parts: &[(String, Value)]) -> TurnDat line["status"] = serde_json::Value::from(status.to_string()); } push_line(line, &mut data); - // Recover the full tool record so graph nodes recorded from - // thin payloads can be enriched with commands/files/outputs. if let Some(call_id) = part.get("callID").and_then(Value::as_str) { - let output = state - .and_then(|s| s.get("output")) - .and_then(Value::as_str) - .map(|o| o.chars().take(2_000).collect()); data.tool_parts.push(ToolPart { call_id: call_id.to_string(), tool: tool.to_string(), - input: state.and_then(|s| s.get("input")).cloned(), - output, - status: status.map(|s| s.to_string()), + input: state.and_then(|value| value.get("input")).cloned(), + output: state + .and_then(|value| value.get("output")) + .and_then(Value::as_str) + .map(ToOwned::to_owned), + status: status.map(ToOwned::to_owned), }); } } diff --git a/atomic-agent/src/turn/mod.rs b/atomic-agent/src/turn/mod.rs index bda0d8f3..04500aab 100644 --- a/atomic-agent/src/turn/mod.rs +++ b/atomic-agent/src/turn/mod.rs @@ -50,7 +50,11 @@ pub mod phase; pub mod session; // Re-export primary types for convenience -pub use orchestrator::{DispatchResult, TurnOrchestrator}; +pub use orchestrator::{ + DispatchResult, JournalAppendAck, JournalCheckpointAttempt, JournalCheckpointSource, + JournalStopCause, JournalTurnLifecycle, JournalTurnReservation, JournalTurnStatus, + ProvenanceJournalSink, TurnOrchestrator, +}; pub use phase::{ apply_common_actions, transition, Action, Event, Phase, SessionState, TransitionContext, TransitionResult, diff --git a/atomic-agent/src/turn/orchestrator/mod.rs b/atomic-agent/src/turn/orchestrator/mod.rs index 20bcb342..90bf19e6 100644 --- a/atomic-agent/src/turn/orchestrator/mod.rs +++ b/atomic-agent/src/turn/orchestrator/mod.rs @@ -81,13 +81,16 @@ pub(crate) fn is_lock_contended(e: &std::io::Error) -> bool { } use std::path::{Path, PathBuf}; +use std::sync::Arc; use crate::error::AgentResult; -use crate::event::{HookType, TurnEvent}; +use crate::event::{HookType, ProvenanceJournalEnvelope, TurnEvent}; use crate::record::TurnRecordOutcome; use crate::turn::phase::Phase; use crate::turn::session::{ManagedRunStamp, SessionStore}; use crate::watcher::{self, FileWatcher, WatcherConfig}; +use atomic_core::change::session::SessionTurn; +use atomic_core::types::Hash; // ═══════════════════════════════════════════════════════════════════════ // ManagedRunContext @@ -224,6 +227,154 @@ impl std::fmt::Display for DispatchResult { /// /// The orchestrator does NOT persist across hook calls — each invocation is /// independent. Session state is persisted to disk via `SessionStore`. +/// Owner-assigned identity and fencing generation for a journaled turn. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct JournalTurnReservation { + pub provenance_id: u64, + pub generation: u64, +} + +/// Durable acknowledgement for one idempotent journal event. +#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct JournalAppendAck { + pub event_id: String, + pub sequence: u64, +} + +/// Immutable graph-building inputs persisted with a checkpoint attempt. +#[derive(Clone, Debug, PartialEq)] +pub struct JournalCheckpointSource { + pub agent_name: String, + pub agent_display_name: String, + pub agent_vendor: String, + pub change_hashes: Vec, + pub previous_provenance: Option, + pub plan_id: Option, + pub ledger_turn_number: u32, +} + +/// Owner-persisted checkpoint frontier used to resume finalization. +#[derive(Clone, Debug, PartialEq)] +pub struct JournalCheckpointAttempt { + pub provenance_id: u64, + pub attempt_generation: u64, + pub frozen_event_count: u64, + pub source: JournalCheckpointSource, + pub provenance_hash: Option, + pub session_turn: Option, + pub manifest_hash: Option, +} + +/// Why an active turn was interrupted before checkpoint publication. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JournalStopCause { + UserRequested, + LeaseExpired, + ProcessExited, + HookFailure, + SystemShutdown, + Abandoned, +} + +/// Persisted lifecycle state returned by the repository owner. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum JournalTurnLifecycle { + Running, + Stopped { + cause: JournalStopCause, + observed_at: i64, + last_event_seq: Option, + resumable: bool, + }, + Checkpointing, + Completed, + Abandoned { + observed_at: i64, + last_event_seq: Option, + }, +} + +/// Current owner state for one external session turn. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct JournalTurnStatus { + pub provenance_id: u64, + pub generation: u64, + pub lifecycle: JournalTurnLifecycle, +} + +/// Committed provenance-journal boundary supplied by the CLI owner client. +pub trait ProvenanceJournalSink: Send + Sync { + fn reserve_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> Result; + + fn append( + &self, + reservation: JournalTurnReservation, + envelopes: Vec, + now: i64, + ) -> Result, String>; + + fn prepare_checkpoint( + &self, + reservation: JournalTurnReservation, + source: JournalCheckpointSource, + now: i64, + ) -> Result; + + fn load_frozen_envelopes( + &self, + checkpoint: &JournalCheckpointAttempt, + ) -> Result>, String>; + + fn bind_checkpoint_hash( + &self, + checkpoint: &JournalCheckpointAttempt, + hash: Hash, + session_turn: SessionTurn, + now: i64, + ) -> Result; + + fn acknowledge_checkpoint( + &self, + checkpoint: &JournalCheckpointAttempt, + manifest_hash: Hash, + completed_at: i64, + ) -> Result<(), String>; + + fn stop_turn( + &self, + session_id: &str, + turn_number: u32, + cause: JournalStopCause, + resumable: bool, + observed_at: i64, + ) -> Result, String>; + + fn resume_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> Result, String>; + + fn abandon_turn( + &self, + session_id: &str, + turn_number: u32, + observed_at: i64, + ) -> Result, String>; + + fn turn_status( + &self, + session_id: &str, + turn_number: u32, + ) -> Result, String>; +} + pub struct TurnOrchestrator { /// Path to the repository root (where `.atomic/` lives). pub(crate) repo_root: PathBuf, @@ -246,6 +397,10 @@ pub struct TurnOrchestrator { /// Managed-run context when a governing lifecycle covers this hook; /// `None` for direct agent usage (behavior unchanged). pub(crate) managed_run: Option, + + /// Required committed journal sink for mutable provenance. Legacy JSON is + /// accepted only as a one-time import before the next hook event. + pub(crate) journal_sink: Option>, } impl TurnOrchestrator { @@ -283,6 +438,7 @@ impl TurnOrchestrator { agent_name: "unknown".to_string(), agent_display_name: "Unknown Agent".to_string(), managed_run: None, + journal_sink: None, }) } @@ -302,6 +458,7 @@ impl TurnOrchestrator { agent_name: "unknown".to_string(), agent_display_name: "Unknown Agent".to_string(), managed_run: None, + journal_sink: None, } } @@ -321,6 +478,11 @@ impl TurnOrchestrator { self.managed_run = Some(context); } + /// Route provenance mutations through a committed repository owner. + pub fn set_journal_sink(&mut self, sink: Arc) { + self.journal_sink = Some(sink); + } + /// The view declared by the governing managed run, if any. pub(crate) fn managed_view(&self) -> Option<&str> { self.managed_run.as_ref().and_then(|m| m.view.as_deref()) diff --git a/atomic-agent/src/turn/orchestrator/provenance.rs b/atomic-agent/src/turn/orchestrator/provenance.rs index 95133d96..3aa28579 100644 --- a/atomic-agent/src/turn/orchestrator/provenance.rs +++ b/atomic-agent/src/turn/orchestrator/provenance.rs @@ -1,26 +1,15 @@ //! Provenance graph helpers and attestation creation for the turn orchestrator. //! -//! Contains methods for: -//! - Loading/saving the provenance accumulator -//! - Ingesting Sherpa JSONL trace files -//! - Saving turn provenance graphs -//! - Injecting reasoning/thinking blocks -//! - Creating session attestations -//! -//! # Concurrency -//! -//! Each hook event (session-start, user-prompt-submit, post-tool, stop) -//! spawns a separate process. Multiple events can fire close together, -//! causing concurrent access to the accumulator's `graph.json`. All -//! load → mutate → save cycles are serialized through an advisory file -//! lock (`{session_dir}/graph.lock`) to prevent corruption. +//! Contains owner-journal migration, event normalization, deterministic +//! checkpoint finalization, transcript recovery, and attestation helpers. +//! Mutable provenance is committed through the repository owner. Legacy +//! `graph.json` is read once for pending-delta migration and then removed. -use std::collections::HashMap; use std::path::{Path, PathBuf}; -use crate::event::TurnEvent; -use crate::provenance::accumulator::{build_tool_detail, ProvenanceAccumulator}; -use crate::provenance::classify::summarize_tool_call; +use crate::error::{AgentError, AgentResult}; +use crate::event::{HookType, ProvenanceJournalEnvelope, ProvenanceJournalEvent, TurnEvent}; +use crate::provenance::accumulator::ProvenanceAccumulator; use crate::record::TurnRecordOutcome; use crate::transcript; use crate::turn::session::AgentSession; @@ -28,232 +17,302 @@ use atomic_core::change::session::SessionTodo; use super::{truncate_prompt, TurnOrchestrator}; -/// Filename for the advisory lock that serializes accumulator access. -const LOCK_FILENAME: &str = "graph.lock"; +struct JournalDraft { + event_id: String, + timestamp_ms: i64, + causal_parent_ids: Vec, + event: ProvenanceJournalEvent, +} impl TurnOrchestrator { - /// Get the session directory for provenance graph storage. - /// - /// Returns `{sessions_dir}/{session_id}/` — a subdirectory alongside - /// the session's JSON file. The `ProvenanceAccumulator` stores its - /// `graph.json` here. - pub(crate) fn session_graph_dir(&self, session_id: &str) -> PathBuf { - self.session_store.sessions_dir().join(session_id) - } - - /// Execute `f` while holding an exclusive file lock on the session's - /// accumulator. The lock file is `{session_dir}/graph.lock`. - /// - /// The callback receives a mutable `ProvenanceAccumulator`. If `f` - /// returns `true`, the accumulator is saved back to disk before the - /// lock is released. If `f` returns `false`, the accumulator is - /// discarded (read-only access). - /// - /// Best-effort: waits for concurrent updates and returns `None` if the lock - /// or load fails. - fn with_accumulator(&self, session_id: &str, f: F) -> Option - where - F: FnOnce(&mut ProvenanceAccumulator) -> bool, - { - use fs2::FileExt; - - let dir = self.session_graph_dir(session_id); - - // Ensure the directory exists before creating the lock file. - if let Err(e) = std::fs::create_dir_all(&dir) { - log::warn!("Failed to create session dir for {}: {}", session_id, e,); - return None; + fn migrate_legacy_accumulator( + &self, + session_id: &str, + turn_number: u32, + timestamp_ms: i64, + ) -> AgentResult<()> { + let session_dir = self.session_graph_dir(session_id); + let graph_path = ProvenanceAccumulator::graph_path(&session_dir); + if !graph_path.exists() { + // A stale lock has no authority without its graph payload. + let _ = std::fs::remove_file(session_dir.join("graph.lock")); + return Ok(()); } - - // Open (or create) the lock file and acquire an exclusive lock. - let lock_path = dir.join(LOCK_FILENAME); - let lock_file = match std::fs::OpenOptions::new() - .create(true) - .write(true) - .truncate(false) - .open(&lock_path) - { - Ok(f) => f, - Err(e) => { - log::warn!("Failed to open lock file for session {}: {}", session_id, e,); - return None; + let accumulator = ProvenanceAccumulator::load_or_create(&session_dir, session_id)?; + if let Some(event) = accumulator.pending_graph_delta() { + if self.journal_sink.is_none() { + return Err(AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: "legacy graph.json requires an owner-backed migration sink".to_string(), + }); } - }; - - if let Err(e) = lock_file.lock_exclusive() { - log::warn!("Failed to acquire lock for session {}: {}", session_id, e,); - return None; + self.commit_journal_drafts( + session_id, + turn_number, + vec![JournalDraft { + event_id: stable_journal_id(session_id, turn_number, "legacy-graph-import"), + timestamp_ms, + causal_parent_ids: Vec::new(), + event, + }], + )?; } + // Deletion is strictly after parse and committed acknowledgement (when + // a pending delta existed). Immutable content-addressed history is not + // stored here and remains untouched. + std::fs::remove_file(&graph_path).map_err(|error| AgentError::SessionSaveFailed { + session_id: session_id.to_string(), + reason: format!("failed to remove migrated graph.json: {error}"), + })?; + let _ = std::fs::remove_file(session_dir.join("graph.lock")); + Ok(()) + } - // Load (or create) the accumulator while holding the lock. - let mut acc = match ProvenanceAccumulator::load_or_create(&dir, session_id) { - Ok(a) => a, - Err(e) => { - log::warn!( - "Failed to load provenance accumulator for {}: {}", - session_id, - e, - ); - let _ = lock_file.unlock(); - return None; - } + pub(super) fn resume_journal_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> AgentResult<()> { + let Some(sink) = &self.journal_sink else { + return Ok(()); }; - - // Run the callback. - let should_save = f(&mut acc); - - // Save if the callback mutated the accumulator. - if should_save { - if let Err(e) = acc.save(&dir) { - log::warn!( - "Failed to save provenance accumulator for {}: {}", - session_id, - e, - ); - } - } - - // Release the lock (also released on drop, but be explicit). - let _ = lock_file.unlock(); - - Some(acc) + sink.resume_turn(session_id, turn_number, now) + .map(|_| ()) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + }) } - /// Mutate and save a session's provenance accumulator under one lock. - /// - /// Concurrent hook processes wait their turn rather than dropping an update. - pub(super) fn update_accumulator( + pub(super) fn stop_journal_turn( &self, session_id: &str, - update: F, - ) -> Option - where - F: FnOnce(&mut ProvenanceAccumulator), - { - self.with_accumulator(session_id, |acc| { - update(acc); - true - }) + turn_number: u32, + cause: super::JournalStopCause, + resumable: bool, + observed_at: i64, + ) -> AgentResult<()> { + let Some(sink) = &self.journal_sink else { + return Ok(()); + }; + sink.stop_turn(session_id, turn_number, cause, resumable, observed_at) + .map(|_| ()) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + }) } - /// Inject reasoning/thinking blocks from the stop event into the - /// ProvenanceAccumulator as Decision nodes. - /// - /// The OpenCode plugin sends `reasoning_text` (blocks separated by - /// `\n---\n`) and `reasoning_signature` (last block's Anthropic signature) - /// in the `stop` payload. Each block becomes a Decision node in the - /// provenance graph with the full thinking text and signature in its detail. - pub(crate) fn inject_reasoning_nodes(&mut self, session_id: &str, event: &TurnEvent) { - let raw = match event.raw_json.as_ref() { - Some(r) => r, - None => return, + fn commit_journal_drafts( + &self, + session_id: &str, + turn_number: u32, + drafts: Vec, + ) -> AgentResult<()> { + let Some(sink) = &self.journal_sink else { + return Ok(()); }; - - let timestamp = event.timestamp.timestamp(); - - self.with_accumulator(session_id, |acc| { - let mut block_count = 0; - - // Prefer the structured `reasoning_blocks` array when available. - if let Some(blocks_arr) = raw.get("reasoning_blocks").and_then(|v| v.as_array()) { - for block in blocks_arr { - let text = match block.get("text").and_then(|v| v.as_str()) { - Some(t) if !t.trim().is_empty() => t.trim(), - _ => continue, - }; - let duration_ms = block.get("duration_ms").and_then(|v| v.as_u64()); - let signature = block.get("signature").and_then(|v| v.as_str()); - - acc.append_reasoning(text, duration_ms, signature, timestamp); - block_count += 1; - } - } else { - // Fallback: split concatenated reasoning_text on "\n---\n" - let reasoning_text = match raw.get("reasoning_text").and_then(|v| v.as_str()) { - Some(t) if !t.is_empty() => t, - _ => return false, - }; - let reasoning_signature = raw.get("reasoning_signature").and_then(|v| v.as_str()); - - let blocks: Vec<&str> = reasoning_text - .split("\n---\n") - .filter(|b| !b.trim().is_empty()) - .collect(); - - let total = blocks.len(); - for (i, block) in blocks.iter().enumerate() { - let sig = if i == total - 1 { - reasoning_signature - } else { - None - }; - acc.append_reasoning(block.trim(), None, sig, timestamp); - block_count += 1; - } - } - - if block_count > 0 { - log::info!( - "Injected {} reasoning node{} into provenance for session {}", - block_count, - if block_count == 1 { "" } else { "s" }, + if drafts.is_empty() { + return Ok(()); + } + let now = drafts + .iter() + .map(|draft| draft.timestamp_ms.div_euclid(1000)) + .max() + .unwrap_or(0); + let reservation = sink + .reserve_turn(session_id, turn_number, now) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + })?; + let envelopes: Vec<_> = drafts + .into_iter() + .map(|draft| { + ProvenanceJournalEnvelope::new( + draft.event_id, session_id, - ); + turn_number, + reservation.generation, + draft.timestamp_ms, + draft.event, + ) + .with_causal_parents(draft.causal_parent_ids) + }) + .collect(); + let expected_ids: Vec<_> = envelopes + .iter() + .map(|envelope| envelope.event_id.clone()) + .collect(); + let acknowledgements = sink.append(reservation, envelopes, now).map_err(|reason| { + AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, } + })?; + let acknowledged_ids: std::collections::HashSet<_> = acknowledgements + .into_iter() + .map(|ack| ack.event_id) + .collect(); + if expected_ids + .iter() + .any(|event_id| !acknowledged_ids.contains(event_id)) + { + return Err(AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: "owner omitted a committed event acknowledgement".to_string(), + }); + } + Ok(()) + } - block_count > 0 - }); + pub(super) fn commit_hook_event(&self, event: &TurnEvent, turn_number: u32) -> AgentResult<()> { + self.migrate_legacy_accumulator( + &event.session_id, + turn_number, + event.timestamp.timestamp_millis(), + )?; + let discriminator = match event.event_type { + HookType::TurnStart => "goal".to_string(), + HookType::PreToolUse => format!( + "tool-before:{}", + event + .tool_use_id + .clone() + .unwrap_or_else(|| anonymous_tool_key(event)) + ), + HookType::PostToolUse => format!( + "tool-after:{}", + event + .tool_use_id + .clone() + .unwrap_or_else(|| anonymous_tool_key(event)) + ), + HookType::TurnEnd => "turn-end".to_string(), + HookType::SessionStart => "session-start".to_string(), + HookType::SessionEnd => "session-end".to_string(), + }; + let event_id = stable_journal_id(&event.session_id, turn_number, &discriminator); + let envelope = ProvenanceJournalEnvelope::from_turn_event(&event_id, turn_number, 1, event); + self.commit_journal_drafts( + &event.session_id, + turn_number, + vec![JournalDraft { + event_id, + timestamp_ms: envelope.timestamp_ms, + causal_parent_ids: Vec::new(), + event: envelope.event, + }], + ) } - /// Inject an LLM response node into the ProvenanceAccumulator. - /// - /// The agent's closing message for the turn — what it *concluded*, as - /// opposed to the tool-derived nodes that capture what it *did*. - /// Sources, in priority order: - /// - /// 1. The stop payload, when the agent sends the response there - /// (`last_assistant_message` for codex/grok, `prompt_response` for - /// gemini-cli, `response` for plugins that supply it). - /// 2. The last assistant entry of the session transcript (claude-code: - /// the Stop hook carries `transcript_path`, applied to the session - /// before recording). - /// - /// Agents with neither source available get no node. - pub(crate) fn inject_response_node( - &mut self, - session_id: &str, + pub(super) fn commit_turn_completion_events( + &self, session: &AgentSession, event: &TurnEvent, - ) { - let raw = event.raw_json.as_ref(); - let from_payload = |key: &str| -> Option { - raw.and_then(|r| r.get(key)) - .and_then(|v| v.as_str()) - .map(|s| s.trim().to_string()) - .filter(|s| !s.is_empty()) - }; + turn_number: u32, + ) -> AgentResult<()> { + self.migrate_legacy_accumulator( + &event.session_id, + turn_number, + event.timestamp.timestamp_millis(), + )?; + let mut drafts = Vec::new(); + let mut previous = None::; + let mut terminal_parents = Vec::new(); + for (index, (text, duration_ms, signature)) in + reasoning_blocks(event).into_iter().enumerate() + { + let event_id = stable_journal_id( + &event.session_id, + turn_number, + &format!("reasoning:{index}"), + ); + drafts.push(JournalDraft { + event_id: event_id.clone(), + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: previous.iter().cloned().collect(), + event: ProvenanceJournalEvent::Reasoning { + text, + duration_ms, + signature, + }, + }); + previous = Some(event_id); + } - let response = from_payload("last_assistant_message") - .or_else(|| from_payload("prompt_response")) - .or_else(|| from_payload("response")) - .or_else(|| { - let path = session.transcript_path.as_ref()?; - let data = std::fs::read(path).ok()?; - transcript::last_assistant_text( - &data, - transcript::format_for_agent(&session.agent_name), - ) + if let Some(last_reasoning) = previous.clone() { + terminal_parents.push(last_reasoning); + } + for todo in extract_turn_todos(event, &event.session_id, turn_number.saturating_sub(1)) { + let event_id = + stable_journal_id(&event.session_id, turn_number, &format!("todo:{}", todo.id)); + terminal_parents.push(event_id.clone()); + drafts.push(JournalDraft { + event_id, + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: Vec::new(), + event: ProvenanceJournalEvent::Todo { todo }, }); + } - let Some(response) = response else { - return; - }; + if let Some(text) = response_text(session, event) { + let event_id = stable_journal_id(&event.session_id, turn_number, "response"); + drafts.push(JournalDraft { + event_id: event_id.clone(), + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: previous.iter().cloned().collect(), + event: ProvenanceJournalEvent::Response { text }, + }); + terminal_parents.push(event_id); + } - let timestamp = event.timestamp.timestamp(); - self.with_accumulator(session_id, |acc| { - acc.append_llm_response(&response, timestamp); - true + let terminal_id = stable_journal_id(&event.session_id, turn_number, "turn-end"); + drafts.push(JournalDraft { + event_id: terminal_id, + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: terminal_parents, + event: ProvenanceJournalEvent::Terminal { + hook_type: HookType::TurnEnd, + reason: event + .raw_json + .as_ref() + .and_then(|raw| raw.get("reason")) + .and_then(serde_json::Value::as_str) + .map(ToOwned::to_owned), + payload: event.raw_json.clone(), + }, }); + self.commit_journal_drafts(&event.session_id, turn_number, drafts) + } + + fn commit_recorded_turn_events( + &self, + session_id: &str, + turn_number: u32, + event: &TurnEvent, + outcome: &TurnRecordOutcome, + ) -> AgentResult<()> { + use atomic_core::types::Base32; + + let mut drafts = Vec::new(); + let change_hash = outcome.hash.to_base32(); + drafts.push(JournalDraft { + event_id: stable_journal_id(session_id, turn_number, &format!("patch:{change_hash}")), + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: Vec::new(), + event: ProvenanceJournalEvent::PatchProposal { + change_hash, + files: outcome.recorded_file_list().to_vec(), + }, + }); + self.commit_journal_drafts(session_id, turn_number, drafts) + } + + /// Get the session directory used by session-adjacent migration/transcripts. + pub(crate) fn session_graph_dir(&self, session_id: &str) -> PathBuf { + self.session_store.sessions_dir().join(session_id) } /// OpenCode: recover transcript, reasoning, and response from @@ -270,21 +329,22 @@ impl TurnOrchestrator { /// - the transcript is synthesized into the session directory and set /// as `session.transcript_path` (consumed by /// `build_unhashed_turn_data` via the `opencode` condense format); - /// - the turn's reasoning/response/token/cost fields are injected - /// into `event.raw_json` only when the plugin didn't send them - /// (consumed by `build_turn_provenance`, `inject_reasoning_nodes`, - /// and `inject_response_node`). + /// - the turn's reasoning/response/token/cost fields are injected into + /// `event.raw_json` only when the plugin didn't send them; the owner + /// journal then commits the enriched terminal envelopes. /// - /// Best-effort: any failure leaves the turn recording what the plugin - /// sent. - pub(crate) fn enrich_opencode_turn(&self, session: &mut AgentSession, event: &mut TurnEvent) { + pub(crate) fn enrich_opencode_turn( + &self, + session: &mut AgentSession, + event: &mut TurnEvent, + ) -> AgentResult<()> { if session.agent_name != "opencode" { - return; + return Ok(()); } let Some(data) = transcript::opencode::read_turn(&session.session_id, &self.repo_root) else { - return; + return Ok(()); }; // 1. Transcript file → transcript_path (unblocks agent_turn). @@ -310,10 +370,10 @@ impl TurnOrchestrator { // 2. Stop-payload fields the plugin didn't send. let Some(raw) = event.raw_json.as_mut() else { - return; + return Ok(()); }; let Some(obj) = raw.as_object_mut() else { - return; + return Ok(()); }; if !obj.contains_key("reasoning_blocks") @@ -380,49 +440,31 @@ impl TurnOrchestrator { obj.insert("step_count".to_string(), serde_json::json!(data.step_count)); } - // 3. Enrich the session graph's tool nodes. Thin plugin payloads carry - // no tool input/output, so nodes recorded at hook time hold bare - // summaries ("Execute bash"). The store's tool parts carry the - // command, file and output under the same call id — rewrite the - // summary and detail so the graph reads as rich as the rich-plugin - // path. Runs over ALL nodes, so one enriched turn repairs earlier - // thin turns of the same session. - if !data.tool_parts.is_empty() { - let by_call: HashMap<&str, &transcript::opencode::ToolPart> = data - .tool_parts - .iter() - .map(|tp| (tp.call_id.as_str(), tp)) - .collect(); - - self.with_accumulator(&session.session_id, |acc| { - let mut changed = false; - for node in acc.nodes.iter_mut() { - let Some(call_id) = node.tool_call_id.as_deref() else { - continue; - }; - let Some(tp) = by_call.get(call_id) else { - continue; - }; - let tool_name = node.tool_name.as_deref().unwrap_or(tp.tool.as_str()); - let input = tp.input.as_ref(); - let output = tp.output.as_deref(); - let status = tp.status.as_deref(); - - let summary = summarize_tool_call(tool_name, node.kind, input, output, status); - if summary != node.summary { - node.summary = summary; - changed = true; - } - if let Some(detail) = - build_tool_detail(node.kind, tool_name, input, output, status) - { - node.detail = Some(detail); - changed = true; - } - } - changed - }); - } + let drafts = data + .tool_parts + .iter() + .map(|tool| JournalDraft { + event_id: stable_journal_id( + &session.session_id, + session.turn_count.saturating_add(1), + &format!("opencode-tool-enrichment:{}", tool.call_id), + ), + timestamp_ms: event.timestamp.timestamp_millis(), + causal_parent_ids: Vec::new(), + event: ProvenanceJournalEvent::ToolEnrichment { + tool_call_id: tool.call_id.clone(), + tool_name: tool.tool.clone(), + input: tool.input.clone(), + output: tool.output.clone(), + status: tool.status.clone(), + }, + }) + .collect(); + self.commit_journal_drafts( + &session.session_id, + session.turn_count.saturating_add(1), + drafts, + )?; log::info!( "Recovered opencode turn data from local store for session {} \ @@ -438,309 +480,430 @@ impl TurnOrchestrator { data.step_count, if data.step_count == 1 { "" } else { "s" }, ); + Ok(()) } /// Read a Sherpa JSONL trace file and create provenance nodes for /// every record, preserving the full agent-trace + Sherpa extension data. /// /// Returns `true` if at least one record was successfully ingested. - pub(crate) fn ingest_sherpa_trace(&self, session_id: &str, trace_path: &Path) -> bool { - use crate::provenance::types::NodeKind; + pub(crate) fn ingest_sherpa_trace( + &self, + session_id: &str, + turn_number: u32, + trace_path: &Path, + ) -> AgentResult { + use crate::provenance::types::{GraphNode, NodeKind}; let content = match std::fs::read_to_string(trace_path) { - Ok(c) => c, - Err(e) => { + Ok(content) => content, + Err(error) => { log::warn!( "sherpa trace: failed to read {}: {}", trace_path.display(), - e + error ); - return false; + return Ok(false); } }; - - let mut ingested_any = false; - - self.with_accumulator(session_id, |acc| { - let mut ingested = 0u32; - for (line_no, line) in content.lines().enumerate() { - if line.trim().is_empty() { + let mut drafts = Vec::new(); + for (line_no, line) in content.lines().enumerate() { + if line.trim().is_empty() { + continue; + } + let record: serde_json::Value = match serde_json::from_str(line) { + Ok(record) => record, + Err(error) => { + log::warn!("sherpa trace: line {} parse error: {}", line_no + 1, error); continue; } - - let record: serde_json::Value = match serde_json::from_str(line) { - Ok(v) => v, - Err(e) => { - log::warn!("sherpa trace: line {} parse error: {}", line_no + 1, e); - continue; - } - }; - - let dev_atomic = &record["metadata"]["dev.atomic"]; - let record_type = dev_atomic["record_type"].as_str().unwrap_or("unknown"); - let timestamp = record["timestamp"] - .as_str() - .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok()) - .map(|dt| dt.timestamp_millis()) - .unwrap_or_else(|| chrono::Utc::now().timestamp_millis()); - - let (kind, summary) = match record_type { - "intent" => ( - NodeKind::Goal, - dev_atomic["intent_title"] - .as_str() - .unwrap_or("intent") - .to_string(), + }; + let dev_atomic = &record["metadata"]["dev.atomic"]; + let record_type = dev_atomic["record_type"].as_str().unwrap_or("unknown"); + let timestamp = record["timestamp"] + .as_str() + .and_then(|value| chrono::DateTime::parse_from_rfc3339(value).ok()) + .map(|value| value.timestamp_millis()) + .unwrap_or(0); + let (kind, summary) = match record_type { + "intent" => ( + NodeKind::Goal, + dev_atomic["intent_title"] + .as_str() + .unwrap_or("intent") + .to_string(), + ), + "commitment" => { + let file = record["files"] + .as_array() + .and_then(|files| files.first()) + .and_then(|file| file["path"].as_str()) + .unwrap_or(""); + (NodeKind::Commitment, format!("wrote {file}")) + } + "execution" => ( + NodeKind::Execution, + dev_atomic["command"] + .as_str() + .unwrap_or("command") + .to_string(), + ), + "todo" => ( + NodeKind::Todo, + format!( + "[{}] {}", + dev_atomic["todo_id"].as_str().unwrap_or(""), + dev_atomic["content"].as_str().unwrap_or("") ), - "commitment" => { - let file = record["files"] - .as_array() - .and_then(|f| f.first()) - .and_then(|f| f["path"].as_str()) - .unwrap_or(""); - (NodeKind::Commitment, format!("wrote {}", file)) - } - "execution" => ( - NodeKind::Execution, - dev_atomic["command"] - .as_str() - .unwrap_or("command") - .to_string(), + ), + "todo_status" => ( + NodeKind::TodoStatusChange, + format!( + "{}: {} → {}", + dev_atomic["todo_id"].as_str().unwrap_or(""), + dev_atomic["from_status"].as_str().unwrap_or(""), + dev_atomic["to_status"].as_str().unwrap_or("") ), - "todo" => { - let tid = dev_atomic["todo_id"].as_str().unwrap_or(""); - let content_str = dev_atomic["content"].as_str().unwrap_or(""); - (NodeKind::Todo, format!("[{}] {}", tid, content_str)) - } - "todo_status" => { - let tid = dev_atomic["todo_id"].as_str().unwrap_or(""); - let from = dev_atomic["from_status"].as_str().unwrap_or(""); - let to = dev_atomic["to_status"].as_str().unwrap_or(""); - ( - NodeKind::TodoStatusChange, - format!("{}: {} → {}", tid, from, to), - ) - } - "phase_transition" => { - let from = dev_atomic["from_phase"].as_str().unwrap_or(""); - let to = dev_atomic["to_phase"].as_str().unwrap_or(""); - (NodeKind::PhaseTransition, format!("{} → {}", from, to)) - } - "lesson" => ( - NodeKind::Lesson, - dev_atomic["label"].as_str().unwrap_or("lesson").to_string(), + ), + "phase_transition" => ( + NodeKind::PhaseTransition, + format!( + "{} → {}", + dev_atomic["from_phase"].as_str().unwrap_or(""), + dev_atomic["to_phase"].as_str().unwrap_or("") ), - "llm_response" => ( - NodeKind::LlmResponse, - truncate_prompt( - dev_atomic["reply"].as_str().unwrap_or("llm response"), - 200, - ), + ), + "lesson" => ( + NodeKind::Lesson, + dev_atomic["label"].as_str().unwrap_or("lesson").to_string(), + ), + "llm_response" => ( + NodeKind::LlmResponse, + truncate_prompt(dev_atomic["reply"].as_str().unwrap_or("llm response"), 200), + ), + "verification" => ( + NodeKind::Verification, + dev_atomic["summary"] + .as_str() + .unwrap_or("verification") + .to_string(), + ), + "human_gate" => ( + NodeKind::HumanGateResolution, + format!( + "resolution: {}", + dev_atomic["resolution"].as_str().unwrap_or("") ), - "verification" => ( - NodeKind::Verification, - dev_atomic["summary"] - .as_str() - .unwrap_or("verification") - .to_string(), - ), - "human_gate" => { - let resolution = dev_atomic["resolution"].as_str().unwrap_or(""); - ( - NodeKind::HumanGateResolution, - format!("resolution: {}", resolution), - ) - } - _ => { - log::debug!( - "sherpa trace: skipping unknown record_type '{}'", - record_type - ); - continue; - } - }; - - acc.append_raw_node(kind, timestamp, &summary, Some(dev_atomic.clone())); - ingested += 1; - } - - if ingested > 0 { - log::info!( - "sherpa trace: ingested {} records from {}", - ingested, - trace_path.display() - ); - ingested_any = true; - } - - ingested > 0 - }); - - ingested_any + ), + _ => continue, + }; + let discriminator = format!("sherpa:{}", blake3::hash(line.as_bytes()).to_hex()); + let event_id = stable_journal_id(session_id, turn_number, &discriminator); + let node = + GraphNode::new(&event_id, kind, timestamp, summary).with_detail(dev_atomic.clone()); + drafts.push(JournalDraft { + event_id, + timestamp_ms: timestamp, + causal_parent_ids: Vec::new(), + event: ProvenanceJournalEvent::GraphDelta { + nodes: vec![node], + edges: Vec::new(), + }, + }); + } + let ingested = drafts.len(); + self.commit_journal_drafts(session_id, turn_number, drafts)?; + Ok(ingested > 0) } - /// Save the provenance graph for a recorded turn. - /// - /// Appends a patch proposal node to the accumulator, converts to a - /// content-addressed `ProvenanceGraph`, and saves it to the repository. - /// The accumulator's `last_provenance_hash` is updated so subsequent - /// graphs chain correctly via `previous`. - /// - /// Best-effort: all failures are logged but never block the session. + /// Finalize a recorded turn through the persisted checkpoint state machine. pub(crate) fn save_turn_provenance( &self, session_id: &str, session: &AgentSession, outcome: &TurnRecordOutcome, event: &TurnEvent, - ) { - use atomic_core::types::Base32; - - let plan_id = session - .managed_run - .as_ref() - .and_then(|run| run.work_item_id.clone()); - let ledger_turn = session.turn_count.saturating_sub(1); - let todos = extract_turn_todos(event, session_id, ledger_turn); - - self.with_accumulator(session_id, |acc| { - for todo in &todos { - acc.append_todo_snapshot(todo, event.timestamp.timestamp()); - } - - // Append a patch proposal node for the recorded change - let change_hash_base32 = outcome.hash.to_base32(); - acc.append_patch_proposal( - &change_hash_base32, - outcome.recorded_file_list(), - event.timestamp.timestamp(), - ); - - // Convert the accumulated graph to a content-addressed ProvenanceGraph - let change_hashes = vec![outcome.hash]; - let mut graph = acc.to_provenance_graph( - &session.agent_name, - &session.agent_display_name, - &session.agent_vendor, - &change_hashes, + ) -> AgentResult<()> { + use atomic_core::change::session::SessionTurn; + use atomic_core::types::{Base32, Hash}; + + self.commit_recorded_turn_events(session_id, session.turn_count.max(1), event, outcome)?; + let Some(sink) = self.journal_sink.as_ref() else { + log::debug!( + "Skipping provenance finalization for {} without an owner journal sink", + session_id ); + return Ok(()); + }; - // Set the Sherpa profile if this is a Sherpa session. - if session.agent_name == "sherpa" { - graph.profile = Some("sherpa-trace/1.0.0".to_string()); - } - graph.plan_id = plan_id.clone(); - graph.todos = todos.clone(); - - // Save the provenance graph in two phases: - // - // Phase 1 (non-blocking): Write the content-addressed file to - // disk via ChangeStore. This is pure filesystem I/O and never - // contends on the redb write lock. - // - // Phase 2 (best-effort): Open the repository and register the - // provenance in the pristine database (change deps, session - // tables). We use Repository::open_existing() which calls - // Pristine::open_existing() — this skips the table-init write - // transaction so it never blocks on the redb write lock. - // Failure is still treated as non-fatal; the provenance chain - // remains intact and the DB metadata can be rebuilt later. - - // Resolve the *canonical* changes dir. In a sandbox `repo_root` - // has no graph of its own — the pointer file names the canonical - // repository. Joining `.atomic` onto `repo_root` would write the - // graph into a throwaway dir inside the sandbox, so it would be - // absent from the real graph whenever the best-effort Phase 2 - // below loses the redb write-lock race with a concurrent agent. - // `canonical_dot_dir` follows the pointer without opening redb, so - // Phase 1 stays lock-free. - let changes_dir = - match atomic_repository::Repository::canonical_dot_dir(&self.repo_root) { - Ok(dot_dir) => dot_dir.join("changes"), - Err(e) => { - log::warn!( - "Could not resolve canonical changes dir to save \ - provenance graph for session {}: {}", - session_id, - e, - ); - return true; - } - }; - - // Phase 1: Filesystem write — never blocks on redb. - let hash = match atomic_repository::ChangeStore::new( - changes_dir, - atomic_repository::DEFAULT_CACHE_CAPACITY, - ) { - Ok(store) => match store.save_provenance_graph(&graph) { - Ok(h) => h, - Err(e) => { - log::warn!( - "Failed to write provenance graph to disk for \ - session {}: {}", - session_id, - e, - ); - return true; - } - }, - Err(e) => { - log::warn!( - "Could not open change store to save provenance \ - graph for session {}: {}", - session_id, - e, + let previous_provenance = atomic_repository::Repository::open_existing(&self.repo_root) + .ok() + .and_then(|repository| repository.get_session_ledger(session_id).ok().flatten()) + .and_then(|(_, turns)| turns.last().map(|turn| turn.provenance_hash)); + let source = super::JournalCheckpointSource { + agent_name: session.agent_name.clone(), + agent_display_name: session.agent_display_name.clone(), + agent_vendor: session.agent_vendor.clone(), + change_hashes: vec![outcome.hash], + previous_provenance, + plan_id: session + .managed_run + .as_ref() + .and_then(|run| run.work_item_id.clone()), + ledger_turn_number: session.turn_count.saturating_sub(1), + }; + let reservation = sink + .reserve_turn( + session_id, + session.turn_count.max(1), + event.timestamp.timestamp(), + ) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + })?; + let mut checkpoint = sink + .prepare_checkpoint(reservation, source, event.timestamp.timestamp()) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + })?; + + let changes_dir = atomic_repository::Repository::canonical_dot_dir(&self.repo_root) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })? + .join("changes"); + let change_store = atomic_repository::ChangeStore::new( + changes_dir, + atomic_repository::DEFAULT_CACHE_CAPACITY, + ) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + + let (graph, _provenance_hash, session_turn) = + match (checkpoint.provenance_hash, checkpoint.session_turn.clone()) { + (Some(hash), Some(turn)) => { + let graph = change_store.load_provenance_graph(&hash).map_err(|error| { + AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: format!("bound provenance graph is unavailable: {error}"), + } + })?; + (graph, hash, turn) + } + (None, None) => { + let frozen = sink.load_frozen_envelopes(&checkpoint).map_err(|reason| { + AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + } + })?; + let envelopes = frozen + .iter() + .map(|bytes| ProvenanceJournalEnvelope::from_json_bytes(bytes)) + .collect::, _>>() + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + let legacy_previous = + envelopes.iter().find_map(|envelope| match &envelope.event { + ProvenanceJournalEvent::LegacyGraphImport { + previous_provenance: Some(previous), + .. + } => Hash::from_base32(previous.as_bytes()), + _ => None, + }); + let effective_previous = + checkpoint.source.previous_provenance.or(legacy_previous); + let todos = envelopes + .iter() + .filter_map(|envelope| match &envelope.event { + ProvenanceJournalEvent::Todo { todo } => Some(todo.clone()), + _ => None, + }) + .collect::>(); + let accumulator = ProvenanceAccumulator::replay_provenance_journal(envelopes) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + let prepared = accumulator.prepare_provenance_graph( + &checkpoint.source.agent_name, + &checkpoint.source.agent_display_name, + &checkpoint.source.agent_vendor, + &checkpoint.source.change_hashes, ); - return true; + let mut graph = prepared.graph; + graph.previous = effective_previous; + graph.plan_id = checkpoint.source.plan_id.clone(); + graph.todos = todos.clone(); + let hash = change_store + .save_provenance_graph(&graph) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + let turn = SessionTurn { + session_id: session_id.to_string(), + turn_number: checkpoint.source.ledger_turn_number, + goal: graph + .nodes + .iter() + .find(|node| { + matches!( + node.kind, + atomic_core::change::provenance_graph::ProvenanceNodeKind::Goal + ) + }) + .map(|node| node.summary.clone()), + provenance_hash: hash, + change_hashes: checkpoint.source.change_hashes.clone(), + previous_provenance: effective_previous, + timestamp: graph.timestamp, + plan_id: checkpoint.source.plan_id.clone(), + todos, + }; + checkpoint = sink + .bind_checkpoint_hash( + &checkpoint, + hash, + turn.clone(), + event.timestamp.timestamp(), + ) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + })?; + (graph, hash, turn) + } + _ => { + return Err(AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: "checkpoint has a partial hash binding".to_string(), + }) } }; - acc.set_last_provenance_hash(hash.to_base32()); - log::info!( - "Saved provenance graph {} for session {} \ - ({} nodes, {} edges, {} changes)", - hash.to_base32(), - session_id, - graph.node_count(), - graph.edge_count(), - graph.change_count(), - ); - - // Phase 2: Database registration — best-effort. - // We use open_existing() which skips the table-init write - // transaction, so it won't block on the redb write lock. - // Failure here is still non-fatal: the provenance file is on - // disk and the DB metadata (EXTERNAL/INTERNAL mapping, DEPS, - // session tables) can be populated on a subsequent open or - // explicit rebuild. - match atomic_repository::Repository::open_existing(&self.repo_root) { - Ok(repo) => { - if let Err(e) = repo.save_provenance_graph(&graph) { - log::warn!( - "Provenance graph {} saved to disk but database \ - registration failed for session {}: {}", - hash.to_base32(), - session_id, - e, - ); - } - } - Err(e) => { - log::warn!( - "Provenance graph {} saved to disk but could not \ - open repository for database registration \ - (session {}): {}", - hash.to_base32(), - session_id, - e, - ); + let repository = + atomic_repository::Repository::open_existing(&self.repo_root).map_err(|error| { + AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), } - } + })?; + let publication = repository + .publish_provenance_checkpoint(&graph, session_turn) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + sink.acknowledge_checkpoint( + &checkpoint, + publication.manifest_hash, + event.timestamp.timestamp(), + ) + .map_err(|reason| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason, + })?; + + Ok(()) + } +} - true // always save — we appended the patch proposal node - }); +fn anonymous_tool_key(event: &TurnEvent) -> String { + let bytes = serde_json::to_vec(&event.raw_json).unwrap_or_default(); + let digest = blake3::hash(&bytes).to_hex().to_string(); + format!("anonymous-{}", &digest[..16]) +} + +fn stable_journal_id(session_id: &str, turn_number: u32, discriminator: &str) -> String { + let digest = blake3::hash(format!("{session_id}\0{turn_number}\0{discriminator}").as_bytes()) + .to_hex() + .to_string(); + format!("hook-{}", &digest[..32]) +} + +fn reasoning_blocks(event: &TurnEvent) -> Vec<(String, Option, Option)> { + let Some(raw) = event.raw_json.as_ref() else { + return Vec::new(); + }; + if let Some(blocks) = raw + .get("reasoning_blocks") + .and_then(serde_json::Value::as_array) + { + return blocks + .iter() + .filter_map(|block| { + let text = block.get("text")?.as_str()?.trim(); + if text.is_empty() { + return None; + } + Some(( + text.to_string(), + block.get("duration_ms").and_then(serde_json::Value::as_u64), + block + .get("signature") + .and_then(serde_json::Value::as_str) + .map(ToOwned::to_owned), + )) + }) + .collect(); } + + let Some(text) = raw + .get("reasoning_text") + .and_then(serde_json::Value::as_str) + else { + return Vec::new(); + }; + let signature = raw + .get("reasoning_signature") + .and_then(serde_json::Value::as_str) + .map(ToOwned::to_owned); + let blocks: Vec<_> = text + .split("\n---\n") + .filter_map(|block| { + let block = block.trim(); + (!block.is_empty()).then(|| block.to_string()) + }) + .collect(); + let last = blocks.len().saturating_sub(1); + blocks + .into_iter() + .enumerate() + .map(|(index, block)| { + let block_signature = (index == last).then(|| signature.clone()).flatten(); + (block, None, block_signature) + }) + .collect() +} + +fn response_text(session: &AgentSession, event: &TurnEvent) -> Option { + let raw = event.raw_json.as_ref(); + let from_payload = |key: &str| -> Option { + raw.and_then(|value| value.get(key)) + .and_then(serde_json::Value::as_str) + .map(str::trim) + .filter(|text| !text.is_empty()) + .map(ToOwned::to_owned) + }; + from_payload("last_assistant_message") + .or_else(|| from_payload("prompt_response")) + .or_else(|| from_payload("response")) + .or_else(|| { + let path = session.transcript_path.as_ref()?; + let data = std::fs::read(path).ok()?; + transcript::last_assistant_text( + &data, + transcript::format_for_agent(&session.agent_name), + ) + }) } /// Extract the generic end-of-turn todo snapshot supplied by current agent diff --git a/atomic-agent/src/turn/orchestrator/session_end.rs b/atomic-agent/src/turn/orchestrator/session_end.rs index 052a58fc..c9bc5bd3 100644 --- a/atomic-agent/src/turn/orchestrator/session_end.rs +++ b/atomic-agent/src/turn/orchestrator/session_end.rs @@ -36,8 +36,18 @@ impl TurnOrchestrator { } }; + let had_active_turn = session.is_turn_active(); + let journal_turn = if had_active_turn { + session.turn_count.saturating_add(1) + } else { + session.turn_count.max(1) + }; + if had_active_turn { + self.commit_hook_event(&event, journal_turn)?; + } + // If a turn is still active, cancel the watcher - if session.is_turn_active() { + if had_active_turn { if let Err(e) = self.watcher.cancel_turn().await { log::warn!( "Failed to cancel turn watcher for session {}: {}", @@ -97,6 +107,9 @@ impl TurnOrchestrator { .or_else(|| session.first_prompt.clone()); let turn_number = session.turn_count + 1; let turn_duration_ms = session.current_turn_duration_ms().unwrap_or(0); + if had_active_turn { + self.commit_turn_completion_events(&session, &event, turn_number)?; + } let record_result = { let record_options = TurnRecordOptions { session: &session, @@ -114,8 +127,7 @@ impl TurnOrchestrator { session.add_files_touched(&recorded_files); session.recorded_change_hashes.push(outcome.hash); session.clear_current_prompt(); - self.inject_reasoning_nodes(session_id, &event); - self.save_turn_provenance(session_id, &session, &outcome, &event); + self.save_turn_provenance(session_id, &session, &outcome, &event)?; log::info!( "SessionEnd flushed a pending turn for session {}: {}", session_id, @@ -155,6 +167,16 @@ impl TurnOrchestrator { } } + if had_active_turn { + self.stop_journal_turn( + session_id, + journal_turn, + super::JournalStopCause::ProcessExited, + true, + event.timestamp.timestamp(), + )?; + } + // State machine transition let result = phase::transition( session.phase, diff --git a/atomic-agent/src/turn/orchestrator/tests.rs b/atomic-agent/src/turn/orchestrator/tests.rs index d918d921..f41d9c5e 100644 --- a/atomic-agent/src/turn/orchestrator/tests.rs +++ b/atomic-agent/src/turn/orchestrator/tests.rs @@ -3,7 +3,9 @@ use super::*; use atomic_repository::Repository; +use crate::error::AgentError; use crate::event::{HookType, TurnEvent}; +use crate::provenance::accumulator::ProvenanceAccumulator; use crate::turn::phase::Phase; use crate::turn::session::{AgentSession, SessionStore}; use crate::watcher::fallback::FallbackWatcher; @@ -39,42 +41,117 @@ fn session_end_event(session_id: &str) -> TurnEvent { TurnEvent::new(session_id, HookType::SessionEnd) } -#[test] -fn concurrent_provenance_updates_are_serialized() { - use crate::provenance::accumulator::ProvenanceAccumulator; - use std::sync::{Arc, Barrier}; +struct RejectingJournalSink; + +impl ProvenanceJournalSink for RejectingJournalSink { + fn reserve_turn( + &self, + _session_id: &str, + _turn_number: u32, + _now: i64, + ) -> Result { + Err("owner unavailable".to_string()) + } + + fn append( + &self, + _reservation: JournalTurnReservation, + _envelopes: Vec, + _now: i64, + ) -> Result, String> { + unreachable!("append must not run when reservation fails") + } + + fn prepare_checkpoint( + &self, + _reservation: JournalTurnReservation, + _source: JournalCheckpointSource, + _now: i64, + ) -> Result { + unreachable!("checkpoint must not run when reservation fails") + } - const WRITERS: usize = 16; - const SESSION_ID: &str = "concurrent-provenance"; + fn load_frozen_envelopes( + &self, + _checkpoint: &JournalCheckpointAttempt, + ) -> Result>, String> { + unreachable!("checkpoint must not run when reservation fails") + } + + fn bind_checkpoint_hash( + &self, + _checkpoint: &JournalCheckpointAttempt, + _hash: atomic_core::types::Hash, + _session_turn: atomic_core::change::session::SessionTurn, + _now: i64, + ) -> Result { + unreachable!("checkpoint must not run when reservation fails") + } + + fn acknowledge_checkpoint( + &self, + _checkpoint: &JournalCheckpointAttempt, + _manifest_hash: atomic_core::types::Hash, + _completed_at: i64, + ) -> Result<(), String> { + unreachable!("checkpoint must not run when reservation fails") + } + + fn stop_turn( + &self, + _session_id: &str, + _turn_number: u32, + _cause: JournalStopCause, + _resumable: bool, + _observed_at: i64, + ) -> Result, String> { + Err("owner unavailable".to_string()) + } + fn resume_turn( + &self, + _session_id: &str, + _turn_number: u32, + _now: i64, + ) -> Result, String> { + Err("owner unavailable".to_string()) + } + + fn abandon_turn( + &self, + _session_id: &str, + _turn_number: u32, + _observed_at: i64, + ) -> Result, String> { + Err("owner unavailable".to_string()) + } + + fn turn_status( + &self, + _session_id: &str, + _turn_number: u32, + ) -> Result, String> { + Err("owner unavailable".to_string()) + } +} + +#[tokio::test] +async fn journal_failure_prevents_unacknowledged_graph_fallback() { let dir = TempDir::new().unwrap(); - let root = dir.path().to_path_buf(); - fs::create_dir_all(root.join(".atomic/sessions")).unwrap(); - let barrier = Arc::new(Barrier::new(WRITERS)); - - std::thread::scope(|scope| { - for writer in 0..WRITERS { - let root = root.clone(); - let barrier = Arc::clone(&barrier); - scope.spawn(move || { - let session_store = SessionStore::for_repo(&root).unwrap(); - let watcher = FallbackWatcher::new(WatcherConfig::new(&root)); - let orchestrator = - TurnOrchestrator::with_watcher(&root, session_store, Box::new(watcher)); - - barrier.wait(); - orchestrator - .update_accumulator(SESSION_ID, |acc| { - acc.append_goal(&format!("goal-{writer}"), writer as i64); - }) - .unwrap(); - }); - } - }); - - let graph_dir = root.join(".atomic/sessions").join(SESSION_ID); - let accumulator = ProvenanceAccumulator::load_or_create(&graph_dir, SESSION_ID).unwrap(); - assert_eq!(accumulator.nodes.len(), WRITERS); + let mut orchestrator = make_orchestrator(&dir); + orchestrator.set_journal_sink(std::sync::Arc::new(RejectingJournalSink)); + + let result = orchestrator + .dispatch(turn_start_event("journal-failure", "must commit first")) + .await; + assert!(matches!( + result, + Err(AgentError::ProvenanceJournalFailed { .. }) + )); + assert!(!ProvenanceAccumulator::graph_path( + &dir.path().join(".atomic/sessions/journal-failure") + ) + .exists()); } // DispatchResult tests @@ -290,7 +367,7 @@ async fn test_sandbox_session_on_a_root_view_records_no_parent() { } #[tokio::test] -async fn test_full_turn_in_sandbox_records_provenance_into_canonical_graph() { +async fn test_sandbox_without_owner_sink_does_not_create_fallback_provenance() { // Canonical repo with a distinct view the sandbox operates on. let canonical = TempDir::new().unwrap(); let repo = Repository::init(canonical.path()).unwrap(); @@ -331,20 +408,15 @@ async fn test_full_turn_in_sandbox_records_provenance_into_canonical_graph() { ); let change_hash = result.change_recorded.as_ref().unwrap().hash; - // The provenance graph file must be written into the CANONICAL change - // store (not a throwaway `.atomic/changes` inside the sandbox). Phase 1 of - // the save is the lock-free durability guarantee; if it targets the - // sandbox's local dir, provenance is lost whenever the best-effort Phase 2 - // (which takes the redb write lock) loses a race with a concurrent agent. + // A library harness without an owner sink may still record source changes, + // but must not resurrect either canonical or sandbox-local mutable + // provenance. Production hook coverage installs the owner sink. let canonical_changes = atomic_repository::ChangeStore::new( canonical.path().join(".atomic").join("changes"), atomic_repository::DEFAULT_CACHE_CAPACITY, ) .unwrap(); - assert!( - canonical_changes.count_provenance_graphs().unwrap() >= 1, - "provenance graph must be written to the canonical change store" - ); + assert_eq!(canonical_changes.count_provenance_graphs().unwrap(), 0); // Nothing should be written into a sandbox-local change store. let sandbox_changes = sandbox_dir.path().join(".atomic").join("changes"); @@ -361,16 +433,12 @@ async fn test_full_turn_in_sandbox_records_provenance_into_canonical_graph() { ); } - // End-to-end: the change and its provenance are both registered in the - // canonical graph. + // No fallback provenance registration occurs without the owner journal. let canonical_repo = Repository::open(canonical.path()).unwrap(); let provenance = canonical_repo .find_provenance_for_change(&change_hash) .unwrap(); - assert!( - !provenance.is_empty(), - "provenance graph for the sandbox turn must be registered in the canonical graph" - ); + assert!(provenance.is_empty()); } /// Recording a sandbox turn must not persist the session view into the diff --git a/atomic-agent/src/turn/orchestrator/turn.rs b/atomic-agent/src/turn/orchestrator/turn.rs index e81ef563..3fa96e4f 100644 --- a/atomic-agent/src/turn/orchestrator/turn.rs +++ b/atomic-agent/src/turn/orchestrator/turn.rs @@ -6,7 +6,7 @@ use std::fs::File; use std::path::Path; use crate::error::{AgentError, AgentResult}; -use crate::event::{HookType, TurnEvent}; +use crate::event::TurnEvent; use crate::record::{record_turn, TurnRecordOptions}; use crate::turn::phase::{self, Action, Event, TransitionContext}; @@ -41,6 +41,11 @@ impl TurnOrchestrator { let session_id = &event.session_id; let mut session = self.load_or_create_session(session_id, &event)?; + let turn_number = session.turn_count.saturating_add(1); + if session.managed_run.is_none() || self.managed_run.is_some() { + self.resume_journal_turn(session_id, turn_number, event.timestamp.timestamp())?; + } + self.commit_hook_event(&event, turn_number)?; // Store the prompt if let Some(ref prompt) = event.prompt { @@ -101,16 +106,6 @@ impl TurnOrchestrator { } } - // Provenance: append a goal node from the user's prompt. - // Best-effort — failures are logged but never block the session. - if let Some(ref prompt) = event.prompt { - if !prompt.is_empty() { - self.update_accumulator(session_id, |acc| { - acc.append_goal(prompt, event.timestamp.timestamp()); - }); - } - } - self.session_store.save(&session)?; Ok(dispatch) @@ -151,22 +146,6 @@ impl TurnOrchestrator { TurnEndLock::Unavailable => None, }; - // Fast gate: check if anything changed since the last record. - // This bypasses the entire status machinery (TREE scan, filesystem - // walk, etc.) and just checks the pristine database mtime. - // If the DB hasn't been written since the last record, nothing - // in the working copy could have been recorded — but files may - // have been edited. We check the working copy for recent mtimes - // by scanning only the repo root (not recursively) and common - // source directories. - if !self.has_working_copy_changes() { - log::info!( - "Turn end for session {} — no changes detected, skipping record", - session_id - ); - return Ok(DispatchResult::new(session_id, phase::Phase::Idle)); - } - let mut session = self.load_or_create_session(session_id, &event)?; // Extract model/provider from the TurnEnd event's raw_json. @@ -199,7 +178,19 @@ impl TurnOrchestrator { // OpenCode: recover transcript/reasoning/response from its local // store before recording — thin plugins send none of these, and // OpenCode writes no transcript file of its own. - self.enrich_opencode_turn(&mut session, &mut event); + self.enrich_opencode_turn(&mut session, &mut event)?; + let pending_turn_number = session.turn_count.saturating_add(1); + self.commit_turn_completion_events(&session, &event, pending_turn_number)?; + + // The terminal event is durably journaled even for an empty turn. The + // graph/checkpoint path below remains conditional until intent 108. + if !self.has_working_copy_changes() { + log::info!( + "Turn end for session {} — no changes detected, skipping record", + session_id + ); + return Ok(DispatchResult::new(session_id, phase::Phase::Idle)); + } // Release the watcher if it was active (best-effort, ignore errors) if self.watcher.is_active() { @@ -282,15 +273,17 @@ impl TurnOrchestrator { .and_then(|r| r.get("trace_file")) .and_then(|v| v.as_str()) { - self.ingest_sherpa_trace(session_id, Path::new(trace_path)); + self.ingest_sherpa_trace( + session_id, + turn_number, + Path::new(trace_path), + )?; } // Provenance: inject reasoning blocks as Decision nodes // and the agent's closing message as an LlmResponse node, // then append a patch proposal node and save the graph. - self.inject_reasoning_nodes(session_id, &event); - self.inject_response_node(session_id, &session, &event); - self.save_turn_provenance(session_id, &session, &outcome, &event); + self.save_turn_provenance(session_id, &session, &outcome, &event)?; log::info!( "Recorded turn {} for session {}: {}", @@ -375,6 +368,8 @@ impl TurnOrchestrator { let session_id = &event.session_id; let session = self.load_or_create_session(session_id, &event)?; + let turn_number = session.turn_count.saturating_add(1); + self.commit_hook_event(&event, turn_number)?; // Log tool usage if let Some(ref tool_name) = event.tool_name { @@ -386,66 +381,6 @@ impl TurnOrchestrator { ); } - // Provenance: append tool call nodes on PostToolUse. - // - // PreToolUse doesn't have output or duration yet, so we only - // record on PostToolUse where the full picture is available. - // The classifier uses tool name + input + output to determine - // the node kind (Exploration, Commitment, Verification, etc.). - if event.event_type == HookType::PostToolUse { - self.update_accumulator(session_id, |acc| { - let tool_name = event.tool_name.as_deref().unwrap_or("unknown"); - let tool_call_id = event.tool_use_id.as_deref(); - - // Extract tool_input, tool_output, status, duration from raw_json. - // - // The enriched OpenCode plugin sends top-level fields alongside - // tool_input: filediff, diagnostics, title, file_path, exit_code. - // We merge these INTO tool_input so the accumulator's classify - // and detail-building functions can find them without changing - // their signature. - let raw = event.raw_json.as_ref(); - let tool_output = raw.and_then(|r| r.get("tool_output").and_then(|v| v.as_str())); - let status = raw.and_then(|r| r.get("status").and_then(|v| v.as_str())); - let duration_ms = raw.and_then(|r| r.get("duration").and_then(|v| v.as_u64())); - - // Build a merged tool_input that includes both the original - // tool_input fields AND the top-level enriched fields. - let merged_input: Option = raw.map(|r| { - let mut merged = r - .get("tool_input") - .and_then(|v| v.as_object().cloned()) - .unwrap_or_default(); - - // Merge enriched top-level fields into tool_input - for key in &[ - "filediff", - "diagnostics", - "title", - "file_path", - "exit_code", - "diff", - ] { - if let Some(val) = r.get(*key) { - merged.insert(key.to_string(), val.clone()); - } - } - - serde_json::Value::Object(merged) - }); - - acc.append_tool_call( - tool_name, - tool_call_id, - merged_input.as_ref(), - tool_output, - status, - duration_ms, - event.timestamp.timestamp(), - ); - }); - } - Ok(DispatchResult::new(session_id, session.phase)) } diff --git a/atomic-cli/Cargo.toml b/atomic-cli/Cargo.toml index 8addfead..8602e0c8 100644 --- a/atomic-cli/Cargo.toml +++ b/atomic-cli/Cargo.toml @@ -76,6 +76,7 @@ uuid = { version = "1.0", features = ["serde", "v4"] } serde = { workspace = true } serde_json = { workspace = true } bytes = { workspace = true } +fs2 = "0.4" url = { workspace = true } # Parallelism diff --git a/atomic-cli/src/commands/agent/hooks.rs b/atomic-cli/src/commands/agent/hooks.rs index 52a969d7..83e61589 100644 --- a/atomic-cli/src/commands/agent/hooks.rs +++ b/atomic-cli/src/commands/agent/hooks.rs @@ -51,6 +51,7 @@ use std::io::{Read, Write}; use std::process::{Command as ProcessCommand, Stdio}; +use std::sync::Arc; use anyhow::anyhow; use clap::Args; @@ -240,6 +241,8 @@ impl Command for Hooks { // Set the agent identity so new sessions get the correct name // (e.g., "claude-code" / "Claude Code" instead of "unknown") orchestrator.set_agent(&agent_name, &agent_display); + orchestrator + .set_journal_sink(Arc::new(super::owner::OwnerJournalSink::new(&repo_root))); // Under a managed lifecycle, sessions adopt the declared view // and carry the run stamp (see lifecycle module docs). diff --git a/atomic-cli/src/commands/agent/lifecycle.rs b/atomic-cli/src/commands/agent/lifecycle.rs index 71fdf31c..7582566d 100644 --- a/atomic-cli/src/commands/agent/lifecycle.rs +++ b/atomic-cli/src/commands/agent/lifecycle.rs @@ -18,11 +18,12 @@ use std::fs; use std::path::{Path, PathBuf}; use anyhow::anyhow; -use clap::{Args, Subcommand}; +use clap::{Args, Subcommand, ValueEnum}; use serde::{Deserialize, Serialize}; use atomic_agent::turn::orchestrator::ManagedRunContext; -use atomic_agent::turn::session::{ManagedRunStamp, SessionStore}; +use atomic_agent::turn::session::{AgentSession, ManagedRunStamp, SessionStore}; +use atomic_agent::{JournalStopCause, JournalTurnLifecycle, ProvenanceJournalSink}; use atomic_core::types::Base32; use crate::commands::Command; @@ -46,6 +47,15 @@ enum LifecycleCommands { /// Renew a managed run's lease. Renew(Renew), + /// Stop a managed run while preserving a resumable pending turn. + Stop(Stop), + + /// Resume a stopped managed run and fence prior writers. + Resume(Resume), + + /// Explicitly abandon and seal a pending turn. + Abandon(Abandon), + /// End a managed run and print its summary (sessions, changes, views). End(End), @@ -109,6 +119,48 @@ struct Renew { json: bool, } +#[derive(Clone, Copy, Debug, ValueEnum, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +enum StopReason { + UserRequested, + ProcessExited, + HookFailure, + SystemShutdown, +} + +#[derive(Debug, Args)] +struct Stop { + #[arg(long)] + run_id: String, + + #[arg(long, value_enum, default_value_t = StopReason::UserRequested)] + cause: StopReason, + + #[arg(long)] + json: bool, +} + +#[derive(Debug, Args)] +struct Resume { + #[arg(long)] + run_id: String, + + #[arg(long, default_value_t = DEFAULT_TTL_SECONDS)] + ttl_seconds: i64, + + #[arg(long)] + json: bool, +} + +#[derive(Debug, Args)] +struct Abandon { + #[arg(long)] + run_id: String, + + #[arg(long)] + json: bool, +} + #[derive(Debug, Args)] struct End { /// Run id returned by lifecycle begin. @@ -127,6 +179,24 @@ struct Status { json: bool, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +struct ManagedStopState { + cause: JournalStopCauseWire, + observed_at: i64, + resumable: bool, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +enum JournalStopCauseWire { + UserRequested, + LeaseExpired, + ProcessExited, + HookFailure, + SystemShutdown, + Abandoned, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub(super) struct ManagedLifecycle { pub run_id: String, @@ -142,6 +212,8 @@ pub(super) struct ManagedLifecycle { pub created_at: i64, pub updated_at: i64, pub expires_at: i64, + #[serde(default, skip_serializing_if = "Option::is_none")] + stop_state: Option, } impl ManagedLifecycle { @@ -159,7 +231,7 @@ impl ManagedLifecycle { /// must be the owner or the declared executor (any agent when no /// executor is declared). fn governs(&self, cwd: &Path, agent_name: &str) -> bool { - if !cwd.starts_with(&self.workdir) { + if self.stop_state.is_some() || !cwd.starts_with(&self.workdir) { return false; } if self.owner_agent == agent_name { @@ -214,6 +286,19 @@ struct LifecycleStatus { interrupted: bool, lifecycles: Vec, stale_lifecycles: Vec, + turns: Vec, +} + +#[derive(Debug, Serialize)] +struct LifecycleTurnStatus { + run_id: String, + session_id: String, + turn_number: u32, + provenance_id: u64, + generation: u64, + state: String, + last_event_seq: Option, + resumable: bool, } impl Command for Lifecycle { @@ -221,6 +306,9 @@ impl Command for Lifecycle { match &self.command { LifecycleCommands::Begin(cmd) => cmd.run(), LifecycleCommands::Renew(cmd) => cmd.run(), + LifecycleCommands::Stop(cmd) => cmd.run(), + LifecycleCommands::Resume(cmd) => cmd.run(), + LifecycleCommands::Abandon(cmd) => cmd.run(), LifecycleCommands::End(cmd) => cmd.run(), LifecycleCommands::Status(cmd) => cmd.run(), } @@ -243,12 +331,27 @@ impl Begin { // Idempotent begin: the same owner+session renews its existing run // (noname retries begin on reconnect) instead of minting a new id. - let existing = list_active(&dir, now) + let existing = list_lifecycles(&dir) .into_iter() .find(|l| l.owner_agent == self.owner && l.owner_session_id == self.session); let lifecycle = match existing { Some(mut active) => { + if matches!( + active.stop_state.as_ref().map(|state| state.cause), + Some(JournalStopCauseWire::Abandoned) + ) { + return Err(CliError::InvalidArgument { + message: format!( + "managed lifecycle '{}' was abandoned and cannot resume", + active.run_id + ), + }); + } + if active.stop_state.is_some() || active.is_expired(now) { + resume_lifecycle_turns(&dot_dir, &active, now)?; + active.stop_state = None; + } active.executor_agent = self.executor.clone(); active.work_item_id = self.work_item.clone(); active.view = self.view.clone(); @@ -267,6 +370,7 @@ impl Begin { created_at: now, updated_at: now, expires_at: now + self.ttl_seconds.max(1), + stop_state: None, }, }; @@ -282,7 +386,7 @@ impl Renew { let now = now_secs(); let mut lifecycle = load_lifecycle(&dir, &self.run_id)? - .filter(|l| !l.is_expired(now)) + .filter(|l| !l.is_expired(now) && l.stop_state.is_none()) .ok_or_else(|| CliError::InvalidArgument { message: format!("no active managed lifecycle with run_id '{}'", self.run_id), })?; @@ -293,6 +397,79 @@ impl Renew { } } +impl Stop { + fn run(&self) -> CliResult<()> { + let dot_dir = resolve_dot_dir()?; + let dir = lifecycle_dir(&dot_dir); + let mut lifecycle = + load_lifecycle(&dir, &self.run_id)?.ok_or_else(|| CliError::InvalidArgument { + message: format!("no managed lifecycle with run_id '{}'", self.run_id), + })?; + let now = now_secs(); + let cause = match self.cause { + StopReason::UserRequested => JournalStopCauseWire::UserRequested, + StopReason::ProcessExited => JournalStopCauseWire::ProcessExited, + StopReason::HookFailure => JournalStopCauseWire::HookFailure, + StopReason::SystemShutdown => JournalStopCauseWire::SystemShutdown, + }; + stop_lifecycle_turns(&dot_dir, &lifecycle, cause, true, now)?; + lifecycle.stop_state = Some(ManagedStopState { + cause, + observed_at: now, + resumable: true, + }); + lifecycle.updated_at = now; + save_lifecycle(&dir, &lifecycle)?; + print_lifecycle(&lifecycle, self.json) + } +} + +impl Resume { + fn run(&self) -> CliResult<()> { + let dot_dir = resolve_dot_dir()?; + let dir = lifecycle_dir(&dot_dir); + let mut lifecycle = + load_lifecycle(&dir, &self.run_id)?.ok_or_else(|| CliError::InvalidArgument { + message: format!("no managed lifecycle with run_id '{}'", self.run_id), + })?; + if matches!( + lifecycle.stop_state.as_ref().map(|state| state.cause), + Some(JournalStopCauseWire::Abandoned) + ) { + return Err(CliError::InvalidArgument { + message: "abandoned lifecycle cannot resume".to_string(), + }); + } + let now = now_secs(); + resume_lifecycle_turns(&dot_dir, &lifecycle, now)?; + lifecycle.stop_state = None; + lifecycle.renew(now, self.ttl_seconds); + save_lifecycle(&dir, &lifecycle)?; + print_lifecycle(&lifecycle, self.json) + } +} + +impl Abandon { + fn run(&self) -> CliResult<()> { + let dot_dir = resolve_dot_dir()?; + let dir = lifecycle_dir(&dot_dir); + let mut lifecycle = + load_lifecycle(&dir, &self.run_id)?.ok_or_else(|| CliError::InvalidArgument { + message: format!("no managed lifecycle with run_id '{}'", self.run_id), + })?; + let now = now_secs(); + abandon_lifecycle_turns(&dot_dir, &lifecycle, now)?; + lifecycle.stop_state = Some(ManagedStopState { + cause: JournalStopCauseWire::Abandoned, + observed_at: now, + resumable: false, + }); + lifecycle.updated_at = now; + save_lifecycle(&dir, &lifecycle)?; + print_lifecycle(&lifecycle, self.json) + } +} + impl End { fn run(&self) -> CliResult<()> { let dot_dir = resolve_dot_dir()?; @@ -300,6 +477,17 @@ impl End { let lifecycle = load_lifecycle(&dir, &self.run_id)?; let ended = lifecycle.is_some(); + if let Some(lifecycle) = &lifecycle { + if lifecycle.stop_state.is_none() { + stop_lifecycle_turns( + &dot_dir, + lifecycle, + JournalStopCauseWire::UserRequested, + true, + now_secs(), + )?; + } + } remove_lifecycle(&dir, &self.run_id)?; // Harvest the run summary from session stamps — even for an @@ -346,7 +534,29 @@ impl Status { fn run(&self) -> CliResult<()> { let dot_dir = resolve_dot_dir()?; let dir = lifecycle_dir(&dot_dir); - let (lifecycles, stale_lifecycles) = list_by_state(&dir, now_secs()); + let now = now_secs(); + for mut lifecycle in list_lifecycles(&dir) { + if lifecycle.is_expired(now) && lifecycle.stop_state.is_none() { + stop_lifecycle_turns( + &dot_dir, + &lifecycle, + JournalStopCauseWire::LeaseExpired, + true, + now, + )?; + lifecycle.stop_state = Some(ManagedStopState { + cause: JournalStopCauseWire::LeaseExpired, + observed_at: now, + resumable: true, + }); + lifecycle.updated_at = now; + save_lifecycle(&dir, &lifecycle)?; + } + } + let (lifecycles, stale_lifecycles) = list_by_state(&dir, now); + let mut all_lifecycles = lifecycles.clone(); + all_lifecycles.extend(stale_lifecycles.clone()); + let turns = collect_lifecycle_turn_statuses(&dot_dir, &all_lifecycles)?; if self.json { let status = LifecycleStatus { @@ -354,6 +564,7 @@ impl Status { interrupted: !stale_lifecycles.is_empty(), lifecycles, stale_lifecycles, + turns, }; println!("{}", serde_json::to_string(&status).unwrap()); } else { @@ -372,16 +583,38 @@ impl Status { ); } } - for l in stale_lifecycles { + for lifecycle in stale_lifecycles { + let remediation = match lifecycle.stop_state.as_ref() { + Some(state) if state.cause == JournalStopCauseWire::Abandoned => { + "sealed; start a new run" + } + Some(state) if state.resumable => { + "run lifecycle resume --run-id to continue" + } + Some(_) => "non-resumable; abandon or end the run", + None => "run lifecycle status again to persist lease expiry", + }; + println!( + "Interrupted managed run {}: owner={} session={} view={} workdir={} stop={:?} ({})", + lifecycle.run_id, + lifecycle.owner_agent, + lifecycle.owner_session_id, + lifecycle.view.as_deref().unwrap_or("-"), + lifecycle.workdir.display(), + lifecycle.stop_state.as_ref().map(|state| state.cause), + remediation.replace("", &lifecycle.run_id), + ); + } + for turn in turns { println!( - "Interrupted managed run {}: owner={} session={} view={} workdir={} lease_expired_at={} (run lifecycle end --run-id {} to harvest and remove)", - l.run_id, - l.owner_agent, - l.owner_session_id, - l.view.as_deref().unwrap_or("-"), - l.workdir.display(), - l.expires_at, - l.run_id, + " session={} turn={} provenance={} generation={} state={} frontier={:?} resumable={}", + turn.session_id, + turn.turn_number, + turn.provenance_id, + turn.generation, + turn.state, + turn.last_event_seq, + turn.resumable, ); } } @@ -481,7 +714,7 @@ fn list_lifecycles(dir: &Path) -> Vec { fn list_by_state(dir: &Path, now: i64) -> (Vec, Vec) { list_lifecycles(dir) .into_iter() - .partition(|lifecycle| !lifecycle.is_expired(now)) + .partition(|lifecycle| !lifecycle.is_expired(now) && lifecycle.stop_state.is_none()) } fn list_active(dir: &Path, now: i64) -> Vec { @@ -536,6 +769,144 @@ fn remove_lifecycle(dir: &Path, run_id: &str) -> CliResult<()> { } } +fn sessions_for_run(dot_dir: &Path, run_id: &str) -> Vec { + let Ok(store) = SessionStore::new(dot_dir.join("sessions")) else { + return Vec::new(); + }; + store + .list() + .unwrap_or_default() + .into_iter() + .filter(|session| { + session + .managed_run + .as_ref() + .is_some_and(|stamp| stamp.run_id == run_id) + }) + .collect() +} + +fn pending_turn_number(session: &AgentSession) -> u32 { + if session.is_turn_active() { + session.turn_count.saturating_add(1) + } else { + session.turn_count.max(1) + } +} + +fn owner_sink(dot_dir: &Path) -> CliResult { + let root = dot_dir.parent().ok_or_else(|| { + CliError::Internal(anyhow!( + "canonical .atomic directory has no repository parent" + )) + })?; + Ok(super::owner::OwnerJournalSink::new(root)) +} + +fn map_stop_cause(cause: JournalStopCauseWire) -> JournalStopCause { + match cause { + JournalStopCauseWire::UserRequested => JournalStopCause::UserRequested, + JournalStopCauseWire::LeaseExpired => JournalStopCause::LeaseExpired, + JournalStopCauseWire::ProcessExited => JournalStopCause::ProcessExited, + JournalStopCauseWire::HookFailure => JournalStopCause::HookFailure, + JournalStopCauseWire::SystemShutdown => JournalStopCause::SystemShutdown, + JournalStopCauseWire::Abandoned => JournalStopCause::Abandoned, + } +} + +fn stop_lifecycle_turns( + dot_dir: &Path, + lifecycle: &ManagedLifecycle, + cause: JournalStopCauseWire, + resumable: bool, + observed_at: i64, +) -> CliResult<()> { + let sink = owner_sink(dot_dir)?; + for session in sessions_for_run(dot_dir, &lifecycle.run_id) { + sink.stop_turn( + &session.session_id, + pending_turn_number(&session), + map_stop_cause(cause), + resumable, + observed_at, + ) + .map_err(|reason| CliError::Internal(anyhow!(reason)))?; + } + Ok(()) +} + +fn resume_lifecycle_turns(dot_dir: &Path, lifecycle: &ManagedLifecycle, now: i64) -> CliResult<()> { + let sink = owner_sink(dot_dir)?; + for session in sessions_for_run(dot_dir, &lifecycle.run_id) { + sink.resume_turn(&session.session_id, pending_turn_number(&session), now) + .map_err(|reason| CliError::Internal(anyhow!(reason)))?; + } + Ok(()) +} + +fn abandon_lifecycle_turns( + dot_dir: &Path, + lifecycle: &ManagedLifecycle, + now: i64, +) -> CliResult<()> { + let sink = owner_sink(dot_dir)?; + for session in sessions_for_run(dot_dir, &lifecycle.run_id) { + sink.abandon_turn(&session.session_id, pending_turn_number(&session), now) + .map_err(|reason| CliError::Internal(anyhow!(reason)))?; + } + Ok(()) +} + +fn collect_lifecycle_turn_statuses( + dot_dir: &Path, + lifecycles: &[ManagedLifecycle], +) -> CliResult> { + let sink = owner_sink(dot_dir)?; + let mut result = Vec::new(); + for lifecycle in lifecycles { + for session in sessions_for_run(dot_dir, &lifecycle.run_id) { + let turn_number = pending_turn_number(&session); + let Some(status) = sink + .turn_status(&session.session_id, turn_number) + .map_err(|reason| CliError::Internal(anyhow!(reason)))? + else { + continue; + }; + let (state, last_event_seq, resumable) = match status.lifecycle { + JournalTurnLifecycle::Running => ("running", None, true), + JournalTurnLifecycle::Stopped { + last_event_seq, + resumable, + .. + } => ("stopped", last_event_seq, resumable), + JournalTurnLifecycle::Checkpointing => ("checkpointing", None, false), + JournalTurnLifecycle::Completed => ("completed", None, false), + JournalTurnLifecycle::Abandoned { last_event_seq, .. } => { + ("abandoned", last_event_seq, false) + } + }; + result.push(LifecycleTurnStatus { + run_id: lifecycle.run_id.clone(), + session_id: session.session_id, + turn_number, + provenance_id: status.provenance_id, + generation: status.generation, + state: state.to_string(), + last_event_seq, + resumable, + }); + } + } + result.sort_by(|left, right| { + (&left.run_id, &left.session_id, left.turn_number).cmp(&( + &right.run_id, + &right.session_id, + right.turn_number, + )) + }); + Ok(result) +} + /// Collect sessions stamped with `run_id` from the canonical session store. fn collect_run_sessions(dot_dir: &Path, run_id: &str) -> Vec { let store = match SessionStore::new(dot_dir.join("sessions")) { @@ -614,6 +985,7 @@ mod tests { created_at: 1, updated_at: 1, expires_at, + stop_state: None, } } @@ -657,6 +1029,7 @@ mod tests { interrupted: true, lifecycles: Vec::new(), stale_lifecycles: vec![lifecycle("run-old", "sherpa", temp.path(), 1)], + turns: Vec::new(), }; let json = serde_json::to_value(status).unwrap(); diff --git a/atomic-cli/src/commands/agent/mod.rs b/atomic-cli/src/commands/agent/mod.rs index 6d687958..67fa5202 100644 --- a/atomic-cli/src/commands/agent/mod.rs +++ b/atomic-cli/src/commands/agent/mod.rs @@ -43,6 +43,7 @@ mod enable; mod explain; mod hooks; mod lifecycle; +mod owner; mod status; use clap::{Args, Subcommand}; @@ -201,6 +202,10 @@ pub enum AgentCommands { /// nothing is suppressed; `lifecycle end --json` returns the run summary. Lifecycle(Lifecycle), + /// Run or inspect the repository-local redb database owner. + #[command(name = "database-owner", hide = true)] + DatabaseOwner(owner::DatabaseOwner), + /// Internal hook handlers (called by agent hooks). /// /// These commands are invoked by the hooks installed in agent @@ -222,6 +227,7 @@ impl Command for Agent { AgentCommands::Explain(cmd) => cmd.run(), AgentCommands::Attest(cmd) => cmd.run(), AgentCommands::Lifecycle(cmd) => cmd.run(), + AgentCommands::DatabaseOwner(cmd) => cmd.run(), AgentCommands::Hooks(cmd) => cmd.run(), } } diff --git a/atomic-cli/src/commands/agent/owner.rs b/atomic-cli/src/commands/agent/owner.rs new file mode 100644 index 00000000..021fdd88 --- /dev/null +++ b/atomic-cli/src/commands/agent/owner.rs @@ -0,0 +1,1377 @@ +//! Per-repository owner for the redb-native change and provenance store. +//! +//! redb permits one writable process to open a database. This service elects +//! that process with an OS-backed file lock and exposes a small, versioned local +//! protocol so short-lived agent hooks never open `changes.redb` themselves. + +use std::fs::{File, OpenOptions}; +use std::path::{Path, PathBuf}; +use std::process::{Command as ProcessCommand, Stdio}; +use std::sync::Arc; +use std::time::Duration; + +use anyhow::{anyhow, Context}; +use atomic_agent::{ + JournalAppendAck, JournalCheckpointAttempt, JournalCheckpointSource, JournalStopCause, + JournalTurnLifecycle, JournalTurnReservation, JournalTurnStatus, ProvenanceJournalEnvelope, + ProvenanceJournalSink, +}; +use atomic_core::change::session::SessionTurn; +use atomic_core::types::Hash; +use atomic_repository::redb_change_store::{ + ProvenanceCheckpointAttempt, ProvenanceCheckpointSource, ProvenanceId, ProvenanceTurnState, + RedbChangeStore, StopCause, StopState, StoredProvenanceTurn, +}; +use atomic_repository::Repository; +use clap::{Args, Subcommand}; +use fs2::FileExt; +use serde::{Deserialize, Serialize}; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::sync::Notify; +use uuid::Uuid; + +use crate::commands::Command; +use crate::error::CliResult; + +const PROTOCOL_VERSION: u16 = 1; +const MAX_FRAME_BYTES: usize = 8 * 1024 * 1024; +const OWNER_LOCK_FILE: &str = "changes-owner.lock"; +const START_ATTEMPTS: usize = 80; +const START_RETRY_DELAY: Duration = Duration::from_millis(25); + +#[derive(Debug, Args)] +#[command(arg_required_else_help = true)] +pub struct DatabaseOwner { + #[command(subcommand)] + command: OwnerCommand, +} + +#[derive(Debug, Subcommand)] +enum OwnerCommand { + /// Start the owner if needed, or reconnect to the existing owner. + Start(RepositoryPath), + /// Check owner health without starting it. + Ping(RepositoryPath), + /// Reserve an idempotent provenance turn through the owner. + Reserve(ReserveArgs), + /// Ask the owner to shut down after replying. + Shutdown(RepositoryPath), + /// Run the foreground owner process. + #[command(hide = true)] + Serve(RepositoryPath), +} + +#[derive(Clone, Debug, Args)] +struct RepositoryPath { + /// Path inside the repository to own. + #[arg(long, default_value = ".")] + repository: PathBuf, + + /// Emit a machine-readable response. + #[arg(long)] + json: bool, +} + +#[derive(Clone, Debug, Args)] +struct ReserveArgs { + /// Path inside the repository to own. + #[arg(long, default_value = ".")] + repository: PathBuf, + + /// Stable external agent session ID. + #[arg(long)] + session_id: String, + + /// Turn number within the session. + #[arg(long)] + turn: u32, + + /// Event timestamp in Unix seconds. + #[arg(long)] + now: i64, + + /// Emit a machine-readable response. + #[arg(long)] + json: bool, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +struct RequestFrame { + version: u16, + request_id: String, + request: OwnerRequest, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +enum OwnerRequest { + Ping, + ReserveProvenanceTurn { + session_id: String, + turn_number: u32, + now: i64, + }, + AppendProvenanceEnvelopes { + provenance_id: u64, + expected_generation: u64, + envelopes: Vec, + now: i64, + }, + PrepareCheckpoint { + provenance_id: u64, + expected_generation: u64, + source: ProvenanceCheckpointSource, + now: i64, + }, + LoadFrozenEnvelopes { + provenance_id: u64, + }, + BindCheckpointHash { + provenance_id: u64, + expected_generation: u64, + hash: Hash, + session_turn: SessionTurn, + now: i64, + }, + AcknowledgeCheckpoint { + provenance_id: u64, + expected_generation: u64, + manifest_hash: Hash, + completed_at: i64, + }, + StopTurn { + session_id: String, + turn_number: u32, + cause: StopCause, + resumable: bool, + observed_at: i64, + }, + ResumeTurn { + session_id: String, + turn_number: u32, + now: i64, + }, + AbandonTurn { + session_id: String, + turn_number: u32, + observed_at: i64, + }, + TurnStatus { + session_id: String, + turn_number: u32, + }, + Shutdown, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +struct WireEnvelope { + event_id: String, + bytes: Vec, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +struct ResponseFrame { + version: u16, + request_id: String, + response: OwnerResponse, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub(crate) enum OwnerResponse { + Pong { + pid: u32, + }, + ProvenanceTurn { + turn: StoredProvenanceTurn, + committed: bool, + }, + ProvenanceEnvelopesCommitted { + acknowledgements: Vec, + }, + CheckpointPrepared { + attempt: ProvenanceCheckpointAttempt, + }, + FrozenEnvelopes { + envelopes: Vec>, + }, + CheckpointAcknowledged, + TurnLifecycle { + turn: Option, + }, + ShuttingDown { + pid: u32, + }, + Error { + code: String, + message: String, + }, +} + +#[derive(Clone, Debug, Serialize)] +struct HealthOutput { + protocol_version: u16, + pid: u32, +} + +#[derive(Clone, Debug, Serialize)] +struct ReserveOutput { + protocol_version: u16, + committed: bool, + turn: StoredProvenanceTurn, +} + +/// Hook-facing client for committed provenance journal RPCs. +pub(crate) struct OwnerJournalSink { + repository: PathBuf, +} + +impl OwnerJournalSink { + pub(crate) fn new(repository: impl Into) -> Self { + Self { + repository: repository.into(), + } + } +} + +impl ProvenanceJournalSink for OwnerJournalSink { + fn reserve_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> Result { + let repository = self.repository.clone(); + let session_id = session_id.to_string(); + run_outside_async_runtime(move || { + let response = request_with_reconnect( + &repository, + OwnerRequest::ReserveProvenanceTurn { + session_id, + turn_number, + now, + }, + )?; + match response { + OwnerResponse::ProvenanceTurn { + turn, + committed: true, + } => Ok(JournalTurnReservation { + provenance_id: turn.provenance_id.get(), + generation: turn.generation, + }), + other => Err(unexpected_response("reserve", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn append( + &self, + reservation: JournalTurnReservation, + envelopes: Vec, + now: i64, + ) -> Result, String> { + let repository = self.repository.clone(); + let envelopes = envelopes + .into_iter() + .map(|envelope| { + Ok(WireEnvelope { + event_id: envelope.event_id.clone(), + bytes: envelope.to_json_bytes()?, + }) + }) + .collect::, atomic_agent::ProvenanceJournalError>>() + .map_err(|error| error.to_string())?; + run_outside_async_runtime(move || { + let response = request_with_reconnect( + &repository, + OwnerRequest::AppendProvenanceEnvelopes { + provenance_id: reservation.provenance_id, + expected_generation: reservation.generation, + envelopes, + now, + }, + )?; + match response { + OwnerResponse::ProvenanceEnvelopesCommitted { acknowledgements } => { + Ok(acknowledgements) + } + other => Err(unexpected_response("append provenance", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn prepare_checkpoint( + &self, + reservation: JournalTurnReservation, + source: JournalCheckpointSource, + now: i64, + ) -> Result { + let repository = self.repository.clone(); + run_outside_async_runtime(move || { + let response = request_with_reconnect( + &repository, + OwnerRequest::PrepareCheckpoint { + provenance_id: reservation.provenance_id, + expected_generation: reservation.generation, + source: to_store_checkpoint_source(source), + now, + }, + )?; + match response { + OwnerResponse::CheckpointPrepared { attempt } => Ok(to_journal_checkpoint_attempt( + reservation.provenance_id, + attempt, + )), + other => Err(unexpected_response("prepare checkpoint", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn load_frozen_envelopes( + &self, + checkpoint: &JournalCheckpointAttempt, + ) -> Result>, String> { + let repository = self.repository.clone(); + let provenance_id = checkpoint.provenance_id; + run_outside_async_runtime(move || { + match request_with_reconnect( + &repository, + OwnerRequest::LoadFrozenEnvelopes { provenance_id }, + )? { + OwnerResponse::FrozenEnvelopes { envelopes } => Ok(envelopes), + other => Err(unexpected_response("load frozen envelopes", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn bind_checkpoint_hash( + &self, + checkpoint: &JournalCheckpointAttempt, + hash: Hash, + session_turn: SessionTurn, + now: i64, + ) -> Result { + let repository = self.repository.clone(); + let provenance_id = checkpoint.provenance_id; + let expected_generation = checkpoint.attempt_generation; + run_outside_async_runtime(move || { + match request_with_reconnect( + &repository, + OwnerRequest::BindCheckpointHash { + provenance_id, + expected_generation, + hash, + session_turn, + now, + }, + )? { + OwnerResponse::CheckpointPrepared { attempt } => { + Ok(to_journal_checkpoint_attempt(provenance_id, attempt)) + } + other => Err(unexpected_response("bind checkpoint hash", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn acknowledge_checkpoint( + &self, + checkpoint: &JournalCheckpointAttempt, + manifest_hash: Hash, + completed_at: i64, + ) -> Result<(), String> { + let repository = self.repository.clone(); + let provenance_id = checkpoint.provenance_id; + let expected_generation = checkpoint.attempt_generation; + run_outside_async_runtime(move || { + match request_with_reconnect( + &repository, + OwnerRequest::AcknowledgeCheckpoint { + provenance_id, + expected_generation, + manifest_hash, + completed_at, + }, + )? { + OwnerResponse::CheckpointAcknowledged => Ok(()), + other => Err(unexpected_response("acknowledge checkpoint", other)), + } + }) + .map_err(|error| error.to_string()) + } + + fn stop_turn( + &self, + session_id: &str, + turn_number: u32, + cause: JournalStopCause, + resumable: bool, + observed_at: i64, + ) -> Result, String> { + let request = OwnerRequest::StopTurn { + session_id: session_id.to_string(), + turn_number, + cause: to_store_stop_cause(cause), + resumable, + observed_at, + }; + request_turn_lifecycle(self.repository.clone(), request).map_err(|error| error.to_string()) + } + + fn resume_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> Result, String> { + request_turn_lifecycle( + self.repository.clone(), + OwnerRequest::ResumeTurn { + session_id: session_id.to_string(), + turn_number, + now, + }, + ) + .map_err(|error| error.to_string()) + } + + fn abandon_turn( + &self, + session_id: &str, + turn_number: u32, + observed_at: i64, + ) -> Result, String> { + request_turn_lifecycle( + self.repository.clone(), + OwnerRequest::AbandonTurn { + session_id: session_id.to_string(), + turn_number, + observed_at, + }, + ) + .map_err(|error| error.to_string()) + } + + fn turn_status( + &self, + session_id: &str, + turn_number: u32, + ) -> Result, String> { + request_turn_lifecycle( + self.repository.clone(), + OwnerRequest::TurnStatus { + session_id: session_id.to_string(), + turn_number, + }, + ) + .map_err(|error| error.to_string()) + } +} + +fn request_turn_lifecycle( + repository: PathBuf, + request: OwnerRequest, +) -> anyhow::Result> { + run_outside_async_runtime( + move || match request_with_reconnect(&repository, request)? { + OwnerResponse::TurnLifecycle { turn } => Ok(turn.map(to_journal_turn_status)), + other => Err(unexpected_response("turn lifecycle", other)), + }, + ) +} + +fn to_store_stop_cause(cause: JournalStopCause) -> StopCause { + match cause { + JournalStopCause::UserRequested => StopCause::UserRequested, + JournalStopCause::LeaseExpired => StopCause::LeaseExpired, + JournalStopCause::ProcessExited => StopCause::ProcessExited, + JournalStopCause::HookFailure => StopCause::HookFailure, + JournalStopCause::SystemShutdown => StopCause::SystemShutdown, + JournalStopCause::Abandoned => StopCause::Abandoned, + } +} + +fn to_journal_stop_cause(cause: StopCause) -> JournalStopCause { + match cause { + StopCause::UserRequested => JournalStopCause::UserRequested, + StopCause::LeaseExpired => JournalStopCause::LeaseExpired, + StopCause::ProcessExited => JournalStopCause::ProcessExited, + StopCause::HookFailure => JournalStopCause::HookFailure, + StopCause::SystemShutdown => JournalStopCause::SystemShutdown, + StopCause::Abandoned => JournalStopCause::Abandoned, + } +} + +fn to_journal_turn_status(turn: StoredProvenanceTurn) -> JournalTurnStatus { + let lifecycle = match turn.state { + ProvenanceTurnState::Running => JournalTurnLifecycle::Running, + ProvenanceTurnState::Stopped(stop) => JournalTurnLifecycle::Stopped { + cause: to_journal_stop_cause(stop.cause), + observed_at: stop.observed_at, + last_event_seq: stop.last_event_seq, + resumable: stop.resumable, + }, + ProvenanceTurnState::Checkpointing => JournalTurnLifecycle::Checkpointing, + ProvenanceTurnState::Completed => JournalTurnLifecycle::Completed, + ProvenanceTurnState::Abandoned(stop) => JournalTurnLifecycle::Abandoned { + observed_at: stop.observed_at, + last_event_seq: stop.last_event_seq, + }, + }; + JournalTurnStatus { + provenance_id: turn.provenance_id.get(), + generation: turn.generation, + lifecycle, + } +} + +fn to_store_checkpoint_source(source: JournalCheckpointSource) -> ProvenanceCheckpointSource { + ProvenanceCheckpointSource { + agent_name: source.agent_name, + agent_display_name: source.agent_display_name, + agent_vendor: source.agent_vendor, + change_hashes: source.change_hashes, + previous_provenance: source.previous_provenance, + plan_id: source.plan_id, + ledger_turn_number: source.ledger_turn_number, + } +} + +fn to_journal_checkpoint_attempt( + provenance_id: u64, + attempt: ProvenanceCheckpointAttempt, +) -> JournalCheckpointAttempt { + JournalCheckpointAttempt { + provenance_id, + attempt_generation: attempt.attempt_generation, + frozen_event_count: attempt.frozen_event_count, + source: JournalCheckpointSource { + agent_name: attempt.source.agent_name, + agent_display_name: attempt.source.agent_display_name, + agent_vendor: attempt.source.agent_vendor, + change_hashes: attempt.source.change_hashes, + previous_provenance: attempt.source.previous_provenance, + plan_id: attempt.source.plan_id, + ledger_turn_number: attempt.source.ledger_turn_number, + }, + provenance_hash: attempt.provenance_hash, + session_turn: attempt.session_turn, + manifest_hash: attempt.manifest_hash, + } +} + +impl Command for DatabaseOwner { + fn run(&self) -> CliResult<()> { + match &self.command { + OwnerCommand::Start(args) => { + let response = start_or_reconnect(&args.repository)?; + print_health(response, args.json) + } + OwnerCommand::Ping(args) => { + let response = request(&args.repository, OwnerRequest::Ping)?; + print_health(response, args.json) + } + OwnerCommand::Reserve(args) => { + start_or_reconnect(&args.repository)?; + let response = request( + &args.repository, + OwnerRequest::ReserveProvenanceTurn { + session_id: args.session_id.clone(), + turn_number: args.turn, + now: args.now, + }, + )?; + print_reservation(response, args.json) + } + OwnerCommand::Shutdown(args) => { + let response = request(&args.repository, OwnerRequest::Shutdown)?; + let pid = match response { + OwnerResponse::ShuttingDown { pid } => pid, + other => return Err(unexpected_response("shutdown", other).into()), + }; + if args.json { + println!( + "{}", + serde_json::json!({ + "protocol_version": PROTOCOL_VERSION, + "pid": pid, + "status": "shutting-down" + }) + ); + } else { + println!("database owner {pid} is shutting down"); + } + Ok(()) + } + OwnerCommand::Serve(args) => serve(&args.repository), + } + } +} + +fn print_health(response: OwnerResponse, json: bool) -> CliResult<()> { + let pid = match response { + OwnerResponse::Pong { pid } => pid, + other => return Err(unexpected_response("ping", other).into()), + }; + let output = HealthOutput { + protocol_version: PROTOCOL_VERSION, + pid, + }; + if json { + println!( + "{}", + serde_json::to_string(&output).map_err(anyhow::Error::from)? + ); + } else { + println!("database owner {pid} is healthy (protocol v{PROTOCOL_VERSION})"); + } + Ok(()) +} + +fn print_reservation(response: OwnerResponse, json: bool) -> CliResult<()> { + let (turn, committed) = match response { + OwnerResponse::ProvenanceTurn { turn, committed } => (turn, committed), + other => return Err(unexpected_response("reserve", other).into()), + }; + let output = ReserveOutput { + protocol_version: PROTOCOL_VERSION, + committed, + turn, + }; + if json { + println!( + "{}", + serde_json::to_string(&output).map_err(anyhow::Error::from)? + ); + } else { + println!( + "reserved provenance turn {} generation {} (committed)", + output.turn.provenance_id.get(), + output.turn.generation + ); + } + Ok(()) +} + +fn unexpected_response(operation: &str, response: OwnerResponse) -> anyhow::Error { + match response { + OwnerResponse::Error { code, message } => { + anyhow!("database owner {operation} failed [{code}]: {message}") + } + other => anyhow!("database owner returned an unexpected {operation} response: {other:?}"), + } +} + +fn runtime() -> anyhow::Result { + tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .context("failed to create database-owner runtime") +} + +/// Start the repository owner or reconnect when another process won election. +pub(crate) fn start_or_reconnect(repository: &Path) -> anyhow::Result { + if let Ok(response) = request(repository, OwnerRequest::Ping) { + return Ok(response); + } + + let executable = std::env::current_exe().context("failed to locate atomic executable")?; + let mut command = ProcessCommand::new(executable); + command + .arg("agent") + .arg("database-owner") + .arg("serve") + .arg("--repository") + .arg(repository) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()); + configure_detached(&mut command); + let mut child = command + .spawn() + .context("failed to spawn repository database owner")?; + + for _ in 0..START_ATTEMPTS { + if let Ok(response) = request(repository, OwnerRequest::Ping) { + return Ok(response); + } + if let Some(status) = child + .try_wait() + .context("failed to inspect database-owner bootstrap")? + { + // A concurrent bootstrap may have won election. Give its endpoint + // the remainder of the retry window before reporting our exit. + if !status.success() { + for _ in 0..START_ATTEMPTS { + if let Ok(response) = request(repository, OwnerRequest::Ping) { + return Ok(response); + } + std::thread::sleep(START_RETRY_DELAY); + } + return Err(anyhow!("database owner exited during bootstrap: {status}")); + } + } + std::thread::sleep(START_RETRY_DELAY); + } + + Err(anyhow!( + "database owner did not become healthy before timeout" + )) +} + +fn request_with_reconnect( + repository: &Path, + request_body: OwnerRequest, +) -> anyhow::Result { + start_or_reconnect(repository)?; + let mut last_error = None; + for _ in 0..3 { + match request(repository, request_body.clone()) { + Ok(response) => return Ok(response), + Err(error) => { + last_error = Some(error); + start_or_reconnect(repository)?; + } + } + } + Err(last_error.unwrap_or_else(|| anyhow!("database owner request retry exhausted"))) +} + +fn run_outside_async_runtime(operation: F) -> anyhow::Result +where + T: Send + 'static, + F: FnOnce() -> anyhow::Result + Send + 'static, +{ + std::thread::spawn(operation) + .join() + .map_err(|_| anyhow!("database owner client thread panicked"))? +} + +/// Send one request to an already-running owner. +fn request(repository: &Path, request_body: OwnerRequest) -> anyhow::Result { + let dot_dir = Repository::canonical_dot_dir(repository)?; + let endpoint = endpoint_name(&dot_dir); + let frame = RequestFrame { + version: PROTOCOL_VERSION, + request_id: Uuid::new_v4().to_string(), + request: request_body, + }; + let response = runtime()?.block_on(exchange(&endpoint, &frame))?; + if response.version != PROTOCOL_VERSION { + return Err(anyhow!( + "database owner protocol mismatch: client {}, server {}", + PROTOCOL_VERSION, + response.version + )); + } + if response.request_id != frame.request_id { + return Err(anyhow!( + "database owner response request id mismatch: sent {}, received {}", + frame.request_id, + response.request_id + )); + } + match response.response { + OwnerResponse::Error { code, message } => { + Err(anyhow!("database owner request failed [{code}]: {message}")) + } + response => Ok(response), + } +} + +fn serve(repository: &Path) -> CliResult<()> { + let dot_dir = Repository::canonical_dot_dir(repository)?; + let owner_lock = acquire_owner_lock(&dot_dir)?; + let store_path = Repository::canonical_change_store_path(repository)?; + let store = Arc::new( + RedbChangeStore::open(&store_path) + .with_context(|| format!("failed to open {}", store_path.display()))?, + ); + let endpoint = endpoint_name(&dot_dir); + runtime()?.block_on(run_server(&endpoint, store))?; + FileExt::unlock(&owner_lock).context("failed to release database-owner lock")?; + Ok(()) +} + +fn acquire_owner_lock(dot_dir: &Path) -> anyhow::Result { + let path = dot_dir.join(OWNER_LOCK_FILE); + let file = OpenOptions::new() + .create(true) + .read(true) + .write(true) + .open(&path) + .with_context(|| format!("failed to open owner lock {}", path.display()))?; + file.try_lock_exclusive().map_err(|error| { + anyhow!( + "another database owner already holds {}: {error}", + path.display() + ) + })?; + Ok(file) +} + +fn owner_failpoint(name: &str) { + if std::env::var("ATOMIC_OWNER_FAILPOINT").ok().as_deref() != Some(name) { + return; + } + let should_trip = match std::env::var_os("ATOMIC_OWNER_FAILPOINT_MARKER") { + Some(path) => OpenOptions::new() + .create_new(true) + .write(true) + .open(path) + .is_ok(), + None => true, + }; + if should_trip { + std::process::abort(); + } +} + +fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFrame, bool) { + let request_id = frame.request_id; + if frame.version != PROTOCOL_VERSION { + return ( + ResponseFrame { + version: PROTOCOL_VERSION, + request_id, + response: OwnerResponse::Error { + code: "unsupported-version".to_string(), + message: format!( + "client requested protocol {}, owner supports {}", + frame.version, PROTOCOL_VERSION + ), + }, + }, + false, + ); + } + + let (response, shutdown) = match frame.request { + OwnerRequest::Ping => ( + OwnerResponse::Pong { + pid: std::process::id(), + }, + false, + ), + OwnerRequest::ReserveProvenanceTurn { + session_id, + turn_number, + now, + } => match store.reserve_provenance_turn(&session_id, turn_number, now) { + Ok(turn) => ( + OwnerResponse::ProvenanceTurn { + turn, + // reserve_provenance_turn returns only after txn.commit(). + committed: true, + }, + false, + ), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-store".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::AppendProvenanceEnvelopes { + provenance_id, + expected_generation, + envelopes, + now, + } => { + owner_failpoint("before-envelope-commit"); + let mut acknowledgements = Vec::with_capacity(envelopes.len()); + let mut failure = None; + for envelope in envelopes { + match store.append_provenance_envelope( + ProvenanceId::new(provenance_id), + expected_generation, + &envelope.event_id, + &envelope.bytes, + now, + ) { + Ok(stored) => acknowledgements.push(JournalAppendAck { + event_id: stored.event_id, + sequence: stored.seq, + }), + Err(error) => { + failure = Some(error); + break; + } + } + } + match failure { + Some(error) => ( + OwnerResponse::Error { + code: "provenance-store".to_string(), + message: error.to_string(), + }, + false, + ), + None => { + owner_failpoint("after-envelope-commit"); + ( + OwnerResponse::ProvenanceEnvelopesCommitted { acknowledgements }, + false, + ) + } + } + } + OwnerRequest::PrepareCheckpoint { + provenance_id, + expected_generation, + source, + now, + } => match store.prepare_provenance_checkpoint( + ProvenanceId::new(provenance_id), + expected_generation, + source, + now, + ) { + Ok(attempt) => { + owner_failpoint("after-checkpoint-prepare"); + (OwnerResponse::CheckpointPrepared { attempt }, false) + } + Err(error) => ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::LoadFrozenEnvelopes { provenance_id } => { + match store.load_frozen_provenance_envelopes(ProvenanceId::new(provenance_id)) { + Ok(stored) => ( + OwnerResponse::FrozenEnvelopes { + envelopes: stored.into_iter().map(|entry| entry.envelope).collect(), + }, + false, + ), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: error.to_string(), + }, + false, + ), + } + } + OwnerRequest::BindCheckpointHash { + provenance_id, + expected_generation, + hash, + session_turn, + now, + } => match store.bind_provenance_checkpoint_hash( + ProvenanceId::new(provenance_id), + expected_generation, + hash, + session_turn, + now, + ) { + Ok(attempt) => { + owner_failpoint("after-checkpoint-bind"); + (OwnerResponse::CheckpointPrepared { attempt }, false) + } + Err(error) => ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::AcknowledgeCheckpoint { + provenance_id, + expected_generation, + manifest_hash, + completed_at, + } => match store.acknowledge_provenance_checkpoint( + ProvenanceId::new(provenance_id), + expected_generation, + manifest_hash, + completed_at, + ) { + Ok(_) => (OwnerResponse::CheckpointAcknowledged, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::StopTurn { + session_id, + turn_number, + cause, + resumable, + observed_at, + } => match store.get_provenance_turn_for(&session_id, turn_number) { + Ok(None) => (OwnerResponse::TurnLifecycle { turn: None }, false), + Ok(Some(turn)) => match store.stop_provenance_turn( + turn.provenance_id, + turn.generation, + StopState { + cause, + observed_at, + last_event_seq: None, + resumable, + }, + ) { + Ok(turn) => (OwnerResponse::TurnLifecycle { turn: Some(turn) }, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::ResumeTurn { + session_id, + turn_number, + now, + } => match store.get_provenance_turn_for(&session_id, turn_number) { + Ok(None) => (OwnerResponse::TurnLifecycle { turn: None }, false), + Ok(Some(turn)) => { + match store.resume_provenance_turn(turn.provenance_id, turn.generation, now) { + Ok(turn) => (OwnerResponse::TurnLifecycle { turn: Some(turn) }, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + } + } + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::AbandonTurn { + session_id, + turn_number, + observed_at, + } => match store.get_provenance_turn_for(&session_id, turn_number) { + Ok(None) => (OwnerResponse::TurnLifecycle { turn: None }, false), + Ok(Some(turn)) => match store.abandon_provenance_turn( + turn.provenance_id, + turn.generation, + StopState { + cause: StopCause::Abandoned, + observed_at, + last_event_seq: None, + resumable: false, + }, + ) { + Ok(turn) => (OwnerResponse::TurnLifecycle { turn: Some(turn) }, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::TurnStatus { + session_id, + turn_number, + } => match store.get_provenance_turn_for(&session_id, turn_number) { + Ok(turn) => (OwnerResponse::TurnLifecycle { turn }, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-lifecycle".to_string(), + message: error.to_string(), + }, + false, + ), + }, + OwnerRequest::Shutdown => ( + OwnerResponse::ShuttingDown { + pid: std::process::id(), + }, + true, + ), + }; + + ( + ResponseFrame { + version: PROTOCOL_VERSION, + request_id, + response, + }, + shutdown, + ) +} + +async fn handle_connection( + mut stream: S, + store: Arc, + shutdown: Arc, +) -> anyhow::Result<()> +where + S: AsyncRead + AsyncWrite + Unpin, +{ + let request: RequestFrame = read_frame(&mut stream).await?; + let (response, should_shutdown) = handle_request(&store, request); + write_frame(&mut stream, &response).await?; + stream.shutdown().await?; + if should_shutdown { + // `notify_one` retains a permit if the accept loop is between polls, + // preventing a shutdown request from being acknowledged but lost. + shutdown.notify_one(); + } + Ok(()) +} + +async fn read_frame(stream: &mut S) -> anyhow::Result +where + T: for<'de> Deserialize<'de>, + S: AsyncRead + Unpin, +{ + let length = stream.read_u32().await? as usize; + if length == 0 || length > MAX_FRAME_BYTES { + return Err(anyhow!("invalid database-owner frame length {length}")); + } + let mut payload = vec![0; length]; + stream.read_exact(&mut payload).await?; + serde_json::from_slice(&payload).context("invalid database-owner JSON frame") +} + +async fn write_frame(stream: &mut S, value: &T) -> anyhow::Result<()> +where + T: Serialize, + S: AsyncWrite + Unpin, +{ + let payload = serde_json::to_vec(value)?; + if payload.len() > MAX_FRAME_BYTES { + return Err(anyhow!("database-owner frame exceeds size limit")); + } + stream.write_u32(payload.len() as u32).await?; + stream.write_all(&payload).await?; + stream.flush().await?; + Ok(()) +} + +fn endpoint_name(dot_dir: &Path) -> String { + let canonical = std::fs::canonicalize(dot_dir).unwrap_or_else(|_| dot_dir.to_path_buf()); + let digest = blake3::hash(canonical.to_string_lossy().as_bytes()) + .to_hex() + .to_string(); + endpoint_for_digest(&digest[..24]) +} + +#[cfg(unix)] +fn endpoint_for_digest(digest: &str) -> String { + // macOS limits Unix-domain socket paths to roughly 104 bytes. Environment + // temp directories can be much longer, so use the stable short Unix temp + // root and keep repository identity in the canonical-path digest. + Path::new("/tmp") + .join(format!("atomic-owner-{digest}.sock")) + .to_string_lossy() + .into_owned() +} + +#[cfg(windows)] +fn endpoint_for_digest(digest: &str) -> String { + format!(r"\\.\pipe\atomic-owner-{digest}") +} + +#[cfg(unix)] +async fn exchange(endpoint: &str, frame: &RequestFrame) -> anyhow::Result { + let mut stream = tokio::net::UnixStream::connect(endpoint) + .await + .with_context(|| format!("database owner is not reachable at {endpoint}"))?; + write_frame(&mut stream, frame).await?; + read_frame(&mut stream).await +} + +#[cfg(windows)] +async fn exchange(endpoint: &str, frame: &RequestFrame) -> anyhow::Result { + use tokio::net::windows::named_pipe::ClientOptions; + + let mut stream = ClientOptions::new() + .open(endpoint) + .with_context(|| format!("database owner is not reachable at {endpoint}"))?; + write_frame(&mut stream, frame).await?; + read_frame(&mut stream).await +} + +#[cfg(unix)] +async fn run_server(endpoint: &str, store: Arc) -> anyhow::Result<()> { + use tokio::net::UnixListener; + + let path = Path::new(endpoint); + if path.exists() { + std::fs::remove_file(path) + .with_context(|| format!("failed to remove stale endpoint {endpoint}"))?; + } + let listener = UnixListener::bind(path) + .with_context(|| format!("failed to bind database owner at {endpoint}"))?; + let shutdown = Arc::new(Notify::new()); + + loop { + tokio::select! { + accepted = listener.accept() => { + let (stream, _) = accepted?; + let store = Arc::clone(&store); + let shutdown = Arc::clone(&shutdown); + tokio::spawn(async move { + if let Err(error) = handle_connection(stream, store, shutdown).await { + log::warn!("database-owner connection failed: {error}"); + } + }); + } + () = shutdown.notified() => break, + } + } + + drop(listener); + if path.exists() { + std::fs::remove_file(path) + .with_context(|| format!("failed to remove endpoint {endpoint}"))?; + } + Ok(()) +} + +#[cfg(windows)] +async fn run_server(endpoint: &str, store: Arc) -> anyhow::Result<()> { + use tokio::net::windows::named_pipe::ServerOptions; + + let shutdown = Arc::new(Notify::new()); + let mut first = true; + loop { + let mut options = ServerOptions::new(); + if first { + options.first_pipe_instance(true); + } + let mut server = options + .create(endpoint) + .with_context(|| format!("failed to create database owner pipe {endpoint}"))?; + tokio::select! { + connected = server.connect() => { + connected?; + first = false; + let store = Arc::clone(&store); + let shutdown = Arc::clone(&shutdown); + tokio::spawn(async move { + if let Err(error) = handle_connection(server, store, shutdown).await { + log::warn!("database-owner connection failed: {error}"); + } + }); + } + () = shutdown.notified() => break, + } + } + Ok(()) +} + +#[cfg(unix)] +fn configure_detached(_command: &mut ProcessCommand) {} + +#[cfg(windows)] +fn configure_detached(command: &mut ProcessCommand) { + use std::os::windows::process::CommandExt; + const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200; + const DETACHED_PROCESS: u32 = 0x0000_0008; + command.creation_flags(CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn framing_round_trips_request_id_and_version() { + let (mut client, mut server) = tokio::io::duplex(4096); + let expected = RequestFrame { + version: PROTOCOL_VERSION, + request_id: "request-1".to_string(), + request: OwnerRequest::Ping, + }; + let sent = expected.clone(); + let writer = tokio::spawn(async move { write_frame(&mut client, &sent).await.unwrap() }); + let actual: RequestFrame = read_frame(&mut server).await.unwrap(); + writer.await.unwrap(); + assert_eq!(actual.version, expected.version); + assert_eq!(actual.request_id, expected.request_id); + assert!(matches!(actual.request, OwnerRequest::Ping)); + } + + #[test] + fn owner_propagates_stale_generation_fencing() { + use atomic_repository::redb_change_store::{StopCause, StopState}; + + let dir = tempfile::tempdir().unwrap(); + let store = RedbChangeStore::open(dir.path().join("changes.redb")).unwrap(); + let running = store.reserve_provenance_turn("session", 1, 1).unwrap(); + store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 2, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + let frame = RequestFrame { + version: PROTOCOL_VERSION, + request_id: "stale-request".to_string(), + request: OwnerRequest::AppendProvenanceEnvelopes { + provenance_id: running.provenance_id.get(), + expected_generation: running.generation, + envelopes: vec![WireEnvelope { + event_id: "event".to_string(), + bytes: b"envelope".to_vec(), + }], + now: 3, + }, + }; + let (response, shutdown) = handle_request(&store, frame); + assert!(!shutdown); + match response.response { + OwnerResponse::Error { code, message } => { + assert_eq!(code, "provenance-store"); + assert!(message.contains("generation is stale")); + } + other => panic!("expected fencing error, got {other:?}"), + } + } + + #[test] + fn endpoint_is_stable_and_bounded() { + let digest = "0123456789abcdef01234567"; + assert_eq!(endpoint_for_digest(digest), endpoint_for_digest(digest)); + assert!(endpoint_for_digest(digest).len() < 100); + } +} diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs new file mode 100644 index 00000000..41a47f3e --- /dev/null +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -0,0 +1,992 @@ +use std::collections::HashSet; +use std::io::{Read, Write}; +use std::process::{Child, Command, Output, Stdio}; +use std::thread; +use std::time::{Duration, Instant}; + +use atomic_agent::{ProvenanceAccumulator, ProvenanceJournalEnvelope, ProvenanceJournalEvent}; +use atomic_core::types::{Base32, Hash}; +use atomic_repository::redb_change_store::RedbChangeStore; +use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; +use serde_json::Value; +use tempfile::TempDir; + +fn owner_command(repository: &std::path::Path, operation: &str) -> Command { + let mut command = Command::new(env!("CARGO_BIN_EXE_atomic")); + command + .arg("agent") + .arg("database-owner") + .arg(operation) + .arg("--repository") + .arg(repository) + .arg("--no-color"); + command +} + +fn spawn_owner(repository: &std::path::Path) -> Child { + owner_command(repository, "serve") + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn foreground database owner") +} + +fn spawn_owner_with_failpoint( + repository: &std::path::Path, + failpoint: &str, + marker: &std::path::Path, +) -> Child { + owner_command(repository, "serve") + .env("ATOMIC_OWNER_FAILPOINT", failpoint) + .env("ATOMIC_OWNER_FAILPOINT_MARKER", marker) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn failpoint database owner") +} + +fn run_owner(repository: &std::path::Path, operation: &str) -> Output { + owner_command(repository, operation) + .arg("--json") + .output() + .expect("run database-owner command") +} + +fn wait_for_ping(repository: &std::path::Path, child: &mut Child) -> Value { + let deadline = Instant::now() + Duration::from_secs(5); + loop { + let output = run_owner(repository, "ping"); + if output.status.success() { + return serde_json::from_slice(&output.stdout).expect("parse ping response"); + } + if let Some(status) = child.try_wait().expect("inspect owner process") { + let mut stderr = String::new(); + child + .stderr + .take() + .expect("owner stderr") + .read_to_string(&mut stderr) + .expect("read owner stderr"); + panic!("database owner exited with {status}: {stderr}"); + } + assert!( + Instant::now() < deadline, + "database owner did not become healthy: {}", + String::from_utf8_lossy(&output.stderr) + ); + thread::sleep(Duration::from_millis(25)); + } +} + +fn reserve(repository: &std::path::Path) -> Value { + let output = owner_command(repository, "reserve") + .arg("--session-id") + .arg("owner-service-test") + .arg("--turn") + .arg("7") + .arg("--now") + .arg("1700000000") + .arg("--json") + .output() + .expect("reserve provenance turn"); + assert!( + output.status.success(), + "reservation failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + serde_json::from_slice(&output.stdout).expect("parse reservation response") +} + +fn run_lifecycle(repository: &std::path::Path, args: &[&str]) -> Output { + Command::new(env!("CARGO_BIN_EXE_atomic")) + .arg("agent") + .arg("lifecycle") + .args(args) + .arg("--no-color") + .current_dir(repository) + .output() + .expect("run lifecycle command") +} + +fn run_hook(repository: &std::path::Path, verb: &str, payload: &[u8]) -> Output { + let mut child = Command::new(env!("CARGO_BIN_EXE_atomic")) + .arg("agent") + .arg("hooks") + .arg("claude-code") + .arg(verb) + .arg("--foreground") + .arg("--no-color") + .current_dir(repository) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn hook process"); + child + .stdin + .take() + .expect("hook stdin") + .write_all(payload) + .expect("write hook payload"); + child.wait_with_output().expect("wait for hook process") +} + +fn wait_for_shutdown(repository: &std::path::Path) { + let deadline = Instant::now() + Duration::from_secs(5); + loop { + if !run_owner(repository, "ping").status.success() { + return; + } + assert!( + Instant::now() < deadline, + "database owner did not shut down" + ); + thread::sleep(Duration::from_millis(25)); + } +} + +#[test] +fn concurrent_hooks_commit_lossless_envelopes_without_output_or_drops() { + const TOOL_EVENTS: usize = 16; + + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + + let session_start = run_hook( + &repository, + "session-start", + br#"{"session_id":"hook-concurrent"}"#, + ); + assert!( + session_start.status.success(), + "session start failed: {}", + String::from_utf8_lossy(&session_start.stderr) + ); + + let turn_start = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"hook-concurrent","prompt":"test concurrent journal routing"}"#, + ); + assert!( + turn_start.status.success(), + "turn start failed: {}", + String::from_utf8_lossy(&turn_start.stderr) + ); + + let append_started = Instant::now(); + let mut workers = Vec::new(); + for index in 0..TOOL_EVENTS { + let repository = repository.clone(); + workers.push(thread::spawn(move || { + let payload = format!( + "{{\"session_id\":\"hook-concurrent\",\"tool_use_id\":\"tool-{index}\",\"tool_name\":\"Read\",\"tool_input\":{{\"path\":\"src/{index}.rs\"}},\"tool_output\":\"ok\",\"status\":\"completed\"}}" + ); + run_hook(&repository, "post-tool", payload.as_bytes()) + })); + } + for worker in workers { + let output = worker.join().expect("join hook worker"); + assert!( + output.status.success(), + "tool hook failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + assert!( + output.stdout.is_empty(), + "successful tool hook wrote stdout" + ); + assert!( + output.stderr.is_empty(), + "successful tool hook wrote stderr" + ); + } + let append_elapsed = append_started.elapsed(); + assert!( + append_elapsed / (TOOL_EVENTS as u32) < Duration::from_secs(1), + "average hook append latency exceeded 1s: {:?}", + append_elapsed / (TOOL_EVENTS as u32) + ); + + let retry = run_hook( + &repository, + "post-tool", + br#"{"session_id":"hook-concurrent","tool_use_id":"tool-0","tool_name":"Read","tool_input":{"path":"src/0.rs"},"tool_output":"ok","status":"completed"}"#, + ); + assert!(retry.status.success()); + assert!(retry.stdout.is_empty()); + assert!(retry.stderr.is_empty()); + + let stop = run_hook( + &repository, + "stop", + br#"{"session_id":"hook-concurrent","reason":"end_turn","reasoning_blocks":[{"text":"checked all concurrent events","duration_ms":9,"signature":"sig"}],"response":"all events committed","todos":[{"id":"todo-1","content":"verify journal","status":"completed","priority":"high"}]}"#, + ); + assert!( + stop.status.success(), + "stop hook failed: {}", + String::from_utf8_lossy(&stop.stderr) + ); + assert!(stop.stdout.is_empty()); + assert!(stop.stderr.is_empty()); + + let shutdown = run_owner(&repository, "shutdown"); + assert!(shutdown.status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let turn = store + .get_provenance_turn_for("hook-concurrent", 1) + .unwrap() + .expect("reserved hook turn"); + let stored = store.load_provenance_envelopes(turn.provenance_id).unwrap(); + assert_eq!(stored.len(), TOOL_EVENTS + 5); + assert_eq!( + stored.iter().map(|event| event.seq).collect::>(), + (0..(TOOL_EVENTS as u64 + 5)).collect::>() + ); + let ids: HashSet<_> = stored.iter().map(|event| &event.event_id).collect(); + assert_eq!(ids.len(), TOOL_EVENTS + 5); + let mut saw_reasoning = false; + let mut saw_response = false; + let mut saw_todo = false; + let mut saw_terminal = false; + for event in stored { + let envelope = ProvenanceJournalEnvelope::from_json_bytes(&event.envelope).unwrap(); + saw_reasoning |= matches!(&envelope.event, ProvenanceJournalEvent::Reasoning { .. }); + saw_response |= matches!(&envelope.event, ProvenanceJournalEvent::Response { .. }); + saw_todo |= matches!(&envelope.event, ProvenanceJournalEvent::Todo { .. }); + saw_terminal |= matches!(&envelope.event, ProvenanceJournalEvent::Terminal { .. }); + assert_eq!(envelope.session_id, "hook-concurrent"); + assert_eq!(envelope.turn_number, 1); + assert_eq!(envelope.generation, turn.generation); + } + assert!(saw_reasoning && saw_response && saw_todo && saw_terminal); +} + +#[test] +fn lifecycle_stop_resume_zombie_abandon_and_lease_expiry() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let workdir = repository.to_string_lossy().to_string(); + + let begin = run_lifecycle( + &repository, + &[ + "begin", + "--owner", + "sherpa", + "--session", + "owner-session", + "--executor", + "claude-code", + "--workdir", + &workdir, + "--ttl-seconds", + "60", + "--json", + ], + ); + assert!( + begin.status.success(), + "{}", + String::from_utf8_lossy(&begin.stderr) + ); + let lifecycle: Value = serde_json::from_slice(&begin.stdout).unwrap(); + let run_id = lifecycle["run_id"].as_str().unwrap().to_string(); + + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"lifecycle-session"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"lifecycle-session","prompt":"resume me"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "post-tool", + br#"{"session_id":"lifecycle-session","tool_use_id":"before-stop","tool_name":"Read","tool_input":{"path":"a.rs"},"tool_output":"ok"}"#, + ) + .status + .success()); + + let stopped = run_lifecycle( + &repository, + &[ + "stop", + "--run-id", + &run_id, + "--cause", + "process-exited", + "--json", + ], + ); + assert!( + stopped.status.success(), + "{}", + String::from_utf8_lossy(&stopped.stderr) + ); + let stopped_json: Value = serde_json::from_slice(&stopped.stdout).unwrap(); + assert_eq!(stopped_json["stop_state"]["cause"], "process-exited"); + assert_eq!(stopped_json["stop_state"]["resumable"], true); + + let status = run_lifecycle(&repository, &["status", "--json"]); + assert!(status.status.success()); + let status_json: Value = serde_json::from_slice(&status.stdout).unwrap(); + let stopped_turn = status_json["turns"] + .as_array() + .unwrap() + .iter() + .find(|turn| turn["session_id"] == "lifecycle-session") + .unwrap(); + let provenance_id = stopped_turn["provenance_id"].as_u64().unwrap(); + assert_eq!(stopped_turn["state"], "stopped"); + assert_eq!(stopped_turn["generation"], 2); + assert_eq!(stopped_turn["last_event_seq"], 1); + assert_eq!(stopped_turn["resumable"], true); + + let zombie = run_hook( + &repository, + "post-tool", + br#"{"session_id":"lifecycle-session","tool_use_id":"zombie","tool_name":"Read","tool_input":{"path":"zombie.rs"},"tool_output":"late"}"#, + ); + assert!( + !zombie.status.success(), + "stopped writer unexpectedly appended" + ); + + let resumed = run_lifecycle( + &repository, + &[ + "resume", + "--run-id", + &run_id, + "--ttl-seconds", + "60", + "--json", + ], + ); + assert!( + resumed.status.success(), + "{}", + String::from_utf8_lossy(&resumed.stderr) + ); + assert!(run_hook( + &repository, + "post-tool", + br#"{"session_id":"lifecycle-session","tool_use_id":"after-resume","tool_name":"Read","tool_input":{"path":"b.rs"},"tool_output":"ok"}"#, + ) + .status + .success()); + + let abandoned = run_lifecycle(&repository, &["abandon", "--run-id", &run_id, "--json"]); + assert!(abandoned.status.success()); + let abandoned_json: Value = serde_json::from_slice(&abandoned.stdout).unwrap(); + assert_eq!(abandoned_json["stop_state"]["cause"], "abandoned"); + assert_eq!(abandoned_json["stop_state"]["resumable"], false); + assert!( + !run_lifecycle(&repository, &["resume", "--run-id", &run_id, "--json"]) + .status + .success() + ); + + let lease_begin = run_lifecycle( + &repository, + &[ + "begin", + "--owner", + "sherpa", + "--session", + "lease-owner", + "--executor", + "claude-code", + "--workdir", + &workdir, + "--ttl-seconds", + "60", + "--json", + ], + ); + assert!(lease_begin.status.success()); + let lease_lifecycle: Value = serde_json::from_slice(&lease_begin.stdout).unwrap(); + let lease_run_id = lease_lifecycle["run_id"].as_str().unwrap(); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"lease-session"}"#, + ) + .status + .success()); + let lease_turn_start = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"lease-session","prompt":"expire me"}"#, + ); + assert!( + lease_turn_start.status.success(), + "lease turn start failed: {}", + String::from_utf8_lossy(&lease_turn_start.stderr) + ); + assert!(run_lifecycle( + &repository, + &[ + "renew", + "--run-id", + lease_run_id, + "--ttl-seconds", + "1", + "--json", + ], + ) + .status + .success()); + thread::sleep(Duration::from_millis(1_100)); + let lease_status = run_lifecycle(&repository, &["status", "--json"]); + assert!(lease_status.status.success()); + let lease_json: Value = serde_json::from_slice(&lease_status.stdout).unwrap(); + assert!(lease_json["stale_lifecycles"] + .as_array() + .unwrap() + .iter() + .any(|lifecycle| lifecycle["stop_state"]["cause"] == "lease-expired")); + + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let abandoned_turn = store + .get_provenance_turn_for("lifecycle-session", 1) + .unwrap() + .unwrap(); + assert_eq!(abandoned_turn.provenance_id.get(), provenance_id); + assert_eq!(abandoned_turn.generation, 4); + match abandoned_turn.state { + atomic_repository::redb_change_store::ProvenanceTurnState::Abandoned(stop) => { + assert_eq!(stop.last_event_seq, Some(2)); + assert!(!stop.resumable); + } + other => panic!("expected abandoned turn, got {other:?}"), + } + let lease_turn = store + .get_provenance_turn_for("lease-session", 1) + .unwrap() + .unwrap(); + match lease_turn.state { + atomic_repository::redb_change_store::ProvenanceTurnState::Stopped(stop) => { + assert_eq!( + stop.cause, + atomic_repository::redb_change_store::StopCause::LeaseExpired + ); + assert!(stop.resumable); + } + other => panic!("expected lease-expired stop, got {other:?}"), + } +} + +#[test] +fn owner_death_before_and_after_event_commit_retries_exactly_once() { + for failpoint in ["before-envelope-commit", "after-envelope-commit"] { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"event-crash"}"#, + ) + .status + .success()); + + let marker = temp.path().join(format!("{failpoint}.marker")); + let mut owner = spawn_owner_with_failpoint(&repository, failpoint, &marker); + wait_for_ping(&repository, &mut owner); + let started = Instant::now(); + let hook = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"event-crash","prompt":"survive owner crash"}"#, + ); + assert!( + hook.status.success(), + "{failpoint} retry failed: {}", + String::from_utf8_lossy(&hook.stderr) + ); + assert!(started.elapsed() < Duration::from_secs(10)); + assert!(!owner.wait().unwrap().success()); + + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let turn = store + .get_provenance_turn_for("event-crash", 1) + .unwrap() + .unwrap(); + assert_eq!( + store + .load_provenance_envelopes(turn.provenance_id) + .unwrap() + .len(), + 1 + ); + } +} + +#[test] +fn owner_death_after_checkpoint_prepare_and_bind_recovers_in_hook_process() { + for failpoint in ["after-checkpoint-prepare", "after-checkpoint-bind"] { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"checkpoint-crash"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"checkpoint-crash","prompt":"checkpoint despite crash"}"#, + ) + .status + .success()); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + std::fs::write(repository.join("crash.txt"), b"recover\n").unwrap(); + + let marker = temp.path().join(format!("{failpoint}.marker")); + let mut owner = spawn_owner_with_failpoint(&repository, failpoint, &marker); + wait_for_ping(&repository, &mut owner); + let started = Instant::now(); + let stop = run_hook( + &repository, + "stop", + br#"{"session_id":"checkpoint-crash","response":"recovered"}"#, + ); + assert!( + stop.status.success(), + "{failpoint} retry failed: {}", + String::from_utf8_lossy(&stop.stderr) + ); + assert!(started.elapsed() < Duration::from_secs(15)); + assert!(!owner.wait().unwrap().success()); + + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let turn = store + .get_provenance_turn_for("checkpoint-crash", 1) + .unwrap() + .unwrap(); + assert!(matches!( + turn.state, + atomic_repository::redb_change_store::ProvenanceTurnState::Completed + )); + drop(store); + let repo = Repository::open(&repository).unwrap(); + let (_, turns) = repo + .get_session_ledger("checkpoint-crash") + .unwrap() + .unwrap(); + assert_eq!(turns.len(), 1); + } +} + +#[test] +fn corrupt_legacy_graph_is_retained_when_migration_cannot_verify_it() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + let repo = Repository::init(&repository).unwrap(); + let session_dir = repo.dot_dir().join("sessions/corrupt-legacy"); + std::fs::create_dir_all(&session_dir).unwrap(); + let graph_path = ProvenanceAccumulator::graph_path(&session_dir); + std::fs::write(&graph_path, b"not valid graph json").unwrap(); + std::fs::write(session_dir.join("graph.lock"), b"legacy lock").unwrap(); + drop(repo); + + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"corrupt-legacy"}"#, + ) + .status + .success()); + let migration = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"corrupt-legacy","prompt":"do not discard"}"#, + ); + assert!(!migration.status.success()); + assert!(graph_path.exists()); + assert!(session_dir.join("graph.lock").exists()); + + // TurnStart probes the owner before migration, so clean it up explicitly. + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); +} + +#[test] +fn legacy_graph_pending_delta_imports_once_then_json_authority_is_removed() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + let repo = Repository::init(&repository).unwrap(); + let session_dir = repo.dot_dir().join("sessions/legacy-session"); + std::fs::create_dir_all(&session_dir).unwrap(); + + let mut legacy = ProvenanceAccumulator::new("legacy-session"); + legacy.append_goal("already finalized", 1_000); + let historical_graph = legacy.to_provenance_graph( + "claude-code", + "Claude Code", + "anthropic", + &[Hash::of(b"historical-change")], + ); + let change_store = ChangeStore::new(repo.changes_dir(), DEFAULT_CACHE_CAPACITY).unwrap(); + let historical_hash = change_store + .save_provenance_graph(&historical_graph) + .unwrap(); + legacy.set_last_provenance_hash(historical_hash.to_base32()); + legacy.append_tool_call( + "read", + Some("legacy-read"), + Some(&serde_json::json!({"path": "src/legacy.rs"})), + Some("contents"), + Some("completed"), + Some(4), + 2_000, + ); + legacy.save(&session_dir).unwrap(); + std::fs::write(session_dir.join("graph.lock"), b"legacy lock").unwrap(); + drop(repo); + + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"legacy-session"}"#, + ) + .status + .success()); + let first = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"legacy-session","prompt":"continue legacy work"}"#, + ); + assert!( + first.status.success(), + "{}", + String::from_utf8_lossy(&first.stderr) + ); + assert!(!ProvenanceAccumulator::graph_path(&session_dir).exists()); + assert!(!session_dir.join("graph.lock").exists()); + + // Simulate a crash after owner acknowledgement but before obsolete-file + // deletion by restoring the exact legacy cache. Retry must not duplicate it. + legacy.save(&session_dir).unwrap(); + std::fs::write(session_dir.join("graph.lock"), b"legacy lock").unwrap(); + let retry = run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"legacy-session","prompt":"continue legacy work"}"#, + ); + assert!( + retry.status.success(), + "{}", + String::from_utf8_lossy(&retry.stderr) + ); + assert!(!ProvenanceAccumulator::graph_path(&session_dir).exists()); + assert!(!session_dir.join("graph.lock").exists()); + + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + let redb = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let turn = redb + .get_provenance_turn_for("legacy-session", 1) + .unwrap() + .unwrap(); + let stored = redb.load_provenance_envelopes(turn.provenance_id).unwrap(); + assert_eq!( + stored.len(), + 2, + "migration marker and goal must each commit once" + ); + let envelopes = stored + .iter() + .map(|stored| ProvenanceJournalEnvelope::from_json_bytes(&stored.envelope).unwrap()) + .collect::>(); + let legacy_import = envelopes + .iter() + .find_map(|envelope| match &envelope.event { + ProvenanceJournalEvent::LegacyGraphImport { + nodes, + previous_provenance, + .. + } => Some((nodes, previous_provenance)), + _ => None, + }) + .expect("legacy import marker"); + assert_eq!( + legacy_import.0.len(), + 1, + "only the unsaved suffix is imported" + ); + assert_eq!( + legacy_import.0[0].tool_call_id.as_deref(), + Some("legacy-read") + ); + let historical_base32 = historical_hash.to_base32(); + assert_eq!(legacy_import.1.as_deref(), Some(historical_base32.as_str())); + assert_eq!( + change_store + .load_provenance_graph(&historical_hash) + .unwrap() + .session_id, + "legacy-session", + "immutable finalized history remains readable" + ); +} + +#[test] +fn turn_end_publishes_one_checkpoint_turn_and_advances_head() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"checkpoint-e2e"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"checkpoint-e2e","prompt":"record checkpoint"}"#, + ) + .status + .success()); + std::fs::write(repository.join("checkpoint.txt"), b"checkpointed\n").unwrap(); + let checkpoint_started = Instant::now(); + let stop = run_hook( + &repository, + "stop", + br#"{"session_id":"checkpoint-e2e","reason":"end_turn","response":"checkpoint complete"}"#, + ); + assert!( + stop.status.success(), + "turn end failed: {}", + String::from_utf8_lossy(&stop.stderr) + ); + assert!(stop.stdout.is_empty()); + assert!(stop.stderr.is_empty()); + assert!( + checkpoint_started.elapsed() < Duration::from_secs(10), + "checkpoint latency exceeded 10s: {:?}", + checkpoint_started.elapsed() + ); + + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + + let redb = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let completed = redb + .get_provenance_turn_for("checkpoint-e2e", 1) + .unwrap() + .unwrap(); + assert!(matches!( + completed.state, + atomic_repository::redb_change_store::ProvenanceTurnState::Completed + )); + let attempt = completed.checkpoint_attempt.unwrap(); + assert_eq!( + attempt.phase, + atomic_repository::redb_change_store::ProvenanceCheckpointPhase::Published + ); + let provenance_hash = attempt.provenance_hash.unwrap(); + let manifest_hash = attempt.manifest_hash.unwrap(); + drop(redb); + + let repo = Repository::open(&repository).unwrap(); + let (_, turns) = repo.get_session_ledger("checkpoint-e2e").unwrap().unwrap(); + assert_eq!(turns.len(), 1); + assert_eq!(turns[0].provenance_hash, provenance_hash); + assert_eq!( + repo.get_session_head("checkpoint-e2e").unwrap(), + Some(manifest_hash) + ); + let graph_dir = repo.dot_dir().join("sessions/checkpoint-e2e"); + assert!(!ProvenanceAccumulator::graph_path(&graph_dir).exists()); + assert!(!graph_dir.join("graph.lock").exists()); + assert_eq!( + repo.load_provenance_graph(&provenance_hash) + .unwrap() + .session_id, + "checkpoint-e2e" + ); +} + +#[test] +fn crashing_second_checkpoint_keeps_first_turn_immutable() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"immutable-turns"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"immutable-turns","prompt":"first"}"#, + ) + .status + .success()); + std::fs::write(repository.join("first.txt"), b"first\n").unwrap(); + assert!(run_hook( + &repository, + "stop", + br#"{"session_id":"immutable-turns","response":"first done"}"#, + ) + .status + .success()); + let first_hash = Repository::open(&repository) + .unwrap() + .get_session_ledger("immutable-turns") + .unwrap() + .unwrap() + .1[0] + .provenance_hash; + + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"immutable-turns","prompt":"second"}"#, + ) + .status + .success()); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + std::fs::write(repository.join("second.txt"), b"second\n").unwrap(); + let marker = temp.path().join("second-bind.marker"); + let mut owner = spawn_owner_with_failpoint(&repository, "after-checkpoint-bind", &marker); + wait_for_ping(&repository, &mut owner); + let second = run_hook( + &repository, + "stop", + br#"{"session_id":"immutable-turns","response":"second done"}"#, + ); + assert!( + second.status.success(), + "{}", + String::from_utf8_lossy(&second.stderr) + ); + assert!(!owner.wait().unwrap().success()); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + + let repo = Repository::open(&repository).unwrap(); + let (_, turns) = repo.get_session_ledger("immutable-turns").unwrap().unwrap(); + assert_eq!(turns.len(), 2); + assert_eq!(turns[0].provenance_hash, first_hash); + assert_ne!(turns[1].provenance_hash, first_hash); +} + +#[test] +fn owner_election_commit_reconnect_and_crash_restart() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + + let mut first_owner = spawn_owner(&repository); + let first_health = wait_for_ping(&repository, &mut first_owner); + let first_pid = first_health["pid"].as_u64().unwrap(); + assert_eq!(first_health["protocol_version"], 1); + + let duplicate = owner_command(&repository, "serve") + .output() + .expect("run duplicate owner"); + assert!(!duplicate.status.success()); + assert!(String::from_utf8_lossy(&duplicate.stderr).contains("another database owner")); + + let first_reservation = reserve(&repository); + assert_eq!(first_reservation["committed"], true); + let provenance_id = first_reservation["turn"]["provenance_id"].clone(); + + first_owner.kill().expect("kill first owner"); + first_owner.wait().expect("reap first owner"); + + let first_bootstrap = owner_command(&repository, "start") + .arg("--json") + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn first bootstrap contender"); + let second_bootstrap = owner_command(&repository, "start") + .arg("--json") + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn second bootstrap contender"); + let first_bootstrap = first_bootstrap + .wait_with_output() + .expect("wait for first bootstrap contender"); + let second_bootstrap = second_bootstrap + .wait_with_output() + .expect("wait for second bootstrap contender"); + assert!(first_bootstrap.status.success()); + assert!(second_bootstrap.status.success()); + let restarted_health: Value = serde_json::from_slice(&first_bootstrap.stdout).unwrap(); + let concurrent_health: Value = serde_json::from_slice(&second_bootstrap.stdout).unwrap(); + assert_ne!(restarted_health["pid"].as_u64().unwrap(), first_pid); + assert_eq!(concurrent_health["pid"], restarted_health["pid"]); + + let replayed = reserve(&repository); + assert_eq!(replayed["committed"], true); + assert_eq!(replayed["turn"]["provenance_id"], provenance_id); + + let reconnected = run_owner(&repository, "start"); + assert!(reconnected.status.success()); + let reconnected_health: Value = serde_json::from_slice(&reconnected.stdout).unwrap(); + assert_eq!(reconnected_health["pid"], restarted_health["pid"]); + + let shutdown = run_owner(&repository, "shutdown"); + assert!( + shutdown.status.success(), + "shutdown failed: {}", + String::from_utf8_lossy(&shutdown.stderr) + ); + wait_for_shutdown(&repository); +} diff --git a/atomic-core/src/change/session.rs b/atomic-core/src/change/session.rs index 522fd24d..a40066b6 100644 --- a/atomic-core/src/change/session.rs +++ b/atomic-core/src/change/session.rs @@ -48,7 +48,7 @@ pub struct SessionRecord { } /// Index entry connecting one session turn to its immutable Atomic objects. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct SessionTurn { pub session_id: String, pub turn_number: u32, @@ -65,6 +65,13 @@ pub struct SessionTurn { pub todos: Vec, } +/// Result of atomically appending one checkpoint turn and advancing its head. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct SessionCheckpointPublication { + pub turn: SessionTurn, + pub manifest_hash: Hash, +} + /// Return a deterministic, causality-aware ordering for a session's turns. /// /// Stored provenance can arrive in any order (for example during pull). A diff --git a/atomic-core/src/pristine/tables.rs b/atomic-core/src/pristine/tables.rs index e659beca..269bcaa8 100644 --- a/atomic-core/src/pristine/tables.rs +++ b/atomic-core/src/pristine/tables.rs @@ -505,6 +505,19 @@ pub const CHANGE_CHUNKS: TableDefinition<&[u8; 36], &[u8; 32]> = pub const CHANGE_UNHASHED: TableDefinition<&[u8; 32], &[u8]> = TableDefinition::new("change_unhashed"); +// Pending provenance journal tables used by the redb-native change store. +pub const PROVENANCE_STORE_META: TableDefinition<&str, u64> = + TableDefinition::new("provenance_store_meta"); +pub const PROVENANCE_TURN_INDEX: TableDefinition<&[u8; 40], u64> = + TableDefinition::new("provenance_turn_index"); +pub const PROVENANCE_TURNS: TableDefinition = TableDefinition::new("provenance_turns"); +pub const PROVENANCE_JOURNAL_EVENTS: TableDefinition<&[u8; 16], &[u8]> = + TableDefinition::new("provenance_journal_events"); +pub const PROVENANCE_EVENT_INDEX: TableDefinition<&[u8; 32], &[u8; 16]> = + TableDefinition::new("provenance_event_index"); +pub const PROVENANCE_FINAL_HASHES: TableDefinition<&[u8; 32], u64> = + TableDefinition::new("provenance_final_hashes"); + // Session Tables (provenance-derived session data) // // Populated from every provenance graph, regardless of the producing agent. diff --git a/atomic-core/src/pristine/txn/write/mod.rs b/atomic-core/src/pristine/txn/write/mod.rs index 68c9c882..69428c71 100644 --- a/atomic-core/src/pristine/txn/write/mod.rs +++ b/atomic-core/src/pristine/txn/write/mod.rs @@ -538,6 +538,100 @@ impl<'a> WriteTxn<'a> { self.rewrite_session_turns(record, canonical) } + /// Atomically append one immutable checkpoint turn and advance its manifest head. + /// + /// Unlike import/rebuild indexing, this live publication path never rewrites + /// prior `SESSION_TURNS` rows. Repeating the exact turn is idempotent; any + /// conflicting row or non-contiguous append fails closed. + pub fn publish_session_checkpoint( + &mut self, + json_path: &str, + turn: crate::change::session::SessionTurn, + ) -> PristineResult { + use crate::change::session::{ + SessionCheckpointPublication, SessionManifest, SessionRecord, + }; + + let mut turns = self.load_session_turns_for_write(&turn.session_id)?; + if let Some(existing) = turns + .iter() + .find(|existing| existing.turn_number == turn.turn_number) + { + if existing != &turn { + return Err(PristineError::Serialization { + message: format!( + "session checkpoint turn {} conflicts for {}", + turn.turn_number, turn.session_id + ), + }); + } + } else { + if turn.turn_number as usize != turns.len() + || turn.previous_provenance != turns.last().map(|prior| prior.provenance_hash) + { + return Err(PristineError::Serialization { + message: format!( + "session checkpoint turn {} is not an append for {}", + turn.turn_number, turn.session_id + ), + }); + } + let record = self + .load_session_record_for_write(&turn.session_id)? + .unwrap_or_else(|| SessionRecord { + session_id: turn.session_id.clone(), + json_path: json_path.to_string(), + view_name: None, + parent_view: None, + first_provenance: None, + latest_provenance: None, + turn_count: 0, + started_at: turn.timestamp, + ended_at: None, + }); + self.append_session_turn(record, turn.clone(), &turns)?; + self.mark_current_session_ledger_schema(&turn.session_id)?; + turns.push(turn.clone()); + } + + let (parent_session, fork_turn) = { + let heads = self.txn.open_table(SESSION_HEADS)?; + let manifests = self.txn.open_table(SESSION_MANIFESTS)?; + let lineage = match heads.get(turn.session_id.as_str())? { + Some(head) => match manifests.get(head.value())? { + Some(bytes) => { + let manifest = + SessionManifest::from_bytes(bytes.value()).map_err(|error| { + PristineError::Serialization { + message: format!("session manifest decode: {error}"), + } + })?; + (manifest.parent_session, manifest.fork_turn) + } + None => (None, None), + }, + None => (None, None), + }; + lineage + }; + let goal_provenance = turns + .iter() + .find_map(|entry| entry.goal.as_ref().map(|_| entry.provenance_hash)); + let manifest = SessionManifest { + schema_version: 2, + session_id: turn.session_id.clone(), + goal_provenance, + turns, + parent_session, + fork_turn, + }; + let manifest_hash = self.save_session_manifest(&manifest)?; + Ok(SessionCheckpointPublication { + turn, + manifest_hash, + }) + } + /// Index an immutable provenance graph as the next turn of its session. /// /// The session ID is the portable external identity. The turn key uses the diff --git a/atomic-repository/src/redb_change_store/mod.rs b/atomic-repository/src/redb_change_store/mod.rs index a0ba6064..828a28bf 100644 --- a/atomic-repository/src/redb_change_store/mod.rs +++ b/atomic-repository/src/redb_change_store/mod.rs @@ -1,8 +1,11 @@ //! redb-native change storage for Atomic VCS. //! //! This module implements [`RedbChangeStore`], which stores change data directly -//! in redb tables instead of `.change` files. This is the primary storage format -//! for Phase 5 of the V3 change format proposal. +//! in redb tables instead of `.change` files. Production repositories keep the +//! store at `.atomic/changes.redb`; the repository owner service is the sole +//! long-lived opener and ordinary [`crate::Repository`] handles expose only its +//! canonical path. Direct [`RedbChangeStore::open`] calls are intended for the +//! owner service, standalone stores, and tests. //! //! # Sub-modules //! @@ -10,9 +13,15 @@ //! - `queries`: Read-only query/stats/export operations on the store mod batch; +mod provenance; mod queries; pub use batch::StoredSection; +pub use provenance::{ + ProvenanceCheckpointAttempt, ProvenanceCheckpointPhase, ProvenanceCheckpointSource, + ProvenanceId, ProvenanceTurnState, StopCause, StopState, StoredProvenanceEnvelope, + StoredProvenanceEvent, StoredProvenanceTurn, +}; pub use queries::{StoreStats, StoredContentChunk}; use atomic_core::change::format_v3::{self, ChangeReader, FormatError, SectionType}; @@ -77,6 +86,48 @@ pub enum RedbStoreError { /// The change data is corrupt or inconsistent. #[error("Corrupt change data: {0}")] Corrupt(String), + + #[error("Unsupported provenance store schema version {0}")] + UnsupportedProvenanceSchema(u64), + + #[error("Provenance turn {id} was not found")] + ProvenanceTurnNotFound { id: u64 }, + + #[error("Provenance id space is exhausted")] + ProvenanceIdExhausted, + + #[error("Provenance turn {id} generation is stale: expected {expected}, actual {actual}")] + ProvenanceFenced { id: u64, expected: u64, actual: u64 }, + + #[error("Provenance turn {id} is not {expected}")] + InvalidProvenanceState { id: u64, expected: &'static str }, + + #[error("Invalid state transition for provenance turn {id}")] + InvalidProvenanceTransition { id: u64 }, + + #[error("Provenance event id '{event_id}' conflicts in turn {id}")] + ProvenanceEventConflict { id: u64, event_id: String }, + + #[error("Provenance event sequence is exhausted for turn {id}")] + ProvenanceEventSequenceExhausted { id: u64 }, + + #[error("Provenance generation is exhausted for turn {id}")] + ProvenanceGenerationExhausted { id: u64 }, + + #[error("Provenance turn {id} is already bound to another hash")] + ProvenanceFinalHashConflict { id: u64 }, + + #[error("Provenance checkpoint attempt for turn {id} conflicts with persisted source data")] + ProvenanceCheckpointConflict { id: u64 }, + + #[error("Provenance checkpoint attempt for turn {id} has no bound hash")] + ProvenanceCheckpointNotBound { id: u64 }, + + #[error("Provenance checkpoint publication for turn {id} conflicts with persisted state")] + ProvenanceCheckpointPublicationConflict { id: u64 }, + + #[error("Provenance hash is already bound to turn {existing_id}")] + ProvenanceFinalHashAlreadyBound { existing_id: u64 }, } /// Convenience result type for redb store operations. @@ -169,6 +220,9 @@ pub struct StoredChangeMeta { /// | `CONTENT_CHUNKS` | `[u8; 32]` (chunk hash) | compressed content | Deduped content chunks | /// | `CHANGE_CHUNKS` | `[u8; 36]` (hash + idx) | `[u8; 32]` (chunk hash) | Change → chunk manifest | /// | `CHANGE_UNHASHED` | `[u8; 32]` (hash) | compressed JSON | AI transcripts, etc. | +/// | `PROVENANCE_TURNS` | `u64` | pending turn metadata | Resumable fenced turn frontier | +/// | `PROVENANCE_JOURNAL_EVENTS` | `[u8; 16]` | immutable event | Ordered pending provenance | +/// | `PROVENANCE_FINAL_HASHES` | `[u8; 32]` | `u64` | Final hash → reserved turn | pub struct RedbChangeStore { db: Database, } @@ -181,8 +235,9 @@ impl RedbChangeStore { /// /// # Arguments /// - /// * `path` - Path to the redb database file. This can be the same - /// database as the pristine (tables are namespaced) or a separate file. + /// * `path` - Path to the redb database file. Repository-integrated callers + /// use [`crate::Repository::canonical_change_store_path`], which resolves + /// to `.atomic/changes.redb` (including from agent sandboxes). /// /// # Errors /// @@ -200,6 +255,7 @@ impl RedbChangeStore { let _ = txn.open_table(tables::CONTENT_CHUNKS)?; let _ = txn.open_table(tables::CHANGE_CHUNKS)?; let _ = txn.open_table(tables::CHANGE_UNHASHED)?; + Self::initialize_provenance_tables(&txn)?; } txn.commit()?; } @@ -434,7 +490,7 @@ impl RedbChangeStore { impl fmt::Debug for RedbChangeStore { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("RedbChangeStore") - .field("tables", &"[CHANGE_META, CHANGE_GRAPH, CHANGE_SEMANTIC, CONTENT_CHUNKS, CHANGE_CHUNKS, CHANGE_UNHASHED]") + .field("tables", &"[CHANGE_META, CHANGE_GRAPH, CHANGE_SEMANTIC, CONTENT_CHUNKS, CHANGE_CHUNKS, CHANGE_UNHASHED, PROVENANCE_TURNS, PROVENANCE_JOURNAL_EVENTS]") .finish() } } diff --git a/atomic-repository/src/redb_change_store/provenance.rs b/atomic-repository/src/redb_change_store/provenance.rs new file mode 100644 index 00000000..f796db81 --- /dev/null +++ b/atomic-repository/src/redb_change_store/provenance.rs @@ -0,0 +1,1034 @@ +//! Resumable pending provenance journal stored alongside redb-native changes. + +use atomic_core::change::session::{ + encode_session_event_key, encode_session_turn_key, session_turn_namespace, SessionEvent, + SessionTurn, +}; +use atomic_core::pristine::tables; +use atomic_core::types::Hash; +use redb::{ReadableDatabase, ReadableTable}; +use serde::{Deserialize, Serialize}; + +use super::{RedbChangeStore, RedbStoreError, RedbStoreResult}; + +const SCHEMA_VERSION: u64 = 1; +const SCHEMA_VERSION_KEY: &str = "schema_version"; +const NEXT_ID_KEY: &str = "next_provenance_id"; + +/// Database-local identity for a pending provenance turn. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct ProvenanceId(u64); + +impl ProvenanceId { + /// Construct an ID returned by a trusted store. + pub const fn new(value: u64) -> Self { + Self(value) + } + + /// Return the database-local numeric value. + pub const fn get(self) -> u64 { + self.0 + } +} + +/// Why a pending turn stopped before completion. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum StopCause { + UserRequested, + LeaseExpired, + ProcessExited, + HookFailure, + SystemShutdown, + Abandoned, +} + +/// Recoverable checkpoint for a stopped turn. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct StopState { + pub cause: StopCause, + pub observed_at: i64, + pub last_event_seq: Option, + pub resumable: bool, +} + +/// Current state of a reserved provenance turn. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum ProvenanceTurnState { + Running, + Stopped(StopState), + Checkpointing, + Completed, + Abandoned(StopState), +} + +/// Mutable metadata for one pending or completed provenance turn. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct StoredProvenanceTurn { + pub schema_version: u8, + pub provenance_id: ProvenanceId, + pub session_id: String, + pub turn_number: u32, + pub state: ProvenanceTurnState, + pub generation: u64, + pub next_event_seq: u64, + pub created_at: i64, + pub updated_at: i64, + pub completed_at: Option, + pub final_hash: Option, + #[serde(default)] + pub checkpoint_attempt: Option, +} + +/// Immutable source inputs captured when a turn checkpoint is prepared. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProvenanceCheckpointSource { + pub agent_name: String, + pub agent_display_name: String, + pub agent_vendor: String, + pub change_hashes: Vec, + pub previous_provenance: Option, + pub plan_id: Option, + pub ledger_turn_number: u32, +} + +/// Durable phase of one checkpoint attempt. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum ProvenanceCheckpointPhase { + Prepared, + HashBound, + Published, +} + +/// Persisted recovery record for a frozen turn finalization. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct ProvenanceCheckpointAttempt { + pub attempt_generation: u64, + /// Exclusive journal sequence cutoff frozen by the prepare transaction. + pub frozen_event_count: u64, + pub source: ProvenanceCheckpointSource, + pub phase: ProvenanceCheckpointPhase, + pub provenance_hash: Option, + pub session_turn: Option, + pub manifest_hash: Option, + pub prepared_at: i64, + pub updated_at: i64, +} + +impl StoredProvenanceTurn { + fn to_bytes(&self) -> RedbStoreResult> { + postcard::to_allocvec(self) + .map_err(|error| RedbStoreError::Serialization(error.to_string())) + } + + fn from_bytes(bytes: &[u8]) -> RedbStoreResult { + match postcard::from_bytes(bytes) { + Ok(turn) => Ok(turn), + Err(_) => postcard::from_bytes::(bytes) + .map(Into::into) + .map_err(|error| RedbStoreError::Serialization(error.to_string())), + } + } +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +struct StoredProvenanceTurnV1 { + schema_version: u8, + provenance_id: ProvenanceId, + session_id: String, + turn_number: u32, + state: ProvenanceTurnState, + generation: u64, + next_event_seq: u64, + created_at: i64, + updated_at: i64, + completed_at: Option, + final_hash: Option, +} + +impl From for StoredProvenanceTurn { + fn from(value: StoredProvenanceTurnV1) -> Self { + Self { + schema_version: value.schema_version, + provenance_id: value.provenance_id, + session_id: value.session_id, + turn_number: value.turn_number, + state: value.state, + generation: value.generation, + next_event_seq: value.next_event_seq, + created_at: value.created_at, + updated_at: value.updated_at, + completed_at: value.completed_at, + final_hash: value.final_hash, + checkpoint_attempt: None, + } + } +} + +/// Immutable source inputs captured when a turn checkpoint is prepared. +/// An immutable journal entry with a caller-stable idempotency key. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct StoredProvenanceEvent { + pub event_id: String, + pub seq: u64, + pub event: SessionEvent, +} + +/// Opaque lossless envelope bytes committed by the repository owner service. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct StoredProvenanceEnvelope { + pub event_id: String, + pub seq: u64, + pub envelope: Vec, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +enum StoredJournalRecord { + Legacy(StoredProvenanceEvent), + Envelope(StoredProvenanceEnvelope), +} + +impl StoredJournalRecord { + fn to_bytes(&self) -> RedbStoreResult> { + postcard::to_allocvec(self) + .map_err(|error| RedbStoreError::Serialization(error.to_string())) + } + + fn from_bytes(bytes: &[u8]) -> RedbStoreResult { + match postcard::from_bytes(bytes) { + Ok(record) => Ok(record), + Err(_) => postcard::from_bytes(bytes) + .map(StoredJournalRecord::Legacy) + .map_err(|error| RedbStoreError::Serialization(error.to_string())), + } + } +} + +fn turn_key(session_id: &str, turn_number: u32) -> [u8; 40] { + encode_session_turn_key(session_turn_namespace(session_id), turn_number) +} + +fn event_id_key(id: ProvenanceId, event_id: &str) -> [u8; 32] { + let mut input = Vec::with_capacity(8 + event_id.len()); + input.extend_from_slice(&id.get().to_be_bytes()); + input.extend_from_slice(event_id.as_bytes()); + *Hash::of(&input).as_bytes() +} + +fn load_turn( + table: &redb::Table, + id: ProvenanceId, +) -> RedbStoreResult { + let value = table + .get(id.get())? + .ok_or(RedbStoreError::ProvenanceTurnNotFound { id: id.get() })?; + StoredProvenanceTurn::from_bytes(value.value()) +} + +fn ensure_generation(turn: &StoredProvenanceTurn, expected: u64) -> RedbStoreResult<()> { + if turn.generation != expected { + return Err(RedbStoreError::ProvenanceFenced { + id: turn.provenance_id.get(), + expected, + actual: turn.generation, + }); + } + Ok(()) +} + +impl RedbChangeStore { + pub(crate) fn initialize_provenance_tables( + txn: &redb::WriteTransaction, + ) -> RedbStoreResult<()> { + let mut meta = txn.open_table(tables::PROVENANCE_STORE_META)?; + let _ = txn.open_table(tables::PROVENANCE_TURN_INDEX)?; + let _ = txn.open_table(tables::PROVENANCE_TURNS)?; + let _ = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let _ = txn.open_table(tables::PROVENANCE_EVENT_INDEX)?; + let _ = txn.open_table(tables::PROVENANCE_FINAL_HASHES)?; + + let stored_version = meta.get(SCHEMA_VERSION_KEY)?.map(|value| value.value()); + match stored_version { + None => { + meta.insert(NEXT_ID_KEY, 1)?; + meta.insert(SCHEMA_VERSION_KEY, SCHEMA_VERSION)?; + } + Some(SCHEMA_VERSION) if meta.get(NEXT_ID_KEY)?.is_some() => {} + Some(SCHEMA_VERSION) => { + return Err(RedbStoreError::Corrupt( + "provenance store is missing its next-id counter".to_string(), + )); + } + Some(version) => return Err(RedbStoreError::UnsupportedProvenanceSchema(version)), + } + Ok(()) + } + + /// Reserve or retrieve the stable local identity for a session turn. + pub fn reserve_provenance_turn( + &self, + session_id: &str, + turn_number: u32, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let key = turn_key(session_id, turn_number); + let mut index = txn.open_table(tables::PROVENANCE_TURN_INDEX)?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + + if let Some(existing) = index.get(&key)? { + let turn = load_turn(&turns, ProvenanceId::new(existing.value()))?; + if turn.session_id != session_id || turn.turn_number != turn_number { + return Err(RedbStoreError::Corrupt( + "session-turn index does not match its provenance row".to_string(), + )); + } + return Ok(turn); + } + + let mut meta = txn.open_table(tables::PROVENANCE_STORE_META)?; + let id = meta + .get(NEXT_ID_KEY)? + .ok_or_else(|| RedbStoreError::Corrupt("missing provenance id counter".to_string()))? + .value(); + let next = id + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceIdExhausted)?; + meta.insert(NEXT_ID_KEY, next)?; + + let turn = StoredProvenanceTurn { + schema_version: SCHEMA_VERSION as u8, + provenance_id: ProvenanceId::new(id), + session_id: session_id.to_string(), + turn_number, + state: ProvenanceTurnState::Running, + generation: 1, + next_event_seq: 0, + created_at: now, + updated_at: now, + completed_at: None, + final_hash: None, + checkpoint_attempt: None, + }; + let bytes = turn.to_bytes()?; + turns.insert(id, bytes.as_slice())?; + index.insert(&key, id)?; + drop(meta); + drop(turns); + drop(index); + txn.commit()?; + Ok(turn) + } + + /// Return a reserved provenance turn by local ID. + pub fn get_provenance_turn( + &self, + id: ProvenanceId, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let turns = txn.open_table(tables::PROVENANCE_TURNS)?; + turns + .get(id.get())? + .map(|value| StoredProvenanceTurn::from_bytes(value.value())) + .transpose() + } + + /// Return a reserved turn by external session identity and turn number. + pub fn get_provenance_turn_for( + &self, + session_id: &str, + turn_number: u32, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let index = txn.open_table(tables::PROVENANCE_TURN_INDEX)?; + let turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let key = turn_key(session_id, turn_number); + let Some(id) = index.get(&key)?.map(|value| value.value()) else { + return Ok(None); + }; + let value = turns + .get(id)? + .ok_or(RedbStoreError::ProvenanceTurnNotFound { id })?; + let turn = StoredProvenanceTurn::from_bytes(value.value())?; + if turn.session_id != session_id || turn.turn_number != turn_number { + return Err(RedbStoreError::Corrupt( + "session-turn index does not match its provenance row".to_string(), + )); + } + Ok(Some(turn)) + } + + /// Return the completed turn bound to a final provenance hash. + pub fn get_provenance_turn_by_hash( + &self, + hash: &Hash, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let hashes = txn.open_table(tables::PROVENANCE_FINAL_HASHES)?; + let turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let Some(id) = hashes.get(hash.as_bytes())?.map(|value| value.value()) else { + return Ok(None); + }; + let value = turns + .get(id)? + .ok_or(RedbStoreError::ProvenanceTurnNotFound { id })?; + Ok(Some(StoredProvenanceTurn::from_bytes(value.value())?)) + } + + /// Append one immutable event, assigning its sequence transactionally. + pub fn append_provenance_event( + &self, + id: ProvenanceId, + expected_generation: u64, + event_id: &str, + mut event: SessionEvent, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut events = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let mut event_index = txn.open_table(tables::PROVENANCE_EVENT_INDEX)?; + let id_key = event_id_key(id, event_id); + + if let Some(existing_key) = event_index.get(&id_key)? { + let existing = events.get(existing_key.value())?.ok_or_else(|| { + RedbStoreError::Corrupt("event index points to no event".to_string()) + })?; + let StoredJournalRecord::Legacy(stored) = + StoredJournalRecord::from_bytes(existing.value())? + else { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + }; + event.seq = stored.seq; + if stored.event_id != event_id || stored.event != event { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + } + return Ok(stored); + } + + let mut turn = load_turn(&turns, id)?; + ensure_generation(&turn, expected_generation)?; + if !matches!(turn.state, ProvenanceTurnState::Running) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "running", + }); + } + + let seq = turn.next_event_seq; + event.seq = seq; + let stored = StoredProvenanceEvent { + event_id: event_id.to_string(), + seq, + event, + }; + let key = encode_session_event_key(id.get(), seq); + let event_bytes = StoredJournalRecord::Legacy(stored.clone()).to_bytes()?; + events.insert(&key, event_bytes.as_slice())?; + event_index.insert(&id_key, &key)?; + + turn.next_event_seq = seq + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceEventSequenceExhausted { id: id.get() })?; + turn.updated_at = now; + let turn_bytes = turn.to_bytes()?; + turns.insert(id.get(), turn_bytes.as_slice())?; + drop(event_index); + drop(events); + drop(turns); + txn.commit()?; + Ok(stored) + } + + /// Append one serialized lossless envelope with generation fencing. + /// + /// The store treats envelope bytes as opaque so `atomic-repository` does + /// not depend on the agent schema crate. A successful return occurs only + /// after the event and updated turn sequence are durably committed. + pub fn append_provenance_envelope( + &self, + id: ProvenanceId, + expected_generation: u64, + event_id: &str, + envelope: &[u8], + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut events = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let mut event_index = txn.open_table(tables::PROVENANCE_EVENT_INDEX)?; + let id_key = event_id_key(id, event_id); + + if let Some(existing_key) = event_index.get(&id_key)? { + let existing = events.get(existing_key.value())?.ok_or_else(|| { + RedbStoreError::Corrupt("event index points to no event".to_string()) + })?; + let StoredJournalRecord::Envelope(stored) = + StoredJournalRecord::from_bytes(existing.value())? + else { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + }; + if stored.event_id != event_id { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + } + // The stable event ID is the idempotency contract. Hook payloads + // often omit source timestamps, so a process-level retry can carry + // a different observation time; return the first committed bytes. + return Ok(stored); + } + + let mut turn = load_turn(&turns, id)?; + ensure_generation(&turn, expected_generation)?; + if !matches!(turn.state, ProvenanceTurnState::Running) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "running", + }); + } + + let seq = turn.next_event_seq; + let stored = StoredProvenanceEnvelope { + event_id: event_id.to_string(), + seq, + envelope: envelope.to_vec(), + }; + let key = encode_session_event_key(id.get(), seq); + let event_bytes = StoredJournalRecord::Envelope(stored.clone()).to_bytes()?; + events.insert(&key, event_bytes.as_slice())?; + event_index.insert(&id_key, &key)?; + + turn.next_event_seq = seq + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceEventSequenceExhausted { id: id.get() })?; + turn.updated_at = now; + let turn_bytes = turn.to_bytes()?; + turns.insert(id.get(), turn_bytes.as_slice())?; + drop(event_index); + drop(events); + drop(turns); + txn.commit()?; + Ok(stored) + } + + /// Load serialized lossless envelope entries in committed sequence order. + pub fn load_provenance_envelopes( + &self, + id: ProvenanceId, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let table = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let start = encode_session_event_key(id.get(), 0); + let end = encode_session_event_key(id.get(), u64::MAX); + let mut result = Vec::new(); + for entry in table.range::<&[u8; 16]>(&start..=&end)? { + let (_, value) = entry?; + if let StoredJournalRecord::Envelope(stored) = + StoredJournalRecord::from_bytes(value.value())? + { + result.push(stored); + } + } + Ok(result) + } + + /// Load all legacy session events for a turn in sequence order. + pub fn load_provenance_events( + &self, + id: ProvenanceId, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let table = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let start = encode_session_event_key(id.get(), 0); + let end = encode_session_event_key(id.get(), u64::MAX); + let mut result = Vec::new(); + for entry in table.range::<&[u8; 16]>(&start..=&end)? { + let (_, value) = entry?; + if let StoredJournalRecord::Legacy(stored) = + StoredJournalRecord::from_bytes(value.value())? + { + result.push(stored); + } + } + Ok(result) + } + + /// Freeze the current journal frontier and persist one recoverable attempt. + pub fn prepare_provenance_checkpoint( + &self, + id: ProvenanceId, + expected_generation: u64, + source: ProvenanceCheckpointSource, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + + if let Some(attempt) = &turn.checkpoint_attempt { + if attempt.source == source { + return Ok(attempt.clone()); + } + return Err(RedbStoreError::ProvenanceCheckpointConflict { id: id.get() }); + } + + ensure_generation(&turn, expected_generation)?; + if !matches!(turn.state, ProvenanceTurnState::Running) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "running", + }); + } + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.state = ProvenanceTurnState::Checkpointing; + turn.updated_at = now; + let attempt = ProvenanceCheckpointAttempt { + attempt_generation: turn.generation, + frozen_event_count: turn.next_event_seq, + source, + phase: ProvenanceCheckpointPhase::Prepared, + provenance_hash: None, + session_turn: None, + manifest_hash: None, + prepared_at: now, + updated_at: now, + }; + turn.checkpoint_attempt = Some(attempt.clone()); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(attempt) + } + + /// Load only envelopes below the persisted exclusive freeze cutoff. + pub fn load_frozen_provenance_envelopes( + &self, + id: ProvenanceId, + ) -> RedbStoreResult> { + let txn = self.db.begin_read()?; + let turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let turn = turns + .get(id.get())? + .ok_or(RedbStoreError::ProvenanceTurnNotFound { id: id.get() })?; + let turn = StoredProvenanceTurn::from_bytes(turn.value())?; + let attempt = turn + .checkpoint_attempt + .ok_or(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "checkpoint prepared", + })?; + if attempt.frozen_event_count == 0 { + return Ok(Vec::new()); + } + + let table = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let start = encode_session_event_key(id.get(), 0); + let end = encode_session_event_key(id.get(), attempt.frozen_event_count - 1); + let mut result = Vec::new(); + for entry in table.range::<&[u8; 16]>(&start..=&end)? { + let (_, value) = entry?; + if let StoredJournalRecord::Envelope(stored) = + StoredJournalRecord::from_bytes(value.value())? + { + result.push(stored); + } + } + Ok(result) + } + + /// Bind the prepared graph hash and exact immutable session turn once. + pub fn bind_provenance_checkpoint_hash( + &self, + id: ProvenanceId, + expected_generation: u64, + hash: Hash, + session_turn: SessionTurn, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut hashes = txn.open_table(tables::PROVENANCE_FINAL_HASHES)?; + let mut turn = load_turn(&turns, id)?; + let mut attempt = + turn.checkpoint_attempt + .clone() + .ok_or(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "checkpoint prepared", + })?; + + if attempt.provenance_hash == Some(hash) + && attempt.session_turn.as_ref() == Some(&session_turn) + { + return Ok(attempt); + } + if attempt.provenance_hash.is_some() || attempt.session_turn.is_some() { + return Err(RedbStoreError::ProvenanceCheckpointConflict { id: id.get() }); + } + ensure_generation(&turn, expected_generation)?; + if attempt.attempt_generation != expected_generation + || !matches!(turn.state, ProvenanceTurnState::Checkpointing) + || session_turn.provenance_hash != hash + || session_turn.session_id != turn.session_id + || session_turn.turn_number != attempt.source.ledger_turn_number + { + return Err(RedbStoreError::ProvenanceCheckpointConflict { id: id.get() }); + } + if let Some(existing) = hashes.get(hash.as_bytes())? { + if existing.value() != id.get() { + return Err(RedbStoreError::ProvenanceFinalHashAlreadyBound { + existing_id: existing.value(), + }); + } + } + + hashes.insert(hash.as_bytes(), id.get())?; + attempt.phase = ProvenanceCheckpointPhase::HashBound; + attempt.provenance_hash = Some(hash); + attempt.session_turn = Some(session_turn); + attempt.updated_at = now; + turn.final_hash = Some(hash); + turn.updated_at = now; + turn.checkpoint_attempt = Some(attempt.clone()); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(hashes); + drop(turns); + txn.commit()?; + Ok(attempt) + } + + /// Acknowledge atomic SESSION_TURNS/head publication and complete the turn. + pub fn acknowledge_provenance_checkpoint( + &self, + id: ProvenanceId, + expected_generation: u64, + manifest_hash: Hash, + completed_at: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + let mut attempt = + turn.checkpoint_attempt + .clone() + .ok_or(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "checkpoint hash bound", + })?; + + if matches!(turn.state, ProvenanceTurnState::Completed) + && attempt.manifest_hash == Some(manifest_hash) + { + return Ok(turn); + } + ensure_generation(&turn, expected_generation)?; + if attempt.attempt_generation != expected_generation + || attempt.phase != ProvenanceCheckpointPhase::HashBound + || attempt.provenance_hash.is_none() + || attempt.session_turn.is_none() + { + return Err(RedbStoreError::ProvenanceCheckpointNotBound { id: id.get() }); + } + if attempt.manifest_hash.is_some() { + return Err(RedbStoreError::ProvenanceCheckpointPublicationConflict { id: id.get() }); + } + + attempt.phase = ProvenanceCheckpointPhase::Published; + attempt.manifest_hash = Some(manifest_hash); + attempt.updated_at = completed_at; + turn.state = ProvenanceTurnState::Completed; + turn.completed_at = Some(completed_at); + turn.updated_at = completed_at; + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.checkpoint_attempt = Some(attempt); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(turn) + } + + /// Stop a running turn while keeping its committed event frontier. + pub fn stop_provenance_turn( + &self, + id: ProvenanceId, + expected_generation: u64, + mut stop: StopState, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + if let ProvenanceTurnState::Stopped(existing) = &turn.state { + if existing.cause == stop.cause && existing.resumable == stop.resumable { + return Ok(turn); + } + } + if matches!( + turn.state, + ProvenanceTurnState::Completed | ProvenanceTurnState::Abandoned(_) + ) { + return Ok(turn); + } + ensure_generation(&turn, expected_generation)?; + if !matches!(turn.state, ProvenanceTurnState::Running) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "running", + }); + } + stop.last_event_seq = turn.next_event_seq.checked_sub(1); + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.updated_at = stop.observed_at; + turn.state = ProvenanceTurnState::Stopped(stop); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(turn) + } + + /// Resume a stopped turn with a new fencing generation and the same ID. + pub fn resume_provenance_turn( + &self, + id: ProvenanceId, + expected_generation: u64, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + if matches!(turn.state, ProvenanceTurnState::Running) { + if turn.generation == expected_generation + || turn.generation == expected_generation.saturating_add(1) + { + return Ok(turn); + } + ensure_generation(&turn, expected_generation)?; + } + ensure_generation(&turn, expected_generation)?; + match &turn.state { + ProvenanceTurnState::Stopped(stop) if stop.resumable => {} + ProvenanceTurnState::Stopped(_) | ProvenanceTurnState::Abandoned(_) => { + return Err(RedbStoreError::InvalidProvenanceTransition { id: id.get() }) + } + ProvenanceTurnState::Completed => return Ok(turn), + _ => { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "resumable stop", + }) + } + } + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.updated_at = now; + turn.state = ProvenanceTurnState::Running; + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(turn) + } + + /// Explicitly seal a pending turn without publishing a checkpoint. + pub fn abandon_provenance_turn( + &self, + id: ProvenanceId, + expected_generation: u64, + mut stop: StopState, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + if matches!( + turn.state, + ProvenanceTurnState::Completed | ProvenanceTurnState::Abandoned(_) + ) { + return Ok(turn); + } + ensure_generation(&turn, expected_generation)?; + if !matches!( + turn.state, + ProvenanceTurnState::Running | ProvenanceTurnState::Stopped(_) + ) { + return Err(RedbStoreError::InvalidProvenanceTransition { id: id.get() }); + } + stop.cause = StopCause::Abandoned; + stop.resumable = false; + stop.last_event_seq = turn.next_event_seq.checked_sub(1); + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.updated_at = stop.observed_at; + turn.state = ProvenanceTurnState::Abandoned(stop); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(turn) + } + + /// Freeze a stopped turn for deterministic finalization. + pub fn begin_provenance_checkpoint( + &self, + id: ProvenanceId, + expected_generation: u64, + now: i64, + ) -> RedbStoreResult { + self.transition_provenance_turn( + id, + expected_generation, + ProvenanceTurnState::Checkpointing, + now, + ) + } + + fn transition_provenance_turn( + &self, + id: ProvenanceId, + expected_generation: u64, + next: ProvenanceTurnState, + now: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut turn = load_turn(&turns, id)?; + ensure_generation(&turn, expected_generation)?; + + let valid = matches!( + (&turn.state, &next), + ( + ProvenanceTurnState::Running, + ProvenanceTurnState::Stopped(_) + ) | ( + ProvenanceTurnState::Stopped(StopState { + resumable: true, + .. + }), + ProvenanceTurnState::Running + ) | ( + ProvenanceTurnState::Stopped(_), + ProvenanceTurnState::Checkpointing + ) | ( + ProvenanceTurnState::Checkpointing, + ProvenanceTurnState::Stopped(_) + ) + ); + if !valid { + return Err(RedbStoreError::InvalidProvenanceTransition { id: id.get() }); + } + + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + turn.updated_at = now; + turn.state = next; + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + Ok(turn) + } + + /// Atomically complete a checkpoint and bind its content hash once. + pub fn bind_final_provenance_hash( + &self, + id: ProvenanceId, + expected_generation: u64, + hash: Hash, + completed_at: i64, + ) -> RedbStoreResult { + let txn = self.db.begin_write()?; + let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let mut hashes = txn.open_table(tables::PROVENANCE_FINAL_HASHES)?; + let mut turn = load_turn(&turns, id)?; + + if turn.final_hash == Some(hash) && matches!(turn.state, ProvenanceTurnState::Completed) { + return Ok(turn); + } + if turn.final_hash.is_some() { + return Err(RedbStoreError::ProvenanceFinalHashConflict { id: id.get() }); + } + ensure_generation(&turn, expected_generation)?; + if !matches!(turn.state, ProvenanceTurnState::Checkpointing) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "checkpointing", + }); + } + if let Some(existing) = hashes.get(hash.as_bytes())? { + if existing.value() != id.get() { + return Err(RedbStoreError::ProvenanceFinalHashAlreadyBound { + existing_id: existing.value(), + }); + } + } + + hashes.insert(hash.as_bytes(), id.get())?; + turn.state = ProvenanceTurnState::Completed; + turn.final_hash = Some(hash); + turn.completed_at = Some(completed_at); + turn.updated_at = completed_at; + turn.generation = turn + .generation + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceGenerationExhausted { id: id.get() })?; + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(hashes); + drop(turns); + txn.commit()?; + Ok(turn) + } +} + +#[cfg(test)] +mod compatibility_tests { + use super::*; + + #[test] + fn checkpoint_field_defaults_when_reading_pre_checkpoint_turn() { + let legacy = StoredProvenanceTurnV1 { + schema_version: 1, + provenance_id: ProvenanceId::new(7), + session_id: "legacy".to_string(), + turn_number: 1, + state: ProvenanceTurnState::Running, + generation: 1, + next_event_seq: 2, + created_at: 3, + updated_at: 4, + completed_at: None, + final_hash: None, + }; + let bytes = postcard::to_allocvec(&legacy).unwrap(); + let decoded = StoredProvenanceTurn::from_bytes(&bytes).unwrap(); + assert_eq!(decoded.provenance_id, ProvenanceId::new(7)); + assert!(decoded.checkpoint_attempt.is_none()); + } +} diff --git a/atomic-repository/src/redb_change_store/tests.rs b/atomic-repository/src/redb_change_store/tests.rs index 066e98d0..2ce839f4 100644 --- a/atomic-repository/src/redb_change_store/tests.rs +++ b/atomic-repository/src/redb_change_store/tests.rs @@ -518,3 +518,471 @@ fn test_debug_format() { assert!(debug.contains("RedbChangeStore")); assert!(debug.contains("CHANGE_META")); } + +fn provenance_event(label: &str) -> atomic_core::change::session::SessionEvent { + atomic_core::change::session::SessionEvent { + seq: u64::MAX, + timestamp: "2026-09-08T16:00:00Z".to_string(), + event_kind: "tool".to_string(), + place: None, + transition: None, + token_id: label.to_string(), + token_kind: "artifact".to_string(), + token_data: format!(r#"{{"label":"{label}"}}"#), + record_type: Some("tool".to_string()), + } +} + +#[test] +fn provenance_turn_reservation_is_idempotent_and_persistent() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("store.redb"); + let first_id; + { + let store = RedbChangeStore::open(&path).unwrap(); + let first = store.reserve_provenance_turn("session-a", 3, 100).unwrap(); + let duplicate = store.reserve_provenance_turn("session-a", 3, 200).unwrap(); + let next = store.reserve_provenance_turn("session-a", 4, 200).unwrap(); + assert_eq!(first, duplicate); + assert_ne!(first.provenance_id, next.provenance_id); + assert_eq!( + store + .get_provenance_turn_for("session-a", 3) + .unwrap() + .unwrap(), + first + ); + first_id = first.provenance_id; + } + + let reopened = RedbChangeStore::open(&path).unwrap(); + assert_eq!( + reopened + .get_provenance_turn(first_id) + .unwrap() + .unwrap() + .session_id, + "session-a" + ); + assert_ne!( + reopened + .reserve_provenance_turn("session-b", 0, 300) + .unwrap() + .provenance_id, + first_id + ); +} + +#[test] +fn provenance_events_are_ordered_idempotent_and_fenced() { + let (_dir, store) = temp_store(); + let turn = store.reserve_provenance_turn("session-a", 0, 1).unwrap(); + + let first = store + .append_provenance_event( + turn.provenance_id, + turn.generation, + "event-a", + provenance_event("a"), + 2, + ) + .unwrap(); + let duplicate = store + .append_provenance_event( + turn.provenance_id, + turn.generation, + "event-a", + provenance_event("a"), + 3, + ) + .unwrap(); + assert_eq!(first, duplicate); + + store + .append_provenance_event( + turn.provenance_id, + turn.generation, + "event-b", + provenance_event("b"), + 4, + ) + .unwrap(); + let events = store.load_provenance_events(turn.provenance_id).unwrap(); + assert_eq!( + events.iter().map(|event| event.seq).collect::>(), + vec![0, 1] + ); + + let stopped = store + .stop_provenance_turn( + turn.provenance_id, + turn.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 5, + last_event_seq: Some(1), + resumable: true, + }, + ) + .unwrap(); + assert!(matches!(stopped.state, ProvenanceTurnState::Stopped(_))); + assert!(matches!( + store.append_provenance_event( + turn.provenance_id, + turn.generation, + "event-c", + provenance_event("c"), + 6, + ), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); +} + +#[test] +fn lossless_envelopes_share_sequence_space_and_preserve_legacy_events() { + let (_dir, store) = temp_store(); + let turn = store.reserve_provenance_turn("session-a", 1, 1).unwrap(); + + store + .append_provenance_event( + turn.provenance_id, + turn.generation, + "legacy", + provenance_event("legacy"), + 2, + ) + .unwrap(); + let first = store + .append_provenance_envelope( + turn.provenance_id, + turn.generation, + "envelope-a", + br#"{"schema_version":1,"event_id":"envelope-a"}"#, + 3, + ) + .unwrap(); + let retry = store + .append_provenance_envelope( + turn.provenance_id, + turn.generation, + "envelope-a", + br#"{\"schema_version\":1,\"event_id\":\"envelope-a\",\"retry_observed_at\":4}"#, + 4, + ) + .unwrap(); + assert_eq!(first, retry); + assert_eq!(first.seq, 1); + assert_eq!( + store + .load_provenance_events(turn.provenance_id) + .unwrap() + .len(), + 1 + ); + assert_eq!( + store.load_provenance_envelopes(turn.provenance_id).unwrap(), + vec![first] + ); + + let stopped = store + .stop_provenance_turn( + turn.provenance_id, + turn.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 5, + last_event_seq: Some(1), + resumable: true, + }, + ) + .unwrap(); + assert!(matches!( + store.append_provenance_envelope( + stopped.provenance_id, + turn.generation, + "stale", + b"stale", + 6, + ), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); +} + +#[test] +fn stop_resume_and_abandon_preserve_identity_frontier_and_fencing() { + let (_dir, store) = temp_store(); + let running = store.reserve_provenance_turn("lifecycle", 1, 1).unwrap(); + for index in 0..2 { + store + .append_provenance_envelope( + running.provenance_id, + running.generation, + &format!("event-{index}"), + format!("event-{index}").as_bytes(), + 2 + index, + ) + .unwrap(); + } + + let stopped = store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 5, + last_event_seq: Some(999), + resumable: true, + }, + ) + .unwrap(); + assert_eq!(stopped.provenance_id, running.provenance_id); + assert_eq!(stopped.generation, running.generation + 1); + match &stopped.state { + ProvenanceTurnState::Stopped(stop) => { + assert_eq!(stop.cause, StopCause::ProcessExited); + assert_eq!(stop.last_event_seq, Some(1)); + assert!(stop.resumable); + } + other => panic!("expected stopped turn, got {other:?}"), + } + let stopped_retry = store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 9, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + assert_eq!(stopped_retry, stopped); + assert!(matches!( + store.append_provenance_envelope( + running.provenance_id, + running.generation, + "zombie", + b"zombie", + 6, + ), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); + + let resumed = store + .resume_provenance_turn(stopped.provenance_id, stopped.generation, 7) + .unwrap(); + assert_eq!(resumed.provenance_id, running.provenance_id); + assert_eq!(resumed.generation, stopped.generation + 1); + assert!(matches!(resumed.state, ProvenanceTurnState::Running)); + assert!(matches!( + store.append_provenance_envelope( + running.provenance_id, + stopped.generation, + "old-generation", + b"old", + 8, + ), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); + store + .append_provenance_envelope( + running.provenance_id, + resumed.generation, + "resumed", + b"resumed", + 8, + ) + .unwrap(); + + let abandoned = store + .abandon_provenance_turn( + resumed.provenance_id, + resumed.generation, + StopState { + cause: StopCause::UserRequested, + observed_at: 9, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + match &abandoned.state { + ProvenanceTurnState::Abandoned(stop) => { + assert_eq!(stop.cause, StopCause::Abandoned); + assert_eq!(stop.last_event_seq, Some(2)); + assert!(!stop.resumable); + } + other => panic!("expected abandoned turn, got {other:?}"), + } + assert!(matches!( + store.resume_provenance_turn(abandoned.provenance_id, abandoned.generation, 10,), + Err(RedbStoreError::InvalidProvenanceTransition { .. }) + )); +} + +#[test] +fn stopped_provenance_turn_resumes_and_finalizes_once() { + let (_dir, store) = temp_store(); + let running = store.reserve_provenance_turn("session-a", 0, 1).unwrap(); + let stopped = store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::UserRequested, + observed_at: 2, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + let resumed = store + .resume_provenance_turn(stopped.provenance_id, stopped.generation, 3) + .unwrap(); + assert!(matches!(resumed.state, ProvenanceTurnState::Running)); + + let stopped_again = store + .stop_provenance_turn( + resumed.provenance_id, + resumed.generation, + StopState { + cause: StopCause::UserRequested, + observed_at: 3, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + let checkpoint = store + .begin_provenance_checkpoint(stopped_again.provenance_id, stopped_again.generation, 4) + .unwrap(); + let hash = Hash::of(b"provenance"); + let completed = store + .bind_final_provenance_hash(checkpoint.provenance_id, checkpoint.generation, hash, 4) + .unwrap(); + assert!(matches!(completed.state, ProvenanceTurnState::Completed)); + assert_eq!(completed.final_hash, Some(hash)); + assert_eq!( + store.get_provenance_turn_by_hash(&hash).unwrap().unwrap(), + completed + ); + + let same = store + .bind_final_provenance_hash(completed.provenance_id, 0, hash, 5) + .unwrap(); + assert_eq!(same, completed); + assert_eq!( + store.reserve_provenance_turn("session-a", 0, 99).unwrap(), + completed + ); + assert_eq!( + store + .stop_provenance_turn( + completed.provenance_id, + completed.generation, + StopState { + cause: StopCause::SystemShutdown, + observed_at: 6, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(), + completed + ); + assert_eq!( + store + .abandon_provenance_turn( + completed.provenance_id, + completed.generation, + StopState { + cause: StopCause::Abandoned, + observed_at: 7, + last_event_seq: None, + resumable: false, + }, + ) + .unwrap(), + completed + ); +} + +#[test] +fn non_resumable_provenance_stop_rejects_resume() { + let (_dir, store) = temp_store(); + let running = store.reserve_provenance_turn("session-a", 0, 1).unwrap(); + let stopped = store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::LeaseExpired, + observed_at: 2, + last_event_seq: None, + resumable: false, + }, + ) + .unwrap(); + + assert!(matches!( + store.resume_provenance_turn(stopped.provenance_id, stopped.generation, 3), + Err(RedbStoreError::InvalidProvenanceTransition { .. }) + )); +} + +#[test] +fn final_provenance_hash_is_unique_across_turns() { + let (_dir, store) = temp_store(); + let mut checkpoints = Vec::new(); + for turn_number in 0..2 { + let running = store + .reserve_provenance_turn("session-a", turn_number, 1) + .unwrap(); + let stopped = store + .stop_provenance_turn( + running.provenance_id, + running.generation, + StopState { + cause: StopCause::UserRequested, + observed_at: 2, + last_event_seq: None, + resumable: true, + }, + ) + .unwrap(); + checkpoints.push( + store + .begin_provenance_checkpoint(stopped.provenance_id, stopped.generation, 3) + .unwrap(), + ); + } + + let hash = Hash::of(b"same-provenance"); + store + .bind_final_provenance_hash( + checkpoints[0].provenance_id, + checkpoints[0].generation, + hash, + 3, + ) + .unwrap(); + assert!(matches!( + store.bind_final_provenance_hash( + checkpoints[1].provenance_id, + checkpoints[1].generation, + hash, + 3, + ), + Err(RedbStoreError::ProvenanceFinalHashAlreadyBound { .. }) + )); + assert!(matches!( + store + .get_provenance_turn(checkpoints[1].provenance_id) + .unwrap() + .unwrap() + .state, + ProvenanceTurnState::Checkpointing + )); +} diff --git a/atomic-repository/src/repository/changes.rs b/atomic-repository/src/repository/changes.rs index 8575f63a..9d1c7d82 100644 --- a/atomic-repository/src/repository/changes.rs +++ b/atomic-repository/src/repository/changes.rs @@ -1048,6 +1048,72 @@ impl Repository { // Provenance Graph Operations // ========================================================================= + /// Publish a prepared turn checkpoint without rewriting prior session turns. + /// + /// The content-addressed provenance file is written first. Its registration, + /// dependencies, derived session tables, immutable `SESSION_TURNS` append, + /// manifest, and `SESSION_HEADS` advance then commit in one pristine + /// transaction. Repeating the exact publication is idempotent. + pub fn publish_provenance_checkpoint( + &self, + graph: &atomic_core::change::ProvenanceGraph, + turn: atomic_core::change::session::SessionTurn, + ) -> Result { + use atomic_core::pristine::MutTxnT; + + let hash = self + .change_store + .save_provenance_graph(graph) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + if turn.provenance_hash != hash + || turn.session_id != graph.session_id + || turn.change_hashes != graph.changes_explained + || turn.previous_provenance != graph.previous + { + return Err(RepositoryError::Database( + "prepared session turn does not match provenance graph".to_string(), + )); + } + + let mut txn = self + .pristine + .write_txn() + .map_err(|error| RepositoryError::Database(error.to_string()))?; + let provenance_id = txn + .register_provenance(&hash) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + for change_hash in &graph.changes_explained { + let change_id = txn + .register_change(change_hash) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + txn.put_dep(provenance_id, change_id) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + } + if let Some(previous) = graph.previous { + if let Some(previous_id) = txn + .get_internal(&previous) + .map_err(|error| RepositoryError::Database(error.to_string()))? + { + txn.put_dep(provenance_id, previous_id) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + } + } + txn.populate_session_tables(provenance_id.get(), graph) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + let json_path = self + .dot_dir + .join("sessions") + .join(format!("{}.json", graph.session_id)) + .to_string_lossy() + .to_string(); + let publication = txn + .publish_session_checkpoint(&json_path, turn) + .map_err(|error| RepositoryError::Database(error.to_string()))?; + txn.commit() + .map_err(|error| RepositoryError::Database(error.to_string()))?; + Ok(publication) + } + /// Save a provenance graph to the repository. /// /// Serializes the graph to disk, registers it in the pristine database diff --git a/atomic-repository/src/repository/mod.rs b/atomic-repository/src/repository/mod.rs index 164a6c43..2053e0e5 100644 --- a/atomic-repository/src/repository/mod.rs +++ b/atomic-repository/src/repository/mod.rs @@ -58,6 +58,7 @@ use crate::ignore::IgnoreRules; use crate::record::{ build_header, filter_files, RecordError, RecordOptions, RecordOutcome, RecordStats, }; + use crate::remote::{RemoteConfig, RemoteEntry}; use crate::status::{ collect_working_copy_files_with_rules, hash_file_contents, FileStatus, FileStatusEntry, @@ -155,6 +156,14 @@ pub const DEFAULT_VIEW: &str = "dev"; /// Backward-compatible alias for [`DEFAULT_VIEW`]. pub const DEFAULT_STACK: &str = DEFAULT_VIEW; +/// Canonical redb change-store filename inside [`.atomic`](DOT_DIR). +/// +/// The filesystem-backed [`ChangeStore`] remains authoritative during the +/// additive migration. This database is the single repository-local location +/// for redb-native changes and provenance and is opened by the repository owner +/// service, not by ordinary `Repository` handles. +pub const REDB_CHANGE_STORE_FILE: &str = "changes.redb"; + /// Subdirectory inside `.atomic/` that holds per-view workspace state. /// /// Each view gets a directory at `.atomic/workspaces//` where @@ -198,7 +207,7 @@ pub struct Repository { /// `open_with_pristine`; `open` / `open_readonly` create a fresh /// `Pristine` for each `Repository`. pristine: Arc, - /// The change store for persisting changes + /// The filesystem change store for persisting canonical `.change` files. change_store: ChangeStore, /// Whether this handle was opened for an agent sandbox (via /// [`Repository::open_sandbox`]). A sandbox's `dot_dir`/`pristine`/ @@ -315,7 +324,9 @@ default = "{}" } ensure_workspace_dir(&dot_dir, view_name)?; - // Initialize the change store + // Initialize the filesystem authority. The owner service creates and + // exclusively holds `changes.redb` on first start, avoiding a competing + // writable handle in ordinary repository processes. let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY) .map_err(|e| RepositoryError::Database(e.to_string()))?; @@ -365,7 +376,6 @@ default = "{}" let current_view = Self::read_current_view(&dot_dir).unwrap_or_else(|_| DEFAULT_STACK.to_string()); - // Open the change store let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY) .map_err(|e| RepositoryError::Database(e.to_string()))?; @@ -467,7 +477,6 @@ default = "{}" let current_view = Self::read_current_view(&dot_dir).unwrap_or_else(|_| DEFAULT_STACK.to_string()); - // Open the change store let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY) .map_err(|e| RepositoryError::Database(e.to_string()))?; @@ -595,6 +604,16 @@ default = "{}" Ok(Self::find_root(path.as_ref())?.join(DOT_DIR)) } + /// Resolve the canonical redb change-store path without opening redb. + /// + /// Sandboxes resolve to the owning repository's `.atomic/changes.redb`, + /// never to a sandbox-local database. + pub fn canonical_change_store_path>( + path: P, + ) -> Result { + Ok(Self::canonical_dot_dir(path)?.join(REDB_CHANGE_STORE_FILE)) + } + /// Get the repository root path. #[inline] pub fn root(&self) -> &Path { @@ -619,6 +638,12 @@ default = "{}" self.dot_dir.join("changes") } + /// Get the canonical redb change-store path. + #[inline] + pub fn redb_change_store_path(&self) -> PathBuf { + self.dot_dir.join(REDB_CHANGE_STORE_FILE) + } + /// Get the current view name. #[inline] pub fn current_view(&self) -> &str { diff --git a/atomic-repository/src/repository/tests/init_tests.rs b/atomic-repository/src/repository/tests/init_tests.rs index 2edab7d3..5161a275 100644 --- a/atomic-repository/src/repository/tests/init_tests.rs +++ b/atomic-repository/src/repository/tests/init_tests.rs @@ -8,6 +8,11 @@ fn test_init_creates_structure() { assert!(repo.dot_dir().exists()); assert!(repo.pristine_path().exists()); assert!(repo.changes_dir().exists()); + assert_eq!( + repo.redb_change_store_path(), + repo.dot_dir().join(REDB_CHANGE_STORE_FILE) + ); + assert!(!repo.redb_change_store_path().exists()); assert!(repo.config_path().exists()); } @@ -32,6 +37,40 @@ fn test_open_existing() { assert_eq!(opened.current_view(), DEFAULT_STACK); } +#[test] +fn test_open_legacy_repository_defers_redb_store_without_touching_changes() { + let (temp_dir, repo) = create_temp_repo(); + let store_path = repo.redb_change_store_path(); + let legacy_change = repo.changes_dir().join("legacy-change"); + std::fs::write(&legacy_change, b"existing filesystem authority").unwrap(); + drop(repo); + + assert!(!store_path.exists()); + + let reopened = Repository::open(temp_dir.path()).unwrap(); + assert_eq!(reopened.redb_change_store_path(), store_path); + assert!(!store_path.exists()); + assert_eq!( + std::fs::read(&legacy_change).unwrap(), + b"existing filesystem authority" + ); +} + +#[test] +fn test_canonical_change_store_path_follows_sandbox_pointer() { + let temp_dir = TempDir::new().unwrap(); + let repo_root = temp_dir.path().join("repo"); + let sandbox = temp_dir.path().join("agent-sandbox"); + let repo = Repository::init(&repo_root).unwrap(); + repo.provision_sandbox(&sandbox, repo.current_view()) + .unwrap(); + + assert_eq!( + Repository::canonical_change_store_path(&sandbox).unwrap(), + repo.redb_change_store_path() + ); +} + #[test] fn test_open_from_subdirectory() { let (temp_dir, repo) = create_temp_repo(); diff --git a/atomic-repository/tests/provenance_checkpoint_test.rs b/atomic-repository/tests/provenance_checkpoint_test.rs new file mode 100644 index 00000000..537f32d4 --- /dev/null +++ b/atomic-repository/tests/provenance_checkpoint_test.rs @@ -0,0 +1,214 @@ +use atomic_core::change::session::SessionTurn; +use atomic_core::change::ProvenanceGraph; +use atomic_core::types::Hash; +use atomic_repository::redb_change_store::{ + ProvenanceCheckpointPhase, ProvenanceCheckpointSource, ProvenanceTurnState, RedbChangeStore, + RedbStoreError, +}; +use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; + +#[test] +fn checkpoint_recovers_idempotently_across_every_publication_boundary() { + let temp = tempfile::tempdir().unwrap(); + let root = temp.path().join("repo"); + let repository = Repository::init(&root).unwrap(); + let redb_path = repository.redb_change_store_path(); + let changes_dir = repository.changes_dir(); + drop(repository); + + let store = RedbChangeStore::open(&redb_path).unwrap(); + let running = store + .reserve_provenance_turn("checkpoint-session", 1, 10) + .unwrap(); + store + .append_provenance_envelope( + running.provenance_id, + running.generation, + "goal", + br#"{"schema_version":1,"event_id":"goal"}"#, + 11, + ) + .unwrap(); + store + .append_provenance_envelope( + running.provenance_id, + running.generation, + "terminal", + br#"{"schema_version":1,"event_id":"terminal"}"#, + 12, + ) + .unwrap(); + + let source_change = Hash::of(b"recorded source change"); + let source = ProvenanceCheckpointSource { + agent_name: "opencode".to_string(), + agent_display_name: "OpenCode".to_string(), + agent_vendor: "openai".to_string(), + change_hashes: vec![source_change], + previous_provenance: None, + plan_id: Some("ATOM-108".to_string()), + ledger_turn_number: 0, + }; + let prepared = store + .prepare_provenance_checkpoint( + running.provenance_id, + running.generation, + source.clone(), + 13, + ) + .unwrap(); + assert_eq!(prepared.phase, ProvenanceCheckpointPhase::Prepared); + assert_eq!(prepared.frozen_event_count, 2); + assert!(matches!( + store.append_provenance_envelope( + running.provenance_id, + running.generation, + "late", + b"late", + 14, + ), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); + drop(store); + + // Crash after prepare: the attempt and exact exclusive cutoff survive. + let store = RedbChangeStore::open(&redb_path).unwrap(); + let prepared_retry = store + .prepare_provenance_checkpoint( + running.provenance_id, + running.generation, + source.clone(), + 15, + ) + .unwrap(); + assert_eq!(prepared_retry, prepared); + let frozen = store + .load_frozen_provenance_envelopes(running.provenance_id) + .unwrap(); + assert_eq!(frozen.len(), 2); + assert_eq!( + frozen.iter().map(|event| event.seq).collect::>(), + vec![0, 1] + ); + + let graph = ProvenanceGraph::builder("checkpoint-session", "opencode") + .agent_display_name("OpenCode") + .agent_vendor("openai") + .changes_explained(vec![source_change]) + .timestamp(12_000) + .plan_id("ATOM-108") + .build(); + let change_store = ChangeStore::new(changes_dir, DEFAULT_CACHE_CAPACITY).unwrap(); + let provenance_hash = change_store.save_provenance_graph(&graph).unwrap(); + let turn = SessionTurn { + session_id: "checkpoint-session".to_string(), + turn_number: 0, + goal: None, + provenance_hash, + change_hashes: vec![source_change], + previous_provenance: None, + timestamp: graph.timestamp, + plan_id: Some("ATOM-108".to_string()), + todos: Vec::new(), + }; + let bound = store + .bind_provenance_checkpoint_hash( + running.provenance_id, + prepared.attempt_generation, + provenance_hash, + turn.clone(), + 16, + ) + .unwrap(); + assert_eq!(bound.phase, ProvenanceCheckpointPhase::HashBound); + drop(store); + + // Crash after hash bind: the exact hash and SessionTurn survive and rebind idempotently. + let store = RedbChangeStore::open(&redb_path).unwrap(); + let rebound = store + .bind_provenance_checkpoint_hash( + running.provenance_id, + prepared.attempt_generation, + provenance_hash, + turn.clone(), + 17, + ) + .unwrap(); + assert_eq!(rebound, bound); + + let repository = Repository::open(&root).unwrap(); + let publication = repository + .publish_provenance_checkpoint(&graph, turn.clone()) + .unwrap(); + let retry_publication = repository + .publish_provenance_checkpoint(&graph, turn.clone()) + .unwrap(); + assert_eq!(retry_publication, publication); + let (_, turns) = repository + .get_session_ledger("checkpoint-session") + .unwrap() + .unwrap(); + assert_eq!(turns, vec![turn.clone()]); + assert_eq!( + repository.get_session_head("checkpoint-session").unwrap(), + Some(publication.manifest_hash) + ); + + // A different immutable turn at the same ordinal cannot rewrite the completed row. + let conflicting_graph = ProvenanceGraph::builder("checkpoint-session", "opencode") + .agent_display_name("OpenCode") + .agent_vendor("openai") + .changes_explained(vec![source_change]) + .timestamp(13_000) + .plan_id("ATOM-108") + .build(); + let conflicting_hash = change_store + .save_provenance_graph(&conflicting_graph) + .unwrap(); + let mut conflicting_turn = turn.clone(); + conflicting_turn.provenance_hash = conflicting_hash; + conflicting_turn.timestamp = conflicting_graph.timestamp; + assert!(repository + .publish_provenance_checkpoint(&conflicting_graph, conflicting_turn) + .is_err()); + let (_, unchanged) = repository + .get_session_ledger("checkpoint-session") + .unwrap() + .unwrap(); + assert_eq!(unchanged, vec![turn]); + drop(repository); + + // Crash after pristine publication: retrying publication above is harmless, + // and acknowledgement is itself idempotent after completion. + let completed = store + .acknowledge_provenance_checkpoint( + running.provenance_id, + prepared.attempt_generation, + publication.manifest_hash, + 18, + ) + .unwrap(); + assert!(matches!(completed.state, ProvenanceTurnState::Completed)); + assert_eq!(completed.final_hash, Some(provenance_hash)); + drop(store); + + let reopened = RedbChangeStore::open(&redb_path).unwrap(); + let acknowledged_retry = reopened + .acknowledge_provenance_checkpoint( + running.provenance_id, + prepared.attempt_generation, + publication.manifest_hash, + 19, + ) + .unwrap(); + assert_eq!(acknowledged_retry, completed); + let persisted = reopened + .get_provenance_turn(running.provenance_id) + .unwrap() + .unwrap(); + assert_eq!(persisted, completed); + assert_eq!( + persisted.checkpoint_attempt.unwrap().phase, + ProvenanceCheckpointPhase::Published + ); +} diff --git a/packages/opencode-atomic-hooks/README.md b/packages/opencode-atomic-hooks/README.md index 696cf59a..23ab8492 100644 --- a/packages/opencode-atomic-hooks/README.md +++ b/packages/opencode-atomic-hooks/README.md @@ -129,7 +129,7 @@ src/ | **handlers/chat.ts** | Captures prompt text and model info on user messages | `createChatHandler()`, `extractPrompt()` | | **handlers/tool.ts** | Tracks tool timing, classifies file mutations, truncates output | `createBeforeToolHandler()`, `createAfterToolHandler()`, `isEditTool()` | | **handlers/shell.ts** | Injects `ATOMIC_AGENT` and `ATOMIC_AGENT_VERSION` into shell env | `createShellHandler()` | -| **handlers/compaction.ts** | Reads provenance graph from disk, injects summary into compaction context | `createCompactionHandler()` | +| **handlers/compaction.ts** | Reads a pre-cutover graph cache when present; current provenance is owner-journaled | `createCompactionHandler()` | ### Dependency Graph @@ -138,7 +138,7 @@ No circular dependencies. Each module imports only from modules "below" it: ``` index.ts → cli, session, log, handlers/* handlers/* → cli, session, log, constants, types -handlers/compaction → log (reads graph.json from disk, no CLI calls) +handlers/compaction → log (legacy graph-cache compatibility only) cli → constants, types session → types log → constants, types @@ -344,10 +344,11 @@ into OpenCode's compaction context. This means the LLM retains knowledge of what was explored, decided, committed, and verified — even after the conversation is compacted to fit the context window. -The provenance graph itself is built and stored entirely on the Rust side. -The plugin only reads it from `.atomic/sessions/{id}/graph.json` during -compaction — no graph accumulation, no classification, no state management -in TypeScript. +Mutable provenance is committed by the Rust repository-owner service into +`.atomic/changes.redb`; immutable finalized graphs remain content-addressed in +`.atomic/changes/`. `graph.json` is no longer written. The compaction handler +still tolerates a pre-cutover cache while its one-time migration is pending, +but never creates or mutates provenance in TypeScript. ## License diff --git a/packages/opencode-atomic-hooks/src/handlers/compaction.ts b/packages/opencode-atomic-hooks/src/handlers/compaction.ts index 6f000f24..6e827f24 100644 --- a/packages/opencode-atomic-hooks/src/handlers/compaction.ts +++ b/packages/opencode-atomic-hooks/src/handlers/compaction.ts @@ -6,8 +6,8 @@ * * Without this handler, all tool call history and reasoning context is lost * at compaction — the LLM starts fresh with a generic summary. This handler - * reads the provenance graph built by the Rust-side `TurnOrchestrator` from - * disk and injects a structured summary into the compacted context. + * reads a pre-cutover provenance cache when one is still pending migration + * and injects a structured summary into the compacted context. * * The result: the LLM retains structural knowledge of what was explored, * decided, committed, and verified — even after compaction. Multi-hour @@ -21,8 +21,8 @@ * ▼ * experimental.session.compacting hook fires * │ - * ├── Read .atomic/sessions/{sessionID}/graph.json - * │ (written by Rust-side TurnOrchestrator on every hook) + * ├── Read legacy .atomic/sessions/{sessionID}/graph.json if present + * │ (current hooks use the repository-owner redb journal) * │ * ├── Format a token-efficient structured summary * │ (goals, changes, verifications, human gates) @@ -33,10 +33,9 @@ * * ## Design * - * This handler is intentionally thin — the provenance graph is built and - * maintained entirely on the Rust side. This handler just reads the JSON - * file from disk and formats it. No graph accumulation, no classification, - * no state management. Consistent with the plugin's "thin pipe" design. + * This handler is intentionally thin and compatibility-only. It never writes + * provenance; current state is owned by Rust/redb. While a legacy cache still + * exists, the handler may format it until the next hook migrates and removes it. * * All errors are swallowed — if the graph file doesn't exist (session * hasn't recorded any tool calls yet) or can't be parsed, the handler @@ -118,8 +117,8 @@ interface SerializedGraph { * Create a compaction handler that injects the provenance graph summary * into the compacted context. * - * The handler reads the graph from `.atomic/sessions/{sessionID}/graph.json`, - * formats a structured summary, and pushes it into `output.context[]`. + * The handler reads a legacy `.atomic/sessions/{sessionID}/graph.json` when + * present, formats a summary, and pushes it into `output.context[]`. * * @param deps - Injected dependencies * @returns An async function matching the `Hooks["experimental.session.compacting"]` signature @@ -157,8 +156,8 @@ export function createCompactionHandler(deps: CompactionHandlerDeps) { summaryLength: summary.length, }) } catch { - // Graph doesn't exist yet or can't be read — that's fine. - // Early in a session there may be no tool calls recorded yet. + // Current owner-journal sessions have no graph.json; corrupt legacy + // caches are also left for the Rust migration path to diagnose. // This is expected and not worth logging above debug level. log.debug("No provenance graph available for compaction", { sessionID: input.sessionID, diff --git a/tests/harness/25_agent_provenance.sh b/tests/harness/25_agent_provenance.sh index 92d48a58..d2061961 100755 --- a/tests/harness/25_agent_provenance.sh +++ b/tests/harness/25_agent_provenance.sh @@ -124,33 +124,18 @@ else _fail "session transcript_path points at the synthesized transcript" "got: $tp" fi -# #1 + #4 (graph side) — llm_response and decision nodes present. -graph=".atomic/sessions/ses_harness/graph.json" -if python3 - "$graph" <<'EOF' -import json, sys -kinds = [n["kind"] for n in json.load(open(sys.argv[1]))["nodes"]] -assert "llm_response" in kinds, kinds -assert "decision" in kinds, kinds -EOF -then - _pass "graph has llm_response and decision nodes" -else - _fail "graph has llm_response and decision nodes" "$(cat "$graph" 2>/dev/null | head -3)" -fi -if python3 - "$graph" <<'EOF' -import json, sys -nodes = json.load(open(sys.argv[1]))["nodes"] -resp = next(n for n in nodes if n["kind"] == "llm_response") -assert resp["summary"] == "The widget is fixed.", resp["summary"] -EOF -then - _pass "llm_response carries the store response text" +# Finalized history remains readable through the immutable session ledger. +HASH="$(atomic log -f json 2>/dev/null | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['hash'])")" +ledger_json="$(atomic session show ses_harness --json 2>/dev/null)" +if echo "$ledger_json" | python3 -c "import json,sys; d=json.load(sys.stdin); assert len(d[1]) == 1; assert d[1][0]['provenance_hash']"; then + _pass "finalized provenance is readable from the session ledger" else - _fail "llm_response carries the store response text" + _fail "finalized provenance is readable from the session ledger" fi +assert_file_not_exists "graph.json removed after owner-journal cutover" ".atomic/sessions/ses_harness/graph.json" +assert_file_not_exists "graph.lock removed after owner-journal cutover" ".atomic/sessions/ses_harness/graph.lock" # #4 (change side) — reasoning_text, tokens, cost, steps on the provenance. -HASH="$(atomic log -f json 2>/dev/null | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['hash'])")" prov_json="$(atomic change "$HASH" -f json 2>/dev/null)" if echo "$prov_json" | python3 -c " import json, sys @@ -168,21 +153,6 @@ else "$(echo "$prov_json" | head -3)" fi -# Tool nodes recorded from the thin payload get their command and output back -# from the store, matched on the tool call id. -if python3 - "$graph" <<'EOF' -import json, sys -nodes = json.load(open(sys.argv[1]))["nodes"] -node = next(n for n in nodes if n.get("tool_call_id") == "call_h1") -assert "cargo test" in node["summary"], node["summary"] -assert node["detail"]["command"] == "cargo test", node["detail"] -assert "12 passed" in node["detail"]["output_summary"], node["detail"] -EOF -then - _pass "tool node enriched from the store (command + output)" -else - _fail "tool node enriched from the store (command + output)" -fi # #2 — agent_turn persisted inside the change file (unhashed section). change_file="$(find .atomic/changes -name "$HASH.change" | head -1)" @@ -240,22 +210,17 @@ else _fail "transcript_path applied from the Stop event" "got: $after" fi -# #1 (transcript fallback) — response derived from the last assistant entry. -cc_graph=".atomic/sessions/cc-harness/graph.json" -if python3 - "$cc_graph" <<'EOF' -import json, sys -nodes = json.load(open(sys.argv[1]))["nodes"] -resp = next(n for n in nodes if n["kind"] == "llm_response") -assert resp["summary"] == "The parser is patched and verified.", resp["summary"] -EOF -then - _pass "llm_response derived from the transcript fallback" +# #1 (transcript fallback) — immutable turn exists; agent_turn below checks text. +CC_HASH="$(atomic log -f json 2>/dev/null | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['hash'])")" +cc_ledger="$(atomic session show cc-harness --json 2>/dev/null)" +if echo "$cc_ledger" | python3 -c "import json,sys; d=json.load(sys.stdin); assert len(d[1]) == 1; assert d[1][0]['provenance_hash']"; then + _pass "claude finalized provenance is readable from the session ledger" else - _fail "llm_response derived from the transcript fallback" + _fail "claude finalized provenance is readable from the session ledger" fi +assert_file_not_exists "claude graph.json removed after cutover" ".atomic/sessions/cc-harness/graph.json" # #2 — agent_turn persisted for the claude-code change too. -CC_HASH="$(atomic log -f json 2>/dev/null | python3 -c "import json,sys; print(json.load(sys.stdin)[0]['hash'])")" cc_file="$(find .atomic/changes -name "$CC_HASH.change" | head -1)" if last_section_json "$cc_file" | python3 -c " import json, sys From b3dd892466071ea12fb3a8be67bcd232e3ebea12 Mon Sep 17 00:00:00 2001 From: Lee Faus Date: Wed, 9 Sep 2026 07:47:07 -0400 Subject: [PATCH 05/15] fix additional provenance regressions --- README.md | 16 +- .../src/turn/orchestrator/provenance.rs | 17 +- .../tests/database_owner_integration_test.rs | 47 +++++ atomic-core/src/change/change.rs | 39 ++++- atomic-core/src/change/provenance/mod.rs | 160 ++++++++++++++++++ atomic-core/src/change/provenance/tests.rs | 88 ++++++++++ .../src/redb_change_store/provenance.rs | 35 +++- .../src/redb_change_store/tests.rs | 54 ++++++ atomic-repository/src/repository/changes.rs | 12 +- .../tests/provenance_checkpoint_test.rs | 39 +++++ 10 files changed, 489 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index 81439c64..5b4fee6d 100644 --- a/README.md +++ b/README.md @@ -54,6 +54,8 @@ Each repository has an independent ownership namespace: | Unix endpoint | `/tmp/atomic-owner-.sock` | Local IPC transport on macOS and Linux | | Windows endpoint | `\\.\pipe\atomic-owner-` | Local IPC transport on Windows | +These runtime resources do **not** require `sudo`. The owner process runs as the current user: it creates the repository lock and database under the user-writable `.atomic` directory and creates its Unix socket in `/tmp`, which is a shared, sticky-bit-protected runtime directory. Elevated privileges are only needed when installing or replacing the `atomic` executable in a system-owned prefix such as `/usr/local/bin`; they are unrelated to socket creation or owner election. + The endpoint digest is derived from the canonical `.atomic` path and uses 96 bits of BLAKE3 output. Different project paths therefore get different owners, locks, databases, and endpoints. Multiple agents working in one project intentionally share that project's owner; agents working in other projects use different owners and proceed independently. Agent sandboxes and symlinked paths resolve back to the canonical repository, so they share its owner rather than creating competing databases. A clone at a different path gets its own owner. ```text @@ -418,13 +420,25 @@ cargo build --release # Run tests cargo test -# Install CLI +# User-local install to ~/.cargo/bin (normally no sudo) cargo install --path atomic-cli # Verify installation atomic --version ``` +To install a locally built binary system-wide, the destination directory may require administrator privileges. On macOS, replacing the file rather than overwriting its existing inode also avoids retaining stale Gatekeeper provenance metadata: + +```bash +cargo build -p atomic-cli --release +sudo rm -f /usr/local/bin/atomic +sudo cp -X target/release/atomic /usr/local/bin/atomic +sudo chmod 0755 /usr/local/bin/atomic +/usr/local/bin/atomic --version +``` + +Do not run normal Atomic commands or the database owner with `sudo`. Repository state, owner locks, and `/tmp/atomic-owner-*.sock` endpoints should remain owned by the user running Atomic. + ## Project Structure ``` diff --git a/atomic-agent/src/turn/orchestrator/provenance.rs b/atomic-agent/src/turn/orchestrator/provenance.rs index 3aa28579..81fcb53d 100644 --- a/atomic-agent/src/turn/orchestrator/provenance.rs +++ b/atomic-agent/src/turn/orchestrator/provenance.rs @@ -636,10 +636,17 @@ impl TurnOrchestrator { return Ok(()); }; - let previous_provenance = atomic_repository::Repository::open_existing(&self.repo_root) - .ok() - .and_then(|repository| repository.get_session_ledger(session_id).ok().flatten()) - .and_then(|(_, turns)| turns.last().map(|turn| turn.provenance_hash)); + let (previous_provenance, ledger_turn_number) = + atomic_repository::Repository::open_existing(&self.repo_root) + .ok() + .and_then(|repository| repository.get_session_ledger(session_id).ok().flatten()) + .map(|(_, turns)| { + ( + turns.last().map(|turn| turn.provenance_hash), + turns.len() as u32, + ) + }) + .unwrap_or((None, 0)); let source = super::JournalCheckpointSource { agent_name: session.agent_name.clone(), agent_display_name: session.agent_display_name.clone(), @@ -650,7 +657,7 @@ impl TurnOrchestrator { .managed_run .as_ref() .and_then(|run| run.work_item_id.clone()), - ledger_turn_number: session.turn_count.saturating_sub(1), + ledger_turn_number, }; let reservation = sink .reserve_turn( diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 41a47f3e..3e846e80 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -853,6 +853,53 @@ fn turn_end_publishes_one_checkpoint_turn_and_advances_head() { ); } +#[test] +fn pre_cutover_session_count_gap_publishes_at_next_ledger_ordinal() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"legacy-gap"}"#, + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"legacy-gap","prompt":"publish after legacy turns"}"#, + ) + .status + .success()); + + let session_path = repository.join(".atomic/sessions/legacy-gap.json"); + let mut session: Value = + serde_json::from_slice(&std::fs::read(&session_path).unwrap()).unwrap(); + session["turn_count"] = Value::from(20); + std::fs::write(&session_path, serde_json::to_vec_pretty(&session).unwrap()).unwrap(); + std::fs::write(repository.join("legacy-gap.txt"), b"record me\n").unwrap(); + + let stop = run_hook( + &repository, + "stop", + br#"{"session_id":"legacy-gap","response":"published"}"#, + ); + assert!( + stop.status.success(), + "{}", + String::from_utf8_lossy(&stop.stderr) + ); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + thread::sleep(Duration::from_millis(100)); + + let repo = Repository::open(&repository).unwrap(); + let (_, turns) = repo.get_session_ledger("legacy-gap").unwrap().unwrap(); + assert_eq!(turns.len(), 1); + assert_eq!(turns[0].turn_number, 0); +} + #[test] fn crashing_second_checkpoint_keeps_first_turn_immutable() { let temp = TempDir::new().unwrap(); diff --git a/atomic-core/src/change/change.rs b/atomic-core/src/change/change.rs index 83eaf1a2..d4973f36 100644 --- a/atomic-core/src/change/change.rs +++ b/atomic-core/src/change/change.rs @@ -503,12 +503,21 @@ impl Change { let mut unhashed: Option = None; while let Some(section) = change_reader.next_section()? { - match section.section_type { + let section_type = section.section_type; + match section_type { SectionType::Header => { - header = Some(section.deserialize()?); + header = Some(section.deserialize().map_err(|error| { + ChangeError::Invalid(format!( + "failed to deserialize {section_type} section: {error}" + )) + })?); } SectionType::Dependencies => { - let dep_indices: Vec = section.deserialize()?; + let dep_indices: Vec = section.deserialize().map_err(|error| { + ChangeError::Invalid(format!( + "failed to deserialize {section_type} section: {error}" + )) + })?; for idx in dep_indices { if let Some(hash_bytes) = hash_table.resolve(idx) { dependencies.push(Hash::from_bytes(*hash_bytes)); @@ -516,20 +525,32 @@ impl Change { } } SectionType::Provenance => { - let prov_refs: Vec = section.deserialize()?; - provenance = prov_refs; + provenance = super::provenance::deserialize_postcard(§ion.payload) + .map_err(|error| { + ChangeError::Invalid(format!( + "failed to deserialize {section_type} section: {error}" + )) + })?; } SectionType::Graph => { - let graph_payload: GraphSectionPayload = - GraphSectionPayload::from_postcard_bytes(§ion.payload)?; + let graph_payload = GraphSectionPayload::from_postcard_bytes(§ion.payload) + .map_err(|error| { + ChangeError::Invalid(format!( + "failed to deserialize {section_type} section: {error}" + )) + })?; let compactor = compact::Compactor::new(&hash_table); for compact_op in graph_payload.ops() { hunks.push(compactor.expand_graph_op(compact_op)?); } } SectionType::Semantic => { - let ops: Vec = postcard::from_bytes(§ion.payload) - .map_err(format_v3::FormatError::from)?; + let ops: Vec = + postcard::from_bytes(§ion.payload).map_err(|error| { + ChangeError::Invalid(format!( + "failed to deserialize {section_type} section: {error}" + )) + })?; file_ops = ops; } SectionType::Content => { diff --git a/atomic-core/src/change/provenance/mod.rs b/atomic-core/src/change/provenance/mod.rs index aeb92346..cca7db84 100644 --- a/atomic-core/src/change/provenance/mod.rs +++ b/atomic-core/src/change/provenance/mod.rs @@ -195,6 +195,166 @@ pub struct Provenance { pub task_plan: Option, } +#[derive(Serialize, Deserialize)] +enum AIVendorV0 { + Anthropic, + OpenAI, + Google, + Meta, + Mistral, + Cohere, + AmazonBedrock, + AzureOpenAI, + Local, + Other(String), +} + +impl From for AIVendor { + fn from(value: AIVendorV0) -> Self { + match value { + AIVendorV0::Anthropic => Self::Anthropic, + AIVendorV0::OpenAI => Self::OpenAI, + AIVendorV0::Google => Self::Google, + AIVendorV0::Meta => Self::Meta, + AIVendorV0::Mistral => Self::Mistral, + AIVendorV0::Cohere => Self::Cohere, + AIVendorV0::AmazonBedrock => Self::AmazonBedrock, + AIVendorV0::AzureOpenAI => Self::AzureOpenAI, + AIVendorV0::Local => Self::Local, + AIVendorV0::Other(name) => Self::Other(name), + } + } +} + +#[derive(Serialize, Deserialize)] +struct ProvenanceBeforeXai { + vendor: AIVendorV0, + model: String, + model_version: Option, + tool: AITool, + suggestion_type: SuggestionType, + prompt: PromptContent, + system_prompt_hash: Option, + tokens: TokenUsage, + cost: Cost, + temperature: Option, + timestamp: Option, + request_id: Option, + session_id: Option, + metadata: Vec<(String, String)>, + agent_mode: Option, + finish_reason: Option, + step_count: Option, + session_slug: Option, + reasoning_signature: Option, + reasoning_text: Option, + task_plan: Option, +} + +#[derive(Serialize, Deserialize)] +struct ProvenanceV0 { + vendor: AIVendorV0, + model: String, + model_version: Option, + tool: AITool, + suggestion_type: SuggestionType, + prompt: PromptContent, + system_prompt_hash: Option, + tokens: TokenUsageV0, + cost: Cost, + temperature: Option, + timestamp: Option, + request_id: Option, + session_id: Option, + metadata: Vec<(String, String)>, +} + +#[derive(Serialize, Deserialize)] +struct TokenUsageV0 { + input_tokens: u64, + output_tokens: u64, + total_tokens: u64, + cache_read_tokens: u64, + cache_write_tokens: u64, +} + +impl From for Provenance { + fn from(value: ProvenanceBeforeXai) -> Self { + Self { + vendor: value.vendor.into(), + model: value.model, + model_version: value.model_version, + tool: value.tool, + suggestion_type: value.suggestion_type, + prompt: value.prompt, + system_prompt_hash: value.system_prompt_hash, + tokens: value.tokens, + cost: value.cost, + temperature: value.temperature, + timestamp: value.timestamp, + request_id: value.request_id, + session_id: value.session_id, + metadata: value.metadata, + agent_mode: value.agent_mode, + finish_reason: value.finish_reason, + step_count: value.step_count, + session_slug: value.session_slug, + reasoning_signature: value.reasoning_signature, + reasoning_text: value.reasoning_text, + task_plan: value.task_plan, + } + } +} + +impl From for Provenance { + fn from(value: ProvenanceV0) -> Self { + Self { + vendor: value.vendor.into(), + model: value.model, + model_version: value.model_version, + tool: value.tool, + suggestion_type: value.suggestion_type, + prompt: value.prompt, + system_prompt_hash: value.system_prompt_hash, + tokens: TokenUsage { + input_tokens: value.tokens.input_tokens, + output_tokens: value.tokens.output_tokens, + total_tokens: value.tokens.total_tokens, + cache_read_tokens: value.tokens.cache_read_tokens, + cache_write_tokens: value.tokens.cache_write_tokens, + reasoning_tokens: 0, + }, + cost: value.cost, + temperature: value.temperature, + timestamp: value.timestamp, + request_id: value.request_id, + session_id: value.session_id, + metadata: value.metadata, + agent_mode: None, + finish_reason: None, + step_count: None, + session_slug: None, + reasoning_signature: None, + reasoning_text: None, + task_plan: None, + } + } +} + +pub(crate) fn deserialize_postcard(bytes: &[u8]) -> Result, postcard::Error> { + match postcard::from_bytes(bytes) { + Ok(provenance) => Ok(provenance), + Err(current_error) => { + if let Ok(legacy) = postcard::from_bytes::>(bytes) { + return Ok(legacy.into_iter().map(Provenance::from).collect()); + } + postcard::from_bytes::>(bytes) + .map(|legacy| legacy.into_iter().map(Provenance::from).collect()) + .map_err(|_| current_error) + } + } +} + impl Provenance { /// Create a new provenance with minimal required fields. pub fn new(vendor: AIVendor, model: impl Into, tool: AITool) -> Self { diff --git a/atomic-core/src/change/provenance/tests.rs b/atomic-core/src/change/provenance/tests.rs index d2385210..4ba52f11 100644 --- a/atomic-core/src/change/provenance/tests.rs +++ b/atomic-core/src/change/provenance/tests.rs @@ -379,3 +379,91 @@ fn test_very_small_cost() { assert!(!cost.is_zero()); assert_eq!(cost.micro_usd, 1); } + +#[test] +fn postcard_decoder_reads_current_provenance() { + let expected = Provenance::builder() + .vendor(AIVendor::Anthropic) + .model("claude-sonnet") + .tool(AITool::cli("atomic")) + .reasoning_tokens(42) + .agent_mode("build") + .build(); + let bytes = postcard::to_allocvec(&vec![expected.clone()]).unwrap(); + + let decoded = deserialize_postcard(&bytes).unwrap(); + + assert_eq!(decoded, vec![expected]); +} + +#[test] +fn postcard_decoder_reads_provenance_before_reasoning_fields() { + let legacy = ProvenanceV0 { + vendor: AIVendorV0::OpenAI, + model: "gpt-4".to_string(), + model_version: Some("legacy".to_string()), + tool: AITool::cli("opencode"), + suggestion_type: SuggestionType::Complete, + prompt: PromptContent::None, + system_prompt_hash: None, + tokens: TokenUsageV0 { + input_tokens: 100, + output_tokens: 25, + total_tokens: 125, + cache_read_tokens: 10, + cache_write_tokens: 5, + }, + cost: Cost::from_micro_usd(1250), + temperature: Some(700), + timestamp: Some(1_700_000_000), + request_id: Some("request-1".to_string()), + session_id: Some("session-1".to_string()), + metadata: vec![("source".to_string(), "legacy".to_string())], + }; + let bytes = postcard::to_allocvec(&vec![legacy]).unwrap(); + + let decoded = deserialize_postcard(&bytes).unwrap(); + + assert_eq!(decoded.len(), 1); + let provenance = &decoded[0]; + assert_eq!(provenance.model, "gpt-4"); + assert_eq!(provenance.tokens.total_tokens, 125); + assert_eq!(provenance.tokens.reasoning_tokens, 0); + assert_eq!(provenance.agent_mode, None); + assert_eq!(provenance.request_id.as_deref(), Some("request-1")); +} + +#[test] +fn postcard_decoder_preserves_vendor_from_before_xai_variant_was_inserted() { + let legacy = ProvenanceBeforeXai { + vendor: AIVendorV0::Other("openrouter".to_string()), + model: "openai/gpt-5.6-sol".to_string(), + model_version: None, + tool: AITool::cli("opencode"), + suggestion_type: SuggestionType::Complete, + prompt: PromptContent::None, + system_prompt_hash: None, + tokens: TokenUsage::full(100, 25, 10, 5, 2), + cost: Cost::zero(), + temperature: None, + timestamp: Some(1_700_000_000), + request_id: None, + session_id: Some("session-1".to_string()), + metadata: vec![("turn_number".to_string(), "1".to_string())], + agent_mode: None, + finish_reason: None, + step_count: None, + session_slug: None, + reasoning_signature: None, + reasoning_text: None, + task_plan: Some("[]".to_string()), + }; + let bytes = postcard::to_allocvec(&vec![legacy]).unwrap(); + + let decoded = deserialize_postcard(&bytes).unwrap(); + + assert_eq!(decoded.len(), 1); + assert_eq!(decoded[0].vendor, AIVendor::Other("openrouter".to_string())); + assert_eq!(decoded[0].model, "openai/gpt-5.6-sol"); + assert_eq!(decoded[0].tokens.reasoning_tokens, 10); +} diff --git a/atomic-repository/src/redb_change_store/provenance.rs b/atomic-repository/src/redb_change_store/provenance.rs index f796db81..ea9ecd5a 100644 --- a/atomic-repository/src/redb_change_store/provenance.rs +++ b/atomic-repository/src/redb_change_store/provenance.rs @@ -224,6 +224,18 @@ fn load_turn( StoredProvenanceTurn::from_bytes(value.value()) } +fn checkpoint_source_matches_except_ordinal( + left: &ProvenanceCheckpointSource, + right: &ProvenanceCheckpointSource, +) -> bool { + left.agent_name == right.agent_name + && left.agent_display_name == right.agent_display_name + && left.agent_vendor == right.agent_vendor + && left.change_hashes == right.change_hashes + && left.previous_provenance == right.previous_provenance + && left.plan_id == right.plan_id +} + fn ensure_generation(turn: &StoredProvenanceTurn, expected: u64) -> RedbStoreResult<()> { if turn.generation != expected { return Err(RedbStoreError::ProvenanceFenced { @@ -575,9 +587,28 @@ impl RedbChangeStore { let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; let mut turn = load_turn(&turns, id)?; - if let Some(attempt) = &turn.checkpoint_attempt { + if let Some(mut attempt) = turn.checkpoint_attempt.clone() { if attempt.source == source { - return Ok(attempt.clone()); + return Ok(attempt); + } + if attempt.phase != ProvenanceCheckpointPhase::Published + && checkpoint_source_matches_except_ordinal(&attempt.source, &source) + { + // Pre-cutover AgentSession counters may include turns that were + // never indexed in SESSION_TURNS. The immutable ledger supplies + // the authoritative append ordinal; graph/hash identity is + // unchanged, so a bound attempt can be repaired safely. + attempt.source.ledger_turn_number = source.ledger_turn_number; + if let Some(session_turn) = attempt.session_turn.as_mut() { + session_turn.turn_number = source.ledger_turn_number; + } + attempt.updated_at = now; + turn.checkpoint_attempt = Some(attempt.clone()); + let bytes = turn.to_bytes()?; + turns.insert(id.get(), bytes.as_slice())?; + drop(turns); + txn.commit()?; + return Ok(attempt); } return Err(RedbStoreError::ProvenanceCheckpointConflict { id: id.get() }); } diff --git a/atomic-repository/src/redb_change_store/tests.rs b/atomic-repository/src/redb_change_store/tests.rs index 2ce839f4..d9a1228c 100644 --- a/atomic-repository/src/redb_change_store/tests.rs +++ b/atomic-repository/src/redb_change_store/tests.rs @@ -822,6 +822,60 @@ fn stop_resume_and_abandon_preserve_identity_frontier_and_fencing() { )); } +#[test] +fn bound_checkpoint_repairs_only_legacy_ledger_ordinal() { + let (_dir, store) = temp_store(); + let running = store + .reserve_provenance_turn("legacy-count", 21, 1) + .unwrap(); + let source = ProvenanceCheckpointSource { + agent_name: "opencode".to_string(), + agent_display_name: "OpenCode".to_string(), + agent_vendor: "openai".to_string(), + change_hashes: vec![Hash::of(b"source")], + previous_provenance: None, + plan_id: None, + ledger_turn_number: 20, + }; + let prepared = store + .prepare_provenance_checkpoint(running.provenance_id, running.generation, source.clone(), 2) + .unwrap(); + let hash = Hash::of(b"provenance"); + let turn = atomic_core::change::session::SessionTurn { + session_id: "legacy-count".to_string(), + turn_number: 20, + goal: None, + provenance_hash: hash, + change_hashes: source.change_hashes.clone(), + previous_provenance: None, + timestamp: 3, + plan_id: None, + todos: Vec::new(), + }; + store + .bind_provenance_checkpoint_hash( + running.provenance_id, + prepared.attempt_generation, + hash, + turn, + 3, + ) + .unwrap(); + + let mut corrected_source = source; + corrected_source.ledger_turn_number = 0; + let corrected = store + .prepare_provenance_checkpoint( + running.provenance_id, + running.generation, + corrected_source, + 4, + ) + .unwrap(); + assert_eq!(corrected.source.ledger_turn_number, 0); + assert_eq!(corrected.session_turn.unwrap().turn_number, 0); +} + #[test] fn stopped_provenance_turn_resumes_and_finalizes_once() { let (_dir, store) = temp_store(); diff --git a/atomic-repository/src/repository/changes.rs b/atomic-repository/src/repository/changes.rs index 9d1c7d82..7897bb8b 100644 --- a/atomic-repository/src/repository/changes.rs +++ b/atomic-repository/src/repository/changes.rs @@ -1057,10 +1057,20 @@ impl Repository { pub fn publish_provenance_checkpoint( &self, graph: &atomic_core::change::ProvenanceGraph, - turn: atomic_core::change::session::SessionTurn, + mut turn: atomic_core::change::session::SessionTurn, ) -> Result { use atomic_core::pristine::MutTxnT; + let existing_turns = self + .get_session_ledger(&turn.session_id)? + .map(|(_, turns)| turns) + .unwrap_or_default(); + turn.turn_number = existing_turns + .iter() + .find(|existing| existing.provenance_hash == turn.provenance_hash) + .map(|existing| existing.turn_number) + .unwrap_or(existing_turns.len() as u32); + let hash = self .change_store .save_provenance_graph(graph) diff --git a/atomic-repository/tests/provenance_checkpoint_test.rs b/atomic-repository/tests/provenance_checkpoint_test.rs index 537f32d4..31704898 100644 --- a/atomic-repository/tests/provenance_checkpoint_test.rs +++ b/atomic-repository/tests/provenance_checkpoint_test.rs @@ -7,6 +7,45 @@ use atomic_repository::redb_change_store::{ }; use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; +#[test] +fn legacy_agent_turn_count_is_normalized_to_next_immutable_ledger_ordinal() { + let temp = tempfile::tempdir().unwrap(); + let root = temp.path().join("repo"); + let repository = Repository::init(&root).unwrap(); + let source_change = Hash::of(b"legacy source"); + let graph = ProvenanceGraph::builder("legacy-count", "opencode") + .changes_explained(vec![source_change]) + .timestamp(1_000) + .build(); + let hash = ChangeStore::new(repository.changes_dir(), DEFAULT_CACHE_CAPACITY) + .unwrap() + .save_provenance_graph(&graph) + .unwrap(); + let publication = repository + .publish_provenance_checkpoint( + &graph, + SessionTurn { + session_id: "legacy-count".to_string(), + turn_number: 20, + goal: None, + provenance_hash: hash, + change_hashes: vec![source_change], + previous_provenance: None, + timestamp: graph.timestamp, + plan_id: None, + todos: Vec::new(), + }, + ) + .unwrap(); + assert_eq!(publication.turn.turn_number, 0); + let (_, turns) = repository + .get_session_ledger("legacy-count") + .unwrap() + .unwrap(); + assert_eq!(turns.len(), 1); + assert_eq!(turns[0].turn_number, 0); +} + #[test] fn checkpoint_recovers_idempotently_across_every_publication_boundary() { let temp = tempfile::tempdir().unwrap(); From 4faf43b2e7d0a1fc618befb71c3d1ef78b968798 Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 15:59:10 -0400 Subject: [PATCH 06/15] fix(storage): share read-only pristine access across CLI processes --- atomic-cli/src/commands/intent/list.rs | 2 +- atomic-cli/src/commands/intent/show.rs | 2 +- .../tests/concurrent_intent_reads_test.rs | 84 ++++++++++++++ atomic-core/src/pristine/txn/pristine.rs | 105 +++++++++++++++--- atomic-repository/src/repository/mod.rs | 4 +- atomic-repository/src/repository/sandbox.rs | 37 ++++-- 6 files changed, 205 insertions(+), 29 deletions(-) create mode 100644 atomic-cli/tests/concurrent_intent_reads_test.rs diff --git a/atomic-cli/src/commands/intent/list.rs b/atomic-cli/src/commands/intent/list.rs index af768179..48a50e5f 100644 --- a/atomic-cli/src/commands/intent/list.rs +++ b/atomic-cli/src/commands/intent/list.rs @@ -287,7 +287,7 @@ fn build_rows( impl Command for IntentList { fn run(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; // Resolve the verifying identity ONCE (soft-fail to "no identity"). let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/intent/show.rs b/atomic-cli/src/commands/intent/show.rs index 2decb51a..5ff78fcf 100644 --- a/atomic-cli/src/commands/intent/show.rs +++ b/atomic-cli/src/commands/intent/show.rs @@ -27,7 +27,7 @@ pub struct IntentShow { impl Command for IntentShow { fn run(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; // Pure read-time projection: lift then render. No gate, no proof // requirement — this must work on a plain (un-attested) intent. The diff --git a/atomic-cli/tests/concurrent_intent_reads_test.rs b/atomic-cli/tests/concurrent_intent_reads_test.rs new file mode 100644 index 00000000..6d7058da --- /dev/null +++ b/atomic-cli/tests/concurrent_intent_reads_test.rs @@ -0,0 +1,84 @@ +use std::process::{Command, Stdio}; +use std::time::{Duration, Instant}; + +use atomic_repository::{IntentCreateOptions, Repository}; + +#[test] +fn intent_queries_share_a_read_only_database_across_processes() { + let temp = tempfile::tempdir().unwrap(); + let repo = Repository::init(temp.path()).unwrap(); + repo.init_vault().unwrap(); + let intent = repo + .vault_intent_create(IntentCreateOptions { + title: "Concurrent read fixture".to_string(), + priority: None, + assignee: None, + labels: Vec::new(), + session_id: None, + turn_id: None, + kind: None, + }) + .unwrap(); + let view = repo.current_view().to_string(); + drop(repo); + + let sandbox = tempfile::tempdir().unwrap(); + std::fs::write( + sandbox.path().join(".atomic-sandbox"), + serde_json::to_vec(&serde_json::json!({ + "canonical": temp.path(), "view": view, + })) + .unwrap(), + ) + .unwrap(); + + // Keep a reader alive throughout every child invocation, making lock + // overlap deterministic instead of relying on scheduler timing. + let _reader = Repository::open_readonly(temp.path()).unwrap(); + let mut children: Vec<_> = (0..8) + .map(|index| { + let args = if index % 2 == 0 { + vec!["intent", "list", "--json"] + } else { + vec!["intent", "show", intent.id.as_str(), "--json"] + }; + Command::new(env!("CARGO_BIN_EXE_atomic")) + .args(args) + .current_dir(if index < 4 { + temp.path() + } else { + sandbox.path() + }) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap() + }) + .collect(); + let deadline = Instant::now() + Duration::from_secs(10); + while children + .iter_mut() + .any(|child| child.try_wait().unwrap().is_none()) + { + if Instant::now() > deadline { + for child in &mut children { + let _ = child.kill(); + let _ = child.wait(); + } + panic!("concurrent intent reads exceeded 10 seconds"); + } + std::thread::sleep(Duration::from_millis(10)); + } + let outputs: Vec<_> = children + .into_iter() + .map(|child| child.wait_with_output().unwrap()) + .collect(); + for output in outputs { + assert!( + output.status.success(), + "query failed with a concurrent reader: {}", + String::from_utf8_lossy(&output.stderr) + ); + let _: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); + } +} diff --git a/atomic-core/src/pristine/txn/pristine.rs b/atomic-core/src/pristine/txn/pristine.rs index 9d49f1f9..566ef487 100644 --- a/atomic-core/src/pristine/txn/pristine.rs +++ b/atomic-core/src/pristine/txn/pristine.rs @@ -7,7 +7,8 @@ //! //! For commands that only need to read data (like `status`, `diff`, `log`), //! use `Pristine::open_readonly()` which doesn't acquire a write lock and -//! can run concurrently with other readers or a single writer. +//! can run concurrently with other readers. A writable handle still requires +//! exclusive process access; redb 4.2 does not allow readers alongside it. //! //! ```ignore //! // For read-only operations (status, diff, log, change) @@ -22,7 +23,7 @@ use std::path::Path; use std::sync::atomic::{AtomicU64, Ordering}; -use redb::{Builder, Database, ReadableDatabase, ReadableTable}; +use redb::{Builder, Database, ReadOnlyDatabase, ReadableDatabase, ReadableTable}; use crate::pristine::error::{PristineError, PristineResult}; use crate::pristine::tables::*; @@ -89,7 +90,7 @@ fn open_database(path: &Path, create: bool, cache_bytes: usize) -> PristineResul /// write_txn.commit()?; /// ``` pub struct Pristine { - db: Database, + db: PristineDatabase, /// Counter for allocating node IDs pub(crate) next_node_id: AtomicU64, /// Counter for allocating view IDs @@ -98,6 +99,20 @@ pub struct Pristine { pub(crate) next_inode: AtomicU64, } +enum PristineDatabase { + Writable(Database), + ReadOnly(ReadOnlyDatabase), +} + +impl PristineDatabase { + fn begin_read(&self) -> Result { + match self { + Self::Writable(db) => db.begin_read(), + Self::ReadOnly(db) => db.begin_read(), + } + } +} + impl Pristine { /// Open or create a pristine database at the given path /// @@ -206,7 +221,7 @@ impl Pristine { }; Ok(Self { - db, + db: PristineDatabase::Writable(db), next_node_id, next_view_id, next_inode, @@ -219,12 +234,10 @@ impl Pristine { /// table-initialization transaction. It assumes all tables already exist /// (true for any database previously created by `open` or `init`). /// - /// The returned `Pristine` still supports [`write_txn`](Self::write_txn) - /// — the write lock is deferred until you actually need one. This is - /// critical for the agent hook path where `Repository::open()` is called - /// from a short-lived process: `begin_write()` blocks **indefinitely** - /// if another process holds a write transaction, so skipping the - /// init-only write eliminates the most common cause of hook hangs. + /// The returned `Pristine` supports [`write_txn`](Self::write_txn) and holds + /// redb's exclusive process lock for its lifetime. Skipping table setup + /// avoids a redundant write transaction, but does not permit another + /// process to open this database. /// /// # Errors /// @@ -233,7 +246,7 @@ impl Pristine { pub fn open_existing>(path: P) -> PristineResult { let cache_bytes = 8 * 1024 * 1024 * 1024; // 8 GiB let db = open_database(path.as_ref(), false, cache_bytes)?; - Self::scan_ids(db) + Self::scan_ids(PristineDatabase::Writable(db)) } /// Open an existing pristine database in read-only mode @@ -257,11 +270,21 @@ impl Pristine { /// // Read operations... /// ``` pub fn open_readonly>(path: P) -> PristineResult { - // Open database without creating (read-only mode) - // Use the same 8 GiB cache as open() for consistent performance. let cache_bytes = 8 * 1024 * 1024 * 1024; // 8 GiB - let db = open_database(path.as_ref(), false, cache_bytes)?; - Self::scan_ids(db) + let mut builder = Builder::new(); + builder.set_cache_size(cache_bytes); + let db = match builder.open_read_only(path.as_ref()) { + Ok(db) => db, + Err(redb::DatabaseError::UpgradeRequired(_) | redb::DatabaseError::RepairAborted) => { + // Migration and crash recovery need a writable handle. Close + // it cleanly to persist allocator state before acquiring the + // shared read lock. Never retry ordinary lock contention here. + drop(open_database(path.as_ref(), false, cache_bytes)?); + builder.open_read_only(path.as_ref())? + } + Err(error) => return Err(error.into()), + }; + Self::scan_ids(PristineDatabase::ReadOnly(db)) } /// Scan existing tables for the next available IDs. @@ -269,7 +292,7 @@ impl Pristine { /// Shared implementation for `open_existing` and `open_readonly` — both /// skip the table-init write transaction and only need a read pass to /// discover the max allocated node, view, and inode IDs. - fn scan_ids(db: Database) -> PristineResult { + fn scan_ids(db: PristineDatabase) -> PristineResult { let read_txn = db.begin_read()?; let next_node_id = { @@ -326,7 +349,13 @@ impl Pristine { /// must be explicitly committed with `commit()` or it will be rolled back /// when dropped. pub fn write_txn(&self) -> PristineResult> { - let txn = self.db.begin_write()?; + let PristineDatabase::Writable(db) = &self.db else { + return Err(PristineError::Io(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "cannot write through a read-only pristine handle", + ))); + }; + let txn = db.begin_write()?; Ok(WriteTxn::new( txn, &self.next_node_id, @@ -364,6 +393,48 @@ mod tests { let _write = pristine.write_txn().unwrap(); } + #[test] + fn read_only_handles_share_access_and_reject_writes() { + let dir = tempdir().unwrap(); + let path = dir.path().join("pristine"); + drop(Pristine::open(&path).unwrap()); + let first = Pristine::open_readonly(&path).unwrap(); + let second = Pristine::open_readonly(&path).unwrap(); + assert!(first.read_txn().is_ok()); + assert!(second.read_txn().is_ok()); + assert!( + matches!(first.write_txn(), Err(PristineError::Io(error)) if error.kind() == std::io::ErrorKind::PermissionDenied) + ); + assert!(Pristine::open_existing(&path).is_err()); + drop(first); + drop(second); + assert!(Pristine::open_existing(&path).is_ok()); + } + + #[test] + fn read_only_open_upgrades_legacy_v2_database() { + let dir = tempdir().unwrap(); + let path = dir.path().join("pristine"); + { + let db = redb_2_6::Database::create(&path).unwrap(); + let txn = db.begin_write().unwrap(); + txn.open_table(redb_2_6::TableDefinition::::new("external")) + .unwrap() + .insert(7, &[42u8; 32]) + .unwrap(); + txn.open_table(redb_2_6::TableDefinition::<&str, &[u8]>::new("views")) + .unwrap(); + txn.open_table(redb_2_6::TableDefinition::::new("inodes")) + .unwrap(); + txn.commit().unwrap(); + } + let db = Pristine::open_readonly(&path).unwrap(); + assert_eq!(db.peek_next_node_id(), 8); + let txn = db.read_txn().unwrap(); + let table = txn.txn.open_table(EXTERNAL).unwrap(); + assert_eq!(table.get(7).unwrap().unwrap().value(), &[42u8; 32]); + } + #[test] fn test_open_upgrades_legacy_v2_database() { use redb_2_6::Database as LegacyDatabase; diff --git a/atomic-repository/src/repository/mod.rs b/atomic-repository/src/repository/mod.rs index 2053e0e5..485f7498 100644 --- a/atomic-repository/src/repository/mod.rs +++ b/atomic-repository/src/repository/mod.rs @@ -440,7 +440,7 @@ default = "{}" /// need to make any modifications. This is especially useful for: /// - CLI commands that only display information /// - Integration tools that poll repository status - /// - Concurrent access scenarios where write operations are happening elsewhere + /// - Concurrent readers of a database that has no writable process handle /// /// # Arguments /// @@ -462,7 +462,7 @@ default = "{}" /// ``` pub fn open_readonly>(path: P) -> Result { if let Some((working_root, canonical, view)) = sandbox::detect_sandbox(path.as_ref()) { - return Self::open_sandbox(working_root, canonical, &view); + return Self::open_sandbox_readonly(working_root, canonical, &view); } let root = Self::find_root(path.as_ref())?; let dot_dir = root.join(DOT_DIR); diff --git a/atomic-repository/src/repository/sandbox.rs b/atomic-repository/src/repository/sandbox.rs index 06afe563..cf10e711 100644 --- a/atomic-repository/src/repository/sandbox.rs +++ b/atomic-repository/src/repository/sandbox.rs @@ -133,8 +133,9 @@ impl Repository { /// is held in memory for this handle only, so concurrent agents on /// different views never clobber one another. /// - /// redb serialises writers, so concurrent `record`s from several agents - /// take turns; reads run concurrently via MVCC. + /// This writable open requires exclusive process access to the canonical + /// database. Read-only sandbox queries use `open_readonly` to share access + /// with other readers. pub fn open_sandbox( working_root: P, canonical: Q, @@ -144,14 +145,34 @@ impl Repository { P: AsRef, Q: AsRef, { - let working_root = working_root.as_ref().to_path_buf(); - let canonical_root = Self::find_root(canonical.as_ref())?; + Self::open_sandbox_with_mode(working_root.as_ref(), canonical.as_ref(), view, false) + } + + pub(super) fn open_sandbox_readonly( + working_root: PathBuf, + canonical: PathBuf, + view: &str, + ) -> Result { + Self::open_sandbox_with_mode(&working_root, &canonical, view, true) + } + + fn open_sandbox_with_mode( + working_root: &Path, + canonical: &Path, + view: &str, + read_only: bool, + ) -> Result { + let working_root = working_root.to_path_buf(); + let canonical_root = Self::find_root(canonical)?; let dot_dir = canonical_root.join(DOT_DIR); - let pristine = Arc::new( - Pristine::open_existing(dot_dir.join("pristine.redb")) - .map_err(|e| RepositoryError::Database(e.to_string()))?, - ); + let path = dot_dir.join("pristine.redb"); + let pristine = if read_only { + Pristine::open_readonly(path) + } else { + Pristine::open_existing(path) + }; + let pristine = Arc::new(pristine.map_err(|e| RepositoryError::Database(e.to_string()))?); let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY) .map_err(|e| RepositoryError::Database(e.to_string()))?; From 25715974e76170a85684e68b4646afb00a727a77 Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 15:59:10 -0400 Subject: [PATCH 07/15] fix(agent): checkpoint read-only turns without contaminating later goals --- .../src/turn/orchestrator/provenance.rs | 14 ++- atomic-agent/src/turn/orchestrator/turn.rs | 32 ++++-- .../tests/database_owner_integration_test.rs | 107 +++++++++++++++++- 3 files changed, 141 insertions(+), 12 deletions(-) diff --git a/atomic-agent/src/turn/orchestrator/provenance.rs b/atomic-agent/src/turn/orchestrator/provenance.rs index 81fcb53d..634a9690 100644 --- a/atomic-agent/src/turn/orchestrator/provenance.rs +++ b/atomic-agent/src/turn/orchestrator/provenance.rs @@ -623,11 +623,21 @@ impl TurnOrchestrator { session: &AgentSession, outcome: &TurnRecordOutcome, event: &TurnEvent, + ) -> AgentResult<()> { + self.commit_recorded_turn_events(session_id, session.turn_count.max(1), event, outcome)?; + self.checkpoint_turn_provenance(session_id, session, &[outcome.hash], event) + } + + pub(super) fn checkpoint_turn_provenance( + &self, + session_id: &str, + session: &AgentSession, + change_hashes: &[atomic_core::types::Hash], + event: &TurnEvent, ) -> AgentResult<()> { use atomic_core::change::session::SessionTurn; use atomic_core::types::{Base32, Hash}; - self.commit_recorded_turn_events(session_id, session.turn_count.max(1), event, outcome)?; let Some(sink) = self.journal_sink.as_ref() else { log::debug!( "Skipping provenance finalization for {} without an owner journal sink", @@ -651,7 +661,7 @@ impl TurnOrchestrator { agent_name: session.agent_name.clone(), agent_display_name: session.agent_display_name.clone(), agent_vendor: session.agent_vendor.clone(), - change_hashes: vec![outcome.hash], + change_hashes: change_hashes.to_vec(), previous_provenance, plan_id: session .managed_run diff --git a/atomic-agent/src/turn/orchestrator/turn.rs b/atomic-agent/src/turn/orchestrator/turn.rs index 3fa96e4f..e0cc5c84 100644 --- a/atomic-agent/src/turn/orchestrator/turn.rs +++ b/atomic-agent/src/turn/orchestrator/turn.rs @@ -148,6 +148,13 @@ impl TurnOrchestrator { let mut session = self.load_or_create_session(session_id, &event)?; + let has_changes = self.has_working_copy_changes(); + if !session.is_turn_active() && session.turn_count > 0 && !has_changes { + // A retried Stop after successful publication must not create a + // second empty checkpoint for the same completed interaction. + return Ok(DispatchResult::new(session_id, session.phase)); + } + // Extract model/provider from the TurnEnd event's raw_json. // OpenCode sends model and provider in every stop payload. // This is the last chance to capture the info before recording, @@ -182,14 +189,21 @@ impl TurnOrchestrator { let pending_turn_number = session.turn_count.saturating_add(1); self.commit_turn_completion_events(&session, &event, pending_turn_number)?; - // The terminal event is durably journaled even for an empty turn. The - // graph/checkpoint path below remains conditional until intent 108. - if !self.has_working_copy_changes() { - log::info!( - "Turn end for session {} — no changes detected, skipping record", - session_id - ); - return Ok(DispatchResult::new(session_id, phase::Phase::Idle)); + // A read-only turn still owns a journal turn number and immutable + // provenance. Finalize it before advancing the session so the next + // prompt cannot be deduplicated against this turn's goal/response IDs. + if !has_changes { + if self.watcher.is_active() { + let _ = self.watcher.cancel_turn().await; + } + session.end_turn(); + self.checkpoint_turn_provenance(session_id, &session, &[], &event)?; + session.clear_current_prompt(); + let result = + phase::transition(session.phase, Event::TurnEnd, TransitionContext::default()); + phase::apply_common_actions(&mut session, &result); + self.session_store.save(&session)?; + return Ok(DispatchResult::new(session_id, session.phase)); } // Release the watcher if it was active (best-effort, ignore errors) @@ -301,6 +315,8 @@ impl TurnOrchestrator { turn_number, session_id ); + self.checkpoint_turn_provenance(session_id, &session, &[], &event)?; + session.clear_current_prompt(); } Err(e) => { log::error!( diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 3e846e80..2d0d43f9 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -111,10 +111,14 @@ fn run_lifecycle(repository: &std::path::Path, args: &[&str]) -> Output { } fn run_hook(repository: &std::path::Path, verb: &str, payload: &[u8]) -> Output { + run_agent_hook(repository, "claude-code", verb, payload) +} + +fn run_agent_hook(repository: &std::path::Path, agent: &str, verb: &str, payload: &[u8]) -> Output { let mut child = Command::new(env!("CARGO_BIN_EXE_atomic")) .arg("agent") .arg("hooks") - .arg("claude-code") + .arg(agent) .arg(verb) .arg("--foreground") .arg("--no-color") @@ -133,6 +137,81 @@ fn run_hook(repository: &std::path::Path, verb: &str, payload: &[u8]) -> Output child.wait_with_output().expect("wait for hook process") } +#[test] +fn read_only_turn_does_not_reuse_its_goal_for_the_next_turn_across_agents() { + for (agent, prompt_verb) in [ + ("codex", "user-prompt-submit"), + ("claude-code", "user-prompt-submit"), + ("opencode", "user-prompt"), + ] { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let hook = |verb: &str, payload: Value| { + let output = run_agent_hook( + &repository, + agent, + verb, + &serde_json::to_vec(&payload).unwrap(), + ); + assert!( + output.status.success(), + "{agent} {verb}: {}", + String::from_utf8_lossy(&output.stderr) + ); + }; + hook( + "session-start", + serde_json::json!({"session_id":"read-then-write"}), + ); + hook( + prompt_verb, + serde_json::json!({"session_id":"read-then-write","prompt":"Inspect without edits"}), + ); + hook( + "stop", + serde_json::json!({"session_id":"read-then-write","last_assistant_message":"Inspected","response":"Inspected"}), + ); + // Retry the same terminal hook before the next user prompt. + hook( + "stop", + serde_json::json!({"session_id":"read-then-write","last_assistant_message":"Inspected","response":"Inspected"}), + ); + hook( + prompt_verb, + serde_json::json!({"session_id":"read-then-write","prompt":"Implement the second request"}), + ); + std::fs::write(repository.join("second.txt"), b"second request\n").unwrap(); + hook( + "stop", + serde_json::json!({"session_id":"read-then-write","last_assistant_message":"Implemented","response":"Implemented"}), + ); + hook( + "stop", + serde_json::json!({"session_id":"read-then-write","last_assistant_message":"Implemented","response":"Implemented"}), + ); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + + let repo = Repository::open(&repository).unwrap(); + let (_, turns) = repo.get_session_ledger("read-then-write").unwrap().unwrap(); + assert_eq!( + turns.last().unwrap().goal.as_deref(), + Some("Implement the second request"), + "{agent}: a read-only turn must not contaminate the next turn" + ); + assert_eq!( + turns.len(), + 2, + "{agent}: read-only provenance must remain queryable" + ); + assert!(turns[0].change_hashes.is_empty()); + assert_eq!(turns[0].goal.as_deref(), Some("Inspect without edits")); + assert_eq!(turns[1].previous_provenance, Some(turns[0].provenance_hash)); + assert_eq!(turns[1].change_hashes.len(), 1); + } +} + fn wait_for_shutdown(repository: &std::path::Path) { let deadline = Instant::now() + Duration::from_secs(5); loop { @@ -177,6 +256,24 @@ fn concurrent_hooks_commit_lossless_envelopes_without_output_or_drops() { String::from_utf8_lossy(&turn_start.stderr) ); + let reservation = owner_command(&repository, "reserve") + .args([ + "--session-id", + "hook-concurrent", + "--turn", + "1", + "--now", + "1700000000", + "--json", + ]) + .output() + .unwrap(); + assert!(reservation.status.success()); + let running_generation = serde_json::from_slice::(&reservation.stdout).unwrap()["turn"] + ["generation"] + .as_u64() + .unwrap(); + let append_started = Instant::now(); let mut workers = Vec::new(); for index in 0..TOOL_EVENTS { @@ -265,9 +362,15 @@ fn concurrent_hooks_commit_lossless_envelopes_without_output_or_drops() { saw_terminal |= matches!(&envelope.event, ProvenanceJournalEvent::Terminal { .. }); assert_eq!(envelope.session_id, "hook-concurrent"); assert_eq!(envelope.turn_number, 1); - assert_eq!(envelope.generation, turn.generation); + // Finalization fences writers by advancing the stored generation; + // immutable events retain the generation acknowledged during append. + assert_eq!(envelope.generation, running_generation); } assert!(saw_reasoning && saw_response && saw_todo && saw_terminal); + assert!(matches!( + turn.state, + atomic_repository::redb_change_store::ProvenanceTurnState::Completed + )); } #[test] From 471833692f61f7e2d71ff68f6be3c45f694cdafa Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 15:59:11 -0400 Subject: [PATCH 08/15] test: document and complete redb provenance validation checks --- atomic-cli/src/commands/agent/owner.rs | 1 + atomic-cli/src/commands/intent/bridge.rs | 9 ++- docs/redb-provenance-validation.md | 82 ++++++++++++++++++++++++ 3 files changed, 91 insertions(+), 1 deletion(-) create mode 100644 docs/redb-provenance-validation.md diff --git a/atomic-cli/src/commands/agent/owner.rs b/atomic-cli/src/commands/agent/owner.rs index 021fdd88..921b4289 100644 --- a/atomic-cli/src/commands/agent/owner.rs +++ b/atomic-cli/src/commands/agent/owner.rs @@ -800,6 +800,7 @@ fn acquire_owner_lock(dot_dir: &Path) -> anyhow::Result { let path = dot_dir.join(OWNER_LOCK_FILE); let file = OpenOptions::new() .create(true) + .truncate(false) .read(true) .write(true) .open(&path) diff --git a/atomic-cli/src/commands/intent/bridge.rs b/atomic-cli/src/commands/intent/bridge.rs index b0a60d00..d6999657 100644 --- a/atomic-cli/src/commands/intent/bridge.rs +++ b/atomic-cli/src/commands/intent/bridge.rs @@ -418,7 +418,14 @@ mod tests { // (derived from the temp dir name); the bare number and lowercase // forms must all resolve to it. let lower = id.to_lowercase(); - let num = id.rsplit('-').next().unwrap().to_string(); + let num = id + .rsplit("::") + .next() + .unwrap() + .rsplit('-') + .next() + .unwrap() + .to_string(); for alias in [id.as_str(), lower.as_str(), num.as_str()] { assert_eq!( attestation_vault_path(&repo, alias).unwrap(), diff --git a/docs/redb-provenance-validation.md b/docs/redb-provenance-validation.md new file mode 100644 index 00000000..1a83f28d --- /dev/null +++ b/docs/redb-provenance-validation.md @@ -0,0 +1,82 @@ +# redb / provenance validation — 2026-09-09 + +Validated Lee's `fix/orchestrator_pass` at `b3dd89246607` on macOS ARM64, +using Rust 1.95.0. Follow-up changes live on `fix/redb-provenance-validation`. + +## Findings and fixes + +### Concurrent intent readers acquired exclusive database locks + +With 16 concurrent workers issuing 64 `atomic intent list --json` requests, +the original branch returned `Database already open. Cannot acquire lock.` +for 60 requests. `Pristine::open_readonly` actually opened a writable redb +`Database`, and `intent list/show` called the writable repository constructor. + +The fix uses redb's `ReadOnlyDatabase` and routes intent projections and +read-only sandbox opens through it. A deterministic integration test keeps a +reader open while eight CLI processes query intents from the canonical +repository and a sandbox. Writes through a read-only handle are rejected. +Legacy migration and required allocator recovery finish through a temporary +writable handle before acquiring shared read access. + +After the fix, the same 64-request smoke test completed with 64 successes and +zero failures. This is a correctness check, not a performance benchmark. + +### A read-only agent turn contaminated the next turn's provenance + +On the original branch, a Codex turn with no file changes left the session +`active` with `turn_count = 0`. The next turn reused the same journal event IDs, +so its recorded goal was the first turn's prompt instead of the current prompt. + +Read-only turns now publish their own immutable checkpoint with an empty +change list, advance the session, clear the completed prompt, and transition +to idle. Repeated Stop events after completion do not create extra checkpoints. +The regression test covers Codex, Claude Code, and OpenCode, asserting separate +goals, linked provenance hashes, and the absence of a change in the first turn. + +### Existing checks needed two small corrections + +- The database owner lock now explicitly uses `truncate(false)`, satisfying + Clippy's `suspicious_open_options` check while preserving the lock file. +- The attestation alias test extracts the numeric suffix from canonical + `PROJECT::author::sequence` IDs before handling legacy hyphenated IDs. Its + original split failed for the locally configured `vscode-e2e` identity. + +## Validation + +Local results: **8,820 tests passed, 0 failed, 242 ignored** across the full +workspace (including documentation tests). Clippy, formatting, and rustdoc +with warnings denied passed. Both shell suites (09 and 25) passed; suite 25 +contains 13 provenance assertions. The OpenCode plugin passed 121 tests. + +Commands: + +```sh +cargo test --workspace --no-fail-fast +cargo clippy --workspace -- -D warnings +cargo fmt --all -- --check +RUSTDOCFLAGS=-Dwarnings cargo doc --workspace --no-deps +ATOMIC_BIN="$PWD/target/debug/atomic" bash tests/harness/run_all.sh 09 25 +(cd packages/opencode-atomic-hooks && bun test src/__tests__/) +``` + +The owner integration suite exercises real child processes for concurrent +append, duplicate event delivery, election/reconnect, owner crashes before and +after commit, checkpoint recovery, stale generation fencing, lifecycle +stop/resume/abandon, legacy graph migration, and previous-turn immutability. +Additional coverage includes legacy redb migration, concurrent intent reads +from sandboxes, and read-only-to-writing turns across three hook adapters. +A smoke test also exercised Codex's default detached Stop path and verified +that it eventually published the expected session ledger. + +## Limits and follow-up + +- redb 4.2 permits multiple read-only process handles, but a writable handle + still excludes them. This change does not promise concurrent readers and + writers of `pristine.redb`. The owner service separately owns `changes.redb`. +- Harness checks invoke actual hook CLI processes with fixture payloads and + transcripts. They do not run paid model sessions or validate every host UI. +- This run covers macOS ARM64. Linux, Windows, and the Rust 1.90 MSRV need CI + validation before release. The draft PR targets `dev` so the existing CI workflow can validate the + complete owner-journal cutover together with these fixes. +- redb 5.0 evaluation and Git–Atomic bridge integration remain separate tasks. From 4bc163c06f4c693bb9c62301efcc5abb66398fc1 Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 16:32:10 -0400 Subject: [PATCH 09/15] test(agent): bound owner subprocesses to diagnose Windows hangs --- .../tests/database_owner_integration_test.rs | 134 ++++++++++++------ 1 file changed, 90 insertions(+), 44 deletions(-) diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 2d0d43f9..6ef99805 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -11,6 +11,64 @@ use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; use serde_json::Value; use tempfile::TempDir; +// Bound child processes so a platform-specific IPC regression produces a +// useful failure instead of occupying a CI runner indefinitely. Drain output +// concurrently so a full pipe cannot prevent the child from exiting. +fn wait_for_output(mut child: Child, operation: &str) -> Output { + fn drain(stream: Option) -> std::sync::mpsc::Receiver> { + let (sender, receiver) = std::sync::mpsc::channel(); + thread::spawn(move || { + let mut bytes = Vec::new(); + if let Some(mut stream) = stream { + stream.read_to_end(&mut bytes).expect("read child output"); + } + let _ = sender.send(bytes); + }); + receiver + } + let stdout = drain(child.stdout.take()); + let stderr = drain(child.stderr.take()); + let deadline = Instant::now() + Duration::from_secs(30); + let (status, timed_out) = loop { + if let Some(status) = child.try_wait().expect("inspect child process") { + break (status, false); + } + if Instant::now() >= deadline { + child.kill().expect("kill timed-out child"); + break (child.wait().expect("reap timed-out child"), true); + } + thread::sleep(Duration::from_millis(10)); + }; + let stdout = stdout + .recv_timeout(Duration::from_secs(2)) + .expect("child stdout stayed open"); + let stderr = stderr + .recv_timeout(Duration::from_secs(2)) + .expect("child stderr stayed open"); + assert!( + !timed_out, + "{operation} timed out after 30s; stdout: {}; stderr: {}", + String::from_utf8_lossy(&stdout), + String::from_utf8_lossy(&stderr) + ); + Output { + status, + stdout, + stderr, + } +} + +fn command_output(command: &mut Command) -> Output { + let operation = format!("{command:?}"); + let child = command + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("spawn command"); + wait_for_output(child, &operation) +} + fn owner_command(repository: &std::path::Path, operation: &str) -> Command { let mut command = Command::new(env!("CARGO_BIN_EXE_atomic")); command @@ -48,10 +106,7 @@ fn spawn_owner_with_failpoint( } fn run_owner(repository: &std::path::Path, operation: &str) -> Output { - owner_command(repository, operation) - .arg("--json") - .output() - .expect("run database-owner command") + command_output(owner_command(repository, operation).arg("--json")) } fn wait_for_ping(repository: &std::path::Path, child: &mut Child) -> Value { @@ -81,16 +136,16 @@ fn wait_for_ping(repository: &std::path::Path, child: &mut Child) -> Value { } fn reserve(repository: &std::path::Path) -> Value { - let output = owner_command(repository, "reserve") - .arg("--session-id") - .arg("owner-service-test") - .arg("--turn") - .arg("7") - .arg("--now") - .arg("1700000000") - .arg("--json") - .output() - .expect("reserve provenance turn"); + let output = command_output( + owner_command(repository, "reserve") + .arg("--session-id") + .arg("owner-service-test") + .arg("--turn") + .arg("7") + .arg("--now") + .arg("1700000000") + .arg("--json"), + ); assert!( output.status.success(), "reservation failed: {}", @@ -100,14 +155,14 @@ fn reserve(repository: &std::path::Path) -> Value { } fn run_lifecycle(repository: &std::path::Path, args: &[&str]) -> Output { - Command::new(env!("CARGO_BIN_EXE_atomic")) - .arg("agent") - .arg("lifecycle") - .args(args) - .arg("--no-color") - .current_dir(repository) - .output() - .expect("run lifecycle command") + command_output( + Command::new(env!("CARGO_BIN_EXE_atomic")) + .arg("agent") + .arg("lifecycle") + .args(args) + .arg("--no-color") + .current_dir(repository), + ) } fn run_hook(repository: &std::path::Path, verb: &str, payload: &[u8]) -> Output { @@ -134,7 +189,7 @@ fn run_agent_hook(repository: &std::path::Path, agent: &str, verb: &str, payload .expect("hook stdin") .write_all(payload) .expect("write hook payload"); - child.wait_with_output().expect("wait for hook process") + wait_for_output(child, &format!("{agent} {verb}")) } #[test] @@ -256,18 +311,15 @@ fn concurrent_hooks_commit_lossless_envelopes_without_output_or_drops() { String::from_utf8_lossy(&turn_start.stderr) ); - let reservation = owner_command(&repository, "reserve") - .args([ - "--session-id", - "hook-concurrent", - "--turn", - "1", - "--now", - "1700000000", - "--json", - ]) - .output() - .unwrap(); + let reservation = command_output(owner_command(&repository, "reserve").args([ + "--session-id", + "hook-concurrent", + "--turn", + "1", + "--now", + "1700000000", + "--json", + ])); assert!(reservation.status.success()); let running_generation = serde_json::from_slice::(&reservation.stdout).unwrap()["turn"] ["generation"] @@ -1085,9 +1137,7 @@ fn owner_election_commit_reconnect_and_crash_restart() { let first_pid = first_health["pid"].as_u64().unwrap(); assert_eq!(first_health["protocol_version"], 1); - let duplicate = owner_command(&repository, "serve") - .output() - .expect("run duplicate owner"); + let duplicate = command_output(&mut owner_command(&repository, "serve")); assert!(!duplicate.status.success()); assert!(String::from_utf8_lossy(&duplicate.stderr).contains("another database owner")); @@ -1110,12 +1160,8 @@ fn owner_election_commit_reconnect_and_crash_restart() { .stderr(Stdio::piped()) .spawn() .expect("spawn second bootstrap contender"); - let first_bootstrap = first_bootstrap - .wait_with_output() - .expect("wait for first bootstrap contender"); - let second_bootstrap = second_bootstrap - .wait_with_output() - .expect("wait for second bootstrap contender"); + let first_bootstrap = wait_for_output(first_bootstrap, "first bootstrap contender"); + let second_bootstrap = wait_for_output(second_bootstrap, "second bootstrap contender"); assert!(first_bootstrap.status.success()); assert!(second_bootstrap.status.success()); let restarted_health: Value = serde_json::from_slice(&first_bootstrap.stdout).unwrap(); From ca5b2e73863b4e8ce8ceb71c4a92cbec1998e189 Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 16:42:35 -0400 Subject: [PATCH 10/15] fix(agent): keep Windows owner from retaining hook output pipes --- Cargo.lock | 1 + atomic-cli/Cargo.toml | 3 ++ atomic-cli/src/commands/agent/owner.rs | 34 +++++++++++++++++-- .../tests/database_owner_integration_test.rs | 8 +++-- 4 files changed, 41 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d9680c01..0fc902b0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -210,6 +210,7 @@ dependencies = [ "tokio", "url", "uuid", + "windows-sys 0.61.2", ] [[package]] diff --git a/atomic-cli/Cargo.toml b/atomic-cli/Cargo.toml index 8602e0c8..a60709a4 100644 --- a/atomic-cli/Cargo.toml +++ b/atomic-cli/Cargo.toml @@ -85,6 +85,9 @@ rayon = { workspace = true } # Git interop git2 = { workspace = true } +[target.'cfg(windows)'.dependencies] +windows-sys = { version = "0.61", features = ["Win32_Foundation"] } + [dev-dependencies] tempfile = { workspace = true } serial_test = { workspace = true } diff --git a/atomic-cli/src/commands/agent/owner.rs b/atomic-cli/src/commands/agent/owner.rs index 921b4289..ff3a57af 100644 --- a/atomic-cli/src/commands/agent/owner.rs +++ b/atomic-cli/src/commands/agent/owner.rs @@ -689,7 +689,7 @@ pub(crate) fn start_or_reconnect(repository: &Path) -> anyhow::Result) -> anyhow::Resu } #[cfg(unix)] -fn configure_detached(_command: &mut ProcessCommand) {} +fn configure_detached(_command: &mut ProcessCommand) -> anyhow::Result<()> { + Ok(()) +} #[cfg(windows)] -fn configure_detached(command: &mut ProcessCommand) { +fn configure_detached(command: &mut ProcessCommand) -> anyhow::Result<()> { + use std::os::windows::io::AsRawHandle; use std::os::windows::process::CommandExt; + use windows_sys::Win32::Foundation::{ + SetHandleInformation, HANDLE_FLAG_INHERIT, INVALID_HANDLE_VALUE, + }; + + // Rust's Windows spawn inherits every inheritable handle, even when the + // child's configured stdio is NUL. A hook's inherited output pipes would + // therefore stay open in the long-lived owner after the hook exits, making + // callers wait forever for EOF. Clear inheritance on the original handles; + // explicit Stdio::inherit() still works by duplicating them during spawn. + for handle in [ + std::io::stdin().as_raw_handle(), + std::io::stdout().as_raw_handle(), + std::io::stderr().as_raw_handle(), + ] { + if handle.is_null() || handle == INVALID_HANDLE_VALUE { + continue; + } + // SAFETY: These are borrowed standard handles. This only clears an + // inheritance flag; it neither closes nor transfers ownership of them. + if unsafe { SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0) } == 0 { + return Err(std::io::Error::last_os_error()) + .context("failed to prevent database owner from inheriting caller stdio"); + } + } const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200; const DETACHED_PROCESS: u32 = 0x0000_0008; command.creation_flags(CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS); + Ok(()) } #[cfg(test)] diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 6ef99805..ae026a78 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -41,10 +41,14 @@ fn wait_for_output(mut child: Child, operation: &str) -> Output { }; let stdout = stdout .recv_timeout(Duration::from_secs(2)) - .expect("child stdout stayed open"); + .unwrap_or_else(|error| { + panic!("{operation}: child exited with {status}, but stdout stayed open: {error}") + }); let stderr = stderr .recv_timeout(Duration::from_secs(2)) - .expect("child stderr stayed open"); + .unwrap_or_else(|error| { + panic!("{operation}: child exited with {status}, but stderr stayed open: {error}") + }); assert!( !timed_out, "{operation} timed out after 30s; stdout: {}; stderr: {}", From b8f8c140a7ad34ff0f5833bf353e64edb696fe7f Mon Sep 17 00:00:00 2001 From: Vincent Date: Wed, 9 Sep 2026 16:53:12 -0400 Subject: [PATCH 11/15] test(agent): wait for owner lock release before reopening redb --- .../tests/database_owner_integration_test.rs | 33 +++++++++++-------- docs/redb-provenance-validation.md | 24 ++++++++++++-- 2 files changed, 41 insertions(+), 16 deletions(-) diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index ae026a78..5f0de87b 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -8,6 +8,7 @@ use atomic_agent::{ProvenanceAccumulator, ProvenanceJournalEnvelope, ProvenanceJ use atomic_core::types::{Base32, Hash}; use atomic_repository::redb_change_store::RedbChangeStore; use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; +use fs2::FileExt; use serde_json::Value; use tempfile::TempDir; @@ -272,14 +273,30 @@ fn read_only_turn_does_not_reuse_its_goal_for_the_next_turn_across_agents() { } fn wait_for_shutdown(repository: &std::path::Path) { + // A failed ping only proves the endpoint is unavailable. The runtime may + // still be draining tasks and closing redb, especially on Windows. The + // owner releases its election lock only after that cleanup is complete. + let path = Repository::canonical_dot_dir(repository) + .unwrap() + .join("changes-owner.lock"); + let lock = std::fs::OpenOptions::new() + .read(true) + .write(true) + .open(path) + .unwrap(); let deadline = Instant::now() + Duration::from_secs(5); loop { - if !run_owner(repository, "ping").status.success() { - return; + match lock.try_lock_exclusive() { + Ok(()) => { + FileExt::unlock(&lock).unwrap(); + return; + } + Err(error) if error.raw_os_error() == fs2::lock_contended_error().raw_os_error() => {} + Err(error) => panic!("failed to inspect database-owner shutdown: {error}"), } assert!( Instant::now() < deadline, - "database owner did not shut down" + "database owner did not release its lock after shutdown" ); thread::sleep(Duration::from_millis(25)); } @@ -389,7 +406,6 @@ fn concurrent_hooks_commit_lossless_envelopes_without_output_or_drops() { let shutdown = run_owner(&repository, "shutdown"); assert!(shutdown.status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let store = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) @@ -625,7 +641,6 @@ fn lifecycle_stop_resume_zombie_abandon_and_lease_expiry() { assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let store = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) .unwrap(); @@ -691,7 +706,6 @@ fn owner_death_before_and_after_event_commit_retries_exactly_once() { assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let store = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) .unwrap(); @@ -731,7 +745,6 @@ fn owner_death_after_checkpoint_prepare_and_bind_recovers_in_hook_process() { .success()); assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); std::fs::write(repository.join("crash.txt"), b"recover\n").unwrap(); let marker = temp.path().join(format!("{failpoint}.marker")); @@ -753,7 +766,6 @@ fn owner_death_after_checkpoint_prepare_and_bind_recovers_in_hook_process() { assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let store = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) .unwrap(); @@ -881,7 +893,6 @@ fn legacy_graph_pending_delta_imports_once_then_json_authority_is_removed() { assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let redb = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) .unwrap(); let turn = redb @@ -972,7 +983,6 @@ fn turn_end_publishes_one_checkpoint_turn_and_advances_head() { assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let redb = RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) .unwrap(); @@ -1051,7 +1061,6 @@ fn pre_cutover_session_count_gap_publishes_at_next_ledger_ordinal() { ); assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let repo = Repository::open(&repository).unwrap(); let (_, turns) = repo.get_session_ledger("legacy-gap").unwrap().unwrap(); @@ -1103,7 +1112,6 @@ fn crashing_second_checkpoint_keeps_first_turn_immutable() { .success()); assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); std::fs::write(repository.join("second.txt"), b"second\n").unwrap(); let marker = temp.path().join("second-bind.marker"); let mut owner = spawn_owner_with_failpoint(&repository, "after-checkpoint-bind", &marker); @@ -1121,7 +1129,6 @@ fn crashing_second_checkpoint_keeps_first_turn_immutable() { assert!(!owner.wait().unwrap().success()); assert!(run_owner(&repository, "shutdown").status.success()); wait_for_shutdown(&repository); - thread::sleep(Duration::from_millis(100)); let repo = Repository::open(&repository).unwrap(); let (_, turns) = repo.get_session_ledger("immutable-turns").unwrap().unwrap(); diff --git a/docs/redb-provenance-validation.md b/docs/redb-provenance-validation.md index 1a83f28d..08f91129 100644 --- a/docs/redb-provenance-validation.md +++ b/docs/redb-provenance-validation.md @@ -34,6 +34,24 @@ to idle. Repeated Stop events after completion do not create extra checkpoints. The regression test covers Codex, Claude Code, and OpenCode, asserting separate goals, linked provenance hashes, and the absence of a change in the first turn. +### Windows owners retained hook output pipes + +Windows CI hung in every owner integration test. Bounded subprocess diagnostics +showed that the calling processes had already exited, but their stdout pipes +remained open. The detached owner had inherited the caller's original standard +handles even though its own standard streams were redirected to NUL. + +The owner bootstrap now clears `HANDLE_FLAG_INHERIT` on the caller's standard +handles before spawning. Explicit standard-stream inheritance remains available +through Rust's normal handle duplication. This follows the Windows behavior +of [Rust's process spawning](https://github.com/rust-lang/rust/issues/161158). +After this fix, the Windows suite no longer hung and seven owner tests passed. +The remaining four failures exposed a test shutdown race: a failed ping and a +fixed 100 ms sleep did not guarantee that redb had closed. Tests now wait for +the owner election lock to be released, which follows runtime/database cleanup. +Child commands and output collection have deadlines so future failures remain +diagnosable. + ### Existing checks needed two small corrections - The database owner lock now explicitly uses `truncate(false)`, satisfying @@ -76,7 +94,7 @@ that it eventually published the expected session ledger. writers of `pristine.redb`. The owner service separately owns `changes.redb`. - Harness checks invoke actual hook CLI processes with fixture payloads and transcripts. They do not run paid model sessions or validate every host UI. -- This run covers macOS ARM64. Linux, Windows, and the Rust 1.90 MSRV need CI - validation before release. The draft PR targets `dev` so the existing CI workflow can validate the - complete owner-journal cutover together with these fixes. +- The local totals above cover macOS ARM64. PR CI additionally exercises + Linux, Windows, and the Rust 1.90 MSRV. Release readiness requires the checks + on the final code revision to pass; current results are tracked on the PR. - redb 5.0 evaluation and Git–Atomic bridge integration remain separate tasks. From 82f488b0164086decf720569fe34bdced4e1a398 Mon Sep 17 00:00:00 2001 From: Vincent Date: Tue, 15 Sep 2026 17:55:16 -0400 Subject: [PATCH 12/15] fix(agent): harden redb 4.2 provenance checkpoints and batch writes Page frozen journals within the owner response limit, recover previously recorded changes when Stop publication retries, coordinate concurrent Stop publishers, and commit each provenance RPC batch in one durable transaction. Export the recorded follow-ups from Atomic view fix/redb-provenance-validation (ATOM::vince::2, ::5, ::8). Recorded source tip: PTLCNMZQNEAMBLVWV6VI2MXWUM7RXTU7KFXB57IZC6F6MN3XL33Q. Include regression tests, benchmark drivers, and measured results. Preserve PR #190's redb 4.2 dependency and existing history; no bridge integration or redb 5 implementation is imported. --- atomic-agent/src/record/mod.rs | 32 +- .../src/turn/orchestrator/provenance.rs | 53 +- atomic-agent/src/turn/orchestrator/turn.rs | 57 ++ atomic-cli/src/commands/agent/owner.rs | 410 ++++++++++-- .../tests/database_owner_integration_test.rs | 583 ++++++++++++++++++ atomic-repository/src/error.rs | 16 + .../src/redb_change_store/mod.rs | 6 +- .../src/redb_change_store/provenance.rs | 277 +++++++-- .../src/redb_change_store/tests.rs | 217 +++++++ atomic-repository/src/repository/mod.rs | 40 +- atomic-repository/src/repository/sandbox.rs | 2 +- .../tests/database_open_wait_test.rs | 46 ++ .../tests/provenance_checkpoint_test.rs | 143 ++++- docs/concurrent-stop-publication.md | 120 ++++ docs/provenance-pagination.md | 127 ++++ docs/provenance-transaction-batching.md | 94 +++ tools/provenance-eval/multi_session.py | 249 ++++++++ .../results/concurrent-stop-2026-09-11.json | 556 +++++++++++++++++ .../results/concurrent-stop-2026-09-11.tar.gz | Bin 0 -> 270954 bytes .../transaction-batching-2026-09-11.json | 196 ++++++ .../transaction-batching-2026-09-11.tar.gz | Bin 0 -> 242481 bytes tools/provenance-eval/run.py | 373 +++++++++++ 22 files changed, 3468 insertions(+), 129 deletions(-) create mode 100644 atomic-repository/tests/database_open_wait_test.rs create mode 100644 docs/concurrent-stop-publication.md create mode 100644 docs/provenance-pagination.md create mode 100644 docs/provenance-transaction-batching.md create mode 100644 tools/provenance-eval/multi_session.py create mode 100644 tools/provenance-eval/results/concurrent-stop-2026-09-11.json create mode 100644 tools/provenance-eval/results/concurrent-stop-2026-09-11.tar.gz create mode 100644 tools/provenance-eval/results/transaction-batching-2026-09-11.json create mode 100644 tools/provenance-eval/results/transaction-batching-2026-09-11.tar.gz create mode 100644 tools/provenance-eval/run.py diff --git a/atomic-agent/src/record/mod.rs b/atomic-agent/src/record/mod.rs index 5888a056..88e637f1 100644 --- a/atomic-agent/src/record/mod.rs +++ b/atomic-agent/src/record/mod.rs @@ -139,14 +139,16 @@ pub fn record_turn( options: &TurnRecordOptions<'_>, ) -> AgentResult { // Step 1: Open the repository read-only for the initial status check. - // This avoids blocking on the redb write lock — we only need read access - // to decide whether there's work to do and which files are untracked. - let mut repo = atomic_repository::Repository::open_readonly(repo_root).map_err(|e| { - AgentError::RecordFailed { - session_id: options.session.session_id.clone(), - turn_number: options.turn_number, - reason: format!("Failed to open repository (readonly): {}", e), - } + // This can coexist with other readers. Wait for a transient incompatible + // writer before deciding whether work or untracked files exist. + let mut repo = atomic_repository::Repository::open_readonly_wait( + repo_root, + std::time::Duration::from_secs(10), + ) + .map_err(|e| AgentError::RecordFailed { + session_id: options.session.session_id.clone(), + turn_number: options.turn_number, + reason: format!("Failed to open repository (readonly): {}", e), })?; // `status()` reads current_view, while `record()` writes to session.view_name. @@ -200,12 +202,14 @@ pub fn record_turn( // skips the table-init `begin_write()` that `open()` does — the tables // already exist and that write lock is the primary cause of hook hangs // when another process holds a transaction. - let mut repo = atomic_repository::Repository::open_existing(repo_root).map_err(|e| { - AgentError::RecordFailed { - session_id: options.session.session_id.clone(), - turn_number: options.turn_number, - reason: format!("Failed to open repository for recording: {}", e), - } + let mut repo = atomic_repository::Repository::open_existing_wait( + repo_root, + std::time::Duration::from_secs(10), + ) + .map_err(|e| AgentError::RecordFailed { + session_id: options.session.session_id.clone(), + turn_number: options.turn_number, + reason: format!("Failed to open repository for recording: {}", e), })?; // Keep the write handle on the same view for post-add status and record. diff --git a/atomic-agent/src/turn/orchestrator/provenance.rs b/atomic-agent/src/turn/orchestrator/provenance.rs index 634a9690..0e03f0f8 100644 --- a/atomic-agent/src/turn/orchestrator/provenance.rs +++ b/atomic-agent/src/turn/orchestrator/provenance.rs @@ -646,17 +646,33 @@ impl TurnOrchestrator { return Ok(()); }; - let (previous_provenance, ledger_turn_number) = - atomic_repository::Repository::open_existing(&self.repo_root) - .ok() - .and_then(|repository| repository.get_session_ledger(session_id).ok().flatten()) - .map(|(_, turns)| { - ( - turns.last().map(|turn| turn.provenance_hash), - turns.len() as u32, - ) - }) - .unwrap_or((None, 0)); + // A failed read must not masquerade as a new session, which would + // bind a checkpoint with a missing predecessor. Release this handle + // before replaying the journal and opening for publication. + let ledger = { + let repository = atomic_repository::Repository::open_readonly_wait( + &self.repo_root, + std::time::Duration::from_secs(10), + ) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; + repository.get_session_ledger(session_id).map_err(|error| { + AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + } + })? + }; + let (previous_provenance, ledger_turn_number) = ledger + .map(|(_, turns)| { + ( + turns.last().map(|turn| turn.provenance_hash), + turns.len() as u32, + ) + }) + .unwrap_or((None, 0)); let source = super::JournalCheckpointSource { agent_name: session.agent_name.clone(), agent_display_name: session.agent_display_name.clone(), @@ -806,13 +822,14 @@ impl TurnOrchestrator { } }; - let repository = - atomic_repository::Repository::open_existing(&self.repo_root).map_err(|error| { - AgentError::ProvenanceJournalFailed { - session_id: session_id.to_string(), - reason: error.to_string(), - } - })?; + let repository = atomic_repository::Repository::open_existing_wait( + &self.repo_root, + std::time::Duration::from_secs(10), + ) + .map_err(|error| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_string(), + reason: error.to_string(), + })?; let publication = repository .publish_provenance_checkpoint(&graph, session_turn) .map_err(|error| AgentError::ProvenanceJournalFailed { diff --git a/atomic-agent/src/turn/orchestrator/turn.rs b/atomic-agent/src/turn/orchestrator/turn.rs index e0cc5c84..63caa872 100644 --- a/atomic-agent/src/turn/orchestrator/turn.rs +++ b/atomic-agent/src/turn/orchestrator/turn.rs @@ -146,6 +146,12 @@ impl TurnOrchestrator { TurnEndLock::Unavailable => None, }; + // The session lock deduplicates one session's Stops. Independent + // sessions (including sandboxes) still share pristine and must not + // race status/add/record or checkpoint publication. Acquire before + // reading session/status, and retain through publication and save. + let _publication_lock = self.wait_turn_publication_lock(session_id)?; + let mut session = self.load_or_create_session(session_id, &event)?; let has_changes = self.has_working_copy_changes(); @@ -325,6 +331,13 @@ impl TurnOrchestrator { session_id, e ); + if self.journal_sink.is_some() { + // Preserve the active session and durable journal + // for retry; a failed record is not a finished turn. + return Err(e); + } + // Legacy orchestrators without a durable journal + // retain their best-effort recording behavior. dispatch = dispatch.with_warning(format!( "Failed to record turn {}: {}", turn_number, e @@ -400,6 +413,50 @@ impl TurnOrchestrator { Ok(DispatchResult::new(session_id, session.phase)) } + fn wait_turn_publication_lock( + &self, + session_id: &str, + ) -> AgentResult> { + use fs2::FileExt; + let failure = |reason: String| AgentError::ProvenanceJournalFailed { + session_id: session_id.to_owned(), + reason, + }; + let canonical = match atomic_repository::Repository::canonical_dot_dir(&self.repo_root) { + Ok(path) => path, + // Legacy session-only orchestrators can run without a repository. + // A journal-backed Stop must always have canonical coordination. + Err( + atomic_repository::RepositoryError::NotFound { .. } + | atomic_repository::RepositoryError::NotInRepository, + ) if self.journal_sink.is_none() => return Ok(None), + Err(error) => return Err(failure(error.to_string())), + }; + // Never unlink a lock file: waiters must all lock the same inode. + let file = std::fs::OpenOptions::new() + .create(true) + .write(true) + .truncate(false) + .open(canonical.join("turn-publication.lock")) + .map_err(|error| failure(error.to_string()))?; + let start = std::time::Instant::now(); + let timeout = std::time::Duration::from_secs(10); + loop { + match file.try_lock_exclusive() { + Ok(()) => return Ok(Some(TurnEndLockGuard { file })), + Err(error) if super::is_lock_contended(&error) => { + if start.elapsed() >= timeout { + return Err(failure( + "timed out waiting for another Stop to publish; retry this Stop".into(), + )); + } + std::thread::sleep(std::time::Duration::from_millis(10)); + } + Err(error) => return Err(failure(error.to_string())), + } + } + } + fn try_turn_end_lock(&self, session_id: &str) -> TurnEndLock { use fs2::FileExt; diff --git a/atomic-cli/src/commands/agent/owner.rs b/atomic-cli/src/commands/agent/owner.rs index ff3a57af..d1fb7449 100644 --- a/atomic-cli/src/commands/agent/owner.rs +++ b/atomic-cli/src/commands/agent/owner.rs @@ -19,8 +19,9 @@ use atomic_agent::{ use atomic_core::change::session::SessionTurn; use atomic_core::types::Hash; use atomic_repository::redb_change_store::{ - ProvenanceCheckpointAttempt, ProvenanceCheckpointSource, ProvenanceId, ProvenanceTurnState, - RedbChangeStore, StopCause, StopState, StoredProvenanceTurn, + FrozenProvenanceCursor, FrozenProvenancePage, ProvenanceCheckpointAttempt, + ProvenanceCheckpointSource, ProvenanceId, ProvenanceTurnState, RedbChangeStore, StopCause, + StopState, StoredProvenanceTurn, MAX_FROZEN_PAGE_FRAGMENTS, }; use atomic_repository::Repository; use clap::{Args, Subcommand}; @@ -35,6 +36,10 @@ use crate::error::CliResult; const PROTOCOL_VERSION: u16 = 1; const MAX_FRAME_BYTES: usize = 8 * 1024 * 1024; +// A JSON u8 takes at most four bytes including its comma. Reserve 256 bytes +// per fragment for metadata (including 64-bit cursors), plus the next cursor. +const FROZEN_PAGE_BYTES: usize = 1024 * 1024; +const FROZEN_PAGE_METADATA_BYTES: usize = 256 * MAX_FROZEN_PAGE_FRAGMENTS + 256; const OWNER_LOCK_FILE: &str = "changes-owner.lock"; const START_ATTEMPTS: usize = 80; const START_RETRY_DELAY: Duration = Duration::from_millis(25); @@ -120,11 +125,19 @@ enum OwnerRequest { provenance_id: u64, expected_generation: u64, source: ProvenanceCheckpointSource, + #[serde(default)] + reuse_frozen_changes: bool, now: i64, }, LoadFrozenEnvelopes { provenance_id: u64, }, + LoadFrozenEnvelopesPage { + provenance_id: u64, + attempt_generation: u64, + frozen_event_count: u64, + cursor: FrozenProvenanceCursor, + }, BindCheckpointHash { provenance_id: u64, expected_generation: u64, @@ -179,6 +192,9 @@ struct ResponseFrame { pub(crate) enum OwnerResponse { Pong { pid: u32, + // Additive v1 capability: old clients ignore it, old owners omit it. + #[serde(default)] + frozen_envelope_paging: bool, }, ProvenanceTurn { turn: StoredProvenanceTurn, @@ -193,6 +209,9 @@ pub(crate) enum OwnerResponse { FrozenEnvelopes { envelopes: Vec>, }, + FrozenEnvelopesPage { + page: FrozenProvenancePage, + }, CheckpointAcknowledged, TurnLifecycle { turn: Option, @@ -314,6 +333,7 @@ impl ProvenanceJournalSink for OwnerJournalSink { OwnerRequest::PrepareCheckpoint { provenance_id: reservation.provenance_id, expected_generation: reservation.generation, + reuse_frozen_changes: source.change_hashes.is_empty(), source: to_store_checkpoint_source(source), now, }, @@ -335,14 +355,37 @@ impl ProvenanceJournalSink for OwnerJournalSink { ) -> Result>, String> { let repository = self.repository.clone(); let provenance_id = checkpoint.provenance_id; + let attempt_generation = checkpoint.attempt_generation; + let frozen_event_count = checkpoint.frozen_event_count; run_outside_async_runtime(move || { - match request_with_reconnect( - &repository, - OwnerRequest::LoadFrozenEnvelopes { provenance_id }, - )? { - OwnerResponse::FrozenEnvelopes { envelopes } => Ok(envelopes), - other => Err(unexpected_response("load frozen envelopes", other)), + require_frozen_paging(start_or_reconnect(&repository)?)?; + let mut cursor = FrozenProvenanceCursor::default(); + let mut envelopes = Vec::new(); + let mut partial = Vec::new(); + while cursor.seq < frozen_event_count { + let response = request_with_reconnect( + &repository, + OwnerRequest::LoadFrozenEnvelopesPage { + provenance_id, + attempt_generation, + frozen_event_count, + cursor, + }, + )?; + match response { + OwnerResponse::FrozenEnvelopesPage { page } => { + append_frozen_page( + &mut envelopes, + &mut partial, + &mut cursor, + frozen_event_count, + page, + )?; + } + other => return Err(unexpected_response("load frozen envelopes page", other)), + } } + Ok(envelopes) }) .map_err(|error| error.to_string()) } @@ -613,7 +656,7 @@ impl Command for DatabaseOwner { fn print_health(response: OwnerResponse, json: bool) -> CliResult<()> { let pid = match response { - OwnerResponse::Pong { pid } => pid, + OwnerResponse::Pong { pid, .. } => pid, other => return Err(unexpected_response("ping", other).into()), }; let output = HealthOutput { @@ -665,6 +708,67 @@ fn unexpected_response(operation: &str, response: OwnerResponse) -> anyhow::Erro } } +fn require_frozen_paging(response: OwnerResponse) -> anyhow::Result<()> { + match response { + OwnerResponse::Pong { frozen_envelope_paging: true, .. } => Ok(()), + OwnerResponse::Pong { .. } => Err(anyhow!( + "database owner does not support frozen journal pagination; run `atomic agent database-owner shutdown --repository ` with the updated CLI, then retry the Stop hook" + )), + other => Err(unexpected_response("pagination capability", other)), + } +} + +/// Reassemble only complete envelopes, advancing the cursor after a successful +/// page. Retrying an RPC cannot append its bytes twice. +fn append_frozen_page( + envelopes: &mut Vec>, + partial: &mut Vec, + cursor: &mut FrozenProvenanceCursor, + cutoff: u64, + page: FrozenProvenancePage, +) -> anyhow::Result<()> { + let end = FrozenProvenanceCursor { + seq: cutoff, + offset: 0, + }; + if page.next <= *cursor || page.next > end { + return Err(anyhow!("invalid frozen journal page continuation")); + } + let mut position = *cursor; + for fragment in page.fragments { + // Legacy journal records can leave sequence gaps, but never inside an envelope. + if fragment.cursor.seq >= cutoff + || fragment.cursor < position + || (fragment.cursor != position + && (position.offset != 0 || fragment.cursor.offset != 0)) + || (!fragment.complete && fragment.bytes.is_empty()) + { + return Err(anyhow!("invalid frozen journal fragment cursor")); + } + partial.extend_from_slice(&fragment.bytes); + position = if fragment.complete { + envelopes.push(std::mem::take(partial)); + FrozenProvenanceCursor { + seq: fragment.cursor.seq + 1, + offset: 0, + } + } else { + FrozenProvenanceCursor { + seq: fragment.cursor.seq, + offset: partial.len(), + } + }; + } + if page.next < position + || (page.next != position && (position.offset != 0 || page.next.offset != 0)) + || (page.next == end && !partial.is_empty()) + { + return Err(anyhow!("incomplete frozen journal page")); + } + *cursor = page.next; + Ok(()) +} + fn runtime() -> anyhow::Result { tokio::runtime::Builder::new_multi_thread() .enable_all() @@ -854,6 +958,7 @@ fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFram OwnerRequest::Ping => ( OwnerResponse::Pong { pid: std::process::id(), + frozen_envelope_paging: true, }, false, ), @@ -885,36 +990,32 @@ fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFram now, } => { owner_failpoint("before-envelope-commit"); - let mut acknowledgements = Vec::with_capacity(envelopes.len()); - let mut failure = None; - for envelope in envelopes { - match store.append_provenance_envelope( - ProvenanceId::new(provenance_id), - expected_generation, - &envelope.event_id, - &envelope.bytes, - now, - ) { - Ok(stored) => acknowledgements.push(JournalAppendAck { - event_id: stored.event_id, - sequence: stored.seq, - }), - Err(error) => { - failure = Some(error); - break; - } - } - } - match failure { - Some(error) => ( + let batch: Vec<_> = envelopes + .iter() + .map(|envelope| (envelope.event_id.as_str(), envelope.bytes.as_slice())) + .collect(); + match store.append_provenance_envelopes( + ProvenanceId::new(provenance_id), + expected_generation, + &batch, + now, + ) { + Err(error) => ( OwnerResponse::Error { code: "provenance-store".to_string(), message: error.to_string(), }, false, ), - None => { + Ok(stored) => { owner_failpoint("after-envelope-commit"); + let acknowledgements = stored + .into_iter() + .map(|event| JournalAppendAck { + event_id: event.event_id, + sequence: event.seq, + }) + .collect(); ( OwnerResponse::ProvenanceEnvelopesCommitted { acknowledgements }, false, @@ -925,14 +1026,28 @@ fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFram OwnerRequest::PrepareCheckpoint { provenance_id, expected_generation, - source, - now, - } => match store.prepare_provenance_checkpoint( - ProvenanceId::new(provenance_id), - expected_generation, - source, + mut source, + reuse_frozen_changes, now, - ) { + } => match (|| { + let id = ProvenanceId::new(provenance_id); + // A previous Stop may have recorded the change before its journal + // read failed. The retry sees a clean working copy. Recover only + // those frozen hashes, then retain the store's source validation; + // a new nonempty change set must still conflict. + if reuse_frozen_changes && source.change_hashes.is_empty() { + if let Some(turn) = store.get_provenance_turn(id)? { + if turn.generation == expected_generation + && matches!(turn.state, ProvenanceTurnState::Checkpointing) + { + if let Some(attempt) = turn.checkpoint_attempt { + source.change_hashes = attempt.source.change_hashes; + } + } + } + } + store.prepare_provenance_checkpoint(id, expected_generation, source, now) + })() { Ok(attempt) => { owner_failpoint("after-checkpoint-prepare"); (OwnerResponse::CheckpointPrepared { attempt }, false) @@ -962,6 +1077,63 @@ fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFram ), } } + OwnerRequest::LoadFrozenEnvelopesPage { + provenance_id, + attempt_generation, + frozen_event_count, + cursor, + } => { + if cursor != FrozenProvenanceCursor::default() { + owner_failpoint("before-frozen-page-continuation"); + } + // Include the actual escaped request ID in the budget. Reserving the + // worst-case metadata and four bytes per payload byte bounds the + // encoded frame, not merely the event count or raw journal size. + let empty = ResponseFrame { + version: PROTOCOL_VERSION, + request_id: request_id.clone(), + response: OwnerResponse::FrozenEnvelopesPage { + page: FrozenProvenancePage { + fragments: Vec::new(), + next: FrozenProvenanceCursor::default(), + }, + }, + }; + let overhead = serde_json::to_vec(&empty) + .expect("serializable page frame") + .len(); + let budget = (MAX_FRAME_BYTES.saturating_sub(overhead + FROZEN_PAGE_METADATA_BYTES) + / 4) + .min(FROZEN_PAGE_BYTES); + match store.load_frozen_provenance_page( + ProvenanceId::new(provenance_id), + attempt_generation, + frozen_event_count, + cursor, + budget, + ) { + Ok(_) + if std::env::var("ATOMIC_OWNER_FAILPOINT").ok().as_deref() + == Some("frozen-page-unavailable") => + { + ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: "injected frozen page read failure".to_string(), + }, + false, + ) + } + Ok(page) => (OwnerResponse::FrozenEnvelopesPage { page }, false), + Err(error) => ( + OwnerResponse::Error { + code: "provenance-checkpoint".to_string(), + message: error.to_string(), + }, + false, + ), + } + } OwnerRequest::BindCheckpointHash { provenance_id, expected_generation, @@ -1337,6 +1509,166 @@ fn configure_detached(command: &mut ProcessCommand) -> anyhow::Result<()> { mod tests { use super::*; + #[test] + fn frozen_pages_bound_encoded_frames_and_reassemble_large_envelopes() { + let dir = tempfile::tempdir().unwrap(); + let store = RedbChangeStore::open(dir.path().join("journal.redb")).unwrap(); + let turn = store.reserve_provenance_turn("paged", 1, 1).unwrap(); + // Exercise both the fragment-count limit and worst-case JSON expansion. + let mut expected = vec![Vec::new(); 257]; + expected.push(vec![255; 2 * FROZEN_PAGE_BYTES + 17]); + for (index, bytes) in expected.iter().enumerate() { + store + .append_provenance_envelope( + turn.provenance_id, + turn.generation, + &index.to_string(), + bytes, + 2, + ) + .unwrap(); + } + let attempt = store + .prepare_provenance_checkpoint( + turn.provenance_id, + turn.generation, + ProvenanceCheckpointSource { + agent_name: "codex".into(), + agent_display_name: "Codex".into(), + agent_vendor: "openai".into(), + change_hashes: vec![], + previous_provenance: None, + plan_id: None, + ledger_turn_number: 0, + }, + 3, + ) + .unwrap(); + assert!( + serde_json::to_vec(&OwnerResponse::FrozenEnvelopes { + envelopes: expected.clone() + }) + .unwrap() + .len() + > MAX_FRAME_BYTES + ); + for request_id in ["page".to_string(), "\\\"".repeat(1536 * 1024)] { + let mut cursor = FrozenProvenanceCursor::default(); + let mut actual = Vec::new(); + let mut partial = Vec::new(); + let mut pages = 0; + while cursor.seq < attempt.frozen_event_count { + let request = RequestFrame { + version: PROTOCOL_VERSION, + request_id: request_id.clone(), + request: OwnerRequest::LoadFrozenEnvelopesPage { + provenance_id: turn.provenance_id.get(), + attempt_generation: attempt.attempt_generation, + frozen_event_count: attempt.frozen_event_count, + cursor, + }, + }; + // The escaped ID must itself fit in an inbound request. + assert!(serde_json::to_vec(&request).unwrap().len() < MAX_FRAME_BYTES); + let (frame, shutdown) = handle_request(&store, request); + assert!(!shutdown); + assert!(serde_json::to_vec(&frame).unwrap().len() <= MAX_FRAME_BYTES); + let OwnerResponse::FrozenEnvelopesPage { page } = frame.response else { + panic!("expected page") + }; + append_frozen_page( + &mut actual, + &mut partial, + &mut cursor, + attempt.frozen_event_count, + page, + ) + .unwrap(); + pages += 1; + } + assert!(pages >= 4); + assert_eq!(actual, expected); + } + } + + #[test] + fn legacy_owner_requires_an_explicit_restart_for_pagination() { + let old: OwnerResponse = serde_json::from_str(r#"{"Pong":{"pid":42}}"#).unwrap(); + assert!(require_frozen_paging(old) + .unwrap_err() + .to_string() + .contains("database-owner shutdown")); + assert!(require_frozen_paging(OwnerResponse::Pong { + pid: 42, + frozen_envelope_paging: true + }) + .is_ok()); + } + + #[test] + fn checkpoint_read_retry_preserves_source_validation() { + let dir = tempfile::tempdir().unwrap(); + let store = RedbChangeStore::open(dir.path().join("journal.redb")).unwrap(); + let turn = store.reserve_provenance_turn("retry", 1, 1).unwrap(); + let original = ProvenanceCheckpointSource { + agent_name: "codex".into(), + agent_display_name: "Codex".into(), + agent_vendor: "openai".into(), + change_hashes: vec![Hash::of(b"original")], + previous_provenance: None, + plan_id: None, + ledger_turn_number: 0, + }; + let prepared = store + .prepare_provenance_checkpoint(turn.provenance_id, turn.generation, original.clone(), 2) + .unwrap(); + let request = |source, generation, reuse_frozen_changes| { + handle_request( + &store, + RequestFrame { + version: PROTOCOL_VERSION, + request_id: "retry".into(), + request: OwnerRequest::PrepareCheckpoint { + provenance_id: turn.provenance_id.get(), + expected_generation: generation, + source, + reuse_frozen_changes, + now: 3, + }, + }, + ) + .0 + .response + }; + let mut retry = original.clone(); + retry.change_hashes.clear(); + let OwnerResponse::CheckpointPrepared { attempt } = + request(retry.clone(), prepared.attempt_generation, true) + else { + panic!("expected recovery of prepared source") + }; + assert_eq!(attempt, prepared); + assert!(matches!( + request(retry.clone(), turn.generation, true), + OwnerResponse::Error { .. } + )); + assert!(matches!( + request(retry.clone(), prepared.attempt_generation, false), + OwnerResponse::Error { .. } + )); + retry.agent_name = "another-agent".into(); + assert!(matches!( + request(retry, prepared.attempt_generation, true), + OwnerResponse::Error { .. } + )); + let mut changed = original; + changed.change_hashes = vec![Hash::of(b"new change")]; + assert!(matches!( + request(changed, prepared.attempt_generation, true), + OwnerResponse::Error { .. } + )); + } + #[tokio::test] async fn framing_round_trips_request_id_and_version() { let (mut client, mut server) = tokio::io::duplex(4096); diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 5f0de87b..68418f52 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -723,6 +723,95 @@ fn owner_death_before_and_after_event_commit_retries_exactly_once() { } } +#[cfg(unix)] +fn batch_owner_rpc(repository: &std::path::Path, request: &Value) -> std::io::Result { + let dot = std::fs::canonicalize(Repository::canonical_dot_dir(repository).unwrap())?; + let digest = blake3::hash(dot.to_string_lossy().as_bytes()) + .to_hex() + .to_string(); + let mut stream = std::os::unix::net::UnixStream::connect(format!( + "/tmp/atomic-owner-{}.sock", + &digest[..24] + ))?; + stream.set_read_timeout(Some(Duration::from_secs(10)))?; + stream.set_write_timeout(Some(Duration::from_secs(10)))?; + let frame = serde_json::to_vec( + &serde_json::json!({"version":1,"request_id":"batch-regression","request":request}), + )?; + stream.write_all(&(frame.len() as u32).to_be_bytes())?; + stream.write_all(&frame)?; + let mut len = [0; 4]; + stream.read_exact(&mut len)?; + let len = u32::from_be_bytes(len) as usize; + assert!(len <= 8 * 1024 * 1024); + let mut bytes = vec![0; len]; + stream.read_exact(&mut bytes)?; + Ok(serde_json::from_slice(&bytes)?) +} + +#[cfg(unix)] +#[test] +fn owner_batch_crash_retries_the_whole_durable_batch_exactly_once() { + for failpoint in ["before-envelope-commit", "after-envelope-commit"] { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let marker = temp.path().join("batch-crash.marker"); + let mut owner = spawn_owner_with_failpoint(&repository, failpoint, &marker); + wait_for_ping(&repository, &mut owner); + let reserved = reserve(&repository); + let id = reserved["turn"]["provenance_id"].as_u64().unwrap(); + let generation = reserved["turn"]["generation"].as_u64().unwrap(); + let envelopes: Vec<_> = (0..16) + .map(|i| serde_json::json!({"event_id":format!("batch-{i}"),"bytes":[i]})) + .collect(); + let request = serde_json::json!({"AppendProvenanceEnvelopes":{ + "provenance_id":id,"expected_generation":generation,"envelopes":envelopes,"now":1700000001 + }}); + assert!(batch_owner_rpc(&repository, &request).is_err()); + assert!(!wait_for_output(owner, "batch failpoint owner") + .status + .success()); + let path = Repository::canonical_change_store_path(&repository).unwrap(); + let store = RedbChangeStore::open(&path).unwrap(); + let events = store + .load_provenance_envelopes(atomic_repository::redb_change_store::ProvenanceId::new(id)) + .unwrap(); + assert_eq!( + events.len(), + if failpoint == "before-envelope-commit" { + 0 + } else { + 16 + } + ); + drop(store); + + let mut owner = spawn_owner(&repository); + wait_for_ping(&repository, &mut owner); + let retry = batch_owner_rpc(&repository, &request).unwrap(); + let acks = retry["response"]["ProvenanceEnvelopesCommitted"]["acknowledgements"] + .as_array() + .unwrap(); + assert_eq!(acks.len(), 16); + for (i, ack) in acks.iter().enumerate() { + assert_eq!(ack["event_id"], format!("batch-{i}")); + assert_eq!(ack["sequence"], i as u64); + } + assert_eq!(batch_owner_rpc(&repository, &request).unwrap(), retry); + assert!(run_owner(&repository, "shutdown").status.success()); + assert!(wait_for_output(owner, "batch retry owner").status.success()); + let store = RedbChangeStore::open(path).unwrap(); + let events = store + .load_provenance_envelopes(atomic_repository::redb_change_store::ProvenanceId::new(id)) + .unwrap(); + assert_eq!(events.len(), 16); + for (i, event) in events.iter().enumerate() { + assert_eq!(event.envelope, vec![i as u8]); + } + } +} + #[test] fn owner_death_after_checkpoint_prepare_and_bind_recovers_in_hook_process() { for failpoint in ["after-checkpoint-prepare", "after-checkpoint-bind"] { @@ -1022,6 +1111,500 @@ fn turn_end_publishes_one_checkpoint_turn_and_advances_head() { ); } +#[test] +fn concurrent_stops_publish_ordered_ledgers_without_external_serialization() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let begin = run_lifecycle( + &repository, + &[ + "begin", + "--owner", + "test", + "--session", + "coordinator", + "--executor", + "claude-code", + "--view", + "dev", + "--json", + ], + ); + assert!( + begin.status.success(), + "{}", + String::from_utf8_lossy(&begin.stderr) + ); + let sessions: Vec<_> = (0..8).map(|i| format!("concurrent-stop-{i}")).collect(); + for session in &sessions { + let output = run_hook( + &repository, + "session-start", + &serde_json::to_vec(&serde_json::json!({"session_id":session})).unwrap(), + ); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + for round in 0..2 { + for session in &sessions { + let output = run_hook( + &repository, + "user-prompt-submit", + &serde_json::to_vec( + &serde_json::json!({"session_id":session,"prompt":format!("round {round}")}), + ) + .unwrap(), + ); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + // First round includes an actual change. The second is read-only. + if round == 0 { + std::fs::write(repository.join("shared.txt"), "one shared change\n").unwrap(); + } + // Force a transient *database* conflict in addition to simultaneous + // Stops. No test-side Stop lock or retry hides production failures. + let held_repository = Repository::open_existing(&repository).unwrap(); + let gate = std::sync::Arc::new(std::sync::Barrier::new(sessions.len() + 1)); + let mut children = Vec::new(); + for session in &sessions { + let root = repository.clone(); + let session = session.clone(); + let gate = gate.clone(); + children.push(thread::spawn(move || { + gate.wait(); + run_hook( + &root, + "stop", + &serde_json::to_vec(&serde_json::json!({ + "session_id":session,"response":format!("finished {round}") + })) + .unwrap(), + ) + })); + } + gate.wait(); + thread::sleep(Duration::from_millis(200)); + drop(held_repository); + for child in children { + let output = child.join().unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + assert!( + output.stderr.is_empty(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + } + for session in &sessions { + let output = run_hook( + &repository, + "stop", + &serde_json::to_vec(&serde_json::json!({"session_id":session})).unwrap(), + ); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let repo = Repository::open_existing(&repository).unwrap(); + let mut recorded = HashSet::new(); + for session in &sessions { + let (_, turns) = repo.get_session_ledger(session).unwrap().unwrap(); + assert_eq!(turns.len(), 2, "{session}: duplicate or missing checkpoint"); + assert_eq!(turns[1].previous_provenance, Some(turns[0].provenance_hash)); + for (round, turn) in turns.iter().enumerate() { + assert_eq!(turn.turn_number, round as u32); + assert_eq!( + turn.goal.as_deref(), + Some(format!("round {round}").as_str()) + ); + let graph = repo.load_provenance_graph(&turn.provenance_hash).unwrap(); + assert_eq!(graph.previous, turn.previous_provenance); + assert_eq!(graph.session_id, *session); + recorded.extend(turn.change_hashes.iter().copied()); + } + } + assert_eq!(recorded.len(), 1, "one file edit must be recorded once"); +} + +#[test] +fn stop_publication_timeout_preserves_the_active_turn_for_retry() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let payload = br#"{"session_id":"publication-timeout","prompt":"keep this turn"}"#; + assert!(run_hook(&repository, "session-start", payload) + .status + .success()); + assert!(run_hook(&repository, "user-prompt-submit", payload) + .status + .success()); + let file = std::fs::OpenOptions::new() + .create(true) + .write(true) + .truncate(false) + .open(repository.join(".atomic/turn-publication.lock")) + .unwrap(); + file.lock_exclusive().unwrap(); + let output = run_hook(&repository, "stop", payload); + assert!(!output.status.success()); + assert!(String::from_utf8_lossy(&output.stderr).contains("timed out waiting")); + drop(file); + for _ in 0..2 { + let output = run_hook(&repository, "stop", payload); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let repo = Repository::open_existing(&repository).unwrap(); + let (_, turns) = repo + .get_session_ledger("publication-timeout") + .unwrap() + .unwrap(); + assert_eq!(turns.len(), 1); + assert_eq!(turns[0].goal.as_deref(), Some("keep this turn")); +} + +#[test] +fn killed_stop_releases_publication_lock_and_can_be_retried() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let payload = br#"{"session_id":"killed-stop","prompt":"recover my change"}"#; + assert!(run_hook(&repository, "session-start", payload) + .status + .success()); + assert!(run_hook(&repository, "user-prompt-submit", payload) + .status + .success()); + std::fs::write(repository.join("recover.txt"), "durable after retry\n").unwrap(); + // Hold pristine so the real Stop has acquired publication coordination + // but cannot record yet. Kill that process, not a synthetic lock helper. + let held = Repository::open_existing(&repository).unwrap(); + let mut child = Command::new(env!("CARGO_BIN_EXE_atomic")) + .args(["agent", "hooks", "claude-code", "stop", "--foreground"]) + .current_dir(&repository) + .stdin(Stdio::piped()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn() + .unwrap(); + child.stdin.take().unwrap().write_all(payload).unwrap(); + let deadline = Instant::now() + Duration::from_secs(5); + loop { + if let Ok(file) = std::fs::OpenOptions::new() + .write(true) + .open(repository.join(".atomic/turn-publication.lock")) + { + if let Err(error) = file.try_lock_exclusive() { + assert_eq!( + error.raw_os_error(), + fs2::lock_contended_error().raw_os_error() + ); + break; + } + } + assert!( + child.try_wait().unwrap().is_none(), + "Stop exited before acquiring its lock" + ); + assert!( + Instant::now() < deadline, + "Stop never acquired publication lock" + ); + thread::sleep(Duration::from_millis(10)); + } + child.kill().unwrap(); + child.wait().unwrap(); + drop(held); + for _ in 0..2 { + let output = run_hook(&repository, "stop", payload); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + } + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let repo = Repository::open_existing(&repository).unwrap(); + let (_, turns) = repo.get_session_ledger("killed-stop").unwrap().unwrap(); + assert_eq!(turns.len(), 1); + assert_eq!(turns[0].change_hashes.len(), 1); + assert_eq!(turns[0].goal.as_deref(), Some("recover my change")); +} + +fn large_checkpoint_fixture( + agent: &str, + count: usize, + output_bytes: usize, + crash_between_pages: bool, +) { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + let hook = |verb: &str, payload: Value| { + let output = run_agent_hook( + &repository, + agent, + verb, + &serde_json::to_vec(&payload).unwrap(), + ); + assert!( + output.status.success(), + "{agent} {verb}: {}", + String::from_utf8_lossy(&output.stderr) + ); + assert!(output.stdout.is_empty()); + assert!( + output.stderr.is_empty(), + "{agent} {verb}: {}", + String::from_utf8_lossy(&output.stderr) + ); + }; + hook( + "session-start", + serde_json::json!({"session_id":"large-checkpoint"}), + ); + hook( + if agent == "opencode" { + "user-prompt" + } else { + "user-prompt-submit" + }, + serde_json::json!({"session_id":"large-checkpoint","prompt":"Record a large journal"}), + ); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + + // Seed valid, durably committed envelopes using the same store API as the + // owner. Avoid 1024 CLI bootstraps; the actual Stop still runs in a process. + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let turn = store + .get_provenance_turn_for("large-checkpoint", 1) + .unwrap() + .unwrap(); + let mut expected = Vec::new(); + for index in 0..count { + let event_id = format!("large-{index}"); + let output = "x".repeat(output_bytes); + let value = serde_json::json!({ + "schema_version":1,"event_id":event_id,"session_id":"large-checkpoint", + "turn_number":1,"generation":turn.generation,"timestamp_ms":1700000000000_i64 + index as i64, + "event":{"type":"tool","phase":"after","tool_name":"Read","tool_call_id":event_id, + "input":{"path":format!("src/{index}.rs")},"output":output,"status":"completed", + "raw":{"tool_output":output}} + }); + let bytes = serde_json::to_vec(&value).unwrap(); + ProvenanceJournalEnvelope::from_json_bytes(&bytes).unwrap(); + store + .append_provenance_envelope(turn.provenance_id, turn.generation, &event_id, &bytes, 2) + .unwrap(); + expected.push(bytes); + } + if count == 1024 { + assert!(serde_json::to_vec(&expected).unwrap().len() > 8 * 1024 * 1024); + } else { + assert!( + expected[0].len() > 1024 * 1024, + "single envelope must span pages" + ); + } + drop(store); + let marker = temp.path().join("page-retry.marker"); + let mut crashing_owner = if crash_between_pages { + let mut owner = + spawn_owner_with_failpoint(&repository, "before-frozen-page-continuation", &marker); + wait_for_ping(&repository, &mut owner); + Some(owner) + } else { + None + }; + std::fs::write(repository.join("large.txt"), b"large checkpoint\n").unwrap(); + let stop = serde_json::json!({"session_id":"large-checkpoint","reason":"end_turn", + "response":"Completed","last_assistant_message":"Completed"}); + hook("stop", stop.clone()); + if let Some(owner) = &mut crashing_owner { + assert!(marker.exists(), "must crash after the first page was read"); + assert!(!owner.wait().unwrap().success()); + } + let repo = Repository::open(&repository).unwrap(); + let (_, ledger) = repo + .get_session_ledger("large-checkpoint") + .unwrap() + .unwrap(); + assert_eq!(ledger.len(), 1); + let head = repo.get_session_head("large-checkpoint").unwrap(); + drop(repo); + hook("stop", stop); + let repo = Repository::open(&repository).unwrap(); + assert_eq!( + repo.get_session_ledger("large-checkpoint") + .unwrap() + .unwrap() + .1, + ledger + ); + assert_eq!(repo.get_session_head("large-checkpoint").unwrap(), head); + let graph = repo + .load_provenance_graph(&ledger[0].provenance_hash) + .unwrap(); + assert_eq!( + Hash::of(&graph.serialize().unwrap()), + ledger[0].provenance_hash + ); + let tools: HashSet<_> = graph + .nodes + .iter() + .filter_map(|n| n.tool_call_id.as_deref()) + .filter(|id| id.starts_with("large-")) + .collect(); + assert_eq!( + tools.len(), + count, + "published graph must contain every tool event" + ); + for index in 0..count { + assert!(tools.contains(format!("large-{index}").as_str())); + } + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let completed = store + .get_provenance_turn_for("large-checkpoint", 1) + .unwrap() + .unwrap(); + assert!(matches!( + completed.state, + atomic_repository::redb_change_store::ProvenanceTurnState::Completed + )); + let frozen = store + .load_frozen_provenance_envelopes(turn.provenance_id) + .unwrap(); + let actual: Vec<_> = frozen + .into_iter() + .filter(|e| e.event_id.starts_with("large-")) + .map(|e| e.envelope) + .collect(); + assert_eq!( + actual, expected, + "stored bytes and ordering must remain unchanged" + ); +} + +#[test] +fn large_frozen_checkpoint_completes_across_agents() { + for agent in ["codex", "claude-code", "opencode"] { + large_checkpoint_fixture(agent, 1024, 1024, false); + } +} + +#[test] +fn large_envelope_checkpoint_recovers_between_pages() { + large_checkpoint_fixture("claude-code", 1, 600 * 1024, true); +} + +#[test] +fn failed_frozen_read_resumes_recorded_changes_on_next_stop() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + drop(Repository::init(&repository).unwrap()); + assert!(run_hook( + &repository, + "session-start", + br#"{"session_id":"retry-frozen"}"# + ) + .status + .success()); + assert!(run_hook( + &repository, + "user-prompt-submit", + br#"{"session_id":"retry-frozen","prompt":"record before read failure"}"# + ) + .status + .success()); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let marker = temp.path().join("unused.marker"); + let mut owner = spawn_owner_with_failpoint(&repository, "frozen-page-unavailable", &marker); + wait_for_ping(&repository, &mut owner); + std::fs::write(repository.join("retry.txt"), b"preserve this change\n").unwrap(); + let payload = br#"{"session_id":"retry-frozen","response":"complete"}"#; + let failed = run_hook(&repository, "stop", payload); + assert!(!failed.status.success()); + assert!(String::from_utf8_lossy(&failed.stderr).contains("injected frozen page read failure")); + assert!(run_owner(&repository, "shutdown").status.success()); + owner.wait().unwrap(); + wait_for_shutdown(&repository); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let prepared = store + .get_provenance_turn_for("retry-frozen", 1) + .unwrap() + .unwrap() + .checkpoint_attempt + .unwrap(); + assert_eq!(prepared.source.change_hashes.len(), 1); + assert_eq!( + prepared.phase, + atomic_repository::redb_change_store::ProvenanceCheckpointPhase::Prepared + ); + drop(store); + let retry = run_hook(&repository, "stop", payload); + assert!( + retry.status.success(), + "{}", + String::from_utf8_lossy(&retry.stderr) + ); + assert!(retry.stderr.is_empty()); + assert!(run_owner(&repository, "shutdown").status.success()); + wait_for_shutdown(&repository); + let store = + RedbChangeStore::open(Repository::canonical_change_store_path(&repository).unwrap()) + .unwrap(); + let completed = store + .get_provenance_turn_for("retry-frozen", 1) + .unwrap() + .unwrap() + .checkpoint_attempt + .unwrap(); + assert_eq!( + completed.phase, + atomic_repository::redb_change_store::ProvenanceCheckpointPhase::Published + ); + assert_eq!(completed.source, prepared.source); + assert_eq!(completed.frozen_event_count, prepared.frozen_event_count); + assert_eq!(completed.attempt_generation, prepared.attempt_generation); + let repo = Repository::open(&repository).unwrap(); + let (_, ledger) = repo.get_session_ledger("retry-frozen").unwrap().unwrap(); + assert_eq!(ledger.len(), 1); + assert_eq!(ledger[0].change_hashes, prepared.source.change_hashes); +} + #[test] fn pre_cutover_session_count_gap_publishes_at_next_ledger_ordinal() { let temp = TempDir::new().unwrap(); diff --git a/atomic-repository/src/error.rs b/atomic-repository/src/error.rs index 923a97b5..15e6ab90 100644 --- a/atomic-repository/src/error.rs +++ b/atomic-repository/src/error.rs @@ -8,6 +8,18 @@ use crate::remote::RemoteError; /// Result type for repository operations pub type Result = std::result::Result; +impl From for RepositoryError { + fn from(error: atomic_core::pristine::PristineError) -> Self { + if matches!(&error, atomic_core::pristine::PristineError::Database(inner) + if matches!(inner.as_ref(), redb::DatabaseError::DatabaseAlreadyOpen)) + { + Self::DatabaseBusy + } else { + Self::Database(error.to_string()) + } + } +} + /// Errors that can occur during repository operations #[derive(Debug, Error)] pub enum RepositoryError { @@ -177,6 +189,10 @@ pub enum RepositoryError { #[error("Database error: {0}")] Database(String), + /// Another process holds an incompatible pristine database handle. + #[error("Database already open. Cannot acquire lock.")] + DatabaseBusy, + /// Walkdir error (during file traversal) #[error("Directory traversal error: {0}")] WalkDir(#[from] walkdir::Error), diff --git a/atomic-repository/src/redb_change_store/mod.rs b/atomic-repository/src/redb_change_store/mod.rs index 828a28bf..4f9c4f23 100644 --- a/atomic-repository/src/redb_change_store/mod.rs +++ b/atomic-repository/src/redb_change_store/mod.rs @@ -18,9 +18,10 @@ mod queries; pub use batch::StoredSection; pub use provenance::{ + FrozenProvenanceCursor, FrozenProvenanceFragment, FrozenProvenancePage, ProvenanceCheckpointAttempt, ProvenanceCheckpointPhase, ProvenanceCheckpointSource, ProvenanceId, ProvenanceTurnState, StopCause, StopState, StoredProvenanceEnvelope, - StoredProvenanceEvent, StoredProvenanceTurn, + StoredProvenanceEvent, StoredProvenanceTurn, MAX_FROZEN_PAGE_FRAGMENTS, }; pub use queries::{StoreStats, StoredContentChunk}; @@ -105,6 +106,9 @@ pub enum RedbStoreError { #[error("Invalid state transition for provenance turn {id}")] InvalidProvenanceTransition { id: u64 }, + #[error("Invalid frozen journal cursor or page budget for provenance turn {id}")] + InvalidProvenanceCursor { id: u64 }, + #[error("Provenance event id '{event_id}' conflicts in turn {id}")] ProvenanceEventConflict { id: u64, event_id: String }, diff --git a/atomic-repository/src/redb_change_store/provenance.rs b/atomic-repository/src/redb_change_store/provenance.rs index ea9ecd5a..e47c754e 100644 --- a/atomic-repository/src/redb_change_store/provenance.rs +++ b/atomic-repository/src/redb_change_store/provenance.rs @@ -181,6 +181,31 @@ pub struct StoredProvenanceEnvelope { pub envelope: Vec, } +/// Position within a frozen journal. Offsets allow even one large envelope to +/// cross transport pages without changing its persisted bytes. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +pub struct FrozenProvenanceCursor { + pub seq: u64, + pub offset: usize, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct FrozenProvenanceFragment { + pub cursor: FrozenProvenanceCursor, + pub bytes: Vec, + pub complete: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct FrozenProvenancePage { + pub fragments: Vec, + /// The exclusive freeze cutoff with offset zero denotes the end. + pub next: FrozenProvenanceCursor, +} + +/// Bound metadata as well as payloads, including journals of empty envelopes. +pub const MAX_FROZEN_PAGE_FRAGMENTS: usize = 256; + #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] enum StoredJournalRecord { Legacy(StoredProvenanceEvent), @@ -470,67 +495,102 @@ impl RedbChangeStore { envelope: &[u8], now: i64, ) -> RedbStoreResult { + let mut stored = self.append_provenance_envelopes( + id, + expected_generation, + &[(event_id, envelope)], + now, + )?; + Ok(stored.remove(0)) + } + + /// Append a batch in one durable transaction, with acknowledgments in input order. + /// + /// All new events and the sequence frontier commit together, or none do on error. + /// Duplicate IDs return the original stored bytes and sequence, including duplicates + /// earlier in this batch. As with single-event retries, existing IDs can be + /// acknowledged after the turn is fenced; any new event must pass the fence. + /// Empty and entirely duplicate batches perform no durable commit. + pub fn append_provenance_envelopes( + &self, + id: ProvenanceId, + expected_generation: u64, + envelopes: &[(&str, &[u8])], + now: i64, + ) -> RedbStoreResult> { + if envelopes.is_empty() { + return Ok(Vec::new()); + } let txn = self.db.begin_write()?; let mut turns = txn.open_table(tables::PROVENANCE_TURNS)?; let mut events = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; let mut event_index = txn.open_table(tables::PROVENANCE_EVENT_INDEX)?; - let id_key = event_id_key(id, event_id); + let mut turn: Option = None; + let mut acknowledgements = Vec::with_capacity(envelopes.len()); + + for &(event_id, envelope) in envelopes { + let id_key = event_id_key(id, event_id); + if let Some(existing_key) = event_index.get(&id_key)? { + let existing = events.get(existing_key.value())?.ok_or_else(|| { + RedbStoreError::Corrupt("event index points to no event".to_string()) + })?; + let StoredJournalRecord::Envelope(stored) = + StoredJournalRecord::from_bytes(existing.value())? + else { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + }; + if stored.event_id != event_id { + return Err(RedbStoreError::ProvenanceEventConflict { + id: id.get(), + event_id: event_id.to_string(), + }); + } + // Event ID is the idempotency contract; retry observation times may differ. + acknowledgements.push(stored); + continue; + } - if let Some(existing_key) = event_index.get(&id_key)? { - let existing = events.get(existing_key.value())?.ok_or_else(|| { - RedbStoreError::Corrupt("event index points to no event".to_string()) - })?; - let StoredJournalRecord::Envelope(stored) = - StoredJournalRecord::from_bytes(existing.value())? - else { - return Err(RedbStoreError::ProvenanceEventConflict { - id: id.get(), - event_id: event_id.to_string(), - }); - }; - if stored.event_id != event_id { - return Err(RedbStoreError::ProvenanceEventConflict { - id: id.get(), - event_id: event_id.to_string(), - }); + if turn.is_none() { + let loaded = load_turn(&turns, id)?; + ensure_generation(&loaded, expected_generation)?; + if !matches!(loaded.state, ProvenanceTurnState::Running) { + return Err(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "running", + }); + } + turn = Some(loaded); } - // The stable event ID is the idempotency contract. Hook payloads - // often omit source timestamps, so a process-level retry can carry - // a different observation time; return the first committed bytes. - return Ok(stored); + let turn = turn.as_mut().expect("new envelope loaded the turn"); + let seq = turn.next_event_seq; + turn.next_event_seq = seq + .checked_add(1) + .ok_or(RedbStoreError::ProvenanceEventSequenceExhausted { id: id.get() })?; + let stored = StoredProvenanceEnvelope { + event_id: event_id.to_string(), + seq, + envelope: envelope.to_vec(), + }; + let key = encode_session_event_key(id.get(), seq); + let event_bytes = StoredJournalRecord::Envelope(stored.clone()).to_bytes()?; + events.insert(&key, event_bytes.as_slice())?; + event_index.insert(&id_key, &key)?; + acknowledgements.push(stored); } - let mut turn = load_turn(&turns, id)?; - ensure_generation(&turn, expected_generation)?; - if !matches!(turn.state, ProvenanceTurnState::Running) { - return Err(RedbStoreError::InvalidProvenanceState { - id: id.get(), - expected: "running", - }); + if let Some(mut turn) = turn { + turn.updated_at = now; + let turn_bytes = turn.to_bytes()?; + turns.insert(id.get(), turn_bytes.as_slice())?; + drop(event_index); + drop(events); + drop(turns); + txn.commit()?; } - - let seq = turn.next_event_seq; - let stored = StoredProvenanceEnvelope { - event_id: event_id.to_string(), - seq, - envelope: envelope.to_vec(), - }; - let key = encode_session_event_key(id.get(), seq); - let event_bytes = StoredJournalRecord::Envelope(stored.clone()).to_bytes()?; - events.insert(&key, event_bytes.as_slice())?; - event_index.insert(&id_key, &key)?; - - turn.next_event_seq = seq - .checked_add(1) - .ok_or(RedbStoreError::ProvenanceEventSequenceExhausted { id: id.get() })?; - turn.updated_at = now; - let turn_bytes = turn.to_bytes()?; - turns.insert(id.get(), turn_bytes.as_slice())?; - drop(event_index); - drop(events); - drop(turns); - txn.commit()?; - Ok(stored) + Ok(acknowledgements) } /// Load serialized lossless envelope entries in committed sequence order. @@ -681,6 +741,119 @@ impl RedbChangeStore { Ok(result) } + /// Read a bounded part of the persisted checkpoint. Every page validates the + /// same attempt generation and cutoff in its own read transaction, so a + /// retry or owner restart needs no process-local cursor state. + pub fn load_frozen_provenance_page( + &self, + id: ProvenanceId, + attempt_generation: u64, + frozen_event_count: u64, + cursor: FrozenProvenanceCursor, + max_bytes: usize, + ) -> RedbStoreResult { + let invalid_cursor = || RedbStoreError::InvalidProvenanceCursor { id: id.get() }; + if max_bytes == 0 || cursor.seq > frozen_event_count { + return Err(invalid_cursor()); + } + let txn = self.db.begin_read()?; + let turns = txn.open_table(tables::PROVENANCE_TURNS)?; + let turn = turns + .get(id.get())? + .ok_or(RedbStoreError::ProvenanceTurnNotFound { id: id.get() })?; + let turn = StoredProvenanceTurn::from_bytes(turn.value())?; + let attempt = turn + .checkpoint_attempt + .ok_or(RedbStoreError::InvalidProvenanceState { + id: id.get(), + expected: "checkpoint prepared", + })?; + if attempt.attempt_generation != attempt_generation { + return Err(RedbStoreError::ProvenanceFenced { + id: id.get(), + expected: attempt_generation, + actual: attempt.attempt_generation, + }); + } + if attempt.frozen_event_count != frozen_event_count { + return Err(RedbStoreError::ProvenanceCheckpointConflict { id: id.get() }); + } + let end_cursor = FrozenProvenanceCursor { + seq: frozen_event_count, + offset: 0, + }; + if cursor.seq == frozen_event_count { + if cursor.offset != 0 { + return Err(invalid_cursor()); + } + return Ok(FrozenProvenancePage { + fragments: Vec::new(), + next: end_cursor, + }); + } + let table = txn.open_table(tables::PROVENANCE_JOURNAL_EVENTS)?; + let start = encode_session_event_key(id.get(), cursor.seq); + let end = encode_session_event_key(id.get(), frozen_event_count - 1); + let mut fragments = Vec::new(); + let mut remaining = max_bytes; + for entry in table.range::<&[u8; 16]>(&start..=&end)? { + let (_, value) = entry?; + let record = StoredJournalRecord::from_bytes(value.value())?; + let stored = match record { + StoredJournalRecord::Envelope(stored) => stored, + StoredJournalRecord::Legacy(stored) => { + if stored.seq == cursor.seq && cursor.offset != 0 { + return Err(invalid_cursor()); + } + continue; + } + }; + if fragments.is_empty() && cursor.offset != 0 && stored.seq != cursor.seq { + return Err(invalid_cursor()); + } + let offset = if stored.seq == cursor.seq { + cursor.offset + } else { + 0 + }; + if offset > stored.envelope.len() || (offset != 0 && offset == stored.envelope.len()) { + return Err(invalid_cursor()); + } + let length = remaining.min(stored.envelope.len() - offset); + let complete = offset + length == stored.envelope.len(); + let next = if complete { + FrozenProvenanceCursor { + seq: stored.seq + 1, + offset: 0, + } + } else { + FrozenProvenanceCursor { + seq: stored.seq, + offset: offset + length, + } + }; + fragments.push(FrozenProvenanceFragment { + cursor: FrozenProvenanceCursor { + seq: stored.seq, + offset, + }, + bytes: stored.envelope[offset..offset + length].to_vec(), + complete, + }); + remaining -= length; + if remaining == 0 || fragments.len() == MAX_FROZEN_PAGE_FRAGMENTS { + return Ok(FrozenProvenancePage { fragments, next }); + } + } + if fragments.is_empty() && cursor.offset != 0 { + return Err(invalid_cursor()); + } + Ok(FrozenProvenancePage { + fragments, + next: end_cursor, + }) + } + /// Bind the prepared graph hash and exact immutable session turn once. pub fn bind_provenance_checkpoint_hash( &self, diff --git a/atomic-repository/src/redb_change_store/tests.rs b/atomic-repository/src/redb_change_store/tests.rs index d9a1228c..b0425a3e 100644 --- a/atomic-repository/src/redb_change_store/tests.rs +++ b/atomic-repository/src/redb_change_store/tests.rs @@ -638,6 +638,223 @@ fn provenance_events_are_ordered_idempotent_and_fenced() { )); } +#[test] +fn envelope_batch_preserves_order_duplicates_and_reopen() { + let (dir, store) = temp_store(); + let turn = store.reserve_provenance_turn("batch", 1, 1).unwrap(); + let first = store + .append_provenance_envelope(turn.provenance_id, turn.generation, "old", b"original", 2) + .unwrap(); + let batch: &[(&str, &[u8])] = &[ + ("a", b"first a"), + ("old", b"retry"), + ("b", b"b"), + ("a", b"later a"), + ]; + let ack = store + .append_provenance_envelopes(turn.provenance_id, turn.generation, batch, 3) + .unwrap(); + assert_eq!(ack.iter().map(|e| e.seq).collect::>(), [1, 0, 2, 1]); + assert_eq!(ack[1], first); + assert_eq!(ack[0], ack[3]); + assert_eq!(ack[0].envelope, b"first a"); + drop(store); + let store = RedbChangeStore::open(dir.path().join("test_change_store.redb")).unwrap(); + assert_eq!( + store.load_provenance_envelopes(turn.provenance_id).unwrap(), + vec![first, ack[0].clone(), ack[2].clone()] + ); + // Stale-generation duplicates remain valid retries, even after a lifecycle fence. + store + .stop_provenance_turn( + turn.provenance_id, + turn.generation, + StopState { + cause: StopCause::ProcessExited, + observed_at: 4, + last_event_seq: Some(2), + resumable: true, + }, + ) + .unwrap(); + assert_eq!( + store + .append_provenance_envelopes(turn.provenance_id, turn.generation, batch, 5) + .unwrap(), + ack + ); + assert!(store + .append_provenance_envelopes( + turn.provenance_id, + turn.generation, + &[("a", b"retry"), ("new", b"new")], + 6 + ) + .is_err()); + assert_eq!( + store + .load_provenance_envelopes(turn.provenance_id) + .unwrap() + .len(), + 3 + ); + assert!(store + .append_provenance_envelopes(turn.provenance_id, turn.generation, &[], 7) + .unwrap() + .is_empty()); +} + +#[test] +fn envelope_batch_rolls_back_earlier_events_on_legacy_conflict() { + let (_dir, store) = temp_store(); + let turn = store + .reserve_provenance_turn("batch-conflict", 1, 1) + .unwrap(); + store + .append_provenance_event( + turn.provenance_id, + turn.generation, + "legacy", + provenance_event("legacy"), + 2, + ) + .unwrap(); + let before = store + .get_provenance_turn_for("batch-conflict", 1) + .unwrap() + .unwrap(); + assert!(matches!( + store.append_provenance_envelopes( + turn.provenance_id, + turn.generation, + &[("new", b"new"), ("legacy", b"invalid")], + 3 + ), + Err(RedbStoreError::ProvenanceEventConflict { .. }) + )); + assert!(store + .load_provenance_envelopes(turn.provenance_id) + .unwrap() + .is_empty()); + assert_eq!( + store + .get_provenance_turn_for("batch-conflict", 1) + .unwrap() + .unwrap(), + before + ); + let retried = store + .append_provenance_envelope(turn.provenance_id, turn.generation, "new", b"new", 4) + .unwrap(); + assert_eq!( + retried.seq, 1, + "failed batch must leave neither index entry nor sequence gap" + ); +} + +#[test] +fn envelope_batch_sequence_exhaustion_rolls_back_the_entire_batch() { + let (_dir, store) = temp_store(); + let mut turn = store + .reserve_provenance_turn("batch-overflow", 1, 1) + .unwrap(); + turn.next_event_seq = u64::MAX - 1; + let tx = store.db.begin_write().unwrap(); + { + let mut table = tx.open_table(tables::PROVENANCE_TURNS).unwrap(); + table + .insert( + turn.provenance_id.get(), + postcard::to_allocvec(&turn).unwrap().as_slice(), + ) + .unwrap(); + } + tx.commit().unwrap(); + assert!(matches!( + store.append_provenance_envelopes( + turn.provenance_id, + turn.generation, + &[("a", b"a"), ("b", b"b")], + 2 + ), + Err(RedbStoreError::ProvenanceEventSequenceExhausted { .. }) + )); + assert!(store + .load_provenance_envelopes(turn.provenance_id) + .unwrap() + .is_empty()); + assert_eq!( + store + .get_provenance_turn_for("batch-overflow", 1) + .unwrap() + .unwrap(), + turn + ); + assert_eq!( + store + .append_provenance_envelope(turn.provenance_id, turn.generation, "a", b"a", 3) + .unwrap() + .seq, + u64::MAX - 1 + ); +} + +#[test] +fn envelope_batch_and_checkpoint_have_no_partial_frontier() { + let (_dir, store) = temp_store(); + for iteration in 0..16 { + let turn = store + .reserve_provenance_turn(&format!("batch-race-{iteration}"), 1, 1) + .unwrap(); + let barrier = std::sync::Barrier::new(2); + let (append, checkpoint) = std::thread::scope(|scope| { + let append = scope.spawn(|| { + barrier.wait(); + let names: Vec<_> = (0..16).map(|i| format!("event-{i}")).collect(); + let batch: Vec<_> = names + .iter() + .map(|id| (id.as_str(), id.as_bytes())) + .collect(); + store.append_provenance_envelopes(turn.provenance_id, turn.generation, &batch, 2) + }); + barrier.wait(); + let checkpoint = store + .prepare_provenance_checkpoint( + turn.provenance_id, + turn.generation, + ProvenanceCheckpointSource { + agent_name: "codex".into(), + agent_display_name: "Codex".into(), + agent_vendor: "openai".into(), + change_hashes: vec![], + previous_provenance: None, + plan_id: None, + ledger_turn_number: 0, + }, + 3, + ) + .unwrap(); + (append.join().unwrap(), checkpoint) + }); + let count = match append { + Ok(events) => { + assert_eq!(events.len(), 16); + 16 + } + Err(RedbStoreError::ProvenanceFenced { .. }) => 0, + other => panic!("unexpected batch/checkpoint outcome: {other:?}"), + }; + assert_eq!(checkpoint.frozen_event_count, count); + assert_eq!( + store + .load_provenance_envelopes(turn.provenance_id) + .unwrap() + .len() as u64, + count + ); + } +} + #[test] fn lossless_envelopes_share_sequence_space_and_preserve_legacy_events() { let (_dir, store) = temp_store(); diff --git a/atomic-repository/src/repository/mod.rs b/atomic-repository/src/repository/mod.rs index 485f7498..a92220b5 100644 --- a/atomic-repository/src/repository/mod.rs +++ b/atomic-repository/src/repository/mod.rs @@ -409,7 +409,7 @@ default = "{}" let pristine = Arc::new( Pristine::open_existing(dot_dir.join("pristine.redb")) - .map_err(|e| RepositoryError::Database(e.to_string()))?, + .map_err(RepositoryError::from)?, ); let current_view = @@ -470,7 +470,7 @@ default = "{}" // Open the pristine database in read-only mode let pristine = Arc::new( Pristine::open_readonly(dot_dir.join("pristine.redb")) - .map_err(|e| RepositoryError::Database(e.to_string()))?, + .map_err(RepositoryError::from)?, ); // Read current view from config or use default @@ -497,6 +497,42 @@ default = "{}" Ok(repository) } + /// Open for a short-lived writer, waiting at most `timeout` for an + /// incompatible process handle to close. Other errors return immediately. + /// The caller must not already hold a handle to the same database. + pub fn open_existing_wait>( + path: P, + timeout: std::time::Duration, + ) -> Result { + Self::wait_for_database(timeout, || Self::open_existing(path.as_ref())) + } + + /// Read-only counterpart of [`Self::open_existing_wait`]. + pub fn open_readonly_wait>( + path: P, + timeout: std::time::Duration, + ) -> Result { + Self::wait_for_database(timeout, || Self::open_readonly(path.as_ref())) + } + + fn wait_for_database( + timeout: std::time::Duration, + mut open: impl FnMut() -> Result, + ) -> Result { + let start = std::time::Instant::now(); + loop { + match open() { + Err(RepositoryError::DatabaseBusy) if start.elapsed() < timeout => { + std::thread::sleep( + std::time::Duration::from_millis(10) + .min(timeout.saturating_sub(start.elapsed())), + ); + } + result => return result, + } + } + } + /// Open an existing repository using a pre-opened `Pristine`. /// /// This constructor is used by the storage server to share a single diff --git a/atomic-repository/src/repository/sandbox.rs b/atomic-repository/src/repository/sandbox.rs index cf10e711..adb5cebf 100644 --- a/atomic-repository/src/repository/sandbox.rs +++ b/atomic-repository/src/repository/sandbox.rs @@ -172,7 +172,7 @@ impl Repository { } else { Pristine::open_existing(path) }; - let pristine = Arc::new(pristine.map_err(|e| RepositoryError::Database(e.to_string()))?); + let pristine = Arc::new(pristine.map_err(RepositoryError::from)?); let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY) .map_err(|e| RepositoryError::Database(e.to_string()))?; diff --git a/atomic-repository/tests/database_open_wait_test.rs b/atomic-repository/tests/database_open_wait_test.rs new file mode 100644 index 00000000..70c8b0d8 --- /dev/null +++ b/atomic-repository/tests/database_open_wait_test.rs @@ -0,0 +1,46 @@ +use std::time::{Duration, Instant}; + +use atomic_repository::{Repository, RepositoryError}; + +#[test] +fn database_wait_is_bounded_and_does_not_retry_non_contention_errors() { + let temp = tempfile::TempDir::new().unwrap(); + let root = temp.path().join("repo"); + let held = Repository::init(&root).unwrap(); + let start = Instant::now(); + let result = Repository::open_existing_wait(&root, Duration::from_millis(100)); + assert!(matches!(result, Err(RepositoryError::DatabaseBusy))); + assert!(start.elapsed() >= Duration::from_millis(100)); + assert!(start.elapsed() < Duration::from_secs(2)); + drop(held); + std::fs::write(root.join(".atomic/pristine.redb"), b"corrupt database").unwrap(); + let start = Instant::now(); + let result = Repository::open_existing_wait(&root, Duration::from_secs(10)); + assert!(matches!(result, Err(RepositoryError::Database(_)))); + assert!(start.elapsed() < Duration::from_secs(2)); +} + +#[test] +fn sandbox_database_wait_uses_the_canonical_database() { + let temp = tempfile::TempDir::new().unwrap(); + let root = temp.path().join("repo"); + let sandbox = temp.path().join("sandbox"); + let held = Repository::init(&root).unwrap(); + held.provision_sandbox(&sandbox, "dev").unwrap(); + assert_eq!( + Repository::canonical_dot_dir(&sandbox).unwrap(), + held.dot_dir() + ); + assert!(matches!( + Repository::open_readonly_wait(&sandbox, Duration::ZERO), + Err(RepositoryError::DatabaseBusy) + )); + let opener = std::thread::spawn(move || { + Repository::open_readonly_wait(sandbox, Duration::from_secs(5)).unwrap() + }); + std::thread::sleep(Duration::from_millis(100)); + drop(held); + let opened = opener.join().unwrap(); + assert!(opened.is_sandbox()); + assert_eq!(opened.dot_dir(), root.join(".atomic")); +} diff --git a/atomic-repository/tests/provenance_checkpoint_test.rs b/atomic-repository/tests/provenance_checkpoint_test.rs index 31704898..0594d503 100644 --- a/atomic-repository/tests/provenance_checkpoint_test.rs +++ b/atomic-repository/tests/provenance_checkpoint_test.rs @@ -2,11 +2,150 @@ use atomic_core::change::session::SessionTurn; use atomic_core::change::ProvenanceGraph; use atomic_core::types::Hash; use atomic_repository::redb_change_store::{ - ProvenanceCheckpointPhase, ProvenanceCheckpointSource, ProvenanceTurnState, RedbChangeStore, - RedbStoreError, + FrozenProvenanceCursor, ProvenanceCheckpointPhase, ProvenanceCheckpointSource, + ProvenanceTurnState, RedbChangeStore, RedbStoreError, }; use atomic_repository::{ChangeStore, Repository, DEFAULT_CACHE_CAPACITY}; +#[test] +fn frozen_pages_preserve_bytes_and_retries_across_reopen() { + let temp = tempfile::tempdir().unwrap(); + let path = temp.path().join("journal.redb"); + let store = RedbChangeStore::open(&path).unwrap(); + let turn = store.reserve_provenance_turn("paged", 1, 1).unwrap(); + let expected = vec![ + vec![], + vec![255; 19], + (0..=255).collect::>(), + vec![], + ]; + for (index, bytes) in expected.iter().enumerate() { + // Interleave old-format events: pagination must preserve sequence gaps. + store + .append_provenance_event( + turn.provenance_id, + turn.generation, + &format!("legacy-{index}"), + atomic_core::change::session::SessionEvent { + seq: 0, + timestamp: String::new(), + event_kind: "tool".into(), + place: None, + transition: None, + token_id: String::new(), + token_kind: String::new(), + token_data: String::new(), + record_type: None, + }, + 2, + ) + .unwrap(); + store + .append_provenance_envelope( + turn.provenance_id, + turn.generation, + &format!("envelope-{index}"), + bytes, + 2, + ) + .unwrap(); + } + let attempt = store + .prepare_provenance_checkpoint( + turn.provenance_id, + turn.generation, + ProvenanceCheckpointSource { + agent_name: "codex".into(), + agent_display_name: "Codex".into(), + agent_vendor: "openai".into(), + change_hashes: vec![], + previous_provenance: None, + plan_id: None, + ledger_turn_number: 0, + }, + 3, + ) + .unwrap(); + drop(store); + for budget in [1, 8, 256, 4096] { + let mut cursor = FrozenProvenanceCursor::default(); + let mut actual = Vec::new(); + let mut partial = Vec::new(); + while cursor.seq < attempt.frozen_event_count { + let store = RedbChangeStore::open(&path).unwrap(); + let load = || { + store + .load_frozen_provenance_page( + turn.provenance_id, + attempt.attempt_generation, + attempt.frozen_event_count, + cursor, + budget, + ) + .unwrap() + }; + let page = load(); + assert_eq!(page, load(), "same cursor must return identical bytes"); + assert!(page.next > cursor); + assert!(page.fragments.iter().map(|f| f.bytes.len()).sum::() <= budget); + for fragment in page.fragments { + assert_eq!(fragment.cursor.offset, partial.len()); + partial.extend(fragment.bytes); + if fragment.complete { + actual.push(std::mem::take(&mut partial)); + } + } + cursor = page.next; + } + assert!(partial.is_empty()); + assert_eq!(actual, expected); + } + let store = RedbChangeStore::open(&path).unwrap(); + let load = |generation, cutoff, cursor, budget| { + store.load_frozen_provenance_page(turn.provenance_id, generation, cutoff, cursor, budget) + }; + let generation = attempt.attempt_generation; + let cutoff = attempt.frozen_event_count; + assert!(matches!( + load(generation - 1, cutoff, FrozenProvenanceCursor::default(), 8), + Err(RedbStoreError::ProvenanceFenced { .. }) + )); + assert!(matches!( + load(generation, cutoff - 1, FrozenProvenanceCursor::default(), 8), + Err(RedbStoreError::ProvenanceCheckpointConflict { .. }) + )); + for cursor in [ + FrozenProvenanceCursor { seq: 0, offset: 1 }, // legacy record + FrozenProvenanceCursor { seq: 1, offset: 1 }, // empty envelope + FrozenProvenanceCursor { seq: 3, offset: 19 }, // noncanonical end offset + FrozenProvenanceCursor { + seq: cutoff, + offset: 1, + }, + FrozenProvenanceCursor { + seq: cutoff + 1, + offset: 0, + }, + ] { + assert!(matches!( + load(generation, cutoff, cursor, 8), + Err(RedbStoreError::InvalidProvenanceCursor { .. }) + )); + } + assert!(load(generation, cutoff, FrozenProvenanceCursor::default(), 0).is_err()); + let end = load( + generation, + cutoff, + FrozenProvenanceCursor { + seq: cutoff, + offset: 0, + }, + 8, + ) + .unwrap(); + assert!(end.fragments.is_empty()); +} + #[test] fn legacy_agent_turn_count_is_normalized_to_next_immutable_ledger_ordinal() { let temp = tempfile::tempdir().unwrap(); diff --git a/docs/concurrent-stop-publication.md b/docs/concurrent-stop-publication.md new file mode 100644 index 00000000..3563978f --- /dev/null +++ b/docs/concurrent-stop-publication.md @@ -0,0 +1,120 @@ +# Concurrent Stop checkpoint publication + +Work item: `ATOM::vince::5`, view `fix/redb-provenance-validation`. +This change retains redb 4.2 and the existing pagination/recovery repair. + +## Problem and change + +The existing `sessions//turn-end.lock` only deduplicates Stops for +the same session. Independent sessions can still open competing writable +handles to the canonical `pristine.redb`. In addition, checkpoint preparation +used to treat any ledger-open/read error as an empty session history. + +Stops now acquire a canonical `.atomic/turn-publication.lock` before loading +the session and checking the working copy, and hold it through recording, +checkpoint publication and session save. Sandboxes resolve to the same +canonical lock. The per-session duplicate lock remains in place. The lock file +is retained; removing it could split waiters across different inodes. OS file +locks release on normal return, error or process termination. + +Acquiring this Stop lock waits at most 10 seconds. Database opens used by +recording and checkpoint preparation/publication also wait up to 10 seconds +per acquisition for typed `DatabaseAlreadyOpen` contention. Other database +errors return immediately. These are bounded acquisition waits, not a single +10-second deadline for the entire Stop. Ordinary repository-open APIs retain +their immediate-failure behavior. + +Ledger reads use a short-lived read-only handle and propagate errors before +binding a checkpoint. Journal replay occurs without a pristine handle held. +Existing checkpoint binding, atomic publication and acknowledgment remain in +place. A journal-backed record failure now leaves the session active and +returns an error so it can be retried; legacy orchestrators without a durable +journal retain best-effort recording behavior. + +## Regression coverage + +- Eight independent subprocess sessions publish two turns each, including a + real file change, while a separately held pristine handle causes transient + contention. No external Stop coordinator or test-side retry is used. Verify + ledger ordinals, predecessors, graphs and exactly one recorded file change. +- A publication-lock timeout returns failure; retry and duplicate delivery + produce exactly one checkpoint with the original goal. +- Kill a real foreground Stop while it holds the publication lock and waits + for pristine, then retry and verify one recorded change and checkpoint. +- Database acquisition has a bounded wait; a corrupt database fails promptly. +- A sandbox resolves to its canonical database and can acquire it after a + competing handle closes. +- Existing owner-death, pagination, frozen-checkpoint recovery and + cross-harness hook tests remain applicable. + +## Results, September 11, 2026 + +`cargo test --workspace --lib --tests --locked`: **8,353 passed, zero failed, +2 ignored**. This includes five new regression tests. Doctests were not rerun +and are not counted. `cargo fmt --all --check` passed. The release build passed. + +The same release workload ran on the immutable pagination baseline and the +fixed binary, with 1/4/8 independent sessions, 16 tool events per turn, two +turns per session, balanced and read-heavy scenarios, and three repetitions. +Modes alternate order across repetitions. There is **no `--serialize-stop`**. +The fixed binary SHA-256 is +`151212dc8c11d4aa3ae825b0f6541e7c2d60b996d444860d20884ca51ba2e72a`. + +| Result across 18 runs per binary | Pagination baseline, redb 4.2 | Fixed, redb 4.2 | +|---|---:|---:| +| Successful / attempted Stop calls | 40 / 100 | **156 / 156** | +| Sessions with both turns fully verified | 18 / 78 | **78 / 78** | +| Successful / attempted CLI reads | 3,983 / 4,000 | 5,602 / 6,240 | + +The baseline aborts a worker after a failed Stop, so it attempts fewer second +turns and reads. Its shorter concurrent wall times are not a performance win. +The fixed runs verify all 2,496 tool-event payloads, frozen checkpoint source, +ledger links, content hashes and duplicate Stop behavior. Read errors are +collected separately; **638 ordinary CLI reads still failed**, so these are +successful checkpoint runs, not entirely error-free application workloads. + +| Fixed workload | Sessions | Median complete workload | Stop p50 / p95 | +|---|---:|---:|---:| +| Balanced | 1 | 1.037 s | 54 / 66 ms | +| Balanced | 4 | 1.476 s | 103 / 319 ms | +| Balanced | 8 | 2.902 s | 308 / 1,334 ms | +| Read-heavy | 1 | 1.797 s | 53 / 66 ms | +| Read-heavy | 4 | 3.365 s | 112 / 317 ms | +| Read-heavy | 8 | 4.993 s | 301 / 1,252 ms | + +Stop latency includes coordination and database acquisition. These are local +measurements with three repetitions, not a general throughput guarantee or a +redb 5 comparison. The single-session baseline medians were 1.298 s balanced +and 2.211 s read-heavy; there was no observed single-session regression in this +sample. A causal speedup claim would require more profiling and repetitions. + +Machine-readable results: +[summary](../tools/provenance-eval/results/concurrent-stop-2026-09-11.json), +[raw results, logs and source/binary manifest](../tools/provenance-eval/results/concurrent-stop-2026-09-11.tar.gz). +The summary includes the archive checksum. The archive was read back and +checked against each original file. + +Reproduce using `tools/provenance-eval/multi_session.py` with two immutable +release binaries: + +```sh +python tools/provenance-eval/multi_session.py \ + --binary baseline-4.2=/absolute/path/to/atomic-pagination \ + --binary fixed-4.2=/absolute/path/to/atomic-stop-coordinated \ + --workers 1,4,8 --events 16 --turns 2 \ + --scenarios balanced,read-heavy --repetitions 3 --output release.json +``` + +## Scope and remaining limits + +This coordinates cooperating Stop publishers. It does not turn redb 4.2 into +a database that supports readers alongside a writable process. Ordinary CLI +reads may still fail while a writer is open. Other long-lived writers can +exhaust the acquisition timeout; retry the Stop after contention clears. + +The workload replay invokes real independent CLI/hook processes with +deterministic events; it does not run language models. Sessions share a managed +view. Concurrent model edits to the same working files and automatic view +switching are outside this experiment. The fix has not been merged into the +experimental redb 5 or Git–Atomic bridge views, and is not a claim that the +combined release candidate is ready. diff --git a/docs/provenance-pagination.md b/docs/provenance-pagination.md new file mode 100644 index 00000000..11161e7c --- /dev/null +++ b/docs/provenance-pagination.md @@ -0,0 +1,127 @@ +# Bounded frozen-journal reads + +Atomic intent: `ATOM::vince::2`, in `fix/redb-provenance-validation`. + +Long turns could persist every event successfully and then fail at Stop. The +checkpoint requested the entire frozen journal in one owner response; JSON's +numeric byte arrays could exceed the 8 MiB frame limit. The owner closed the +connection, leaving the durable checkpoint prepared but unpublished. + +The hook now uses `LoadFrozenEnvelopesPage`. Each page is tied to the persisted +attempt generation and exclusive event cutoff. The `(sequence, byte offset)` +cursor survives owner restart and allows a large individual envelope to cross +pages. The client reconstructs complete envelopes in order before the existing +replay and publication path. Reads do not change the journal or checkpoint. + +A Stop retry after an unsuccessful read may see a clean working copy because +the previous invocation already recorded its change. Such retries now reuse the +change hashes in the pending frozen checkpoint. The owner requires the current +generation and checkpointing state, then retains the existing source validation. +A different nonempty change set or incompatible source still fails explicitly. + +A page contains at most 1 MiB of raw payload and 256 fragments. Its budget +accounts for the actual escaped request ID, fragment metadata, and the worst +case of four JSON bytes per payload byte. The 8 MiB frame limit remains in force. +The fragment-count bound also covers empty envelopes. Old-format journal +records are skipped consistently with the existing frozen-envelope reader. + +## Compatibility and scope + +The v1 Ping response advertises `frozen_envelope_paging`; older v1 clients can +still use their existing requests. New clients detect an older running owner +before sending page requests and report an explicit restart instruction: + +```sh +atomic agent database-owner shutdown --repository /path/to/repo +# Retry the Stop hook with the updated CLI; it starts an updated owner. +``` + +Use the updated CLI for both the hook and owner. The legacy unpaged request +remains for compatibility and retains its original size limitation. There is +no database schema migration, redb dependency upgrade, or write batching change. +Aaron and Bradley's bridge view is outside this change. + +This removes the single-response size ceiling. It does not make graph building +constant-memory: the client still collects complete envelopes for replay. Page +reads decode one persisted envelope at a time, including when an envelope spans +multiple pages. + +## Regression coverage + +```sh +cargo test -p atomic-cli --bin atomic commands::agent::owner::tests +cargo test -p atomic-repository --test provenance_checkpoint_test +cargo test -p atomic-cli --test database_owner_integration_test +cargo test --workspace +``` + +The new coverage exercises: + +- Frame bounds under worst-case JSON expansion and an unusually long escaped + request ID; fragment count limits and an envelope spanning multiple pages. +- Exact byte/order reconstruction with empty envelopes and legacy sequence gaps; + identical page retries after reopening redb; stale generation, cutoff mismatch, + and invalid cursor rejection. +- Real Codex, Claude Code and OpenCode Stop hooks with 1,024 committed tool + envelopes, each retaining a 1 KiB output plus its raw payload. The unpaged + response would exceed 8 MiB. Tests seed through the owner storage API to avoid + 1,024 CLI bootstraps, then verify actual hook publication and every tool ID. +- A real owner abort after the first page of a large envelope, followed by client + reconnect and successful checkpoint publication. Duplicate Stop preserves the + existing ledger and manifest head. +- A page-read failure that exhausts retries and ends the hook process; a later + Stop completes the same attempt with the original change hashes and cutoff. + +On macOS ARM64 with Rust 1.95.0, the final `cargo test --workspace` run passed +**8,827 tests**, with zero failures and 242 ignored. The owner integration suite +contains 14 passing tests. Targeted formatting checks and the release build pass. +This run does not establish new Linux or Windows CI results; the three harness +checks above exercise real CLI hook processes using fixture payloads. + +An upgrade test detected the old owner's missing capability and completed the +original prepared checkpoint after an explicit restart. Separately, the original +1,024-event benchmark was run against the old binary until its >8 MiB response +failed. Retrying that same frozen checkpoint with the new binary succeeded, +retaining its source, generation, cutoff, all 1,024 tool payloads, and immutable +ledger. Its five page frames measured 2,118,514; 2,126,829; 2,127,113; 2,127,201; +and 11,760 bytes. Duplicate Stop left the ledger unchanged. + +## Release comparison + +Same machine, three repetitions per case, alternating binary order; deterministic +1 KiB tool outputs are also retained in the raw payload. The baseline is PR #190 +at `b8f8c140a7ad34ff0f5833bf353e64edb696fe7f`, using redb 4.2. Both binaries +use that dependency. Values below are checkpoint medians, with min–max in +parentheses, in milliseconds. + +| Scenario | Baseline | Pagination | Successful checkpoints, baseline / pagination | +| --- | ---: | ---: | --- | +| 128 events, 16 per RPC | 153 (148–157) | 152 (150–160) | 3/3 / 3/3 | +| 512 events | 167 (165–177) | 195 (172–381) | 3/3 / 3/3 | +| 1,024 events | Failed: frame limit | 189 (188–309) | 0/3 / 3/3 | +| Five successive 32-event turns | 138 (130–153) | 134 (127–156) | 15/15 / 15/15 | + +The fixed binary completed all 24 checkpoints in 12 fixture runs. Every +successful checkpoint verified payloads, graph hashes, manifest head, previous +ledger rows and duplicate Stop. The unchanged baseline's three boundary failures +are expected. Pagination adds RPCs; this small sample shows a 28 ms median +increase for 512 events, including one 381 ms sample. These measurements support +the correctness repair, not a general performance improvement claim. + +The existing evaluation driver is included with capability-aware page verification: + +```sh +# Python 3 with the blake3 package installed; Unix socket fixture. +python tools/provenance-eval/run.py \ + --binary baseline=/absolute/path/to/baseline/atomic \ + --binary pagination=/absolute/path/to/fixed/atomic \ + --scenarios rpc-batch16 long-turn frame-boundary five-turn-history \ + --repeats 3 --output /tmp/provenance-pagination.json +``` + +The driver retains `frozen_frame_bytes` as the hypothetical unpaged frame size; +`verification_page_sizes` contains the actual paged response sizes. Raw results, +logs, the original-failure recovery fixture and immutable binaries are retained +locally in the workspace's `.gstack/provenance-pagination-2026-09-10/` directory. +The tested release binary SHA-256 is +`4f56676aaae13b6e5a8ac95de2d95ef348756efda4c0590c536e416fce66e2c3`. diff --git a/docs/provenance-transaction-batching.md b/docs/provenance-transaction-batching.md new file mode 100644 index 00000000..e34729b2 --- /dev/null +++ b/docs/provenance-transaction-batching.md @@ -0,0 +1,94 @@ +# Provenance transaction batching + +`ATOM::vince::8` · `fix/redb-provenance-validation` · redb 4.2 + +An owner RPC containing 16 new provenance envelopes previously opened and +committed 16 write transactions. It now writes those envelopes, event-ID index +entries and the turn's sequence frontier in one durable transaction. The owner +returns acknowledgments only after the commit succeeds. The single-envelope +API delegates to the same implementation. + +## Behavior and compatibility + +- Acknowledgments follow input order. Repeated IDs, including repetitions within + the same batch, retain the first bytes and sequence. Changed retry observation + timestamps do not overwrite the original event. +- Existing-event retries remain valid after generation/state fencing, matching + the previous single-event contract. Any new event must match the running + generation. Empty and entirely duplicate batches need no durable commit. +- **A batch is now all-or-nothing.** For example, a new event followed by a + conflicting legacy event previously could leave the first event committed + despite an error response. It now leaves neither event nor index/frontier + changes from that batch. Already committed events remain intact. +- Checkpoint preparation and batch append serialize through redb's write + transaction. The checkpoint sees either the full batch or none of it; if + preparation wins, new appends using the old generation are fenced. +- No wire-format change, timer-based aggregation, dependency upgrade or + durability weakening. This accelerates calls that already contain multiple + events. Single-event hook calls still commit individually. + +## Validation + +Repository regressions cover input-order acknowledgments, within-batch and +cross-reopen duplicate retries, fenced mixed batches, rollback after a later +legacy conflict, sequence exhaustion and a 16-iteration checkpoint race. + +The owner integration regression kills the owner immediately before or after +the batch commit. After restarting, retrying the same 16 events returns one +ordered set of acknowledgments; the database contains exactly 16 events. The +pre-commit crash leaves zero, and the post-commit crash leaves all 16. + +Workspace validation: **8,358 unit/integration tests passed, zero failed, two +existing ignored tests** (`cargo test --workspace --lib --tests --locked --offline`). +Doctests are not included in that count. Five tests are new for this change; +the rest are existing workspace coverage. The owner suite passed all 18 tests, +including the existing large-journal, recovery and concurrent Stop regressions. + +## Measured performance + +Same-machine macOS release comparison against the previous Stop-coordinated +4.2 binary (`ATOM::vince::5`). Five repetitions, rotated mode order, 128 events +per case and 1,024-byte tool outputs. Both builds include the pagination and +Stop coordination fixes. The existing driver is reused with one added scenario +for eight concurrent 16-event RPCs. No builds or tests ran during measurement. + +| Path | Before, events/s | After, events/s | Ratio | +|---|---:|---:|---:| +| One event per RPC | 238.0 | 240.4 | 1.01x | +| 16 events per RPC | 245.4 | 2,387.4 | 9.73x | +| Eight concurrent 16-event RPCs | 247.8 | 2,665.8 | 10.76x | + +Values are medians across runs, not a general application speedup guarantee. +The 16-event request's median p50 latency fell from 63.44 ms to 5.98 ms; +single-event p50 stayed approximately 4.05 ms. Concurrent request latency +includes queueing. The application schema still requires serialization, +indexing and transport, so the result need not equal the raw KV benchmark. + +All **30 measured checkpoints** verified sequence IDs, duplicate delivery, +payloads, graph/ledger links and completion. The separate 1,024-event boundary +test with 2,048-byte tool outputs passed for both binaries, including paged +retrieval of journals larger than the former 8 MiB frame limit. + +The real-CLI multi-session regression used 1/4/8 workers, balanced/read-heavy +workloads, two repetitions and two turns per session, without external Stop +serialization. All **104 Stops and 52 sessions** verified, covering 1,664 tool +payloads. Ordinary `intent list` reads still hit the known database-open lock +conflict: **448 of 4,160 reads failed** with `Database already open`. There were +no session verification or worker failures, but this is not an all-green read +workload or a release-readiness claim. + +[Results, build hashes and validation summary](../tools/provenance-eval/results/transaction-batching-2026-09-11.json) +and [raw results and logs](../tools/provenance-eval/results/transaction-batching-2026-09-11.tar.gz). + +This change does not address ordinary CLI read-open contention, implement a +redb5 single-sync protocol, integrate the bridge, or declare a release candidate. + +## Atomic storage handoff + +Implementation change `JFZCKVVQIRIJPRSDYDQIV3TW3K4IEVR7MYAYT2IULTFBT2YBIUQQ` +was pushed to the existing `oss / atomic` storage project under +`fix/redb-provenance-validation`. The push stored six missing changes, including +the preceding validation/Stop work, and declared that view with 187 changes. +A fresh remote inventory check reported `Already up to date - nothing to push`. +The bridge view was not updated. Intent completion and its signed attestation +are recorded in the following metadata change. diff --git a/tools/provenance-eval/multi_session.py b/tools/provenance-eval/multi_session.py new file mode 100644 index 00000000..a09bf368 --- /dev/null +++ b/tools/provenance-eval/multi_session.py @@ -0,0 +1,249 @@ +#!/usr/bin/env python3 +"""Deterministic multi-process agent-session replay against real Atomic CLI. + +No models are invoked. Each worker has its own session; all share one disposable +repository and owner. Timers exclude setup and post-run persistence verification. +""" +import argparse +import base64 +import concurrent.futures +import contextlib +import hashlib +import json +import multiprocessing +import os +import pathlib +import platform +import shutil +import statistics +import subprocess +import tempfile +import time + +import run as base + + +class SeededFixture(base.Fixture): + def run(self, *args, **kwargs): + result = super().run(*args, **kwargs) + if args[0] == "init": + for number in range(32): + super().run("intent", "new", f"Review benchmark module {number}") + super().run("agent", "lifecycle", "begin", "--owner", "benchmark-orchestrator", + "--session", "benchmark-coordinator", "--executor", "claude-code", "--view", "dev") + return result + + +class PreparedFixture(base.Fixture): + def __init__(self, binary, root, template): + super().__init__(binary, root) + self.template = template + + def run(self, *args, **kwargs): + if args[0] == "init": + shutil.copytree(self.template, self.root, dirs_exist_ok=True) + return super().run("agent", "lifecycle", "begin", "--owner", "benchmark-orchestrator", + "--session", "benchmark-coordinator", "--executor", "claude-code", "--view", "dev") + return super().run(*args, **kwargs) + + +def worker(binary, root, endpoint, number, config, gate, stop_lock): + session = f"multi-agent-{number}" + base.SESSION = session + f = base.Fixture(binary, pathlib.Path(root)) + f.endpoint = endpoint + reads, writes, stops, turn_times, failures = [], [], [], [], [] + gate.wait(timeout=60) + started = time.perf_counter() + try: + for turn in range(1, config["turns"] + 1): + turn_start = time.perf_counter() + f.hook("user-prompt-submit", {"session_id": session, "prompt": f"Review intent and source, turn {turn}"}) + for event in range(config["events"]): + for read in range(config["reads_per_event"]): + command = ["intent", "list", "--json"] if read % 2 == 0 else ["intent", "show", config["intent_id"]] + ts = time.perf_counter() + try: + result = f.run(*command) + text = result.stdout.decode() + if read % 2 == 0: + assert {x["id"] for x in json.loads(text)} == set(config["intent_ids"]), "intent list changed" + else: + assert config["intent_id"] in text, "intent content missing" + reads.append({"ms": (time.perf_counter() - ts) * 1000, "ok": True, "command": command}) + except Exception as error: + reads.append({"ms": (time.perf_counter() - ts) * 1000, "ok": False, "command": command, "error": str(error)}) + ts = time.perf_counter() + f.hook("post-tool", base.tool_payload(event, 1024, turn)) + writes.append((time.perf_counter() - ts) * 1000) + if config.get("think_ms", 0): + time.sleep(config["think_ms"] / 1000) + ts = time.perf_counter() + try: + with stop_lock if config["serialize_stop"] else contextlib.nullcontext(): + acquired = time.perf_counter() + f.hook("stop", {"session_id": session, "reason": "end_turn", "response": f"Review completed {turn}"}) + stops.append({"ms": (time.perf_counter() - ts) * 1000, "queue_ms": (acquired - ts) * 1000, "ok": True}) + except Exception as error: + stops.append({"ms": (time.perf_counter() - ts) * 1000, "ok": False, "error": str(error)}) + break + turn_times.append((time.perf_counter() - turn_start) * 1000) + except Exception as error: + failures.append(str(error)) + wall = time.perf_counter() - started + f.owner_log.close() + return {"session": session, "wall_s": wall, "reads": reads, "writes_ms": writes, + "stops": stops, "turn_ms": turn_times, "failures": failures} + + +def verify(f, sessions, config): + verified = [] + for row in sessions: + sid = row["session"] + ledger = json.loads(f.run("session", "show", sid, "--json").stdout)[1] + assert len(ledger) == config["turns"], (sid, ledger) + for turn, entry in enumerate(ledger, 1): + state = f.rpc({"TurnStatus": {"session_id": sid, "turn_number": turn}})["TurnLifecycle"]["turn"] + assert state["state"] == "Completed", state + attempt = state["checkpoint_attempt"] + assert attempt["phase"] == "Published", attempt + assert not entry["change_hashes"], entry + assert entry["provenance_hash"] == attempt["provenance_hash"] + frozen = f.rpc({"LoadFrozenEnvelopes": {"provenance_id": state["provenance_id"]}})["FrozenEnvelopes"]["envelopes"] + envelopes = [json.loads(bytes(e)) for e in frozen] + assert all(e["session_id"] == sid and e["turn_number"] == turn for e in envelopes) + assert len({e["event_id"] for e in envelopes}) == len(envelopes) + events = [e for e in envelopes if e["event"].get("tool_call_id", "").startswith(f"bench-{turn}-")] + assert len(events) == config["events"], (sid, turn, len(events)) + assert len({e["event"]["tool_call_id"] for e in events}) == config["events"] + for event in events: + i = int(event["event"]["tool_call_id"].rsplit("-", 1)[1]) + assert event["event"]["output"] == base.output_payload(i, 1024) + assert event["event"]["raw"]["tool_output"] == base.output_payload(i, 1024) + digest = entry["provenance_hash"] + data = (f.root / ".atomic" / "changes" / digest[:2] / f"{digest}.provenance").read_bytes() + assert base64.b32encode(base.blake3.blake3(data).digest()).decode().rstrip("=") == digest + if turn > 1: + assert attempt["source"]["previous_provenance"] == ledger[turn - 2]["provenance_hash"] + f.hook("stop", {"session_id": sid, "reason": "end_turn", "response": "duplicate delivery"}) + assert json.loads(f.run("session", "show", sid, "--json").stdout)[1] == ledger + verified.append({"session": sid, "turns": len(ledger), "payloads_and_hashes": True, "duplicate_stop": True}) + return verified + + +def measure(binary, workers, config, template): + with tempfile.TemporaryDirectory(prefix="atomic-multi-session-") as temp: + root = pathlib.Path(temp) + f = PreparedFixture(binary, root, template) + try: + # Seed vault context before opening the owner. + f.start() + config = dict(config) + config["intent_ids"] = sorted(x["id"] for x in json.loads(f.run("intent", "list", "--json").stdout)) + assert len(config["intent_ids"]) == 32 + config["intent_id"] = config["intent_ids"][0] + assert config["intent_id"] in f.run("intent", "show", config["intent_id"]).stdout.decode() + for i in range(workers): + f.hook("session-start", {"session_id": f"multi-agent-{i}"}) + ctx = multiprocessing.get_context("spawn") + with ctx.Manager() as manager: + gate = manager.Barrier(workers + 1) + stop_lock = manager.Lock() + with concurrent.futures.ProcessPoolExecutor(max_workers=workers, mp_context=ctx) as pool: + pending = [pool.submit(worker, str(binary), str(root), f.endpoint, i, config, gate, stop_lock) for i in range(workers)] + gate.wait(timeout=60) + rows = [future.result(timeout=180) for future in pending] + result = {"workers": workers, "config": config, "sessions": rows, + "wall_s": max(r["wall_s"] for r in rows)} + result["verified"], result["verification_errors"] = [], [] + for row in rows: + try: + result["verified"].extend(verify(f, [row], config)) + except Exception as error: + result["verification_errors"].append({"session": row["session"], "error": str(error)}) + return result + finally: + logs = f.close() + if "result" in locals(): + result["owner_log"] = logs + + +def summarize(rows): + grouped = {} + for row in rows: + grouped.setdefault(f"{row['scenario']}:{row['workers']}:{row['mode']}", []).append(row) + output = {} + for key, runs in grouped.items(): + sessions = [s for r in runs for s in r["sessions"]] + reads = [x for s in sessions for x in s["reads"]] + stops = [x for s in sessions for x in s["stops"]] + writes = [x for s in sessions for x in s["writes_ms"]] + lat = lambda xs: base.summary(xs) if xs else None + output[key] = {"runs": len(runs), "wall_s_median": statistics.median(r["wall_s"] for r in runs), + "wall_s_range": [min(r["wall_s"] for r in runs), max(r["wall_s"] for r in runs)], + "read_ok": sum(x["ok"] for x in reads), "read_total": len(reads), + "read_ms": lat([x["ms"] for x in reads if x["ok"]]), + "write_ms": lat(writes), "stop_ms": lat([x["ms"] for x in stops if x["ok"]]), + "stop_ok": sum(x["ok"] for x in stops), "stop_total": len(stops), + "verified_sessions": sum(len(r["verified"]) for r in runs), + "expected_sessions": sum(r["workers"] for r in runs), + "verification_failures": sum(len(r["verification_errors"]) for r in runs), + "worker_failures": sum(len(s["failures"]) for s in sessions), + "turn_ms": lat([x for s in sessions for x in s["turn_ms"]])} + return output + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--binary", action="append", required=True, help="mode=/absolute/path") + ap.add_argument("--output", required=True) + ap.add_argument("--workers", default="1,4,8") + ap.add_argument("--repetitions", type=int, default=5) + ap.add_argument("--scenarios", default="balanced,read-heavy") + ap.add_argument("--events", type=int, default=16) + ap.add_argument("--turns", type=int, default=2) + ap.add_argument("--serialize-stop", action="store_true") + args = ap.parse_args() + binaries = dict(x.split("=", 1) for x in args.binary) + configs = {"balanced": {"reads_per_event": 1}, "read-heavy": {"reads_per_event": 4}, + "paced": {"reads_per_event": 1, "think_ms": 100}} + result = {"kind": "deterministic real-CLI multi-session replay; no model calls", "platform": platform.platform(), + "binaries": {k: {"path": str(pathlib.Path(v).resolve()), "sha256": hashlib.sha256(pathlib.Path(v).read_bytes()).hexdigest()} for k, v in binaries.items()}, "runs": []} + # Reuse stopped, fully recorded fixture templates. Setup is never timed. + # TemporaryDirectory cleanup also removes copied local owner metadata. + with tempfile.TemporaryDirectory(prefix="atomic-multi-templates-") as templates: + roots = {} + for mode, binary in binaries.items(): + root = pathlib.Path(templates) / mode + root.mkdir() + fixture = SeededFixture(pathlib.Path(binary).resolve(), root) + try: + fixture.start() + fixture.hook("user-prompt-submit", {"session_id": base.SESSION, "prompt": "Prepare fixed benchmark context"}) + fixture.hook("stop", {"session_id": base.SESSION, "reason": "end_turn", "response": "Context prepared"}) + finally: + fixture.close() + roots[mode] = root + execute(args, binaries, configs, result, roots) + + +def execute(args, binaries, configs, result, roots): + for repetition in range(args.repetitions): + modes = list(binaries) + modes = modes[repetition % len(modes):] + modes[:repetition % len(modes)] + for scenario in args.scenarios.split(","): + config = {**configs[scenario], "events": args.events, "turns": args.turns, "serialize_stop": args.serialize_stop} + for workers in map(int, args.workers.split(",")): + for mode in modes: + row = measure(pathlib.Path(binaries[mode]).resolve(), workers, config, roots[mode]) + row.update(mode=mode, scenario=scenario, repetition=repetition) + result["runs"].append(row) + result["summary"] = summarize(result["runs"]) + pathlib.Path(args.output).write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({"mode": mode, "scenario": scenario, "workers": workers, "rep": repetition, + "wall_s": row["wall_s"], "verified": len(row.get("verified", [])), + "errors": len(row["verification_errors"])}), flush=True) + + +if __name__ == "__main__": + main() diff --git a/tools/provenance-eval/results/concurrent-stop-2026-09-11.json b/tools/provenance-eval/results/concurrent-stop-2026-09-11.json new file mode 100644 index 00000000..8e7af4f1 --- /dev/null +++ b/tools/provenance-eval/results/concurrent-stop-2026-09-11.json @@ -0,0 +1,556 @@ +{ + "kind": "deterministic real-CLI multi-session replay; no model calls", + "platform": "macOS-26.0-arm64-arm-64bit", + "intent": "ATOM::vince::5", + "view": "fix/redb-provenance-validation", + "binaries": { + "baseline-4.2": { + "path": "/Users/dev-vincent/atomic-workspace/.gstack/provenance-pagination-2026-09-10/atomic-pagination", + "sha256": "4f56676aaae13b6e5a8ac95de2d95ef348756efda4c0590c536e416fce66e2c3" + }, + "fixed-4.2": { + "path": "/Users/dev-vincent/atomic-workspace/.gstack/concurrent-stop-2026-09-11/atomic-stop-coordinated", + "sha256": "151212dc8c11d4aa3ae825b0f6541e7c2d60b996d444860d20884ca51ba2e72a" + } + }, + "command": "multi_session.py --workers 1,4,8 --events 16 --turns 2 --scenarios balanced,read-heavy --repetitions 3 (no --serialize-stop)", + "workspace_tests": { + "command": "cargo test --workspace --lib --tests --locked", + "passed": 8353, + "failed": 0, + "ignored": 2, + "doctests_included": false + }, + "summary": { + "balanced:1:baseline-4.2": { + "runs": 3, + "wall_s_median": 1.2981105000944808, + "wall_s_range": [ + 1.2854354579467326, + 1.4915506249526516 + ], + "read_ok": 96, + "read_total": 96, + "read_ms": { + "count": 96, + "p50_ms": 16.315957996994257, + "p95_ms": 30.554707976989448, + "min_ms": 11.38195802923292, + "max_ms": 77.85308302845806 + }, + "write_ms": { + "count": 96, + "p50_ms": 14.159145473968238, + "p95_ms": 39.998791995458305, + "min_ms": 10.216666967608035, + "max_ms": 41.99275001883507 + }, + "stop_ms": { + "count": 6, + "p50_ms": 70.48452104208991, + "p95_ms": 88.77999999094754, + "min_ms": 67.70241702906787, + "max_ms": 88.77999999094754 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 649.0536664496176, + "p95_ms": 945.9246250335127, + "min_ms": 502.25579203106463, + "max_ms": 945.9246250335127 + } + }, + "balanced:1:fixed-4.2": { + "runs": 3, + "wall_s_median": 1.0370733749587089, + "wall_s_range": [ + 1.0293644170742482, + 1.2705273750470951 + ], + "read_ok": 96, + "read_total": 96, + "read_ms": { + "count": 96, + "p50_ms": 14.846541511360556, + "p95_ms": 25.681958068162203, + "min_ms": 11.514750076457858, + "max_ms": 42.25325002335012 + }, + "write_ms": { + "count": 96, + "p50_ms": 12.701875064522028, + "p95_ms": 21.988042048178613, + "min_ms": 9.94000001810491, + "max_ms": 40.08375003468245 + }, + "stop_ms": { + "count": 6, + "p50_ms": 54.16852096095681, + "p95_ms": 66.17408292368054, + "min_ms": 51.67054105550051, + "max_ms": 66.17408292368054 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 532.6645210734569, + "p95_ms": 723.285417072475, + "min_ms": 485.38695904426277, + "max_ms": 723.285417072475 + } + }, + "balanced:4:baseline-4.2": { + "runs": 3, + "wall_s_median": 1.4452844579936936, + "wall_s_range": [ + 1.1092214589007199, + 1.4520915410248563 + ], + "read_ok": 240, + "read_total": 240, + "read_ms": { + "count": 240, + "p50_ms": 17.885708017274737, + "p95_ms": 36.860916996374726, + "min_ms": 11.3849580520764, + "max_ms": 50.67274998873472 + }, + "write_ms": { + "count": 240, + "p50_ms": 14.939958462491632, + "p95_ms": 34.38399999868125, + "min_ms": 10.01816603820771, + "max_ms": 54.9079580232501 + }, + "stop_ms": { + "count": 6, + "p50_ms": 97.68643754068762, + "p95_ms": 145.25412500370294, + "min_ms": 65.35908300429583, + "max_ms": 145.25412500370294 + }, + "stop_ok": 6, + "stop_total": 15, + "verified_sessions": 3, + "expected_sessions": 12, + "verification_failures": 9, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 632.1896454901434, + "p95_ms": 972.8427500231192, + "min_ms": 459.8636250011623, + "max_ms": 972.8427500231192 + } + }, + "balanced:4:fixed-4.2": { + "runs": 3, + "wall_s_median": 1.4761825000168756, + "wall_s_range": [ + 1.4206848749890924, + 1.5110441249562427 + ], + "read_ok": 332, + "read_total": 384, + "read_ms": { + "count": 332, + "p50_ms": 16.938646498601884, + "p95_ms": 27.602333924733102, + "min_ms": 12.075374950654805, + "max_ms": 36.981042008847 + }, + "write_ms": { + "count": 384, + "p50_ms": 14.743146020919085, + "p95_ms": 23.007125011645257, + "min_ms": 9.758207947015762, + "max_ms": 30.600333004258573 + }, + "stop_ms": { + "count": 24, + "p50_ms": 102.60064608883113, + "p95_ms": 318.9199169864878, + "min_ms": 50.54395797196776, + "max_ms": 321.5247920015827 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 645.2101040049456, + "p95_ms": 916.9357499340549, + "min_ms": 514.9619579315186, + "max_ms": 961.2173750065267 + } + }, + "balanced:8:baseline-4.2": { + "runs": 3, + "wall_s_median": 1.5696516250027344, + "wall_s_range": [ + 1.5244662079494447, + 1.887952166958712 + ], + "read_ok": 460, + "read_total": 464, + "read_ms": { + "count": 460, + "p50_ms": 22.676979016978294, + "p95_ms": 38.244832889176905, + "min_ms": 11.68508396949619, + "max_ms": 59.88216691184789 + }, + "write_ms": { + "count": 464, + "p50_ms": 21.928582922555506, + "p95_ms": 42.48212499078363, + "min_ms": 9.84937499742955, + "max_ms": 148.60658394172788 + }, + "stop_ms": { + "count": 8, + "p50_ms": 195.73062501149252, + "p95_ms": 225.79495806712657, + "min_ms": 77.82604196108878, + "max_ms": 225.79495806712657 + }, + "stop_ok": 8, + "stop_total": 29, + "verified_sessions": 3, + "expected_sessions": 24, + "verification_failures": 21, + "worker_failures": 0, + "turn_ms": { + "count": 8, + "p50_ms": 1002.1604584762827, + "p95_ms": 1193.811583914794, + "min_ms": 510.60208305716515, + "max_ms": 1193.811583914794 + } + }, + "balanced:8:fixed-4.2": { + "runs": 3, + "wall_s_median": 2.90178700000979, + "wall_s_range": [ + 2.8856431250460446, + 3.3475052079884335 + ], + "read_ok": 645, + "read_total": 768, + "read_ms": { + "count": 645, + "p50_ms": 21.370999980717897, + "p95_ms": 59.13233396131545, + "min_ms": 11.765541974455118, + "max_ms": 133.16858292091638 + }, + "write_ms": { + "count": 768, + "p50_ms": 21.572479512542486, + "p95_ms": 59.767041937448084, + "min_ms": 10.106915957294405, + "max_ms": 141.70195895712823 + }, + "stop_ms": { + "count": 48, + "p50_ms": 307.9474994447082, + "p95_ms": 1333.8238330325112, + "min_ms": 53.27354196924716, + "max_ms": 1550.186250009574 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 1091.8086039600894, + "p95_ms": 2374.7532080160454, + "min_ms": 510.8855840517208, + "max_ms": 2574.7223750222474 + } + }, + "read-heavy:1:baseline-4.2": { + "runs": 3, + "wall_s_median": 2.211376375053078, + "wall_s_range": [ + 1.9608556249877438, + 2.4966265419498086 + ], + "read_ok": 384, + "read_total": 384, + "read_ms": { + "count": 384, + "p50_ms": 11.629354557953775, + "p95_ms": 23.201416013762355, + "min_ms": 5.191417061723769, + "max_ms": 104.72741699777544 + }, + "write_ms": { + "count": 96, + "p50_ms": 13.536312500946224, + "p95_ms": 22.711000056006014, + "min_ms": 9.684249991551042, + "max_ms": 30.953833018429577 + }, + "stop_ms": { + "count": 6, + "p50_ms": 71.06268801726401, + "p95_ms": 127.89108289871365, + "min_ms": 65.45733311213553, + "max_ms": 127.89108289871365 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 1095.6300419638865, + "p95_ms": 1319.3290840135887, + "min_ms": 946.887124911882, + "max_ms": 1319.3290840135887 + } + }, + "read-heavy:1:fixed-4.2": { + "runs": 3, + "wall_s_median": 1.7969578340416774, + "wall_s_range": [ + 1.7571780839934945, + 2.246972124907188 + ], + "read_ok": 384, + "read_total": 384, + "read_ms": { + "count": 384, + "p50_ms": 11.397708556614816, + "p95_ms": 18.615208915434778, + "min_ms": 5.024750018492341, + "max_ms": 53.80233295727521 + }, + "write_ms": { + "count": 96, + "p50_ms": 12.003603973425925, + "p95_ms": 17.71066605579108, + "min_ms": 9.378124959766865, + "max_ms": 40.47558410093188 + }, + "stop_ms": { + "count": 6, + "p50_ms": 52.6710000121966, + "p95_ms": 65.57570793665946, + "min_ms": 47.834625001996756, + "max_ms": 65.57570793665946 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 919.0746250096709, + "p95_ms": 1270.1523340074345, + "min_ms": 850.9535830235109, + "max_ms": 1270.1523340074345 + } + }, + "read-heavy:4:baseline-4.2": { + "runs": 3, + "wall_s_median": 2.239198209019378, + "wall_s_range": [ + 2.110156250069849, + 2.485726209008135 + ], + "read_ok": 960, + "read_total": 960, + "read_ms": { + "count": 960, + "p50_ms": 12.226104037836194, + "p95_ms": 26.246167020872235, + "min_ms": 5.050665931776166, + "max_ms": 59.11683395970613 + }, + "write_ms": { + "count": 240, + "p50_ms": 14.198458462487906, + "p95_ms": 31.66366694495082, + "min_ms": 9.661125019192696, + "max_ms": 54.791957954876125 + }, + "stop_ms": { + "count": 6, + "p50_ms": 73.07304145069793, + "p95_ms": 121.97004188783467, + "min_ms": 63.44649998936802, + "max_ms": 121.97004188783467 + }, + "stop_ok": 6, + "stop_total": 15, + "verified_sessions": 3, + "expected_sessions": 12, + "verification_failures": 9, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 1119.5966249797493, + "p95_ms": 1539.795667049475, + "min_ms": 867.9863750003278, + "max_ms": 1539.795667049475 + } + }, + "read-heavy:4:fixed-4.2": { + "runs": 3, + "wall_s_median": 3.36507675005123, + "wall_s_range": [ + 3.283026000019163, + 3.524099124944769 + ], + "read_ok": 1466, + "read_total": 1536, + "read_ms": { + "count": 1466, + "p50_ms": 15.986332960892469, + "p95_ms": 41.05829098261893, + "min_ms": 5.146167008206248, + "max_ms": 130.53529197350144 + }, + "write_ms": { + "count": 384, + "p50_ms": 17.005562549456954, + "p95_ms": 44.4433749653399, + "min_ms": 10.698957950808108, + "max_ms": 66.42166699748486 + }, + "stop_ms": { + "count": 24, + "p50_ms": 112.28535400005057, + "p95_ms": 316.8597500771284, + "min_ms": 60.257375007495284, + "max_ms": 448.60587490256876 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 1594.5909790461883, + "p95_ms": 1920.7014578860253, + "min_ms": 1264.219249947928, + "max_ms": 1968.6110829934478 + } + }, + "read-heavy:8:baseline-4.2": { + "runs": 3, + "wall_s_median": 3.374609166989103, + "wall_s_range": [ + 2.9886893749935552, + 3.400074666016735 + ], + "read_ok": 1843, + "read_total": 1856, + "read_ms": { + "count": 1843, + "p50_ms": 15.599583042785525, + "p95_ms": 36.72604204621166, + "min_ms": 4.916999954730272, + "max_ms": 117.4545829417184 + }, + "write_ms": { + "count": 464, + "p50_ms": 22.581937431823462, + "p95_ms": 47.496916027739644, + "min_ms": 9.882334037683904, + "max_ms": 149.29441595450044 + }, + "stop_ms": { + "count": 8, + "p50_ms": 152.4214165401645, + "p95_ms": 293.78254094626755, + "min_ms": 65.15670905355364, + "max_ms": 293.78254094626755 + }, + "stop_ok": 8, + "stop_total": 29, + "verified_sessions": 3, + "expected_sessions": 24, + "verification_failures": 21, + "worker_failures": 0, + "turn_ms": { + "count": 8, + "p50_ms": 1937.1843339758925, + "p95_ms": 2133.42441606801, + "min_ms": 990.146083990112, + "max_ms": 2133.42441606801 + } + }, + "read-heavy:8:fixed-4.2": { + "runs": 3, + "wall_s_median": 4.993364125024527, + "wall_s_range": [ + 3.998281667008996, + 5.2470251669874415 + ], + "read_ok": 2679, + "read_total": 3072, + "read_ms": { + "count": 2679, + "p50_ms": 18.11175001785159, + "p95_ms": 45.58287502732128, + "min_ms": 5.3131249733269215, + "max_ms": 120.44445797801018 + }, + "write_ms": { + "count": 768, + "p50_ms": 21.678291959688067, + "p95_ms": 59.78904094081372, + "min_ms": 10.620665969327092, + "max_ms": 192.00333300977945 + }, + "stop_ms": { + "count": 48, + "p50_ms": 300.8949999930337, + "p95_ms": 1251.584624988027, + "min_ms": 50.5592079134658, + "max_ms": 1636.4932499127463 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 1981.935958028771, + "p95_ms": 3801.4029159676284, + "min_ms": 1023.7305420450866, + "max_ms": 4223.289666930214 + } + } + }, + "archive": "concurrent-stop-2026-09-11.tar.gz", + "archive_sha256": "7854286778a918ff0fd800a8c3a6d0668c21392d91a70ccf904ace4bc06e52b8" +} diff --git a/tools/provenance-eval/results/concurrent-stop-2026-09-11.tar.gz b/tools/provenance-eval/results/concurrent-stop-2026-09-11.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ce42d7ed66362566b56fd74ba4e9ec4704f55ddf GIT binary patch literal 270954 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 z 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 z

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Κ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%0A)K{bg)86o

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 literal 0 HcmV?d00001 diff --git a/tools/provenance-eval/results/transaction-batching-2026-09-11.json b/tools/provenance-eval/results/transaction-batching-2026-09-11.json new file mode 100644 index 00000000..5d9931d8 --- /dev/null +++ b/tools/provenance-eval/results/transaction-batching-2026-09-11.json @@ -0,0 +1,196 @@ +{ + "intent": "ATOM::vince::8", + "view": "fix/redb-provenance-validation", + "archive_sha256": "94d86b4981f9334b410ba29d57990f6692c299722995d23befee2f3a69613283", + "build": { + "intent": "ATOM::vince::8", + "view": "fix/redb-provenance-validation", + "binary": "/Users/dev-vincent/atomic-workspace/.gstack/provenance-batch-2026-09-11/atomic-batched", + "sha256": "2cd58045ba50665eb4514b1df744e9998ea74d3a56379c2aa5368914ed6b4583", + "source_sha256": { + "Cargo.toml": "78e82fbbfe9ebd8d14f3597be6f06dfde0642156c133fce51394abf87f61bce5", + "Cargo.lock": "3822192eaafd8bfac469c03e57e1adec29c8b38c044207923c8ae4f0c59d8912", + "atomic-cli/src/commands/agent/owner.rs": "255c395b942388f22791366c4129402e71c10fd7d228a44fa003d8bca3604ff1", + "atomic-repository/src/redb_change_store/provenance.rs": "53732a23ee7fdd6491cd858109f32aea8667600fd371485148dfb7f0c0429796", + "atomic-repository/src/redb_change_store/tests.rs": "a846b873ac403f7a91aea4b01d8735a84cd6a0fa726e52f943e2dec5fea58df4", + "atomic-cli/tests/database_owner_integration_test.rs": "455e0fc67fefdf19feafdbe574ef95c35e4840db42688ad21d9d7c9b84cae706", + "tools/provenance-eval/run.py": "2ac80831ba07bb073c6dc2406ffc3e03af32641eadc26722a7d52f166b0fbb6c", + "tools/provenance-eval/multi_session.py": "20b5c39b42c86b2d9b7e133f52f4081e10f1eefc36f84ffc1d6e404eee7663e7" + }, + "rustc": "rustc 1.95.0 (59807616e 2026-04-14)\nbinary: rustc\ncommit-hash: 59807616e1fa2540724bfbac14d7976d7e4a3860\ncommit-date: 2026-04-14\nhost: aarch64-apple-darwin\nrelease: 1.95.0\nLLVM version: 22.1.2\n", + "build": "CARGO_TARGET_DIR=/Users/dev-vincent/atomic-workspace/atomic-redb-validation/target cargo build --release --locked --offline -p atomic-cli" + }, + "workspace_tests": { + "passed": 8358, + "failed": 0, + "ignored": 2, + "command": "cargo test --workspace --lib --tests --locked --offline", + "doctests_included": false + }, + "performance": { + "baseline:rpc-single": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 238.00033236374537, + "min_events_s": 205.08153593252814, + "max_events_s": 247.49216766564172, + "median_request_p50_ms": 4.047021, + "median_request_p95_ms": 5.09725, + "checkpoint": { + "count": 5, + "p50_ms": 129.107667, + "p95_ms": 157.44425, + "min_ms": 127.386375, + "max_ms": 157.44425 + } + }, + "batched:rpc-single": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 240.4041793763238, + "min_events_s": 214.56526588677147, + "max_events_s": 249.92234688142784, + "median_request_p50_ms": 4.0438335, + "median_request_p95_ms": 5.293875, + "checkpoint": { + "count": 5, + "p50_ms": 134.338, + "p95_ms": 148.348667, + "min_ms": 126.379458, + "max_ms": 148.348667 + } + }, + "baseline:rpc-batch16": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 245.38409135980987, + "min_events_s": 239.6006154246632, + "max_events_s": 254.44101901234782, + "median_request_p50_ms": 63.444021, + "median_request_p95_ms": 69.487083, + "checkpoint": { + "count": 5, + "p50_ms": 134.387833, + "p95_ms": 147.854625, + "min_ms": 130.666375, + "max_ms": 147.854625 + } + }, + "batched:rpc-batch16": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 2387.434247169799, + "min_events_s": 1033.409883170429, + "max_events_s": 2562.8661557366063, + "median_request_p50_ms": 5.9803125, + "median_request_p95_ms": 10.90925, + "checkpoint": { + "count": 5, + "p50_ms": 135.904416, + "p95_ms": 257.014458, + "min_ms": 127.015, + "max_ms": 257.014458 + } + }, + "baseline:rpc-batch16-concurrent8": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 247.78160068222635, + "min_events_s": 191.12322221807457, + "max_events_s": 251.2306375762524, + "median_request_p50_ms": 289.72283300000004, + "median_request_p95_ms": 515.5665, + "checkpoint": { + "count": 5, + "p50_ms": 132.804333, + "p95_ms": 141.581459, + "min_ms": 129.820375, + "max_ms": 141.581459 + } + }, + "batched:rpc-batch16-concurrent8": { + "runs": 5, + "turns": 5, + "successful_checkpoints": 5, + "median_events_s": 2665.838201907128, + "min_events_s": 2647.7280745206376, + "max_events_s": 3167.996660139521, + "median_request_p50_ms": 25.83725, + "median_request_p95_ms": 40.188583, + "checkpoint": { + "count": 5, + "p50_ms": 128.318917, + "p95_ms": 156.361958, + "min_ms": 125.962167, + "max_ms": 156.361958 + } + } + }, + "boundary": { + "baseline:frame-boundary": { + "runs": 1, + "turns": 1, + "successful_checkpoints": 1, + "median_events_s": 230.90158677807298, + "min_events_s": 230.90158677807298, + "max_events_s": 230.90158677807298, + "median_request_p50_ms": 67.924521, + "median_request_p95_ms": 87.77225, + "checkpoint": { + "count": 1, + "p50_ms": 229.028, + "p95_ms": 229.028, + "min_ms": 229.028, + "max_ms": 229.028 + } + }, + "batched:frame-boundary": { + "runs": 1, + "turns": 1, + "successful_checkpoints": 1, + "median_events_s": 1811.3016634265712, + "min_events_s": 1811.3016634265712, + "max_events_s": 1811.3016634265712, + "median_request_p50_ms": 7.892146, + "median_request_p95_ms": 13.041083, + "checkpoint": { + "count": 1, + "p50_ms": 226.007791, + "p95_ms": 226.007791, + "min_ms": 226.007791, + "max_ms": 226.007791 + } + } + }, + "multi_session": { + "stop_ok": 104, + "stop_total": 104, + "verified_sessions": 52, + "read_ok": 3712, + "read_total": 4160, + "verification_failures": 0, + "worker_failures": 0 + }, + "verified_counts": { + "performance_checkpoints": 30, + "boundary_checkpoints": 2, + "direct_tool_payloads": 5888, + "multi_session": { + "stop_ok": 104, + "stop_total": 104, + "verified_sessions": 52, + "read_ok": 3712, + "read_total": 4160, + "verification_failures": 0, + "worker_failures": 0 + }, + "known_read_lock_errors": 448 + }, + "known_limitation": "448/4160 ordinary intent reads hit Database already open; not fixed by transaction batching.", + "publication": "Publication verification is performed after Atomic hook recording; this file is the immutable test evidence." +} diff --git a/tools/provenance-eval/results/transaction-batching-2026-09-11.tar.gz b/tools/provenance-eval/results/transaction-batching-2026-09-11.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..905f502012c8e8bdbee0776992972db10c7d113c GIT binary patch literal 242481 zcmV)mK%T!JiwFp4Q>1DF|8#O;ZgXK{bZKvHEn;DGV`yn^XDu=?GBzzRIV~|UE_7jX z0PMYMb6m%fE$Ywu6$pO1H$vR1d{z~2oQNyS@3F@(*&f?+FdE$r5!WC<1E4gT3IF$- zs~QA>U5zG0k+4{9oFk3gyL<0ludK|hm1|9(OrQL}zghhE&(@38`uqp)TwW zZ*jhScKp@)@$<#$@zMI?a{B)+&Q9OM`gh%|@$9x)>wLZDEeXxmze$oG9HfU_|Eu*^ zkH0!TU9L|rw|+0ac62n}`2X)m2M3Ryub&^T&o7={JX^5&qbCRWG(LZ^K0i7;kEyX- zw|Nm)9_ezOvmE7WM|@OW{3x%=+C61DN}0(I7m}8;bXxlQXlWGREUVR;7sO##R*ydJ z?|pLiC2qa)W!36yS|%4wN2~R!O0G5TX^D=OX)}dS4)t)oB8~r*)(cq`IV|y9;q`ivi!FS$Oh-p1 z)t9Ss2Mtn$#r?O zJhG!zU8j{5Uf1PPx8MEh)ep-e#!q6vmg-))to$&#zpisP+2hFHRP(-xyoS%Gb)Pg_@S5Wu>w@Iy_pZ_1w%*50~*_ z4CzrV*~+0*lk2&0`11H#~f8g!$4`^Wyc?K0o_veTtd=_;7K#eD?V0Z29tHy?WL6<#0`F zkNJJ1>$Q}1jtL%PY7|q3i!94ZZMBN&6Kf~?y5z%JWf3ziAF1SJzVkU}U!SheUp<99 zvs+Bex)MKx<#m%~KFpjbua}DytCCkl%hmEI#}Kc}%6NUaI6R`bVCBxITzB8ACoK<` zDV-v$jf}~BNg_uvmr1Hd zkClAnbQu48>&;KjmVd|1r7%*zQN?|aF084IB-W3qC}HSApU zkRHWctE*U9JiGZKUix_XczJUC$;J8dljYg-STU=MPZnRs9`?y*E}UQB!ECmS1$J1& z@|AMLoGXd@QYqF=*pf_3is_hF%w?g9!TWDWos>(R)?`;Zv za&zN+)uQW1qaQBMUOYX+nx>>5-}?0O>~e83yYSWe{P^g2y?S-4_87jtd>;M2xm!&8 z*~hPLr{rmNzvX6D9W9PeUY@UU&)468iH_NK^IE&~&#RXG{WPZM)Aj@yr>E=l^RqTH zW5Yz3fAr6N@b~ZWH|_I3`~1(1{7>w(Q#c1wRQD#}-{9|7to(!bxBlI|J6`Z)|i{-C>|CoJBj~D09UGeY7u7}5$*MZwNm(MmK zv`oYk$+g26eR~;>&*F094YEH@^)b=sWKT$*m_1IKuH*76FYM{r%gYxpFP|QMbJ<)M zjsWiJ8{z7&7tM>KS5Dr^;_qvD8ZOb5llF+FG}Y@&!tv?i{CItF(|dz^esX-ezVTUm z_~kSF{F6Ui#JxVbF&$nx`PXspC)1bFu;t$)$9?A}b}@P1##hhU+B9CStR%I=g(Y{3z&ygbLs}hWRb-UP zdXaS{3vF_)v;E4Lp zk59jRa`5Sk7bok3U)dL@&%Q?XAYA5?_!gY=_R;h8^NZvES%=@P2=b-GqrW(P9dkTi zFD}A;e!kuW4u5UWejNlv$Hm+_!#fo_G`!gs;s<>-w* zYu$*C{ln~rPw*Z5>Iq~YsU$4LX`mL@m-+s>B zFB?}DFJ7#pufJZLoIHKL2^~Zyq*y9%xy94Ak|maAA}gMANttWecFXhiKVC+tyt(UN zZ+zk4Ag8HB9P9q^t&iQNWa^%0ALpqm&ps;?BdgJWT&%=|>u=1WG{14!!c_Z@YdkM+ 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 z z`#82w6F7@UdIb!Ato1vv>V5OpF>xlXo2&;8dG4esPSu%5j$(t9arZ zbd^s5{G@YZ;4^$42QY^;G5o+zZH>^m~33fe)M-aD3PD z0o5&g{UP2^(lk=%OdbHYKH2Sn;)A5ue)f+ndV`kgmIt&Cpz$>OoeKW4B?vYF4C~e& zKh`e7EvykAwg>^IVODEK-)%_W2#kD@s$N7^*g_gWz^qi(T~`0nPs~>H*#$;F1-Ih; zR+IK1w51oPJ1_{acYD8)P2kPyu@1v3*8TGXOmgK<^Tu**R%<@*!3}hWPwjgMbTKD| z#p%Vy(A-tO3E?)vsCT&BlF8SKPO!#ny>y&9K;k^R zeV{=PaGKok^`RjYkWJaKfEjMC9_rQGm%co_CGxu0$!L3co8sm^ft5f>cLa-Md3R71 z4WvRoR5+~*Rjgnd`{7~W4Wc}e8ojUk{BQ*$FvL^m!Pc~x9s?fM+TLxzOb+A_WFJ%0 zM@#6U+Q%m0B!{e^>c>Nno`PhCL$6jl4=G`vs^gUE7<%=@FGw9<%e4!8Q+olLK zD$u0PJW+Y%HJIG|`>n%*+_Dm?BtC4`c@wy&sf&say{gC&j_=J24R{U-d|0#w4o13N z-dn;XpC0^#At0I}eCH~R0%JJJ-2hkyC*aL48aMm@qmg#W2-an?2 zL3HpX)(jW(&VGA%OfmItipVo?)E+i!U$!}o)n(72ZfA8vRiX;JwJPJm@mQvy7#&l! zn&ND*i@>wMFtBnUSF&MFEH8TYjX3qdi#+EP!+MhVq#r3i|WhAb&V!R53zc6L`Bn^gC= zLPdM)9@xLG#`?2})Hzr$da2OeN*0lai#&C24C6nk;Kfa3q*8&w6%wX3ebjk$O#cRK zmWOC(6h=c7i_~6c3_1cEA8k*Y2()pa5NIF4n3RUc*=+(da;dJWP}k;XHUjaS)M}+B zCt`dD_2Pn_e$}1QYiR$$jK68_l2NctQ_r*ua>m@s3*1GM00MjzzA|MHu&6LL&g4$0 zRCM`9CdGXEC=TndDftXHU=`eH1xAxi(ZjhMVhhJ9n8|eh? zxibdp+JI=no5oZcy4U8okf19W2`_nkKo`e^~r z83j-c)9bt-Pokaqh)K&ns;^m@2=n6*Drl>%v$qw>ORMC(|9D=TcpnR5(zPnld2gxX z)tQZJWnnv`Ee?EZQw;szReLxBJ?-v^m%`4}+L0Qjm|L70S@yLF9&u|#657F$r z#{~TqTc6Bz*3Erc=POQ=?G`G)7T6|H?;oGKgQxkEm&?wWD1cc?h|^rH%-sc0sYjp_ zcZWc4H3n3&`lgz*+RLqO<67hX{uA&YRL3nXlxb&BbgM4x%L6+ne(C>RypT9e#rawc zB5XimQUq6In+*rt+?y&<=X{4(M|ER!?_ylB+tpYd@C^To{idA8Rh1Gz)q1ZRs?2Uu zxzP0;m`XDCgz-3wJ2*>k`F$XZC)#UEJ%{@V{8SZVnx`%qqheXAtMA)JP^}rfMMeuA zf53n54q#k$^{j&vSkBwWENk3pG>emN6^`nx`MxreX`#5*xX*$>morp0KUR}e-kN1> z#2)wo5Z#x;M6{{h^4VChz?u6Z*VTd@5T!=8?d{?_*0h?CBb;)t9zRI6kBfE;tDk=i zeYG679aeI+8uhCnb$c_XrF?H|4TV?XQF9zhk1dT~hoyNF*EnVU(qiK6I!i3#Iu5MI zar8co6Y!((5zf-@WqYb#)5Axb2Z(f>rU_(Jn>1IAY*oTk17>rNRd}&OJ)?cAV1wK* z<7MnFci#o8f-WGa)hnwVYIVh`%%z1E zJ}UfpW}llMjUm&&N*=h^dn+1Cvbk@9iG(_G>}nI#v99!;+~178PQNj6e8FwgbqBM> zemX!~-xeL<=Ej%{$Pk`kry2(o%A~TCXxs+Xb=CC6wTos4czph)^D-3MZhjx-xbcj|np|DjfDMJNN9?L(*f2PejSbM$=f!r013P_SC6Cd- zxv$OqytORR>DaBAMyx`t^uMSK^|s>Zbg8cTw_OCU;BZlat#&8#?gaX#eoN(I7gUvpUAVD!!Bo1yA{EkM zv_-ca8;m+xYz!dIZN)xR>Ha>;0(kj{YWiS8z}*gB+nAuGcB%}nBlp#TfIh6$HuH}L zzMC+8#YvoJFwEOsXeb~|``7v9ge(7q;wSyC)r~IfdHtBH?KXreR}B<1b%tP3ZbW&n zf;->w)xkg)StMIn5r|*ce{_9drt%d{ZYb8m^V~{vfLIax`q2tu=)#Ti`ny@fIk<0G z4+SQfXshni8GyEgeTu8aX0<`Jw-I#KUfw*>k9iZyE2PQ^ZYR%eL3SSm&%lY_^ea-8 zJyn@>(mL$JHxT&QaZR$R`S21pNrhfEx?h0a=f4eEZ4d2>^pPi&;M7|L|q>leDw2LK~M>snxND7pjZ0Y+F9dGcHds@%OCXxJDltE3CE zDQ%FNI?<}d3i3|>P1k02yMy_Us-pJ{J(~Dn z-?6pre|V_};Ps>lV>eL9)XS4PDqjSBsi(z`O{scP%C)Z!0;VM9KEL$@e{f){*60dt z$vJfewUrjyhvoM*DBPiEQ9Av%^Ejbx9Jeb{jBVyCX9c^95ybq4d4f9I@BN>;_}X<= zaKd}-sNb-bU;X#Mo0klmr#u)~GVc*sQ+I!I1RfML`^QbO;DyL|OOPi#FrA?-zfxbg-IPJqC35))L+wE6-Wl7 zj+Kc+>xMpX@Ys+^PXu3fLE(UrX0N&Z3$?(v?s+}>{$Ev1Rvr6ZwE8dp}W|2nMN1WQhQA!z2FQRT!Oj721v zSvjy-mr~Ar?MIras-2DQ{GNWVS? z+>0gEGmknllm(VU(3+(knZ1U5XzCh85Bes7bz{8|OoFTl74;*?w6pB29S0v8U-t+? zoois@TQ)(YT~)>bV4}Q$k(wV&>ZKnRHGy7lbH!kCqtI}*M=m%3U6ljMO$6zzU(Jg^ zKvwS`6di4*?x=-EcE-OpjSiXfA6+$Utt;KfX(@Nt2k!mRK!*Aw|FO|UJFu5Y#g~uW zDHuIL>nweK%hCki1zo;TZJ7a}a=A@!0I1&^(BM8!9uT$rw<=bV$gAphw>W|=&^~yK zeUR$x47Cg?*!_BPtH;)J?kG%kfn{gAZ4+@GzTj(6I#I75?etArl;>mqvbha-RsE(2 zc5K56X6_q-5BG{cEK-U#p&Xg!BzJr0C1=$Gw}6-G@#fcK_d>jjmaJn(=wtM+qBeow zsb|e2!`f(V3-r#sUs{Teqhg&f&_Vqv+)@_Z!9CR{k@>K)8K~W{=YgPa7wcOY<}<(t7a zki~Rf2XHwE{iUvUfiY*D7X+#mo=ew&s@W^tw>cE2edwHtd>L==-~X;_L-xH4`<|E| zf_+|^3R~kUzfCVe-+q1weZ_QbBAn>(DGFQv`>OP0t^OVap5FMqrT2||&tIa(YOAW4 z(-=o6etnRee&22ztYD;V+7Feq4(wll?>Gn=u;{WlDI0Vu`mW7oc*9j+2uGB4({(jw zX7vl`^dtVb0^L^mOk|UbHZJEn`FAF;GO$P8K=7Y z?K8ouXOkbOS}&o&?*pzw94*Ph>u`AO@SV`II=F%Q=oIbX`x%fQ6CQ{S7KMaR_`m4A z>Te)y7_blBX%_x~=|AQ$mp0eVs@D>Z-2f+vnFpXpvNw@K>g+lnOuBc$+gEJqUAqHn zDjAJLbL{Std%lLv;dD(7-MFkjp<|0$JSpu!s(?1#M$>fi>iSe@?;{4Y2xnm?V|TB+ zOb7j>s}4us)p&!0#X-*4O6o9%I~wVFPU?dOx%cp*c}3~%HH$5sdK(aF5$SU!J$(m! z9>jcT=t)xaDh*+^aCrhiysUDndIzRrlsCIP9s_JLGvgt1?-}UE+SF zhQWNPbCSq?2-5!;R||o-ZjF;9RL4b3X)DuHuowTwfNh|CbA-SD9X1bEhGD<0n0PK~ zaz3Mdt^D8k>d;lX91K{n=)Ta5$Ra~rF%S6KJ~v>`&%CdG^sX7)z;w>#xJ^R60Zt!@+P(mbWF>0X_vr z>0!F|yH1NS+oZRBfK{HZhc*cNl%9wEL4#?3Z(Q*9-CNJM6IC8K)g`BzWA%HE6-PBA5WKotUL+?&fZ(Lfue+CrN_CS`fm%RWP5Y^P zxCqlFQ3Z!$+BmP)4|90P)E3{JR&;4L{pij}rkazzH8!MdRVE4M=!8})0{Sj$ zqjaAQRj-(Iw^rh#v8A%Ey1)9esJbos3Jybb4~=2Av1dkFWD>3WuRQr4S_FL4x9d~u z8DNaosMZC#SjBJRq488(=Aqe!IvDKJ-4CvA1Slhw=?Zx)xta*TVycE!sK$3dc~4%zZ$=N`eR{E>17&mV4Wh2t>}?2VsG_BZ zS2gvO?e%ycpEl(e7)|p~UE{?CvEOdAm|@%XL7)z_KD?PX7xHfE=k@gzn!W&x`N%YU z8H$4AKjHVPNu(`u^1;Pie>Nu7;8gumWf1GS>YjdqC&{+DNQtA6>uVl*c4>O>5KIU0 z(N%=eP0E*{YR%Z9{g2FCr_;C`=@w_c6OyCXX3WFIm@p#@yl@U4f*wK{n1a8&TV?;tLu+GGn&^4*h zN_u#;CJ5g}rC6@Dj~BRGbf+F6A6T(w#CV{C_tI>mW;RY(_m8<*jmPϝS5PM53 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�+ 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 literal 0 HcmV?d00001 diff --git a/tools/provenance-eval/run.py b/tools/provenance-eval/run.py new file mode 100644 index 00000000..d3e9d6b0 --- /dev/null +++ b/tools/provenance-eval/run.py @@ -0,0 +1,373 @@ +#!/usr/bin/env python3 +"""Benchmark real Atomic owner RPCs and foreground Stop checkpoints on Unix. + +Uses throwaway repositories and explicit binaries. Does not alter installed CLIs, +user configuration, real repositories, or the production owner service. +""" +import argparse +import base64 +import concurrent.futures +import hashlib +import json +import os +import pathlib +import platform +import socket +import statistics +import struct +import subprocess +import tempfile +import time + +import blake3 + +SESSION = "provenance-perf" +SCENARIOS = { + "rpc-single": dict(events=128, batch=1, workers=1, transport="rpc", turns=1), + "rpc-batch16": dict(events=128, batch=16, workers=1, transport="rpc", turns=1), + "rpc-batch16-concurrent8": dict(events=128, batch=16, workers=8, transport="rpc", turns=1), + "rpc-concurrent8": dict(events=128, batch=1, workers=8, transport="rpc", turns=1), + "hook-single": dict(events=32, batch=1, workers=1, transport="hook", turns=1), + "hook-concurrent8": dict(events=32, batch=1, workers=8, transport="hook", turns=1), + "long-turn": dict(events=512, batch=16, workers=1, transport="rpc", turns=1), + "read-only-turn": dict(events=128, batch=1, workers=1, transport="rpc", turns=1, write_file=False), + "five-turn-history": dict(events=32, batch=1, workers=1, transport="rpc", turns=5), + "frame-boundary": dict(events=1024, batch=16, workers=1, transport="rpc", turns=1), +} + + +def encoded(value): + return json.dumps(value, separators=(",", ":"), ensure_ascii=False).encode() + + +def summary(samples): + ordered = sorted(samples) + return {"count": len(samples), "p50_ms": statistics.median(ordered), + "p95_ms": ordered[min(len(ordered) - 1, int(len(ordered) * .95))], + "min_ms": ordered[0], "max_ms": ordered[-1]} + + +def output_payload(index, size): + # Deterministic, varied hex avoids an unrealistically compressible repeated byte. + text = "".join(hashlib.sha256(f"event-{index}-block-{block}".encode()).hexdigest() + for block in range((size + 63) // 64)) + return text[:size] + + +def tool_payload(index, size, turn): + return {"session_id": SESSION, "tool_use_id": f"bench-{turn}-{index}", + "tool_name": "Read", "tool_input": {"path": f"src/module_{index % 16}.rs"}, + "tool_output": output_payload(index, size), "status": "completed"} + + +def envelope(index, size, turn, generation, timestamp_ms): + raw = tool_payload(index, size, turn) + return {"schema_version": 1, "event_id": f"bench-event-{turn}-{index}", + "session_id": SESSION, "turn_number": turn, "generation": generation, + "timestamp_ms": timestamp_ms + index, "causal_parent_ids": [], + "event": {"type": "tool", "phase": "after", "tool_name": raw["tool_name"], + "tool_call_id": raw["tool_use_id"], "input": raw["tool_input"], + "output": raw["tool_output"], "status": "completed", "raw": raw}} + + +class Fixture: + def __init__(self, binary, root): + self.binary = str(binary) + self.root = root + self.env = os.environ.copy() + self.env["NO_COLOR"] = "1" + # The foreground owner is the only process this fixture owns and stops. + self.owner = None + self.owner_log = tempfile.TemporaryFile() + + def start(self): + self.run("init", str(self.root)) + canonical = str((self.root / ".atomic").resolve()) + digest = blake3.blake3(canonical.encode()).hexdigest()[:24] + self.endpoint = f"/tmp/atomic-owner-{digest}.sock" + self.owner = subprocess.Popen( + [self.binary, "agent", "database-owner", "serve", "--repository", str(self.root)], + stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=self.owner_log, + env=self.env) + deadline = time.monotonic() + 15 + while True: + try: + self.rpc("Ping") + break + except (OSError, RuntimeError): + if self.owner.poll() is not None or time.monotonic() > deadline: + raise RuntimeError("owner failed to start") + time.sleep(.025) + self.hook("session-start", {"session_id": SESSION}) + + def run(self, *args, payload=None, timeout=45): + result = subprocess.run([self.binary, *args, "--no-color"], cwd=self.root, + input=payload, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + timeout=timeout, env=self.env) + if result.returncode: + raise RuntimeError(f"{' '.join(args)}: {result.stderr.decode(errors='replace')}") + return result + + def hook(self, verb, payload): + result = self.run("agent", "hooks", "claude-code", verb, "--foreground", + payload=encoded(payload)) + if result.stderr: + raise RuntimeError(result.stderr.decode(errors="replace")) + return result + + def rpc(self, request): + # Match the owner's versioned JSON frame and one connection per RPC. + frame = encoded({"version": 1, "request_id": "perf", "request": request}) + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as stream: + stream.settimeout(45) + stream.connect(self.endpoint) + stream.sendall(struct.pack(">I", len(frame)) + frame) + + def read_exact(size): + data = bytearray() + while len(data) < size: + chunk = stream.recv(size - len(data)) + if not chunk: + raise RuntimeError("owner closed connection before response") + data.extend(chunk) + return data + + size = struct.unpack(">I", read_exact(4))[0] + if not 0 < size <= 8 * 1024 * 1024: + raise RuntimeError(f"invalid owner frame size: {size}") + response = json.loads(read_exact(size))["response"] + if isinstance(response, dict) and "Error" in response: + raise RuntimeError(str(response["Error"])) + return response + + def status(self, turn): + return self.rpc({"TurnStatus": {"session_id": SESSION, "turn_number": turn}})["TurnLifecycle"]["turn"] + + def close(self): + if self.owner is not None and self.owner.poll() is None: + try: + self.rpc("Shutdown") + self.owner.wait(timeout=10) + except (OSError, RuntimeError, subprocess.TimeoutExpired): + self.owner.kill() + self.owner.wait(timeout=10) + self.owner_log.seek(0) + logs = self.owner_log.read().decode(errors="replace") + self.owner_log.close() + return logs + + +def measure_turn(fixture, config, payload_bytes, turn, previous_ledger): + fixture.hook("user-prompt-submit", {"session_id": SESSION, "prompt": f"Implement measured turn {turn}"}) + running = fixture.status(turn) + assert running["state"] == "Running" + start_seq = running["next_event_seq"] + pid = running["provenance_id"] + generation = running["generation"] + count = config["events"] + + requests = [] + if config["transport"] == "rpc": + timestamp_ms = int(time.time() * 1000) + envelopes = [envelope(i, payload_bytes, turn, generation, timestamp_ms) for i in range(count)] + wire = [{"event_id": e["event_id"], "bytes": list(encoded(e))} for e in envelopes] + for offset in range(0, count, config["batch"]): + requests.append({"AppendProvenanceEnvelopes": { + "provenance_id": pid, "expected_generation": generation, + "envelopes": wire[offset:offset + config["batch"]], "now": timestamp_ms // 1000}}) + else: + requests = [tool_payload(i, payload_bytes, turn) for i in range(count)] + + def append(request): + started = time.perf_counter_ns() + if config["transport"] == "rpc": + response = fixture.rpc(request)["ProvenanceEnvelopesCommitted"] + acks = response["acknowledgements"] + else: + fixture.hook("post-tool", request) + acks = [] + return (time.perf_counter_ns() - started) / 1e6, acks + + # Pool creation is outside the timer; lazy thread startup is included in wall time. + with concurrent.futures.ThreadPoolExecutor(max_workers=config["workers"]) as pool: + started = time.perf_counter_ns() + outputs = list(pool.map(append, requests)) + append_wall_ms = (time.perf_counter_ns() - started) / 1e6 + latencies = [row[0] for row in outputs] + acks = [ack for row in outputs for ack in row[1]] + after_append = fixture.status(turn) + assert after_append["next_event_seq"] == start_seq + count, (start_seq, after_append) + if acks: + assert sorted(a["sequence"] for a in acks) == list(range(start_seq, start_seq + count)) + assert len({a["event_id"] for a in acks}) == count + # Duplicate delivery is checked outside the measured append phase. + append(requests[0]) + assert fixture.status(turn)["next_event_seq"] == start_seq + count + + # A real file change causes recording plus graph generation and ledger publication. + source = "\n".join(f"pub fn value_{i}() -> u64 {{ {i + turn} }}" for i in range(128)) + "\n" + writes_file = config.get("write_file", True) + if writes_file: + (fixture.root / "measured.rs").write_text(source) + result = {"turn": turn, "events": count, "append_wall_ms": append_wall_ms, + "events_s": count / (append_wall_ms / 1000), "append_request_ms": latencies, + "append_latency": summary(latencies), "starting_event_seq": start_seq, + "append_verified": True, "duplicate_verified": True, + "file_bytes": len(source.encode()) if writes_file else 0} + if config["transport"] == "rpc": + result["tool_envelope_bytes"] = sum(len(e["bytes"]) for e in wire) + # Lower bound: excludes the goal and terminal/checkpoint envelopes. + result["frozen_tools_json_bytes"] = len(encoded({"FrozenEnvelopes": {"envelopes": [e["bytes"] for e in wire]}})) + checkpoint_start = time.perf_counter_ns() + try: + fixture.hook("stop", {"session_id": SESSION, "reason": "end_turn", "response": f"Completed turn {turn}"}) + except (RuntimeError, subprocess.TimeoutExpired) as error: + result.update(checkpoint_ms=(time.perf_counter_ns() - checkpoint_start) / 1e6, + checkpoint_ok=False, checkpoint_error=str(error), final_state=fixture.status(turn)) + return result, previous_ledger + result["checkpoint_ms"] = (time.perf_counter_ns() - checkpoint_start) / 1e6 + completed = fixture.status(turn) + assert completed["state"] == "Completed", completed + attempt = completed["checkpoint_attempt"] + assert attempt["phase"] == "Published", attempt + assert attempt["provenance_hash"] is not None and attempt["manifest_hash"] is not None + assert bool(attempt["source"]["change_hashes"]) == writes_file, "unexpected recorded file changes" + page_sizes = [] + if fixture.rpc("Ping")["Pong"].get("frozen_envelope_paging", False): + frozen = [] + partial = [] + cursor = {"seq": 0, "offset": 0} + while cursor["seq"] < attempt["frozen_event_count"]: + response = fixture.rpc({"LoadFrozenEnvelopesPage": { + "provenance_id": pid, "attempt_generation": attempt["attempt_generation"], + "frozen_event_count": attempt["frozen_event_count"], "cursor": cursor}}) + page_sizes.append(len(encoded({"version": 1, "request_id": "perf", "response": response}))) + page = response["FrozenEnvelopesPage"]["page"] + assert (page["next"]["seq"], page["next"]["offset"]) > (cursor["seq"], cursor["offset"]) + for fragment in page["fragments"]: + assert fragment["cursor"]["offset"] == len(partial) + partial.extend(fragment["bytes"]) + if fragment["complete"]: + frozen.append(partial) + partial = [] + cursor = page["next"] + assert not partial + assert max(page_sizes) <= 8 * 1024 * 1024 + else: + frozen = fixture.rpc({"LoadFrozenEnvelopes": {"provenance_id": pid}})["FrozenEnvelopes"]["envelopes"] + result["verification_page_sizes"] = page_sizes + decoded = [json.loads(bytes(e)) for e in frozen] + tools = [e for e in decoded if e["event"].get("tool_call_id", "").startswith(f"bench-{turn}-")] + assert len(tools) == count + assert len({e["event_id"] for e in decoded}) == len(decoded) + assert all(e["session_id"] == SESSION and e["turn_number"] == turn for e in decoded) + for e in tools: + index = int(e["event"]["tool_call_id"].rsplit("-", 1)[1]) + assert e["event"]["output"] == output_payload(index, payload_bytes) + assert e["event"]["raw"]["tool_output"] == output_payload(index, payload_bytes) + ledger = json.loads(fixture.run("session", "show", SESSION, "--json").stdout)[1] + assert len(ledger) == turn and ledger[:-1] == previous_ledger + assert ledger[-1]["provenance_hash"] == attempt["provenance_hash"] + assert ledger[-1]["change_hashes"] == attempt["source"]["change_hashes"] + graph_bytes = 0 + for entry in ledger: + digest = entry["provenance_hash"] + data = (fixture.root / ".atomic" / "changes" / digest[:2] / f"{digest}.provenance").read_bytes() + assert base64.b32encode(blake3.blake3(data).digest()).decode().rstrip("=") == digest + if digest == attempt["provenance_hash"]: + graph_bytes = len(data) + detail = fixture.run("session", "show", SESSION).stdout.decode() + assert f"Manifest head: {attempt['manifest_hash']}" in detail + if previous_ledger: + assert attempt["source"]["previous_provenance"] == previous_ledger[-1]["provenance_hash"] + # A repeated Stop must not publish another turn or change earlier ledger entries. + fixture.hook("stop", {"session_id": SESSION, "reason": "end_turn", "response": f"Completed turn {turn}"}) + assert json.loads(fixture.run("session", "show", SESSION, "--json").stdout)[1] == ledger + result.update(checkpoint_ok=True, checkpoint_verified=True, retry_verified=True, + frozen_events=len(decoded), envelope_bytes=sum(len(e) for e in frozen), + frozen_frame_bytes=len(encoded({"version": 1, "request_id": "perf", "response": {"FrozenEnvelopes": {"envelopes": frozen}}})), + ledger_turns=len(ledger), ledger_hash=attempt["provenance_hash"], + manifest_hash=attempt["manifest_hash"], previous_turns_unchanged=True, + graph_hash_verified=True, graph_bytes=graph_bytes, manifest_head_verified=True) + return result, ledger + + +def measure_case(binary, name, config, payload_bytes): + fixture = None + with tempfile.TemporaryDirectory(prefix="atomic-provenance-perf-") as temp: + root = pathlib.Path(temp) + try: + fixture = Fixture(binary, root) + fixture.start() + ledger = [] + turns = [] + for turn in range(1, config["turns"] + 1): + row, ledger = measure_turn(fixture, config, payload_bytes, turn, ledger) + turns.append(row) + if not row["checkpoint_ok"]: + break + result = {"scenario": name, "config": config, "turns": turns} + finally: + if fixture is not None: + logs = fixture.close() + result["owner_log"] = logs + return result + + +def summarize(rows): + groups = {} + for row in rows: + groups.setdefault((row["mode"], row["scenario"]), []).append(row) + output = {} + for (mode, scenario), cases in groups.items(): + turns = [t for case in cases for t in case["turns"]] + checkpoints = [t["checkpoint_ms"] for t in turns if t["checkpoint_ok"]] + rate = [sum(t["events"] for t in c["turns"]) / (sum(t["append_wall_ms"] for t in c["turns"]) / 1000) for c in cases] + output[f"{mode}:{scenario}"] = { + "runs": len(cases), "turns": len(turns), "successful_checkpoints": len(checkpoints), + "median_events_s": statistics.median(rate), "min_events_s": min(rate), "max_events_s": max(rate), + "median_request_p50_ms": statistics.median(t["append_latency"]["p50_ms"] for t in turns), + "median_request_p95_ms": statistics.median(t["append_latency"]["p95_ms"] for t in turns), + "checkpoint": summary(checkpoints) if checkpoints else None} + return output + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--binary", action="append", required=True, help="MODE=/absolute/path/to/release/atomic") + parser.add_argument("--output", type=pathlib.Path, required=True) + parser.add_argument("--repeats", type=int, default=5) + parser.add_argument("--payload-bytes", type=int, default=1024) + parser.add_argument("--scenarios", nargs="+", choices=SCENARIOS, default=[s for s in SCENARIOS if s != "frame-boundary"]) + args = parser.parse_args() + assert hasattr(socket, "AF_UNIX"), "this driver currently supports Unix sockets" + binaries = dict(pair.split("=", 1) for pair in args.binary) + binaries = {mode: pathlib.Path(path).resolve() for mode, path in binaries.items()} + assert args.repeats > 0 and args.payload_bytes > 0 + metadata = {"platform": platform.platform(), "python": platform.python_version(), + "started_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"), + "payload_output_bytes": args.payload_bytes, "repeats": args.repeats, + "blake3_version": blake3.__version__, + "binaries": {m: {"path": str(p), "sha256": hashlib.sha256(p.read_bytes()).hexdigest()} for m, p in binaries.items()}} + if platform.system() == "Darwin": + metadata["hardware"] = subprocess.check_output(["sysctl", "machdep.cpu.brand_string", "hw.logicalcpu", "hw.memsize"], text=True) + result = {"metadata": metadata, "measurements": []} + args.output.parent.mkdir(parents=True, exist_ok=True) + for repeat in range(args.repeats): + modes = list(binaries) + modes = modes[repeat % len(modes):] + modes[:repeat % len(modes)] + for name in args.scenarios: + for mode in modes: + case = measure_case(binaries[mode], name, SCENARIOS[name], args.payload_bytes) + case.update(mode=mode, repeat=repeat) + result["measurements"].append(case) + result["summary"] = summarize(result["measurements"]) + args.output.write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({"repeat": repeat, "mode": mode, "scenario": name, + "events_s": [round(t["events_s"], 1) for t in case["turns"]], + "checkpoint_ms": [round(t["checkpoint_ms"], 1) for t in case["turns"]], + "checkpoint_ok": [t["checkpoint_ok"] for t in case["turns"]]}), flush=True) + + +if __name__ == "__main__": + main() From e1fe242610ba65e0bc65232b9b17a31302097f2e Mon Sep 17 00:00:00 2001 From: Vincent Date: Tue, 15 Sep 2026 18:51:48 -0400 Subject: [PATCH 13/15] fix(cli): wait for transient database locks in ordinary reads Route ordinary read-only CLI queries through the existing ten-second typed contention wait. Preserve library immediate-open behavior and non-lock errors. Exported from Atomic view fix/redb-provenance-validation. Intent: ATOM::vince::9 (01M2KK12S425M8QGZ7RVS2XTES) Atomic change: AVVPMGK2LCE4SCJH7UD3RULX2FN5P5X3AJYXWH5TOGOW5WPK2R5A Validation: 1909 CLI tests, workspace Clippy, format, and release build pass. Three-repeat 1/4/8-session replay: 6240/6240 reads, 156/156 Stops, 78/78 verified sessions; baseline had 678 read lock failures. --- atomic-cli/src/commands/change/command.rs | 2 +- atomic-cli/src/commands/change/tests.rs | 14 +- atomic-cli/src/commands/conflicts.rs | 7 +- atomic-cli/src/commands/diff/command.rs | 7 +- atomic-cli/src/commands/intent/list.rs | 3 +- atomic-cli/src/commands/intent/show.rs | 4 +- atomic-cli/src/commands/log/command.rs | 2 +- atomic-cli/src/commands/log/tests.rs | 60 +- atomic-cli/src/commands/mod.rs | 13 + atomic-cli/src/commands/status.rs | 7 +- atomic-cli/src/commands/vault/context.rs | 3 +- atomic-cli/src/commands/vault/show.rs | 4 +- .../tests/concurrent_intent_reads_test.rs | 149 +++++ docs/concurrent-stop-publication.md | 5 + docs/ordinary-read-lock-wait.md | 83 +++ .../ordinary-read-wait-2026-09-15.json | 576 ++++++++++++++++++ .../ordinary-read-wait-2026-09-15.tar.gz | Bin 0 -> 244677 bytes 17 files changed, 879 insertions(+), 60 deletions(-) create mode 100644 docs/ordinary-read-lock-wait.md create mode 100644 tools/provenance-eval/results/ordinary-read-wait-2026-09-15.json create mode 100644 tools/provenance-eval/results/ordinary-read-wait-2026-09-15.tar.gz diff --git a/atomic-cli/src/commands/change/command.rs b/atomic-cli/src/commands/change/command.rs index 3542d09e..c51ccfba 100644 --- a/atomic-cli/src/commands/change/command.rs +++ b/atomic-cli/src/commands/change/command.rs @@ -761,7 +761,7 @@ impl Command for ChangeCmd { fn run(&self) -> CliResult<()> { // Find and open repository let repo_root = find_repository_root()?; - let repo = Repository::open_readonly(&repo_root).map_err(|e| match e { + let repo = crate::commands::open_readonly_repository(&repo_root).map_err(|e| match e { atomic_repository::RepositoryError::NotFound { path } => CliError::RepositoryNotFound { searched_path: path.into(), }, diff --git a/atomic-cli/src/commands/change/tests.rs b/atomic-cli/src/commands/change/tests.rs index a1c9608c..f9ec7525 100644 --- a/atomic-cli/src/commands/change/tests.rs +++ b/atomic-cli/src/commands/change/tests.rs @@ -595,7 +595,7 @@ mod tests { let _guard = TestGuard::new(); // Initialize empty repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new(); let result = cmd.run(); @@ -609,7 +609,7 @@ mod tests { fn test_change_run_invalid_sequence() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new().with_identifier("#999"); let result = cmd.run(); @@ -623,7 +623,7 @@ mod tests { fn test_change_run_nonexistent_view() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new() .with_identifier("#0") @@ -638,7 +638,7 @@ mod tests { fn test_change_run_json_format() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new().with_format(ChangeFormat::Json); let result = cmd.run(); @@ -652,7 +652,7 @@ mod tests { fn test_change_run_short_format() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new().with_format(ChangeFormat::Short); let result = cmd.run(); @@ -666,7 +666,7 @@ mod tests { fn test_change_run_with_show_deps() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new().with_show_deps(true); let result = cmd.run(); @@ -680,7 +680,7 @@ mod tests { fn test_change_run_with_show_hunks() { let _guard = TestGuard::new(); - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let cmd = ChangeCmd::new().with_show_hunks(true); let result = cmd.run(); diff --git a/atomic-cli/src/commands/conflicts.rs b/atomic-cli/src/commands/conflicts.rs index a7a08f8b..7aeb3a57 100644 --- a/atomic-cli/src/commands/conflicts.rs +++ b/atomic-cli/src/commands/conflicts.rs @@ -44,10 +44,11 @@ impl Conflicts { impl Command for Conflicts { fn run(&self) -> CliResult<()> { let repo_root = find_repository_root()?; - let repo = - Repository::open_readonly(&repo_root).map_err(|e| CliError::InvalidRepository { + let repo = crate::commands::open_readonly_repository(&repo_root).map_err(|e| { + CliError::InvalidRepository { reason: e.to_string(), - })?; + } + })?; let conflicts = repo .list_conflicts() diff --git a/atomic-cli/src/commands/diff/command.rs b/atomic-cli/src/commands/diff/command.rs index a5fccec6..243a9e89 100644 --- a/atomic-cli/src/commands/diff/command.rs +++ b/atomic-cli/src/commands/diff/command.rs @@ -225,10 +225,11 @@ impl Command for Diff { let repo_root = find_repository_root()?; // Open the repository - let repo = - Repository::open_readonly(&repo_root).map_err(|e| CliError::InvalidRepository { + let repo = crate::commands::open_readonly_repository(&repo_root).map_err(|e| { + CliError::InvalidRepository { reason: e.to_string(), - })?; + } + })?; // Parse algorithm let algorithm = self.parse_algorithm()?; diff --git a/atomic-cli/src/commands/intent/list.rs b/atomic-cli/src/commands/intent/list.rs index 48a50e5f..c9314975 100644 --- a/atomic-cli/src/commands/intent/list.rs +++ b/atomic-cli/src/commands/intent/list.rs @@ -287,7 +287,8 @@ fn build_rows( impl Command for IntentList { fn run(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; // Resolve the verifying identity ONCE (soft-fail to "no identity"). let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/intent/show.rs b/atomic-cli/src/commands/intent/show.rs index 5ff78fcf..2e2943e5 100644 --- a/atomic-cli/src/commands/intent/show.rs +++ b/atomic-cli/src/commands/intent/show.rs @@ -3,7 +3,6 @@ use clap::Parser; use atomic_canonical::{render, Target}; -use atomic_repository::Repository; use crate::commands::intent::bridge; use crate::commands::{find_repository_root, Command}; @@ -27,7 +26,8 @@ pub struct IntentShow { impl Command for IntentShow { fn run(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; // Pure read-time projection: lift then render. No gate, no proof // requirement — this must work on a plain (un-attested) intent. The diff --git a/atomic-cli/src/commands/log/command.rs b/atomic-cli/src/commands/log/command.rs index 883eed93..0741d8ae 100644 --- a/atomic-cli/src/commands/log/command.rs +++ b/atomic-cli/src/commands/log/command.rs @@ -499,7 +499,7 @@ impl Command for Log { fn run(&self) -> CliResult<()> { // Find and open repository let repo_root = find_repository_root()?; - let repo = Repository::open_readonly(&repo_root).map_err(|e| match e { + let repo = crate::commands::open_readonly_repository(&repo_root).map_err(|e| match e { atomic_repository::RepositoryError::NotFound { path } => CliError::RepositoryNotFound { searched_path: path.into(), }, diff --git a/atomic-cli/src/commands/log/tests.rs b/atomic-cli/src/commands/log/tests.rs index 99889b67..15a10f66 100644 --- a/atomic-cli/src/commands/log/tests.rs +++ b/atomic-cli/src/commands/log/tests.rs @@ -708,15 +708,13 @@ mod tests { let _guard = TestGuard::new(); // Initialize empty repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new(); let result = log.run(); - // Should succeed but print empty message - // The result could fail due to database initialization issues in tests - // Just verify it doesn't panic - let _ = result; + // The initializer no longer holds the writer lock during the query. + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -725,7 +723,7 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_view("nonexistent-view"); let result = log.run(); @@ -745,13 +743,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_format(LogFormat::Json); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -760,13 +757,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_format(LogFormat::Short); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -775,13 +771,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_format(LogFormat::Oneline); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -790,13 +785,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_count(5); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -805,13 +799,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_reverse(true); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -821,14 +814,13 @@ mod tests { // Initialize repository and drop to release db lock { - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); } let log = Log::new().with_from(0); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -837,13 +829,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_tags_only(true); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -852,13 +843,12 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new().with_full_hash(true); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -867,7 +857,7 @@ mod tests { let _guard = TestGuard::new(); // Initialize repository - let _repo = Repository::init(".").unwrap(); + drop(Repository::init(".").unwrap()); let log = Log::new() .with_count(10) @@ -876,8 +866,7 @@ mod tests { .with_full_hash(true); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } #[test] @@ -891,7 +880,7 @@ mod tests { // Filesystem may be read-only or other issues in test environment return; } - let _repo = repo_result.unwrap(); + drop(repo_result.unwrap()); // Create and move to subdirectory if fs::create_dir("subdir").is_err() { @@ -905,8 +894,7 @@ mod tests { let log = Log::new(); let result = log.run(); - // Result could fail due to database issues; just don't panic - let _ = result; + assert!(result.is_ok(), "{result:?}"); } // Edge Case Tests diff --git a/atomic-cli/src/commands/mod.rs b/atomic-cli/src/commands/mod.rs index 913bdb31..519a0603 100644 --- a/atomic-cli/src/commands/mod.rs +++ b/atomic-cli/src/commands/mod.rs @@ -357,6 +357,19 @@ pub fn open_repository(path: Option<&Path>) -> CliResult { Repository::open(&repo_path).map_err(CliError::from) } +/// Acquire a read-only repository for a CLI query, allowing short-lived writers +/// (such as Stop checkpoint publication) to finish first. Only typed database +/// contention is retried, for at most ten seconds; all other errors propagate +/// immediately. Callers must not already hold a writable repository handle. +/// +/// Keep this policy at the CLI boundary: library callers may require immediate +/// failure or supply their own deadline to `Repository::open_readonly_wait`. +pub(crate) fn open_readonly_repository( + path: impl AsRef, +) -> Result { + Repository::open_readonly_wait(path, std::time::Duration::from_secs(10)) +} + /// Open a repository or return a user-friendly error. /// /// This is a convenience wrapper around [`open_repository`] that provides diff --git a/atomic-cli/src/commands/status.rs b/atomic-cli/src/commands/status.rs index 5014fefa..1e6e46c6 100644 --- a/atomic-cli/src/commands/status.rs +++ b/atomic-cli/src/commands/status.rs @@ -515,10 +515,11 @@ impl Command for Status { } // Open the repository - let repo = - Repository::open_readonly(&repo_root).map_err(|e| CliError::InvalidRepository { + let repo = crate::commands::open_readonly_repository(&repo_root).map_err(|e| { + CliError::InvalidRepository { reason: e.to_string(), - })?; + } + })?; // Debug ignore patterns if requested if self.debug_ignore { diff --git a/atomic-cli/src/commands/vault/context.rs b/atomic-cli/src/commands/vault/context.rs index e3b5ab1e..4c4881df 100644 --- a/atomic-cli/src/commands/vault/context.rs +++ b/atomic-cli/src/commands/vault/context.rs @@ -184,7 +184,8 @@ impl Command for Context { } let root = find_repository_root()?; - let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let limit = self.limit; let candidates = self.gather_candidates(&repo, limit)?; diff --git a/atomic-cli/src/commands/vault/show.rs b/atomic-cli/src/commands/vault/show.rs index c9c2a892..c4674e5d 100644 --- a/atomic-cli/src/commands/vault/show.rs +++ b/atomic-cli/src/commands/vault/show.rs @@ -3,7 +3,6 @@ use clap::Parser; use atomic_core::pristine::vault::VaultEntry; -use atomic_repository::Repository; use crate::commands::{find_repository_root, Command}; use crate::error::{CliError, CliResult}; @@ -49,7 +48,8 @@ pub struct Show { impl Command for Show { fn run(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open_readonly(&root).map_err(CliError::Repository)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let entry = repo .vault_retrieve(&self.path) diff --git a/atomic-cli/tests/concurrent_intent_reads_test.rs b/atomic-cli/tests/concurrent_intent_reads_test.rs index 6d7058da..b58dce1e 100644 --- a/atomic-cli/tests/concurrent_intent_reads_test.rs +++ b/atomic-cli/tests/concurrent_intent_reads_test.rs @@ -3,6 +3,155 @@ use std::time::{Duration, Instant}; use atomic_repository::{IntentCreateOptions, Repository}; +// Ensure a failed assertion or deadline never leaves query processes running. +struct Queries(Vec); + +impl Drop for Queries { + fn drop(&mut self) { + for child in &mut self.0 { + let _ = child.kill(); + let _ = child.wait(); + } + } +} + +fn spawn_query(root: &std::path::Path, args: &[&str]) -> std::process::Child { + Command::new(env!("CARGO_BIN_EXE_atomic")) + .args(args) + .current_dir(root) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap() +} + +fn finish_queries(mut queries: Queries, timeout: Duration) -> Vec { + let deadline = Instant::now() + timeout; + while queries + .0 + .iter_mut() + .any(|child| child.try_wait().unwrap().is_none()) + { + assert!(Instant::now() < deadline, "read commands exceeded deadline"); + std::thread::sleep(Duration::from_millis(10)); + } + std::mem::take(&mut queries.0) + .into_iter() + .map(|child| child.wait_with_output().unwrap()) + .collect() +} + +#[test] +fn ordinary_queries_wait_for_a_writer_including_sandbox_intent_reads() { + let temp = tempfile::tempdir().unwrap(); + let writer = Repository::init(temp.path()).unwrap(); + writer.init_vault().unwrap(); + let intent = writer + .vault_intent_create(IntentCreateOptions { + title: "Read after writer closes".to_string(), + priority: None, + assignee: None, + labels: Vec::new(), + session_id: None, + turn_id: None, + kind: None, + }) + .unwrap(); + let sandbox = tempfile::tempdir().unwrap(); + writer + .provision_sandbox(sandbox.path(), writer.current_view()) + .unwrap(); + let commands: &[&[&str]] = &[ + &["intent", "list", "--json"], + &["intent", "show", &intent.id, "--json"], + &["intent", "list", "--json"], + &["intent", "show", &intent.id, "--json"], + &["status"], + &["log"], + &["diff"], + &["conflicts"], + ]; + let mut queries = Queries( + commands + .iter() + .enumerate() + .map(|(i, args)| { + spawn_query( + if i == 2 || i == 3 { + sandbox.path() + } else { + temp.path() + }, + args, + ) + }) + .collect(), + ); + // A real writable handle prevents all these opens. No command-side retry + // is performed by the test; each child must wait inside its CLI opener. + std::thread::sleep(Duration::from_millis(250)); + for child in &mut queries.0 { + assert!( + child.try_wait().unwrap().is_none(), + "query failed before writer closed" + ); + } + drop(writer); + for (i, output) in finish_queries(queries, Duration::from_secs(10)) + .into_iter() + .enumerate() + { + assert!( + output.status.success(), + "{:?}: {}", + commands[i], + String::from_utf8_lossy(&output.stderr) + ); + if i < 4 { + let _: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); + assert!(String::from_utf8_lossy(&output.stdout).contains(&intent.id)); + } + } +} + +#[test] +fn ordinary_read_timeout_returns_failure_without_waiting_forever() { + let temp = tempfile::tempdir().unwrap(); + let _writer = Repository::init(temp.path()).unwrap(); + let start = Instant::now(); + let outputs = finish_queries( + Queries(vec![spawn_query( + temp.path(), + &["intent", "list", "--json"], + )]), + Duration::from_secs(20), + ); + assert!(start.elapsed() >= Duration::from_secs(10)); + assert!(!outputs[0].status.success()); + assert!(String::from_utf8_lossy(&outputs[0].stderr).contains("Database already open")); +} + +#[test] +fn ordinary_read_corruption_fails_without_contention_wait() { + let temp = tempfile::tempdir().unwrap(); + drop(Repository::init(temp.path()).unwrap()); + std::fs::write( + temp.path().join(".atomic/pristine.redb"), + b"corrupt database", + ) + .unwrap(); + let outputs = finish_queries( + Queries(vec![spawn_query( + temp.path(), + &["intent", "list", "--json"], + )]), + Duration::from_secs(3), + ); + assert!(!outputs[0].status.success()); + assert!(!String::from_utf8_lossy(&outputs[0].stderr).contains("Database already open")); + assert!(outputs[0].stdout.is_empty()); +} + #[test] fn intent_queries_share_a_read_only_database_across_processes() { let temp = tempfile::tempdir().unwrap(); diff --git a/docs/concurrent-stop-publication.md b/docs/concurrent-stop-publication.md index 3563978f..47a7a860 100644 --- a/docs/concurrent-stop-publication.md +++ b/docs/concurrent-stop-publication.md @@ -107,6 +107,11 @@ python tools/provenance-eval/multi_session.py \ ## Scope and remaining limits +September 15 follow-up: ordinary CLI read commands now also use bounded +database acquisition. See [ordinary read lock waiting](ordinary-read-lock-wait.md) +for scope and the new zero-read-failure workload results. The measurements above +describe the earlier Stop-only fix and are retained as historical evidence. + This coordinates cooperating Stop publishers. It does not turn redb 4.2 into a database that supports readers alongside a writable process. Ordinary CLI reads may still fail while a writer is open. Other long-lived writers can diff --git a/docs/ordinary-read-lock-wait.md b/docs/ordinary-read-lock-wait.md new file mode 100644 index 00000000..658c0a3a --- /dev/null +++ b/docs/ordinary-read-lock-wait.md @@ -0,0 +1,83 @@ +# Bounded database acquisition for ordinary CLI reads + +Work item: `ATOM::vince::9` (`01M2KK12S425M8QGZ7RVS2XTES`), independent +`fix/redb-provenance-validation` view. Retains redb 4.2. + +## Behavior + +Stop/checkpoint publication already waited for transient database contention. +Ordinary queries still used immediate read-only opens and failed when a Stop +held the incompatible writer handle. They now acquire the repository through +a shared CLI helper that calls `Repository::open_readonly_wait` with a ten-second +limit. It retries only typed `DatabaseBusy`, not the command or its side effects. +Corruption, permission and other errors propagate immediately; persistent +contention returns an error after the acquisition budget expires. + +Covered commands: `intent list`, `intent show`, `vault show`, `vault context`, +`status` (read phase), `log`, `diff`, `change`, and `conflicts`. Sandbox reads +resolve to the canonical database. The public Repository immediate-open APIs, +write paths, advisory evidence/import probes, and redb version are unchanged. +This is bounded retry, not an API server, a fair queue, or redb 5 shared mode. + +## Regression verification + +- Actual subprocess queries remain alive while a writer is held, then return + successfully when it closes; includes canonical and sandbox intent reads + and status/log/diff/conflicts. No test-side command retry is used. +- A continuously held writer causes an ordinary read to fail after ten seconds. +- A corrupt database fails within the three-second test deadline instead of + spending the contention budget or returning empty success. +- Existing concurrent-reader and owner/checkpoint recovery tests remain green. +- Older change/log fixtures now release their initializer writer before invoking + a query. Empty-log cases assert success instead of accepting any database error. + +**1,909 CLI tests passed, zero failed or ignored** with +`cargo test --locked --offline -p atomic-cli --all-targets --no-fail-fast`. +`cargo fmt --all -- --check`, the release build, and the CI-equivalent +`cargo clippy --locked --offline --workspace -- -D warnings` passed. +An additional all-targets Clippy run reports the existing +`items_after_test_module` lint in `triage/output.rs:761` (HTML_STYLE at 1058). +That file is byte-identical to PR head 82f488b; it is outside this change. + +## Release workload comparison + +The immutable baseline is PR #190 head `82f488b0164086decf720569fe34bdced4e1a398`, +which already contains pagination, concurrent Stop coordination and batching. +Both binaries use the same redb 4.2 dependency lockfile. Existing +`tools/provenance-eval/multi_session.py` runs 1/4/8 independent sessions, +balanced/read-heavy queries, two turns of 16 tool events, three repetitions +per case, alternating binary order. No `--serialize-stop` or external retries. +Compilation and tests finished before measuring. + +| Result across 18 runs per binary | Before read waiting | With read waiting | +|---|---:|---:| +| Reads successful/attempted | 5562/6240 | 6240/6240 | +| Stop successful/attempted | 156/156 | 156/156 | +| Fully verified sessions | 78/78 | 78/78 | + +All 2,496 tool-event payloads, event identities, ledger predecessors, graph +hashes and duplicate Stop behavior were verified in the fixed runs. + +| Workload | Sessions | Before wall median (s) | Fixed wall median (s) | Fixed read p50/p95 (ms) | Fixed Stop p50/p95 (ms) | +|---|---:|---:|---:|---:|---:| +| balanced | 1 | 1.221 | 1.533 | 15.5/42.2 | 50.6/116.7 | +| balanced | 4 | 2.181 | 1.533 | 16.4/48.5 | 107.5/277.6 | +| balanced | 8 | 2.697 | 2.784 | 19.9/72.5 | 268.0/1023.7 | +| read-heavy | 1 | 2.283 | 1.727 | 9.8/15.5 | 50.3/53.8 | +| read-heavy | 4 | 2.778 | 2.734 | 12.5/31.5 | 95.5/275.0 | +| read-heavy | 8 | 5.536 | 4.964 | 19.1/48.3 | 173.8/833.3 | + +Read latency includes internal lock waiting; baseline failed reads are counted +separately, so wall-time ratios are not an equivalent-success speed comparison. +Three local repetitions are validation evidence, not a universal performance +guarantee. These are deterministic sessions using real CLI/owner processes, +without model calls or concurrent model edits to working files. Writers that +remain open beyond the budget still cause a bounded failure. This does not +declare the separate bridge/redb 5 work or a combined release candidate ready. + +Reproduce with `multi_session.py --binary before=/path/to/baseline +--binary waited=/path/to/fixed --workers 1,4,8 --events 16 --turns 2 +--scenarios balanced,read-heavy --repetitions 3 --output results.json`. + +[Summary](../tools/provenance-eval/results/ordinary-read-wait-2026-09-15.json) and +[raw results, commands, build manifest and logs](../tools/provenance-eval/results/ordinary-read-wait-2026-09-15.tar.gz). diff --git a/tools/provenance-eval/results/ordinary-read-wait-2026-09-15.json b/tools/provenance-eval/results/ordinary-read-wait-2026-09-15.json new file mode 100644 index 00000000..62da5930 --- /dev/null +++ b/tools/provenance-eval/results/ordinary-read-wait-2026-09-15.json @@ -0,0 +1,576 @@ +{ + "date": "2026-09-15", + "intent": "ATOM::vince::9", + "intent_uid": "01M2KK12S425M8QGZ7RVS2XTES", + "view": "fix/redb-provenance-validation", + "tests": { + "passed": 1909, + "failed": 0, + "ignored": 0 + }, + "totals": { + "before": { + "runs": 18, + "read_ok": 5562, + "read_total": 6240, + "stop_ok": 156, + "stop_total": 156, + "verified_sessions": 78, + "sessions": 78, + "worker_failures": 0, + "verification_errors": 0 + }, + "waited": { + "runs": 18, + "read_ok": 6240, + "read_total": 6240, + "stop_ok": 156, + "stop_total": 156, + "verified_sessions": 78, + "sessions": 78, + "worker_failures": 0, + "verification_errors": 0 + } + }, + "scenarios": { + "balanced:1:before": { + "runs": 3, + "wall_s_median": 1.2210871660063276, + "wall_s_range": [ + 0.9334762079961365, + 1.6965770840033656 + ], + "read_ok": 96, + "read_total": 96, + "read_ms": { + "count": 96, + "p50_ms": 16.75929149496369, + "p95_ms": 36.18666699912865, + "min_ms": 10.192957997787744, + "max_ms": 73.45545799762476 + }, + "write_ms": { + "count": 96, + "p50_ms": 14.365228998940438, + "p95_ms": 28.008916997350752, + "min_ms": 9.490874988841824, + "max_ms": 46.11675000342075 + }, + "stop_ms": { + "count": 6, + "p50_ms": 53.14335450384533, + "p95_ms": 91.14950000366662, + "min_ms": 44.6812080044765, + "max_ms": 91.14950000366662 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 610.5414164994727, + "p95_ms": 960.8908749942202, + "min_ms": 419.20641700562555, + "max_ms": 960.8908749942202 + } + }, + "balanced:1:waited": { + "runs": 3, + "wall_s_median": 1.5333362499950454, + "wall_s_range": [ + 0.9270581250020768, + 1.576127375010401 + ], + "read_ok": 96, + "read_total": 96, + "read_ms": { + "count": 96, + "p50_ms": 15.542354005447123, + "p95_ms": 42.15537499112543, + "min_ms": 10.239957991871051, + "max_ms": 58.501374995103106 + }, + "write_ms": { + "count": 96, + "p50_ms": 13.95722950110212, + "p95_ms": 47.365457998239435, + "min_ms": 9.402083000168204, + "max_ms": 83.48216699960176 + }, + "stop_ms": { + "count": 6, + "p50_ms": 50.59106249973411, + "p95_ms": 116.71504200785421, + "min_ms": 46.32841600687243, + "max_ms": 116.71504200785421 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 578.9438959982363, + "p95_ms": 1002.3592499928782, + "min_ms": 435.4484999930719, + "max_ms": 1002.3592499928782 + } + }, + "balanced:4:before": { + "runs": 3, + "wall_s_median": 2.18104641600803, + "wall_s_range": [ + 1.672393959001056, + 3.136076208000304 + ], + "read_ok": 342, + "read_total": 384, + "read_ms": { + "count": 342, + "p50_ms": 17.95249999850057, + "p95_ms": 55.75362499803305, + "min_ms": 11.405875004129484, + "max_ms": 198.09304100635927 + }, + "write_ms": { + "count": 384, + "p50_ms": 15.846874994167592, + "p95_ms": 79.08466599474195, + "min_ms": 9.368667000671849, + "max_ms": 261.2225829943782 + }, + "stop_ms": { + "count": 24, + "p50_ms": 144.78237550065387, + "p95_ms": 397.0600829925388, + "min_ms": 55.57883399887942, + "max_ms": 508.92708300671075 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 859.419729502406, + "p95_ms": 2180.303750006715, + "min_ms": 503.8009999989299, + "max_ms": 2328.8901249907212 + } + }, + "balanced:4:waited": { + "runs": 3, + "wall_s_median": 1.5332328340009553, + "wall_s_range": [ + 1.2668013329966925, + 1.9392915830103448 + ], + "read_ok": 384, + "read_total": 384, + "read_ms": { + "count": 384, + "p50_ms": 16.433499498816673, + "p95_ms": 48.54150000028312, + "min_ms": 10.72358300734777, + "max_ms": 109.96241700195242 + }, + "write_ms": { + "count": 384, + "p50_ms": 14.638520500739105, + "p95_ms": 25.0365419924492, + "min_ms": 9.059499992872588, + "max_ms": 74.28583300497849 + }, + "stop_ms": { + "count": 24, + "p50_ms": 107.49720799503848, + "p95_ms": 277.5835419888608, + "min_ms": 54.139583997312, + "max_ms": 304.4461660028901 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 739.8637294973014, + "p95_ms": 1106.4860419865, + "min_ms": 495.529958003317, + "max_ms": 1202.4293750000652 + } + }, + "balanced:8:before": { + "runs": 3, + "wall_s_median": 2.6972537500114413, + "wall_s_range": [ + 2.590861083997879, + 3.2752325420005945 + ], + "read_ok": 624, + "read_total": 768, + "read_ms": { + "count": 624, + "p50_ms": 23.590062497532926, + "p95_ms": 48.02141699474305, + "min_ms": 10.435292002512142, + "max_ms": 114.46837500261609 + }, + "write_ms": { + "count": 768, + "p50_ms": 22.8598960020463, + "p95_ms": 39.95487499923911, + "min_ms": 8.992250004666857, + "max_ms": 102.17725000984501 + }, + "stop_ms": { + "count": 48, + "p50_ms": 369.44108350144234, + "p95_ms": 1281.7605839954922, + "min_ms": 47.49825000180863, + "max_ms": 1560.3976670099655 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 1220.6341454948415, + "p95_ms": 2190.628333002678, + "min_ms": 400.2286670001922, + "max_ms": 2729.2283339920687 + } + }, + "balanced:8:waited": { + "runs": 3, + "wall_s_median": 2.7837842500011902, + "wall_s_range": [ + 2.399214707998908, + 4.567367417010246 + ], + "read_ok": 768, + "read_total": 768, + "read_ms": { + "count": 768, + "p50_ms": 19.86756249971222, + "p95_ms": 72.49487499939278, + "min_ms": 10.328707998269238, + "max_ms": 158.55149998969864 + }, + "write_ms": { + "count": 768, + "p50_ms": 21.507583507627714, + "p95_ms": 68.49025000701658, + "min_ms": 8.689750000485219, + "max_ms": 121.4392090041656 + }, + "stop_ms": { + "count": 48, + "p50_ms": 267.9633340012515, + "p95_ms": 1023.6904170014895, + "min_ms": 46.44416600058321, + "max_ms": 1807.1215000090888 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 1173.334896004235, + "p95_ms": 2296.7669589997968, + "min_ms": 701.1867090041051, + "max_ms": 3524.950417006039 + } + }, + "read-heavy:1:before": { + "runs": 3, + "wall_s_median": 2.282711374995415, + "wall_s_range": [ + 1.549166625001817, + 2.587889875008841 + ], + "read_ok": 384, + "read_total": 384, + "read_ms": { + "count": 384, + "p50_ms": 10.456500000145752, + "p95_ms": 30.216415994800627, + "min_ms": 4.298999992897734, + "max_ms": 109.35695801163092 + }, + "write_ms": { + "count": 96, + "p50_ms": 10.840729002666194, + "p95_ms": 29.16245799860917, + "min_ms": 8.634791010990739, + "max_ms": 54.59595800493844 + }, + "stop_ms": { + "count": 6, + "p50_ms": 49.334770505083725, + "p95_ms": 59.13608300033957, + "min_ms": 46.078125000349246, + "max_ms": 59.13608300033957 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 789.1084375005448, + "p95_ms": 1809.789874998387, + "min_ms": 749.0417499939213, + "max_ms": 1809.789874998387 + } + }, + "read-heavy:1:waited": { + "runs": 3, + "wall_s_median": 1.727485750001506, + "wall_s_range": [ + 1.4042028340045363, + 1.793406833006884 + ], + "read_ok": 384, + "read_total": 384, + "read_ms": { + "count": 384, + "p50_ms": 9.775937505764887, + "p95_ms": 15.466625001863576, + "min_ms": 4.225249998853542, + "max_ms": 32.35679099452682 + }, + "write_ms": { + "count": 96, + "p50_ms": 10.26406199525809, + "p95_ms": 18.37158401031047, + "min_ms": 8.713041999726556, + "max_ms": 40.0325420050649 + }, + "stop_ms": { + "count": 6, + "p50_ms": 50.26454200560693, + "p95_ms": 53.84191600023769, + "min_ms": 45.48241700103972, + "max_ms": 53.84191600023769 + }, + "stop_ok": 6, + "stop_total": 6, + "verified_sessions": 3, + "expected_sessions": 3, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 6, + "p50_ms": 789.2275834965403, + "p95_ms": 1006.7426249879645, + "min_ms": 701.5665409999201, + "max_ms": 1006.7426249879645 + } + }, + "read-heavy:4:before": { + "runs": 3, + "wall_s_median": 2.778132416002336, + "wall_s_range": [ + 2.182820832997095, + 3.0045704579970334 + ], + "read_ok": 1430, + "read_total": 1536, + "read_ms": { + "count": 1430, + "p50_ms": 12.59887449850794, + "p95_ms": 29.50812500785105, + "min_ms": 4.596665996359661, + "max_ms": 68.41733300825581 + }, + "write_ms": { + "count": 384, + "p50_ms": 13.895395495637786, + "p95_ms": 29.683708009542897, + "min_ms": 9.077250011614524, + "max_ms": 74.2685419972986 + }, + "stop_ms": { + "count": 24, + "p50_ms": 103.24647899687989, + "p95_ms": 370.00729200372007, + "min_ms": 52.088791999267414, + "max_ms": 461.6952910000691 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 1182.6488954975503, + "p95_ms": 1874.0464169968618, + "min_ms": 964.5555419992888, + "max_ms": 2000.752708001528 + } + }, + "read-heavy:4:waited": { + "runs": 3, + "wall_s_median": 2.734341957999277, + "wall_s_range": [ + 2.244023624996771, + 2.8755475409998326 + ], + "read_ok": 1536, + "read_total": 1536, + "read_ms": { + "count": 1536, + "p50_ms": 12.456042000849266, + "p95_ms": 31.51800000341609, + "min_ms": 4.506959012360312, + "max_ms": 110.0478329899488 + }, + "write_ms": { + "count": 384, + "p50_ms": 12.914749495394062, + "p95_ms": 22.328000006382354, + "min_ms": 8.669417002238333, + "max_ms": 86.45391699974425 + }, + "stop_ms": { + "count": 24, + "p50_ms": 95.48362500936491, + "p95_ms": 275.0217499997234, + "min_ms": 43.41541699250229, + "max_ms": 307.4719590076711 + }, + "stop_ok": 24, + "stop_total": 24, + "verified_sessions": 12, + "expected_sessions": 12, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 24, + "p50_ms": 1219.5488959987415, + "p95_ms": 1652.2913749940926, + "min_ms": 993.0387079948559, + "max_ms": 1659.2367499979446 + } + }, + "read-heavy:8:before": { + "runs": 3, + "wall_s_median": 5.535983458990813, + "wall_s_range": [ + 4.2410807910055155, + 6.0168094169930555 + ], + "read_ok": 2686, + "read_total": 3072, + "read_ms": { + "count": 2686, + "p50_ms": 20.985083501727786, + "p95_ms": 51.336582997464575, + "min_ms": 4.873958008829504, + "max_ms": 148.95379199879244 + }, + "write_ms": { + "count": 768, + "p50_ms": 28.361749995383434, + "p95_ms": 69.63562499731779, + "min_ms": 9.451542005990632, + "max_ms": 147.15679199434817 + }, + "stop_ms": { + "count": 48, + "p50_ms": 291.9043540023267, + "p95_ms": 1359.9300420028158, + "min_ms": 47.06537499441765, + "max_ms": 1558.9138340001227 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 2457.31579150015, + "p95_ms": 3672.0384579966776, + "min_ms": 887.492709007347, + "max_ms": 4016.8753750040196 + } + }, + "read-heavy:8:waited": { + "runs": 3, + "wall_s_median": 4.963592291009263, + "wall_s_range": [ + 4.140364207996754, + 5.321949041986954 + ], + "read_ok": 3072, + "read_total": 3072, + "read_ms": { + "count": 3072, + "p50_ms": 19.12339600676205, + "p95_ms": 48.30504099663813, + "min_ms": 4.47616699966602, + "max_ms": 131.86066600610502 + }, + "write_ms": { + "count": 768, + "p50_ms": 22.871438006404787, + "p95_ms": 47.1474169899011, + "min_ms": 10.179666001931764, + "max_ms": 152.7488749998156 + }, + "stop_ms": { + "count": 48, + "p50_ms": 173.75135450129164, + "p95_ms": 833.3400830015307, + "min_ms": 48.6453750054352, + "max_ms": 1321.6989579959773 + }, + "stop_ok": 48, + "stop_total": 48, + "verified_sessions": 24, + "expected_sessions": 24, + "verification_failures": 0, + "worker_failures": 0, + "turn_ms": { + "count": 48, + "p50_ms": 2166.4662294933805, + "p95_ms": 2756.4027910120785, + "min_ms": 1593.4133750124602, + "max_ms": 3413.608375005424 + } + } + }, + "archive_sha256": "11bcd27867bf2eb5ac91c7d0da7bd21eb858ad525979559c3bc6186c8479b5b8", + "binaries": { + "before": { + "path": "/Users/dev-vincent/atomic-workspace/.gstack/pr190-lee-revalidation-20260915/bin/atomic-pr190", + "sha256": "2cd58045ba50665eb4514b1df744e9998ea74d3a56379c2aa5368914ed6b4583" + }, + "waited": { + "path": "/Users/dev-vincent/atomic-workspace/.gstack/ordinary-read-wait-20260915/atomic-read-wait", + "sha256": "6e7612d9ba34b60f792272e7bc781b4ce5d3eb918dfd8e63918ea83697de1434" + } + } +} diff --git a/tools/provenance-eval/results/ordinary-read-wait-2026-09-15.tar.gz b/tools/provenance-eval/results/ordinary-read-wait-2026-09-15.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8437eb881dc09df5bbb97e9e6c237cbfa2c280ee GIT binary patch literal 244677 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

f}u*E5HKloa&4kA3j2A%y;thx=983loO)I9 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%0D|>3gwzcH?`g`wmxpZ0E5^cB<-BrO1+z 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%0AC6R)f~=JWgr3(1?~ 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 Date: Tue, 15 Sep 2026 19:55:33 -0400 Subject: [PATCH 14/15] fix(owner): retry busy Windows pipe acquisition Keep a listening server instance during connection handoff and bound ERROR_PIPE_BUSY retries before sending any request. Preserve the original sixteen-concurrent-hook test and add three Windows transport regressions. Atomic-Intent: ATOM::vince::10 Atomic-Change: XBPUJFJFLGORIENA4TW2EEZW2DCUMOVD27HPBBUJJWRZSAPJ4SOA Validation: 18 owner integration tests, workspace Clippy, formatting passed locally; Windows CI pending. --- atomic-cli/src/commands/agent/owner.rs | 130 ++++++++++++++++++++++--- 1 file changed, 116 insertions(+), 14 deletions(-) diff --git a/atomic-cli/src/commands/agent/owner.rs b/atomic-cli/src/commands/agent/owner.rs index d1fb7449..95884abe 100644 --- a/atomic-cli/src/commands/agent/owner.rs +++ b/atomic-cli/src/commands/agent/owner.rs @@ -1388,15 +1388,41 @@ async fn exchange(endpoint: &str, frame: &RequestFrame) -> anyhow::Result anyhow::Result { - use tokio::net::windows::named_pipe::ClientOptions; - - let mut stream = ClientOptions::new() - .open(endpoint) + let mut stream = connect_owner_pipe(endpoint, Duration::from_secs(5)) + .await .with_context(|| format!("database owner is not reachable at {endpoint}"))?; write_frame(&mut stream, frame).await?; read_frame(&mut stream).await } +#[cfg(windows)] +async fn connect_owner_pipe( + endpoint: &str, + timeout: Duration, +) -> std::io::Result { + use tokio::net::windows::named_pipe::ClientOptions; + use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; + + // A live server can temporarily have no listening instance when several + // hooks connect at once. Retry acquisition before sending any frame; a busy + // pipe is not evidence that the owner died or needs another bootstrap. + let started = tokio::time::Instant::now(); + loop { + match ClientOptions::new().open(endpoint) { + Err(error) + if error.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) + && started.elapsed() < timeout => + { + tokio::time::sleep( + START_RETRY_DELAY.min(timeout.saturating_sub(started.elapsed())), + ) + .await; + } + result => return result, + } + } +} + #[cfg(unix)] async fn run_server(endpoint: &str, store: Arc) -> anyhow::Result<()> { use tokio::net::UnixListener; @@ -1439,23 +1465,25 @@ async fn run_server(endpoint: &str, store: Arc) -> anyhow::Resu use tokio::net::windows::named_pipe::ServerOptions; let shutdown = Arc::new(Notify::new()); - let mut first = true; + let mut server = ServerOptions::new() + .first_pipe_instance(true) + .create(endpoint) + .with_context(|| format!("failed to create database owner pipe {endpoint}"))?; loop { - let mut options = ServerOptions::new(); - if first { - options.first_pipe_instance(true); - } - let mut server = options - .create(endpoint) - .with_context(|| format!("failed to create database owner pipe {endpoint}"))?; tokio::select! { connected = server.connect() => { connected?; - first = false; + // Keep an instance available before a fast handler can finish + // and close the connected pipe. Otherwise clients can observe + // a missing endpoint between two successful requests. + let next = ServerOptions::new() + .create(endpoint) + .with_context(|| format!("failed to create database owner pipe {endpoint}"))?; + let connected = std::mem::replace(&mut server, next); let store = Arc::clone(&store); let shutdown = Arc::clone(&shutdown); tokio::spawn(async move { - if let Err(error) = handle_connection(server, store, shutdown).await { + if let Err(error) = handle_connection(connected, store, shutdown).await { log::warn!("database-owner connection failed: {error}"); } }); @@ -1509,6 +1537,80 @@ fn configure_detached(command: &mut ProcessCommand) -> anyhow::Result<()> { mod tests { use super::*; + #[cfg(windows)] + #[tokio::test] + async fn busy_owner_pipe_waits_for_a_new_listening_instance() { + use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions}; + use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; + + let endpoint = format!(r"\\.\pipe\atomic-busy-test-{}", Uuid::new_v4()); + let occupied = ServerOptions::new() + .first_pipe_instance(true) + .create(&endpoint) + .unwrap(); + let _held_client = ClientOptions::new().open(&endpoint).unwrap(); + occupied.connect().await.unwrap(); + assert_eq!( + ClientOptions::new() + .open(&endpoint) + .unwrap_err() + .raw_os_error(), + Some(ERROR_PIPE_BUSY as i32) + ); + + let mut connecting = Box::pin(connect_owner_pipe(&endpoint, Duration::from_secs(2))); + assert!( + tokio::time::timeout(Duration::from_millis(50), &mut connecting) + .await + .is_err() + ); + let next = ServerOptions::new().create(&endpoint).unwrap(); + let _client = tokio::time::timeout(Duration::from_secs(2), connecting) + .await + .expect("client should recover when a listener is available") + .unwrap(); + next.connect().await.unwrap(); + } + + #[cfg(windows)] + #[tokio::test] + async fn busy_owner_pipe_wait_has_a_bounded_timeout() { + use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions}; + use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY; + + let endpoint = format!(r"\\.\pipe\atomic-busy-timeout-{}", Uuid::new_v4()); + let occupied = ServerOptions::new() + .first_pipe_instance(true) + .create(&endpoint) + .unwrap(); + let _held_client = ClientOptions::new().open(&endpoint).unwrap(); + occupied.connect().await.unwrap(); + let started = tokio::time::Instant::now(); + let error = tokio::time::timeout( + Duration::from_secs(2), + connect_owner_pipe(&endpoint, Duration::from_millis(60)), + ) + .await + .expect("busy pipe wait must not hang") + .unwrap_err(); + assert!(started.elapsed() >= Duration::from_millis(60)); + assert_eq!(error.raw_os_error(), Some(ERROR_PIPE_BUSY as i32)); + } + + #[cfg(windows)] + #[tokio::test] + async fn missing_owner_pipe_does_not_use_the_busy_retry_budget() { + let endpoint = format!(r"\\.\pipe\atomic-missing-test-{}", Uuid::new_v4()); + let error = tokio::time::timeout( + Duration::from_secs(2), + connect_owner_pipe(&endpoint, Duration::from_secs(5)), + ) + .await + .expect("a missing owner must return promptly for bootstrap") + .unwrap_err(); + assert_eq!(error.kind(), std::io::ErrorKind::NotFound); + } + #[test] fn frozen_pages_bound_encoded_frames_and_reassemble_large_envelopes() { let dir = tempfile::tempdir().unwrap(); From 79020f0291cf578cd248adb705c363dc7ddce558 Mon Sep 17 00:00:00 2001 From: Vincent Date: Thu, 17 Sep 2026 13:29:01 -0400 Subject: [PATCH 15/15] fix: wait on session-start contention and scope subagent checkpoints (#193) * fix: wait for database contention during session initialization Atomic intent: ATOM::vince::12 (01M2NYA6AV3JHQZP31Z4R8R4MG). Atomic change: RKNP2QWZDOE7ZRANEFYLQFBKNG2LGW6XTDLHYSHAPN2ACSNQAJ2A. Based on PR #190 without PR #189 source changes. * fix: scope shared-workspace checkpoints to verified session files * fix: confirm scoped file contents and document shared workspace validation Atomic intent ATOM::vince::13; recorded by scoped Stop as NGHDDSQINARM3B2BJOUB2J5ZUPBD22D4MYPBKVBPCO2O3O7FDKCA. Independent follow-up to #190; no PR #189 source included. --- Cargo.lock | 1 + atomic-agent/Cargo.toml | 1 + atomic-agent/src/record/mod.rs | 24 ++- atomic-agent/src/record/scope.rs | 166 ++++++++++++++++++ atomic-agent/src/record/tests.rs | 82 +++++++++ .../src/turn/orchestrator/session_end.rs | 2 +- .../src/turn/orchestrator/session_start.rs | 63 ++++++- atomic-agent/src/turn/orchestrator/turn.rs | 7 +- atomic-agent/src/turn/session.rs | 5 + atomic-cli/src/commands/agent/hooks.rs | 20 +++ .../tests/database_owner_integration_test.rs | 143 +++++++++++++++ docs/subagent-file-ownership.md | 93 ++++++++++ docs/subagent-session-start.md | 73 ++++++++ 13 files changed, 672 insertions(+), 8 deletions(-) create mode 100644 atomic-agent/src/record/scope.rs create mode 100644 docs/subagent-file-ownership.md create mode 100644 docs/subagent-session-start.md diff --git a/Cargo.lock b/Cargo.lock index 0fc902b0..41f84dd0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -147,6 +147,7 @@ dependencies = [ "serde", "serde_json", "serial_test", + "sha2", "tempfile", "thiserror 1.0.69", "tokio", diff --git a/atomic-agent/Cargo.toml b/atomic-agent/Cargo.toml index 9ac07fcd..50be2818 100644 --- a/atomic-agent/Cargo.toml +++ b/atomic-agent/Cargo.toml @@ -29,6 +29,7 @@ zstd = { workspace = true } # Hashing blake3 = { workspace = true } +sha2 = "0.10" # Time chrono = { workspace = true } diff --git a/atomic-agent/src/record/mod.rs b/atomic-agent/src/record/mod.rs index 88e637f1..cc20f4cf 100644 --- a/atomic-agent/src/record/mod.rs +++ b/atomic-agent/src/record/mod.rs @@ -58,6 +58,7 @@ pub mod message; pub mod options; pub mod provenance; +pub mod scope; #[cfg(test)] mod tests; @@ -138,6 +139,16 @@ pub fn record_turn( repo_root: &Path, options: &TurnRecordOptions<'_>, ) -> AgentResult { + let manifest = scope::manifest(options)?; + if let Some(files) = &manifest { + scope::validate(repo_root, files, options)?; + if files.is_empty() { + return Err(AgentError::EmptyTurn { + session_id: options.session.session_id.clone(), + turn_number: options.turn_number, + }); + } + } // Step 1: Open the repository read-only for the initial status check. // This can coexist with other readers. Wait for a transient incompatible // writer before deciding whether work or untracked files exist. @@ -169,6 +180,8 @@ pub fn record_turn( reason: format!("Failed to get repository status: {}", e), })?; + let status = scope::filter(status, manifest.as_ref()); + // Check if there's anything to record at all if status.is_clean() && status.untracked_count() == 0 { return Err(AgentError::EmptyTurn { @@ -289,6 +302,10 @@ pub fn record_turn( } } + if let Some(files) = &manifest { + scope::validate(repo_root, files, options)?; + } + if !untracked_paths.is_empty() { log::info!( "Adding {} untracked file{} created by agent", @@ -323,6 +340,7 @@ pub fn record_turn( reason: format!("Failed to refresh repository status after add: {}", e), })?; + let status = scope::filter(status, manifest.as_ref()); if status.is_clean() { return Err(AgentError::EmptyTurn { session_id: options.session.session_id.clone(), @@ -360,7 +378,7 @@ pub fn record_turn( // HashedChange.metadata — part of the change's cryptographic identity. // This means session structure (turn number, timing, files, agent name) // is tamper-evident and commutes via patch theory. - let record_options = atomic_repository::record::RecordOptions::new() + let mut record_options = atomic_repository::record::RecordOptions::new() .with_all(true) .view(options.session.view_name.clone()) .apply_after_record(true) @@ -373,6 +391,10 @@ pub fn record_turn( .provenance(vec![provenance_entry]) .metadata_bytes(envelope_bytes); + if manifest.is_some() { + record_options = record_options.with_all(false).paths(status_files.clone()); + } + let mut outcome = match repo.record(header, record_options) { Ok(outcome) => outcome, Err(atomic_repository::record::RecordError::NothingToRecord) => { diff --git a/atomic-agent/src/record/scope.rs b/atomic-agent/src/record/scope.rs new file mode 100644 index 00000000..1a51611e --- /dev/null +++ b/atomic-agent/src/record/scope.rs @@ -0,0 +1,166 @@ +//! Explicit, fingerprinted file ownership for hooks sharing a working tree. +use std::collections::BTreeMap; +use std::path::{Component, Path}; + +use atomic_repository::status::{RepositoryStatus, StatusOptions}; +use atomic_repository::Repository; +use sha2::{Digest, Sha256}; + +use super::TurnRecordOptions; +use crate::error::{AgentError, AgentResult}; + +pub type FileManifest = BTreeMap>; + +fn checked_path(root: &Path, path: &str) -> Result { + if path.is_empty() + || !Path::new(path) + .components() + .all(|c| matches!(c, Component::Normal(_))) + { + return Err(format!("invalid scoped file path: {path:?}")); + } + let root = root.canonicalize().map_err(|e| e.to_string())?; + let full = root.join(path); + let mut parent = full.parent(); + while let Some(p) = parent { + if p.exists() { + if !p + .canonicalize() + .map_err(|e| e.to_string())? + .starts_with(&root) + { + return Err(format!("scoped path escapes repository: {path}")); + } + break; + } + parent = p.parent(); + } + if Path::new(path) + .components() + .any(|c| matches!(c, Component::Normal(n) if n == ".atomic" || n == ".git")) + { + return Err(format!("repository metadata cannot be scoped: {path}")); + } + Ok(full) +} + +/// Fingerprint a file without following its final symlink. `None` means deleted. +/// Reject directories and paths outside the working tree. +pub fn fingerprint(root: &Path, path: &str) -> Result, String> { + let full = checked_path(root, path)?; + let meta = match std::fs::symlink_metadata(&full) { + Ok(m) => m, + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(e) => return Err(e.to_string()), + }; + if meta.file_type().is_symlink() { + let target = std::fs::read_link(full).map_err(|e| e.to_string())?; + return Ok(Some(format!( + "link:{:x}", + Sha256::digest(target.as_os_str().as_encoded_bytes()) + ))); + } + if !meta.is_file() { + return Err(format!("not a regular scoped file: {path}")); + } + #[cfg(unix)] + let executable = { + use std::os::unix::fs::PermissionsExt; + meta.permissions().mode() & 0o111 != 0 + }; + #[cfg(not(unix))] + let executable = false; + let mut file = std::fs::File::open(full).map_err(|e| e.to_string())?; + let mut hash = Sha256::new(); + std::io::copy(&mut file, &mut hash).map_err(|e| e.to_string())?; + Ok(Some(format!( + "file:{hash:x}:{executable}", + hash = hash.finalize() + ))) +} + +/// Return fingerprints for dirty files and explicitly requested prior candidates. +/// The protocol version also lets plugins refuse an older, unscoped CLI. +pub fn snapshot(root: &Path, extra: &[String]) -> Result { + let repo = Repository::open_readonly_wait(root, std::time::Duration::from_secs(10)) + .map_err(|e| e.to_string())?; + let status = repo + .status(StatusOptions::default().with_untracked(true)) + .map_err(|e| e.to_string())?; + let dirty: Vec = status + .entries() + .iter() + .map(|e| e.path().to_string_lossy().to_string()) + .collect(); + let mut files = FileManifest::new(); + for path in status + .entries() + .iter() + .map(|e| e.path().to_string_lossy().to_string()) + .chain(extra.iter().cloned()) + { + if root.join(&path).is_dir() && !root.join(&path).is_symlink() { + continue; + } + files.insert(path.clone(), fingerprint(root, &path)?); + } + Ok( + serde_json::json!({"scope_version":1, "view":repo.current_view(), "files":files, "dirty":dirty}), + ) +} + +pub(super) fn manifest(options: &TurnRecordOptions<'_>) -> AgentResult> { + let raw = options + .event + .raw_json + .as_ref() + .and_then(|v| v.get("record_files")); + let fail = |reason| AgentError::RecordFailed { + session_id: options.session.session_id.clone(), + turn_number: options.turn_number, + reason, + }; + match raw { + Some(value) => serde_json::from_value(value.clone()) + .map(Some) + .map_err(|e| fail(format!("invalid record_files manifest: {e}"))), + None if options.session.explicit_record_files => Err(fail( + "explicit record_files manifest required; refusing to record shared working tree" + .into(), + )), + None => Ok(None), + } +} + +pub(super) fn validate( + root: &Path, + files: &FileManifest, + options: &TurnRecordOptions<'_>, +) -> AgentResult<()> { + for (path, expected) in files { + let actual = fingerprint(root, path).map_err(|reason| AgentError::RecordFailed { + session_id: options.session.session_id.clone(), + turn_number: options.turn_number, + reason, + })?; + if &actual != expected { + return Err(AgentError::RecordFailed { session_id: options.session.session_id.clone(), turn_number: options.turn_number, reason: format!("scoped file changed after this session's tool finished: {path}; refusing ambiguous ownership") }); + } + } + Ok(()) +} + +pub(super) fn filter(status: RepositoryStatus, files: Option<&FileManifest>) -> RepositoryStatus { + let Some(files) = files else { + return status; + }; + let mut result = RepositoryStatus::new(status.view().to_string(), status.state().copied()); + for entry in status.entries() { + if entry.details() != Some("directory") + && files.contains_key(entry.path().to_string_lossy().as_ref()) + { + result.add_entry(entry.clone()); + } + } + result +} diff --git a/atomic-agent/src/record/tests.rs b/atomic-agent/src/record/tests.rs index 0b37e163..4da15da1 100644 --- a/atomic-agent/src/record/tests.rs +++ b/atomic-agent/src/record/tests.rs @@ -1175,3 +1175,85 @@ fn test_orphaned_session_view_duplicates_content_on_merge() { "session B's edit should survive the merge" ); } + +#[test] +fn scoped_record_keeps_sibling_and_preexisting_files_out() { + let dir = tempfile::tempdir().unwrap(); + let mut repo = atomic_repository::Repository::init(dir.path()).unwrap(); + let parent = repo.current_view().to_string(); + let mut a = AgentSession::new("child-a", "opencode", "OpenCode"); + let mut b = AgentSession::new("child-b", "opencode", "OpenCode"); + for s in [&mut a, &mut b] { + s.explicit_record_files = true; + s.set_parent_view(repo.current_view()); + repo.create_view_from(&s.view_name, &parent).unwrap(); + } + drop(repo); + for (name, text) in [ + ("a.txt", "child a"), + ("b.txt", "child b"), + ("human.txt", "leave alone"), + ] { + std::fs::write(dir.path().join(name), text).unwrap(); + } + let mut hashes = Vec::new(); + for (s, file) in [(&a, "a.txt"), (&b, "b.txt")] { + let event = make_event().with_raw_json( + serde_json::json!({"record_files":{file:scope::fingerprint(dir.path(),file).unwrap()}}), + ); + let outcome = record_turn(dir.path(), &make_options(s, &event)).unwrap(); + assert_eq!(outcome.recorded_file_list(), &[file.to_string()]); + hashes.push(outcome.hash); + } + assert_ne!(hashes[0], hashes[1]); + assert_eq!( + std::fs::read_to_string(dir.path().join("human.txt")).unwrap(), + "leave alone" + ); +} + +#[test] +fn scoped_record_empty_missing_invalid_or_stale_manifest_never_sweeps() { + let dir = tempfile::tempdir().unwrap(); + let repo = atomic_repository::Repository::init(dir.path()).unwrap(); + let mut session = make_session(); + session.view_name = repo.current_view().to_string(); + session.explicit_record_files = true; + drop(repo); + std::fs::write(dir.path().join("unrelated.txt"), "human").unwrap(); + let empty = make_event().with_raw_json(serde_json::json!({"record_files":{}})); + assert!(matches!( + record_turn(dir.path(), &make_options(&session, &empty)), + Err(AgentError::EmptyTurn { .. }) + )); + for payload in [ + serde_json::json!({}), + serde_json::json!({"record_files":null}), + serde_json::json!({"record_files":{"../escape":null}}), + serde_json::json!({"record_files":{"unrelated.txt":"wrong digest"}}), + serde_json::json!({"record_files":{".atomic/config.toml":null}}), + ] { + let event = make_event().with_raw_json(payload); + assert!(matches!( + record_turn(dir.path(), &make_options(&session, &event)), + Err(AgentError::RecordFailed { .. }) + )); + } + assert_eq!( + std::fs::read_to_string(dir.path().join("unrelated.txt")).unwrap(), + "human" + ); +} + +#[test] +fn scoped_snapshot_includes_requested_files_restored_to_clean_and_deletions() { + let dir = tempfile::tempdir().unwrap(); + drop(atomic_repository::Repository::init(dir.path()).unwrap()); + std::fs::write(dir.path().join("a.txt"), "a").unwrap(); + let first = scope::snapshot(dir.path(), &[]).unwrap(); + assert!(first["files"]["a.txt"].is_string()); + std::fs::remove_file(dir.path().join("a.txt")).unwrap(); + let after = scope::snapshot(dir.path(), &["a.txt".into()]).unwrap(); + assert!(after["files"].as_object().unwrap().contains_key("a.txt")); + assert!(after["files"]["a.txt"].is_null()); +} diff --git a/atomic-agent/src/turn/orchestrator/session_end.rs b/atomic-agent/src/turn/orchestrator/session_end.rs index c9bc5bd3..9ae32b89 100644 --- a/atomic-agent/src/turn/orchestrator/session_end.rs +++ b/atomic-agent/src/turn/orchestrator/session_end.rs @@ -63,7 +63,7 @@ impl TurnOrchestrator { // session end. Record them now. Idempotent: agents that already // recorded each turn on `stop` leave a clean working copy here, so // `record_turn` returns `EmptyTurn` and this is a no-op for them. - { + if !session.explicit_record_files || had_active_turn { // Ensure the working copy is on the session's agent view before // recording. session-start aligns to it, but that can drift back to // the parent view by session end (observed with Cursor's CLI), which diff --git a/atomic-agent/src/turn/orchestrator/session_start.rs b/atomic-agent/src/turn/orchestrator/session_start.rs index 83859cff..1965c2ed 100644 --- a/atomic-agent/src/turn/orchestrator/session_start.rs +++ b/atomic-agent/src/turn/orchestrator/session_start.rs @@ -7,6 +7,10 @@ use crate::turn::session::AgentSession; use super::{vendor_from_agent_name, DispatchResult, TurnOrchestrator}; +// Session lifecycle operations use short writable handles, just like recording. +// Retry acquisition only; replaying the whole lifecycle could fork/switch twice. +const SESSION_DATABASE_WAIT: std::time::Duration = std::time::Duration::from_secs(10); + impl TurnOrchestrator { /// Handle a SessionStart event. /// @@ -169,8 +173,54 @@ impl TurnOrchestrator { // Best-effort: if the repo can't be opened or the view already // exists (resumed session), we log and continue — recording will // still work, it just won't have the parent's history. + if event + .raw_json + .as_ref() + .and_then(|v| v.get("recording_scope")) + .and_then(|v| v.as_str()) + == Some("explicit-files-v1") + { + session.explicit_record_files = true; + } + + // Several OpenCode sessions can share one actual working directory. + // Explicit file scopes separate authorship; a common view gives their + // status/add/record operations one baseline and one directory identity. + if let Some(owner_id) = event + .raw_json + .as_ref() + .and_then(|v| v.get("workspace_session_id")) + .and_then(|v| v.as_str()) + { + if !session.explicit_record_files { + return Err(crate::error::AgentError::Internal( + "shared workspace requires explicit file recording".into(), + )); + } + if owner_id != session_id { + let owner = self.session_store.load(owner_id)?.ok_or_else(|| { + crate::error::AgentError::Internal("workspace owner session is missing".into()) + })?; + if !owner.explicit_record_files { + return Err(crate::error::AgentError::Internal( + "workspace owner does not use explicit file recording".into(), + )); + } + if self.managed_run.is_some() && session.view_name != owner.view_name { + return Err(crate::error::AgentError::Internal( + "workspace view conflicts with managed run".into(), + )); + } + session.view_name = owner.view_name.clone(); + session.parent_view = Some(owner.view_name); + } + } + if session.parent_view.is_none() { - match atomic_repository::Repository::open_existing(&self.repo_root) { + match atomic_repository::Repository::open_existing_wait( + &self.repo_root, + SESSION_DATABASE_WAIT, + ) { Ok(repo) if repo.is_sandbox() => { // A sandbox is a materialized copy of the project; `record` // writes to the *canonical* graph (shared pristine + @@ -322,7 +372,10 @@ impl TurnOrchestrator { session: &crate::turn::session::AgentSession, ended_at: Option, ) { - match atomic_repository::Repository::open_existing(&self.repo_root) { + match atomic_repository::Repository::open_existing_wait( + &self.repo_root, + SESSION_DATABASE_WAIT, + ) { Ok(repo) => { if let Err(e) = repo.upsert_session_lifecycle( &session.session_id, @@ -396,8 +449,10 @@ impl TurnOrchestrator { // view from the user's view so that the agent's changes // are isolated and the view filter only exposes the // parent's files. - if let Ok(mut repo) = atomic_repository::Repository::open_existing(&self.repo_root) - { + if let Ok(mut repo) = atomic_repository::Repository::open_existing_wait( + &self.repo_root, + SESSION_DATABASE_WAIT, + ) { let current = repo.current_view().to_string(); if repo.is_sandbox() { diff --git a/atomic-agent/src/turn/orchestrator/turn.rs b/atomic-agent/src/turn/orchestrator/turn.rs index 63caa872..1a1c075c 100644 --- a/atomic-agent/src/turn/orchestrator/turn.rs +++ b/atomic-agent/src/turn/orchestrator/turn.rs @@ -154,8 +154,11 @@ impl TurnOrchestrator { let mut session = self.load_or_create_session(session_id, &event)?; - let has_changes = self.has_working_copy_changes(); - if !session.is_turn_active() && session.turn_count > 0 && !has_changes { + let has_changes = session.explicit_record_files || self.has_working_copy_changes(); + if !session.is_turn_active() + && session.turn_count > 0 + && (session.explicit_record_files || !has_changes) + { // A retried Stop after successful publication must not create a // second empty checkpoint for the same completed interaction. return Ok(DispatchResult::new(session_id, session.phase)); diff --git a/atomic-agent/src/turn/session.rs b/atomic-agent/src/turn/session.rs index 781c654c..e9ead522 100644 --- a/atomic-agent/src/turn/session.rs +++ b/atomic-agent/src/turn/session.rs @@ -116,6 +116,10 @@ pub struct AgentSession { #[serde(alias = "stack_name")] pub view_name: String, + /// Require an explicit file manifest; never sweep a shared working tree. + #[serde(default)] + pub explicit_record_files: bool, + /// Current lifecycle phase. pub phase: Phase, @@ -244,6 +248,7 @@ impl AgentSession { Self { session_id, view_name, + explicit_record_files: false, phase: Phase::Idle, turn_count: 0, agent_name: agent_name.into(), diff --git a/atomic-cli/src/commands/agent/hooks.rs b/atomic-cli/src/commands/agent/hooks.rs index 83e61589..3a115235 100644 --- a/atomic-cli/src/commands/agent/hooks.rs +++ b/atomic-cli/src/commands/agent/hooks.rs @@ -123,6 +123,26 @@ impl Command for Hooks { )) })?; + if self.agent_name == "opencode" && self.verb == "file-snapshot" { + let value: serde_json::Value = + serde_json::from_slice(&input).map_err(|e| CliError::Internal(anyhow!(e)))?; + let cwd = value + .get("cwd") + .and_then(|v| v.as_str()) + .ok_or_else(|| CliError::Internal(anyhow!("file-snapshot requires cwd")))?; + let extra: Vec = serde_json::from_value( + value + .get("paths") + .cloned() + .unwrap_or_else(|| serde_json::json!([])), + ) + .map_err(|e| CliError::Internal(anyhow!(e)))?; + let snapshot = atomic_agent::record::scope::snapshot(std::path::Path::new(cwd), &extra) + .map_err(|e| CliError::Internal(anyhow!(e)))?; + println!("{}", snapshot); + return Ok(()); + } + if self.should_handoff_codex_lifecycle() { return self.handoff_codex_lifecycle(&input); } diff --git a/atomic-cli/tests/database_owner_integration_test.rs b/atomic-cli/tests/database_owner_integration_test.rs index 68418f52..5eb2acdb 100644 --- a/atomic-cli/tests/database_owner_integration_test.rs +++ b/atomic-cli/tests/database_owner_integration_test.rs @@ -197,6 +197,58 @@ fn run_agent_hook(repository: &std::path::Path, agent: &str, verb: &str, payload wait_for_output(child, &format!("{agent} {verb}")) } +#[test] +fn concurrent_session_starts_wait_for_writer_and_persist_views_and_lifecycle() { + let temp = TempDir::new().unwrap(); + let repository = temp.path().join("repo"); + let writer = Repository::init(&repository).unwrap(); + let pending: Vec<_> = (0..8) + .map(|index| { + let root = repository.clone(); + thread::spawn(move || { + let session = format!("start-contended-{index}"); + let payload = serde_json::to_vec(&serde_json::json!({ + "session_id": session, "cwd": root, + })) + .unwrap(); + run_agent_hook(&root, "opencode", "session-start", &payload) + }) + }) + .collect(); + // Hold a real incompatible handle across all eight independent processes. + // The hook must wait internally, without a test-side retry or startup queue. + thread::sleep(Duration::from_millis(300)); + let returned_early = pending.iter().any(thread::JoinHandle::is_finished); + drop(writer); + let outputs: Vec<_> = pending.into_iter().map(|p| p.join().unwrap()).collect(); + assert!( + !returned_early, + "session start skipped a contended database" + ); + let repo = Repository::open_existing(&repository).unwrap(); + let mut views = HashSet::new(); + for (index, output) in outputs.iter().enumerate() { + assert!(output.status.success(), "{output:?}"); + let stderr = String::from_utf8_lossy(&output.stderr); + assert!(!stderr.contains("Cannot acquire lock"), "{stderr}"); + let sid = format!("start-contended-{index}"); + let session: Value = serde_json::from_slice( + &std::fs::read(repository.join(format!(".atomic/sessions/{sid}.json"))).unwrap(), + ) + .unwrap(); + let view = session["view_name"].as_str().unwrap(); + assert!( + views.insert(view.to_string()), + "sessions must have distinct views" + ); + assert!(repo.get_view_info(view).is_ok(), "view {view} missing"); + assert!( + repo.get_session_ledger(&sid).unwrap().is_some(), + "lifecycle missing for {sid}" + ); + } +} + #[test] fn read_only_turn_does_not_reuse_its_goal_for_the_next_turn_across_agents() { for (agent, prompt_verb) in [ @@ -1780,3 +1832,94 @@ fn owner_election_commit_reconnect_and_crash_restart() { ); wait_for_shutdown(&repository); } + +#[test] +fn scoped_concurrent_stops_and_session_end_do_not_record_sibling_files() { + let temp = TempDir::new().unwrap(); + let root = temp.path().join("repo"); + drop(Repository::init(&root).unwrap()); + let hook = |sid: &str, verb: &str, extra: Value| { + let mut value = extra; + value["session_id"] = sid.into(); + let output = run_agent_hook( + &root, + "opencode", + verb, + &serde_json::to_vec(&value).unwrap(), + ); + assert!(output.status.success(), "{output:?}"); + }; + hook( + "workspace-owner", + "session-start", + serde_json::json!({"recording_scope":"explicit-files-v1"}), + ); + for sid in ["child-a", "child-b"] { + hook( + sid, + "session-start", + serde_json::json!({"recording_scope":"explicit-files-v1", "workspace_session_id":"workspace-owner"}), + ); + hook( + sid, + "user-prompt", + serde_json::json!({"prompt":"Write only the assigned file"}), + ); + } + for name in ["child-a.txt", "child-b.txt", "human.txt"] { + std::fs::write(root.join(name), name).unwrap(); + } + let pending:Vec<_> = ["child-a", "child-b"].into_iter().map(|sid|{ + let root=root.clone(); + thread::spawn(move||{ + let path=format!("{sid}.txt"); + let digest=atomic_agent::record::scope::fingerprint(&root,&path).unwrap(); + run_agent_hook(&root,"opencode","stop",&serde_json::to_vec(&serde_json::json!({"session_id":sid,"record_files":{path:digest},"response":"Done"})).unwrap()) + }) + }).collect(); + for handle in pending { + let result = handle.join().unwrap(); + assert!(result.status.success(), "{result:?}"); + } + for sid in ["child-a", "child-b"] { + let state: Value = serde_json::from_slice( + &std::fs::read(root.join(format!(".atomic/sessions/{sid}.json"))).unwrap(), + ) + .unwrap(); + let owner: Value = serde_json::from_slice( + &std::fs::read(root.join(".atomic/sessions/workspace-owner.json")).unwrap(), + ) + .unwrap(); + assert_eq!(state["view_name"], owner["view_name"]); + assert_eq!( + state["files_touched"], + serde_json::json!([format!("{sid}.txt")]) + ); + assert_eq!(state["recorded_change_hashes"].as_array().unwrap().len(), 1); + hook( + sid, + "stop", + serde_json::json!({"record_files":{},"response":"duplicate idle"}), + ); + hook( + sid, + "session-end", + serde_json::json!({"record_files":{},"reason":"deleted"}), + ); + let after: Value = serde_json::from_slice( + &std::fs::read(root.join(format!(".atomic/sessions/{sid}.json"))).unwrap(), + ) + .unwrap(); + assert_eq!( + after["recorded_change_hashes"], + state["recorded_change_hashes"] + ); + assert_eq!(after["turn_count"], state["turn_count"]); + } + assert_eq!( + std::fs::read_to_string(root.join("human.txt")).unwrap(), + "human.txt" + ); + assert!(run_owner(&root, "shutdown").status.success()); + wait_for_shutdown(&root); +} diff --git a/docs/subagent-file-ownership.md b/docs/subagent-file-ownership.md new file mode 100644 index 00000000..8e6479d3 --- /dev/null +++ b/docs/subagent-file-ownership.md @@ -0,0 +1,93 @@ +# Shared-workspace file ownership + +Follow-up to the session-start lock and OpenCode session-routing fixes. The +Atomic implementation remains on redb 4.2 and is isolated from PR #190 on +`fix/subagent-file-ownership`. Intent: `ATOM::vince::13` +(`01M2NZT2H8RPJ0RFPAYX8G8QCY`). The matching atomic-opencode change has intent +`ATOM::vince::2` (`01M2NZT228QP7FKNGJM14E4TMM`). + +## Behavior + +Previously each Stop scanned and recorded the whole working directory. A child +could therefore record its sibling's file even with correctly routed hook events. + +The new OpenCode plugin negotiates `explicit-files-v1` through the CLI's +`agent hooks opencode file-snapshot` operation. It compares dirty-file fingerprints +before and after potentially mutating tools (including bash and unknown tools), +then sends only that session's changed files in `record_files` on Stop. +Fingerprints of candidate files cover contents, executable mode, symlink targets +and deletions. Candidate discovery uses Atomic status and therefore inherits +its file-index/mtime detection limits. It is not a full filesystem audit. +Unchanged pre-existing edits are excluded. Changed pre-existing unowned files, +foreign session rewrites and view changes during a tool block automatic recording. + +Potentially mutating tools, session startup and publication use a workspace queue +with a 30-second acquisition limit. A timeout prevents that queued tool from +starting and does not unlock another running operation. Read tools and model +reasoning can overlap; a parent waiting on `task` never holds the queue. Error +and idle callbacks drain unfinished tool snapshots so partial writes remain +attributed and other sessions can proceed. + +Parent and child sessions in the same plugin instance adopt one working view. +Each retains its own session ID, scoped change and provenance. This matches the +single actual filesystem baseline: the parent sees recorded child work without +an implicit cross-view merge. Separate session views remain the default for +other integrations and sessions that do not request shared-workspace recording. + +The Rust recorder validates the manifest and current fingerprints before adding +and recording, filters status and envelope files to the same scope, and persists +the explicit-scope requirement in the session. An empty scope is a provenance-only +checkpoint. A missing/invalid scope is an error, not permission to sweep the tree. +SessionEnd does not sweep unrelated files after an already-completed scoped turn. + +The plugin must be installed with the matching CLI. It refuses an older CLI +instead of falling back to unscoped recording. + +## Validation on macOS, 2026-09-16 + +- 1,342 atomic-agent unit tests passed, including three new scoped-record tests. +- 20 owner integration and 4 ordinary-read integration tests passed. The added + concurrent-Stop test verifies distinct file lists, a common declared workspace + view, duplicate-Stop idempotency and no SessionEnd sweep. +- 13 plugin tests / 47 assertions passed, covering routing plus file snapshots, + unrelated edits, foreign rewrites, deletions, partial failures, view drift, + capability refusal and bounded queue acquisition. +- Workspace Clippy with `-D warnings` passed. +- A real OpenCode 1.18.30 parent and two overlapping atomic subagents used + openrouter/openai/gpt-5-mini. All 21 tools completed. Three separate changes + contained exactly `results/parent.txt`, `results/child-a.txt`, and + `results/child-b.txt`, respectively. All three checkpoints published; frozen + journal call IDs matched their sessions and all provenance hashes verified. + There were no hook errors or lock warnings, and the final working directory + was clean without a manual insert or record after the run. + +The same real scenario also passed after a disposable local Git merge with +Aaron's PR #189 at `9c6fdff35a6a6ce73ea6a8c79eea1a26af136828`: +21 successful tool calls, three correctly scoped changes, three verified +published checkpoints, no hook errors, and a clean working directory. Child +execution intervals overlapped. This merge is test-only and is not included in +the follow-up branch. Evidence: `live-combined/`. + +## Scope and remaining limits + +This is coordinated attribution within one OpenCode instance, not an operating +system sandbox. Other processes/instances or human edits can still change files; +a post-tool fingerprint change is rejected, but snapshots cannot prove who wrote +bytes concurrently inside an uncoordinated tool interval. Independent overlapping +writers should use separate working directories. + +Conflicting shared-file writes are not automatically merged or rolled back. The +plugin blocks publication and leaves the disk state for explicit reconciliation. +In-memory ownership and queued events are not a crash-persistent execution log. +Immediate OpenCode process exit may still interrupt pending callbacks; the live +test used a persistent server and a 15-second drain period. + +An earlier scoped-record experiment retained separate child views. It preserved +each file's authorship, but explicit insertion into the parent left a child file +untracked even after reindexing. That experiment is retained in local evidence; +the shipped shared-workspace mode uses one baseline instead. It does not claim +to repair general cross-view directory merging. + +Raw local evidence: enclosing workspace `.gstack/subagent-ownership-20260916/`, +particularly `live-shared/`, `integration.log`, `shared-integration.log`, +`agent-tests-final.log`, `integration-final.log`, `plugin-tests.log`, and `clippy-final.log`. diff --git a/docs/subagent-session-start.md b/docs/subagent-session-start.md new file mode 100644 index 00000000..2399f342 --- /dev/null +++ b/docs/subagent-session-start.md @@ -0,0 +1,73 @@ +# Subagent session-start contention + +Follow-up: the shared-directory file-ownership limitation described below is +addressed by the separate `fix/subagent-file-ownership` branch; see +[file ownership](subagent-file-ownership.md). + + +This follow-up is based on PR #190 at +`67b74c8881ce4afe8a758beea093bc486a1da3f7`. It keeps redb 4.2 and does not +include Aaron's identity-delegation changes. Atomic intent: `ATOM::vince::12` +(`01M2NYA6AV3JHQZP31Z4R8R4MG`), view `fix-subagent-session-start`. + +## Problem and change + +Live OpenCode parent/subagent testing exposed session-start warnings that skipped +view creation when another process held the database. The existing record and +ordinary-read waiting paths did not cover session initialization. + +Session creation, fallback creation and lifecycle synchronization now use the +existing typed contention retry helper, with a ten-second limit per database +acquisition. Only opening the handle is retried; view creation and lifecycle +operations are not replayed. Non-contention errors retain their existing +behavior. This does not make a permanently occupied database available. + +## Validation (2026-09-16, macOS) + +- New regression launches eight independent foreground OpenCode session-start + processes while a real writable handle holds the database. After releasing + the handle, all eight create distinct views and persist their lifecycle rows, + without lock warnings or test-side retries. +- 19 database-owner integration tests, 4 ordinary-read contention tests, and + 36 orchestrator tests passed. Workspace Clippy with `-D warnings` passed. +- An initial concurrently loaded run hit an existing three-second corruption + test deadline. The complete two-integration-test-binary rerun passed unchanged; + the deadline was not relaxed. + +An independent fix in `atomic-opencode` is also required: its former plugin-global +session ID and buffers mixed parent/child events. That fix keeps separate state +and ordered foreground hook calls per session. + +With both fixes and Aaron's PR #189 at +`9c6fdff35a6a6ce73ea6a8c79eea1a26af136828` merged **only in a disposable local +build**, OpenCode 1.18.30 ran a real parent and two overlapping atomic subagents +using `openrouter/openai/gpt-5-mini`: + +- All 21 tool calls completed; both child task intervals overlapped for about + 39 seconds. Each child ran three intent-list/status pairs. +- Three separate journal checkpoints reached `Published`. Their provenance + content hashes verified. Frozen journal tool IDs matched their originating + OpenCode sessions, with zero foreign or missing completed tool IDs. +- No database-lock warnings or plugin hook failures were observed. + +The earlier run on #190 plus these fixes also published three correctly routed +checkpoints. Its parent attempted an external `/tmp` write that the test's +OpenCode permissions rejected; that run is not counted as a complete three-file +write test. The combined run constrained all files to its disposable directory. + +## Remaining shared-directory limitation + +This is not a claim of complete multi-agent workspace isolation. In the combined +run, one child's Stop recorded both child result files; the other child's +checkpoint contained provenance but no change hash. The parent recorded its own +file. Both child files exist in the recorded change, but appear untracked from +the parent's view after it becomes current again. + +Separate hook event streams do not assign ownership of all files in a shared +working tree. Workspace/view isolation and merging child changes into the parent +remain separate integration work. This result does not establish overall bridge +or release readiness. + +Local raw evidence is under `.gstack/subagent-fixes-20260916/` in the enclosing +workspace: Rust test logs, plugin regression logs, and `live-with189/` containing +the OpenCode events, session audit, frozen-journal audit and child change details.