//! SMH-SPEC-SPEC0001: atomic completion reader, writer, replay, recovery. use super::*; use crate::frame::ToolCompletionCheckpoint; use crate::metadata::{ToolMutationMetadata, encode}; use crate::session::{EntryContent, TOOL_MUTATION_KIND}; use smith::error::MutationState; use smith::id::ToolCallId; use smith::message::{ContentBlock, Message, Role}; use smith::structured::ToolArguments; pub(super) fn setup(state: MutationState) -> (PathBuf, OpenSession, Frame) { let path = std::env::temp_dir().join(format!("smith-completion-{}.smh", SessionId::new())); let mut opened = create_session(&path, &Session::new(), Config::default_valid()).unwrap(); let receipt = opened .writer .admit(&Message::with_text(Role::User, "write"), None, None) .unwrap(); opened.writer.claim(receipt.submission_id).unwrap(); let call_id = ToolCallId::new(); let intent = EntryFrame::new( Some(receipt.submission_id), &EntryContent::ToolCall { name: "write".into(), input: ToolArguments::empty_object(), call_id, }, ) .unwrap(); let result = EntryFrame::new( Some(intent.id), &EntryContent::ToolResult { call_id, ok: state == MutationState::Applied, output: "evidence".into(), }, ) .unwrap(); let evidence = EntryFrame::new( Some(result.id), &EntryContent::Meta { kind: TOOL_MUTATION_KIND.into(), detail: encode(&ToolMutationMetadata::new(call_id, state)).unwrap(), }, ) .unwrap(); let mut message = Message::new(Role::Tool); message.add_block(ContentBlock::tool_result( call_id, state == MutationState::Applied, "evidence", )); let conversation = EntryFrame::new(Some(evidence.id), &EntryContent::Message(message)).unwrap(); opened .writer .append_frame(&Frame::Known { entry: intent }) .unwrap(); ( path, opened, Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id: receipt.submission_id, call_id, }, entries: Box::new([result, evidence, conversation]), }, ) } #[test] fn completion_validation_failure_does_not_mutate_prior_state() { let (path, mut opened, mut commit) = setup(MutationState::Unknown); let before = std::fs::read(&path).unwrap(); let Frame::Commit { checkpoint, .. } = &mut commit else { unreachable!() }; checkpoint.submission_id = EntryId::new(); assert!(opened.writer.append_frame(&commit).is_err()); assert_eq!(std::fs::read(&path).unwrap(), before); drop(opened); clear(&path); } #[test] fn in_memory_completion_cannot_adopt_another_pending_input() { let (path, opened, commit) = setup(MutationState::Unknown); let reader = SessionReader::open(&path).unwrap(); let mut frames = Vec::new(); reader .scan(Config::default_valid().frame_bytes_max, |frame| { frames.push(frame); Ok(()) }) .unwrap(); let Frame::Commit { checkpoint, .. } = &commit else { unreachable!() }; let queued = EntryFrame::new( Some(checkpoint.submission_id), &EntryContent::Message(Message::with_text(Role::User, "another input")), ) .unwrap(); for frame in &mut frames { if let Frame::Known { entry } = frame { entry.parent = Some(queued.id); } } frames.insert( 2, Frame::Admission { entry: queued, key: None, }, ); frames.push(commit); assert!(Session::from_frames(&frames).is_err()); drop(reader); drop(opened); clear(&path); } #[test] fn admitted_completion_members_cannot_be_flattened_through_entry_writer() { let (path, mut opened, commit) = setup(MutationState::Applied); let before = std::fs::read(&path).unwrap(); for entry in commit.entries() { assert!( opened .writer .append_frame(&Frame::Known { entry: entry.clone() }) .is_err() ); let record = Entry { id: entry.id, parent: entry.parent, timestamp_ms: entry.timestamp_ms, kind: entry.kind, content: crate::session::Span { offset: 0, len: 0 }, }; assert!(opened.writer.append_entry(&record, &entry.content).is_err()); } assert_eq!(std::fs::read(&path).unwrap(), before); drop(opened); clear(&path); } #[test] fn required_semantic_records_cannot_bypass_typed_writer_validation() { let (path, mut opened, commit) = setup(MutationState::Applied); let bytes = commit .encode(Config::default_valid().frame_bytes_max) .unwrap(); let raw = Frame::Unknown { kind: crate::frame::KIND_COMMIT, version: 1, payload: bytes[crate::frame::HEADER_LEN + 4..bytes.len() - 4].to_vec(), }; let before = std::fs::read(&path).unwrap(); assert!(opened.writer.append_frame(&raw).is_err()); assert_eq!(std::fs::read(&path).unwrap(), before); drop(opened); clear(&path); } pub(super) fn clear(path: &Path) { for path in [path.to_path_buf(), lock_path(path), readers_path(path)] { let _ = std::fs::remove_file(path); } } #[test] fn completion_reopens_replays_and_repairs_as_one_semantic_change() { for state in [ MutationState::NotApplied, MutationState::Applied, MutationState::Unknown, ] { let (path, mut opened, commit) = setup(state); let Frame::Commit { checkpoint, ref entries, } = commit else { unreachable!() }; let expected = entries.to_vec(); opened.writer.append_frame(&commit).unwrap(); assert!(opened.writer.append_frame(&commit).is_err()); drop(opened); let reader = SessionReader::open(&path).unwrap(); reader .verify_full(Config::default_valid().frame_bytes_max) .unwrap(); let session = reader .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); assert_eq!(session.mutation_state(checkpoint.call_id).unwrap(), state); assert_eq!(session.active_branch().entries().len(), 5); for entry in &expected { let (found, _) = reader .find_entry(entry.id, Config::default_valid().frame_bytes_max) .unwrap() .unwrap(); assert_eq!(found, *entry); } let mut trace = Vec::new(); crate::trace::replay(&reader, Config::default_valid().frame_bytes_max, |event| { trace.push(event); Ok(()) }) .unwrap(); assert!( trace .iter() .any(|event| event.kind == crate::trace::TraceKind::ToolMutationCompleted) ); assert_eq!( reader .work_status( checkpoint.submission_id, Config::default_valid().frame_bytes_max ) .unwrap(), Some(WorkStatus::Running) ); drop(reader); repair_session(&path, Config::default_valid().frame_bytes_max).unwrap(); let reader = SessionReader::open(&path).unwrap(); reader .verify_full(Config::default_valid().frame_bytes_max) .unwrap(); let mut repaired = Vec::new(); crate::trace::replay(&reader, Config::default_valid().frame_bytes_max, |event| { repaired.push(event); Ok(()) }) .unwrap(); assert_eq!(trace, repaired); drop(reader); let mut reopened = open_session(&path, Config::default_valid()).unwrap(); assert!(reopened.writer.claim(checkpoint.submission_id).is_err()); let output = EntryFrame::new( Some(expected[2].id), &EntryContent::Message(Message::with_text(Role::Assistant, "done")), ) .unwrap(); reopened .writer .settle( checkpoint.submission_id, Some(smith::stream::StopReason::EndTurn), Some(output), ) .unwrap(); drop(reopened); let reader = SessionReader::open(&path).unwrap(); reader .verify_full(Config::default_valid().frame_bytes_max) .unwrap(); assert_eq!( reader .work_status( checkpoint.submission_id, Config::default_valid().frame_bytes_max ) .unwrap(), Some(WorkStatus::Terminal(Some( smith::stream::StopReason::EndTurn ))) ); drop(reader); clear(&path); } } #[test] fn torn_completion_exposes_no_member_and_cannot_reclaim_effect() { let (path, opened, commit) = setup(MutationState::Applied); let Frame::Commit { checkpoint, .. } = &commit else { unreachable!() }; let baseline = std::fs::read(&path).unwrap(); let bytes = commit .encode(Config::default_valid().frame_bytes_max) .unwrap(); drop(opened); for length in 1..bytes.len() { let mut source = baseline.clone(); source.extend_from_slice(&bytes[..length]); std::fs::write(&path, source).unwrap(); let reader = SessionReader::open(&path).unwrap(); let session = reader .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); assert_eq!( session.active_branch().entries().len(), 2, "cut at {length}" ); assert_eq!( session.mutation_state(checkpoint.call_id).unwrap(), MutationState::Unknown ); for entry in commit.entries() { assert!( reader .find_entry(entry.id, Config::default_valid().frame_bytes_max) .unwrap() .is_none() ); } drop(reader); } let mut reopened = open_session(&path, Config::default_valid()).unwrap(); assert!(reopened.writer.claim(checkpoint.submission_id).is_err()); drop(reopened); clear(&path); } #[test] fn completion_sync_failure_poisoning_preserves_recovery_required_work() { let (path, mut opened, commit) = setup(MutationState::Applied); let bytes = commit .encode(Config::default_valid().frame_bytes_max) .unwrap(); assert!( opened .writer .write_step(|file| { file.write_all(&bytes).unwrap(); Err(admission_fault("injected completion sync failure")) }) .is_err() ); assert!(opened.writer.append_frame(&commit).is_err()); drop(opened); let Frame::Commit { checkpoint, .. } = commit else { unreachable!() }; let mut reopened = open_session(&path, Config::default_valid()).unwrap(); assert!(reopened.writer.claim(checkpoint.submission_id).is_err()); drop(reopened); let reader = SessionReader::open(&path).unwrap(); assert_eq!( reader .selected_session(Config::default_valid().frame_bytes_max) .unwrap() .mutation_state(checkpoint.call_id) .unwrap(), MutationState::Applied ); drop(reader); clear(&path); }