//! SMH-SPEC-SPEC0001: durable control remains live independently of execution. use super::*; use smith::stream::StopReason; use smith::tool::CancelHandle; use smith_core::agent::Agent; use smith_core::frame::Frame; use smith_core::store::WorkStatus; use smith_core::tools::ToolSession; use std::sync::mpsc; use std::time::Duration; const DEADLINE: Duration = Duration::from_secs(10); fn config() -> RuntimeConfig { let directory = std::env::temp_dir().join(format!( "smith-durable-control-{}", smith::id::SessionId::new() )); std::fs::create_dir(&directory).unwrap(); RuntimeConfig::mock(&directory, vec![crate::mock_text_reply("answer")]) } #[test] fn backend_retry_inspection_and_busy_never_execute_twice() { let config = config(); let path = config.session_path.clone(); let (control, mut executor) = writer_backend(config).unwrap(); let admission = control.admit("first", Some("key")).unwrap(); let id = admission.work.receipt.submission_id; assert!(admission.is_new); assert_eq!( control.admit("first", Some("key")).unwrap().work, admission.work ); assert!(control.admit("busy", None).is_err()); assert!( control.abort(Some(id)).is_err(), "queued withdrawal is unsupported" ); assert_eq!(executor.execute(id, &mut |_| {}).unwrap().text, "answer"); let retry = control.admit("first", Some("key")).unwrap(); assert!(!retry.is_new); assert_eq!( retry.work.status, WorkStatus::Terminal(Some(StopReason::EndTurn)) ); assert!(executor.execute(id, &mut |_| {}).is_err()); assert_eq!(control.inspect(id).unwrap(), Some(retry.work)); drop((executor, control)); let reader = SessionReader::open(&path).unwrap(); let mut admissions = 0; reader .scan(Config::default_valid().frame_bytes_max, |frame| { if matches!(frame, Frame::Admission { .. }) { admissions += 1; } Ok(()) }) .unwrap(); assert_eq!( admissions, 1, "BUSY and retry must not create another admission" ); } #[test] fn read_only_missing_and_existing_sessions_never_mutate_or_prepare_provider() { let config = config(); let missing = config.session_path.with_file_name("missing.smh"); assert!(ReadOnlyControl::open(&missing).is_err()); assert!(!missing.exists()); let (control, executor) = writer_backend(config.clone()).unwrap(); let id = control .admit("pending", None) .unwrap() .work .receipt .submission_id; drop((control, executor)); let before = std::fs::read(&config.session_path).unwrap(); let reader = ReadOnlyControl::open(&config.session_path).unwrap(); assert_eq!(reader.access_mode(), AccessMode::ReadOnly); assert_eq!( reader.inspect(id).unwrap().unwrap().status, WorkStatus::Queued ); assert!(reader.admit("forbidden", None).is_err()); assert!(reader.abort(Some(id)).is_err()); assert_eq!(std::fs::read(&config.session_path).unwrap(), before); let (control, _executor) = writer_backend(config).unwrap(); assert!(control.admit("blocked after reopen", None).is_err()); assert_eq!( control.inspect(id).unwrap().unwrap().status, WorkStatus::Queued ); } #[test] fn pre_registration_abort_is_durable_before_signal_and_observed_on_binding() { let (control, _executor) = writer_backend(config()).unwrap(); let id = control .admit("input", None) .unwrap() .work .receipt .submission_id; control.storage.claim(id).unwrap(); let storage = Arc::clone(&control.storage); let (ready_tx, ready) = mpsc::sync_channel(1); let (release, release_rx) = mpsc::sync_channel(1); let (done_tx, done) = mpsc::sync_channel(1); let thread = std::thread::spawn(move || { let cancel = CancelHandle::new(); ready_tx.send(()).unwrap(); release_rx.recv_timeout(DEADLINE).unwrap(); storage.register_cancel(id, cancel.clone()).unwrap(); assert!(cancel.is_cancelled()); storage.unregister_cancel(id).unwrap(); done_tx.send(()).unwrap(); }); ready.recv_timeout(DEADLINE).unwrap(); assert!( control.abort(None).is_err(), "no implicit recovery-root resolution" ); assert_eq!(control.abort(Some(id)).unwrap(), id); assert!(control.inspect(id).unwrap().unwrap().cancel_requested); assert!(control.abort(Some(id)).is_err()); release.send(()).unwrap(); done.recv_timeout(DEADLINE).unwrap(); thread.join().unwrap(); assert_eq!( control.inspect(id).unwrap().unwrap().status, WorkStatus::Running ); } #[test] fn acknowledged_cancel_wins_late_success_without_publishing_assistant() { let config = config(); let path = config.session_path.clone(); let (control, _executor) = writer_backend(config.clone()).unwrap(); let id = control .admit("input", None) .unwrap() .work .receipt .submission_id; let session = control.storage.claim(id).unwrap(); let storage = Arc::clone(&control.storage); let (at_settlement_tx, at_settlement) = mpsc::sync_channel(1); let (release, release_rx) = mpsc::sync_channel(1); let (done_tx, done) = mpsc::sync_channel(1); let thread = std::thread::spawn(move || { let tools = ToolSession::with_persist(config.workdir, session, |_, _| Ok(())); let mut agent = Agent::new( crate::mock_stream(vec![crate::mock_text_reply("unstored answer")]), tools, "mock", ); storage.register_cancel(id, agent.cancel_handle()).unwrap(); let result = agent.run_admitted_controlled( id, |command| { if matches!( command, Frame::Settlement { reason: Some(StopReason::EndTurn), .. } ) { at_settlement_tx.send(()).unwrap(); release_rx.recv_timeout(DEADLINE).unwrap(); } storage.settle_execution(command) }, &mut |_| {}, ); storage.unregister_cancel(id).unwrap(); let outcome = result.unwrap(); assert_eq!(outcome.reason, StopReason::Abort); assert_eq!(outcome.text, "unstored answer"); assert_eq!(agent.session().active_branch().entries().len(), 1); done_tx.send(()).unwrap(); }); at_settlement.recv_timeout(DEADLINE).unwrap(); assert_eq!(control.abort(None).unwrap(), id); release.send(()).unwrap(); done.recv_timeout(DEADLINE).unwrap(); thread.join().unwrap(); assert_eq!( control.inspect(id).unwrap().unwrap().status, WorkStatus::Terminal(Some(StopReason::Abort)) ); assert!(control.abort(Some(id)).is_err()); assert!(control.abort(None).is_err()); let reader = SessionReader::open(&path).unwrap(); reader .scan(Config::default_valid().frame_bytes_max, |frame| { if let Frame::Settlement { reason, output, .. } = frame { assert_eq!(reason, Some(StopReason::Abort)); assert!( output.is_none(), "rejected success must not acknowledge assistant output" ); } Ok(()) }) .unwrap(); // Stale unregister and abort cannot target a newer root. let next = control .admit("next", None) .unwrap() .work .receipt .submission_id; control.storage.claim(next).unwrap(); let next_cancel = CancelHandle::new(); control .storage .register_cancel(next, next_cancel.clone()) .unwrap(); control.storage.unregister_cancel(id).unwrap(); assert!(control.abort(Some(id)).is_err()); assert!(!next_cancel.is_cancelled()); assert_eq!(control.abort(None).unwrap(), next); assert!(next_cancel.is_cancelled()); }