//! SMH-SPEC-SPEC0001: Sessions, Context edits and Effective request context. use smith::config::Config; use smith::message::{Message, Role}; use smith_core::context::{ContextEdit, ContextReplacement}; use smith_core::session::{EntryContent, Session}; use smith_core::store::{SessionReader, create_session}; #[test] fn durable_replace_and_omit_preserve_raw_history() { let home = std::env::temp_dir().join(format!("smith-context-{}", smith::id::SessionId::new())); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let mut session = Session::new(); let original = Message::with_text(Role::User, "original"); let target = session .append(&EntryContent::Message(original.clone())) .unwrap() .id; let mut opened = create_session(&path, &session, Config::default_valid()).unwrap(); opened .writer .edit_context(&[ContextEdit { target, replacement: Some(ContextReplacement::Text("replacement".into())), }]) .unwrap(); let reader = SessionReader::open(&path).unwrap(); let projected = reader .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); let message = &projected.projected_messages().unwrap()[0]; assert_eq!(message.id, original.id); assert_eq!(message.role, original.role); assert_eq!(message.timestamp_ms, original.timestamp_ms); assert_eq!( message.blocks, Message::with_text(Role::User, "replacement").blocks ); assert_eq!( projected .content(&projected.active_branch().entries()[0]) .unwrap(), EntryContent::Message(original) ); opened .writer .edit_context(&[ContextEdit { target, replacement: None, }]) .unwrap(); let projected = SessionReader::open(&path) .unwrap() .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); assert!(projected.projected_messages().unwrap().is_empty()); } #[test] fn rejected_batches_leave_file_and_projection_unchanged() { use smith::id::{EntryId, ToolCallId}; use smith::message::ContentBlock; use smith::structured::ToolArguments; let home = std::env::temp_dir().join(format!( "sce-invalid-{:x}", smith::id::SessionId::new().as_u128() )); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let mut session = Session::new(); let root = session .append(&EntryContent::Message(Message::with_text( Role::User, "root", ))) .unwrap() .id; let call_id = ToolCallId::new(); let mut call = Message::new(Role::Assistant); call.add_block(ContentBlock::tool_use( "read", ToolArguments::empty_object(), call_id, )); let call = session.append(&EntryContent::Message(call)).unwrap().id; let mut result = Message::new(Role::Tool); result.add_block(ContentBlock::ToolResult { call_id, ok: true, output: "evidence".into(), }); let result = session.append(&EntryContent::Message(result)).unwrap().id; let mut opened = create_session(&path, &session, Config::default_valid()).unwrap(); let baseline = std::fs::read(&path).unwrap(); let cases = [ vec![ContextEdit { target: call, replacement: None, }], vec![ContextEdit { target: result, replacement: None, }], vec![ContextEdit { target: call, replacement: Some(ContextReplacement::Text("invalid schema".into())), }], vec![ContextEdit { target: EntryId::new(), replacement: None, }], vec![ ContextEdit { target: root, replacement: None }; 65 ], vec![ContextEdit { target: root, replacement: Some(ContextReplacement::Text("x".repeat(65536))), }], vec![ ContextEdit { target: root, replacement: None }; 2 ], vec![], ]; for batch in cases { assert!(opened.writer.edit_context(&batch).is_err()); assert_eq!(std::fs::read(&path).unwrap(), baseline); let projected = SessionReader::open(&path) .unwrap() .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); assert_eq!( projected.projected_messages().unwrap(), session.projected_messages().unwrap() ); } opened.writer.select_entry(root).unwrap(); let navigated = std::fs::read(&path).unwrap(); assert!( opened .writer .edit_context(&[ContextEdit { target: result, replacement: None }]) .is_err() ); assert_eq!(std::fs::read(&path).unwrap(), navigated); opened.writer.select_entry(result).unwrap(); opened .writer .edit_context(&[ ContextEdit { target: call, replacement: None, }, ContextEdit { target: result, replacement: None, }, ]) .unwrap(); let projected = SessionReader::open(&path) .unwrap() .selected_session(Config::default_valid().frame_bytes_max) .unwrap(); assert_eq!(projected.projected_messages().unwrap().len(), 1); assert!(projected.provider_call_ids().unwrap().is_empty()); } #[test] fn generic_append_cannot_bypass_batch_validation() { let mut session = Session::new(); let before = session.clone(); assert!( session .append(&EntryContent::ContextEdit(vec![ContextEdit { target: smith::id::EntryId::new(), replacement: None }])) .is_err() ); assert_eq!(session, before); } #[test] fn codec_rejects_unknown_required_semantics_and_trailing_bytes() { use smith_core::context::ContextBatchView; assert!(ContextBatchView::decode(&[1, 1, 0]).is_err()); let mut bytes = vec![2, 1, 0]; bytes.extend_from_slice(&1u128.to_le_bytes()); bytes.push(2); assert!(ContextBatchView::decode(&bytes).is_err()); bytes[19] = 0; assert!(ContextBatchView::decode(&bytes).is_ok()); bytes.push(0); assert!(ContextBatchView::decode(&bytes).is_err()); } #[cfg(unix)] #[test] fn readonly_session_cannot_admit_edit() { use std::os::unix::fs::PermissionsExt; let home = std::env::temp_dir().join(format!( "sce-ro-{:x}", smith::id::SessionId::new().as_u128() )); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let opened = create_session(&path, &Session::new(), Config::default_valid()).unwrap(); drop(opened); let before = std::fs::read(&path).unwrap(); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o400)).unwrap(); assert!(smith_core::store::SessionWriter::open(&path, Config::default_valid()).is_err()); assert_eq!(std::fs::read(&path).unwrap(), before); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap(); std::fs::remove_dir_all(home).unwrap(); } proptest::proptest! { #[test] fn rejected_batch_preserves_projection(text in ".{0,128}", replacement in ".{0,128}") { let mut session = Session::new(); let target = session.append(&EntryContent::Message(Message::with_text(Role::User, &text))).unwrap().id; let before = session.clone(); let result = session.edit_context_with(&[ContextEdit { target, replacement: None, }, ContextEdit { target: smith::id::EntryId::new(), replacement: Some(ContextReplacement::Text(replacement)), }], |_, _| panic!("rejected batch reached persistence")); proptest::prop_assert!(result.is_err()); proptest::prop_assert_eq!(session, before); } #[test] fn typed_edit_codec_roundtrips(text in ".{0,256}", kind in 0u8..4, identity in 1u128..) { use smith_core::session::EntryFrame; use smith_core::frame::{Frame, visit_frames}; let content = EntryContent::ContextEdit(vec![ContextEdit { target: smith::id::EntryId::from_u128(identity), replacement: match kind { 0 => None, 1 => Some(ContextReplacement::Text(text)), 2 => Some(ContextReplacement::AssistantText(text)), _ => Some(ContextReplacement::ToolResultOutput { call_id: smith::id::ToolCallId::from_u128(identity), output: text }) }, }]); let entry = EntryFrame::new(None, &content).unwrap(); proptest::prop_assert_eq!(EntryContent::decode(&entry.content).unwrap(), content); let frame = Frame::Known { entry }; let encoded = frame.encode(1 << 20).unwrap(); proptest::prop_assert_eq!(u16::from_le_bytes([encoded[4], encoded[5]]), smith_core::frame::KIND_CONTEXT_EDIT); let mut decoded = None; visit_frames(&mut encoded.as_slice(), 1 << 20, |frame| { decoded = Some(frame); false }).unwrap(); proptest::prop_assert_eq!(decoded, Some(frame)); } } #[cfg(target_arch = "x86_64")] #[test] fn edit_layout_bounds() { assert_eq!(std::mem::size_of::(), 56); assert_eq!( std::mem::size_of::>(), 16 ); } #[test] fn worker_ack_failure_preserves_projection_and_readonly_authority_rejects() { use smith_core::tools::ToolSession; let mut session = Session::new(); let target = session .append(&EntryContent::Message(Message::with_text( Role::User, "original", ))) .unwrap() .id; let before = session.clone(); let mut tools = ToolSession::with_persist(std::env::temp_dir(), session, |_, _| { Err(smith::error::SmithError::Cancelled) }); assert!( tools .edit_context(&[ContextEdit { target, replacement: None }]) .is_err() ); assert_eq!(tools.session, before); assert!( tools .edit_context(&[ContextEdit { target, replacement: None }]) .is_err() ); let mut readonly = ToolSession::new(std::env::temp_dir()); let target = readonly .session .append(&EntryContent::Message(Message::with_text( Role::User, "readonly", ))) .unwrap() .id; assert!( readonly .edit_context(&[ContextEdit { target, replacement: None }]) .is_err() ); assert_eq!(readonly.session.projected_messages().unwrap().len(), 1); } #[test] fn exact_wire_bound_and_latest_edit_precedence() { let mut session = Session::new(); let target = session .append(&EntryContent::Message(Message::with_text( Role::User, "original", ))) .unwrap() .id; // 3-byte header + 16-byte ID + 1-byte tag + 4-byte length. let text = "x".repeat(smith_core::context::CONTEXT_EDIT_BYTES_MAX - 24); let first = session .edit_context_with( &[ContextEdit { target, replacement: Some(ContextReplacement::Text(text.clone())), }], |_, _| Ok(()), ) .unwrap(); assert_eq!( session.projected_messages().unwrap()[0].blocks, vec![smith::message::ContentBlock::Text(text)] ); session .edit_context_with( &[ContextEdit { target, replacement: None, }], |_, _| Ok(()), ) .unwrap(); assert!(session.projected_messages().unwrap().is_empty()); let before_edit = session.fork_at(target).unwrap(); assert_eq!( before_edit.projected_messages().unwrap()[0].blocks, vec![smith::message::ContentBlock::Text("original".into())] ); let first_edit = session.fork_at(first).unwrap(); assert_eq!(first_edit.projected_messages().unwrap().len(), 1); } #[test] fn unedited_projection_rejects_invalid_tool_pairing() { use smith::id::ToolCallId; use smith::message::ContentBlock; use smith::structured::ToolArguments; let call_id = ToolCallId::new(); let call = |role| { let mut message = Message::new(role); message.add_block(ContentBlock::tool_use( "read", ToolArguments::empty_object(), call_id, )); message }; let result = |role| { let mut message = Message::new(role); message.add_block(ContentBlock::ToolResult { call_id, ok: true, output: "result".into(), }); message }; for messages in [ vec![Message::with_text(Role::Tool, "missing result")], vec![result(Role::Tool)], vec![call(Role::User)], vec![result(Role::User)], vec![call(Role::Assistant)], vec![ call(Role::Assistant), Message::with_text(Role::User, "interruption"), result(Role::Tool), ], vec![ call(Role::Assistant), result(Role::Tool), call(Role::Assistant), result(Role::Tool), ], ] { let mut session = Session::new(); for message in messages { session.append(&EntryContent::Message(message)).unwrap(); } assert!(matches!( session.projected_messages(), Err(smith::SmithError::Session { code: smith::error::SessionCode::SessionIncompleteContext, .. }) )); } } #[test] fn resulting_context_rejects_tool_role_without_result_schema() { let mut session = Session::new(); let target = session .append(&EntryContent::Message(Message::with_text( Role::Tool, "not a paired result", ))) .unwrap() .id; let before = session.clone(); assert!( session .edit_context_with( &[ContextEdit { target, replacement: Some(ContextReplacement::Text("still not a result".into())), }], |_, _| Ok(()) ) .is_err() ); assert_eq!(session, before); } #[test] fn unknown_required_edit_envelope_fails_both_readers() { use smith_core::frame::{Frame, KIND_CONTEXT_EDIT, read_frames, visit_metadata_reporting}; for version in [0, 1, 3, u16::MAX] { let bytes = Frame::Unknown { kind: KIND_CONTEXT_EDIT, version, payload: vec![0; 32], } .encode(1 << 20) .unwrap(); assert!(read_frames(&mut bytes.as_slice(), 1 << 20).is_err()); assert!( visit_metadata_reporting(&mut bytes.as_slice(), 1 << 20, |_, _| Ok(()), |_| Ok(())) .is_err() ); } } #[test] fn forged_edit_metadata_is_rejected_before_writing() { use smith_core::frame::Frame; use smith_core::session::{EntryFrame, EntryKind}; let home = std::env::temp_dir().join(format!("sce-forged-{}", smith::id::SessionId::new())); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let mut session = Session::new(); let target = session .append(&EntryContent::Message(Message::with_text( Role::User, "raw", ))) .unwrap() .id; let mut opened = create_session(&path, &session, Config::default_valid()).unwrap(); let baseline = std::fs::read(&path).unwrap(); let mut entry = EntryFrame::new( Some(target), &EntryContent::ContextEdit(vec![ContextEdit { target, replacement: None, }]), ) .unwrap(); entry.kind = EntryKind::Meta { compaction: true }; assert!(opened.writer.append_frame(&Frame::Known { entry }).is_err()); assert_eq!(std::fs::read(&path).unwrap(), baseline); std::fs::remove_dir_all(home).unwrap(); } #[test] fn checksummed_invalid_edits_fail_selected_restore() { use smith_core::frame::Frame; use smith_core::session::EntryFrame; use std::io::Write; for case in ["unknown", "offbranch", "duplicate", "future"] { let home = std::env::temp_dir().join(format!("sce-restore-{}", smith::id::SessionId::new())); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let mut session = Session::new(); let root = session .append(&EntryContent::Message(Message::with_text( Role::User, "root", ))) .unwrap() .id; let mut opened = create_session(&path, &session, Config::default_valid()).unwrap(); let sibling = EntryFrame::new( Some(root), &EntryContent::Message(Message::with_text(Role::User, "sibling")), ) .unwrap(); if case == "offbranch" { opened .writer .append_frame(&Frame::Known { entry: sibling.clone(), }) .unwrap(); } drop(opened); let future = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "future")), ) .unwrap(); let target = match case { "duplicate" => root, "offbranch" => sibling.id, "future" => future.id, _ => smith::id::EntryId::new(), }; let edit = ContextEdit { target, replacement: Some(ContextReplacement::Text("edited".into())), }; let entry = EntryFrame::new( Some(root), &EntryContent::ContextEdit(if case == "duplicate" { vec![edit.clone(), edit] } else { vec![edit] }), ) .unwrap(); let id = entry.id; let encoded = Frame::Known { entry }.encode(1 << 20).unwrap(); // Low-level checksummed fixture deliberately bypasses the typed writer guard. let bytes = Frame::Unknown { kind: smith_core::frame::KIND_CONTEXT_EDIT, version: smith_core::frame::VERSION_CONTEXT_EDIT, payload: encoded[16..encoded.len() - 4].to_vec(), } .encode(1 << 20) .unwrap(); let mut file = std::fs::OpenOptions::new() .append(true) .open(&path) .unwrap(); file.write_all(&bytes).unwrap(); if case == "future" { let mut future = future; future.parent = Some(id); file.write_all(&Frame::Known { entry: future }.encode(1 << 20).unwrap()) .unwrap(); } drop(file); let restored = SessionReader::open(&path).and_then(|reader| reader.selected_session(1 << 20)); assert!(restored.is_err(), "accepted {case} edit"); std::fs::remove_dir_all(home).unwrap(); } } #[test] fn typed_tool_replacements_preserve_identity_schema_and_raw_evidence() { use smith::id::ToolCallId; use smith::message::ContentBlock; use smith::structured::ToolArguments; let mut session = Session::new(); let call_id = ToolCallId::new(); let mut call = Message::with_text(Role::Assistant, "raw prose"); call.add_block(ContentBlock::tool_use( "read", ToolArguments::empty_object(), call_id, )); let call_target = session .append(&EntryContent::Message(call.clone())) .unwrap() .id; let mut result = Message::new(Role::Tool); result.add_block(ContentBlock::ToolResult { call_id, ok: true, output: "raw output".into(), }); let result_target = session .append(&EntryContent::Message(result.clone())) .unwrap() .id; let prose: ContextReplacement = serde_json::from_value(serde_json::json!({"AssistantText": "edited prose"})).unwrap(); let output: ContextReplacement = serde_json::from_value( serde_json::json!({"ToolResultOutput": {"call_id": call_id, "output": "edited output"}}), ) .unwrap(); session .edit_context_with( &[ ContextEdit { target: call_target, replacement: Some(prose), }, ContextEdit { target: result_target, replacement: Some(output), }, ], |_, _| Ok(()), ) .unwrap(); let before = session.clone(); for (target, replacement) in [ ( result_target, ContextReplacement::ToolResultOutput { call_id: ToolCallId::new(), output: "retargeted".into(), }, ), ( call_target, ContextReplacement::ToolResultOutput { call_id, output: "role change".into(), }, ), ( result_target, ContextReplacement::AssistantText("role change".into()), ), ] { assert!( session .edit_context_with( &[ContextEdit { target, replacement: Some(replacement) }], |_, _| panic!("invalid replacement reached persistence") ) .is_err() ); assert_eq!(session, before); } let projected = session.projected_messages().unwrap(); assert_eq!( ( projected[0].id, projected[0].role, projected[0].timestamp_ms ), (call.id, call.role, call.timestamp_ms) ); assert_eq!(projected[0].blocks[1], call.blocks[1]); assert_eq!( projected[0].blocks[0], ContentBlock::Text("edited prose".into()) ); assert_eq!( ( projected[1].id, projected[1].role, projected[1].timestamp_ms ), (result.id, result.role, result.timestamp_ms) ); assert_eq!( projected[1].blocks[0], ContentBlock::ToolResult { call_id, ok: true, output: "edited output".into() } ); assert_eq!( session .content(&session.active_branch().entries()[0]) .unwrap(), EntryContent::Message(call) ); assert_eq!( session .content(&session.active_branch().entries()[1]) .unwrap(), EntryContent::Message(result) ); } #[test] fn tool_output_replacement_enforces_exact_encoded_byte_bound() { use smith_core::context::CONTEXT_EDIT_BYTES_MAX; use smith_core::session::EntryFrame; // Header 3 + target 16 + tag 1 + call identity 16 + text length 4. let replacement = |length| { EntryContent::ContextEdit(vec![ContextEdit { target: smith::id::EntryId::from_u128(1), replacement: Some(ContextReplacement::ToolResultOutput { call_id: smith::id::ToolCallId::from_u128(2), output: "x".repeat(length), }), }]) }; let exact = replacement(CONTEXT_EDIT_BYTES_MAX - 40); let encoded = EntryFrame::new(None, &exact).unwrap(); assert_eq!(encoded.content.len(), CONTEXT_EDIT_BYTES_MAX + 1); assert_eq!(EntryContent::decode(&encoded.content).unwrap(), exact); assert!(EntryFrame::new(None, &replacement(CONTEXT_EDIT_BYTES_MAX - 39)).is_err()); } #[test] fn file_backed_live_edits_keep_raw_schema_and_transactional_publication() { use smith::message::ContentBlock; let home = std::env::temp_dir().join(format!("sce-source-{}", smith::id::SessionId::new())); std::fs::create_dir(&home).unwrap(); let path = home.join("context.smh"); let config = Config::default_valid(); let mut initial = Session::new(); let mut raw = Message::with_text(Role::Assistant, "raw prose"); raw.add_block(ContentBlock::Thinking("raw thinking".into())); let target = initial .append(&EntryContent::Message(raw.clone())) .unwrap() .id; let mut opened = create_session(&path, &initial, config.clone()).unwrap(); opened .writer .edit_context(&[ContextEdit { target, replacement: Some(ContextReplacement::Text("first".into())), }]) .unwrap(); let reader = SessionReader::open(&path).unwrap(); let mut session = reader.selected_session(config.frame_bytes_max).unwrap(); let old_edit = *session.active_branch().selected_entry().unwrap(); let raw_record = session.active_branch().entries()[0]; assert!(session.bytes(&raw_record).is_empty()); assert_eq!( EntryContent::decode(&session.raw_bytes(&raw_record).unwrap()).unwrap(), EntryContent::Message(raw.clone()) ); let next = session .append_with( &EntryContent::Message(Message::with_text(Role::User, "new raw")), |entry, bytes| opened.writer.append_entry(entry, bytes), ) .unwrap() .id; let edits = [ ContextEdit { target, replacement: Some(ContextReplacement::AssistantText("latest".into())), }, ContextEdit { target: next, replacement: Some(ContextReplacement::Text("new effective".into())), }, ]; let before = session.clone(); assert!( session .edit_context_with(&edits, |_, _| Err(smith::error::SmithError::Cancelled)) .is_err() ); assert_eq!(session, before); session .edit_context_with(&edits, |entry, bytes| { opened.writer.append_entry(entry, bytes) }) .unwrap(); let projected = session.projected_messages().unwrap(); assert_eq!( projected[0].blocks, vec![ ContentBlock::Text("latest".into()), ContentBlock::Thinking("raw thinking".into()) ] ); assert_eq!( projected[1].blocks, Message::with_text(Role::User, "new effective").blocks ); assert!(matches!( session.content(&old_edit).unwrap(), EntryContent::ContextEdit(_) )); assert_eq!( session.content(&raw_record).unwrap(), EntryContent::Message(raw) ); assert_eq!( SessionReader::open(&path) .unwrap() .selected_session(config.frame_bytes_max) .unwrap() .projected_messages() .unwrap(), projected ); let archived_live_edit = *session.active_branch().selected_entry().unwrap(); session .edit_context_with(&edits, |entry, bytes| { opened.writer.append_entry(entry, bytes) }) .unwrap(); assert!(matches!( session.content(&archived_live_edit).unwrap(), EntryContent::ContextEdit(_) )); assert_eq!( session .fork_at(target) .unwrap() .projected_messages() .unwrap(), initial.projected_messages().unwrap() ); assert_eq!( session .fork_at(archived_live_edit.id) .unwrap() .projected_messages() .unwrap(), projected ); drop(before); drop(session); drop(reader); drop(opened); std::fs::remove_dir_all(home).unwrap(); }