//! SMH-SPEC-PLUG0001, SMH-SPEC-SPEC0001: lifecycle evidence shares writer/reopen/memory ownership laws. use super::*; use crate::metadata::encode; use crate::metadata::lifecycle as evidence; use crate::session::{EntryContent, Session}; use smith::message::{Message, Role}; fn component() -> crate::tools::ToolComponentProvenance { crate::tools::ToolComponentProvenance { source_id: "example:lifecycle".into(), manifest_sha256: "0".repeat(64), component_sha256: "1".repeat(64), } } fn record(id: EntryId, kind: &str, detail: smith::structured::StructuredData) -> Frame { let mut entry = EntryFrame::new( None, &EntryContent::Meta { kind: kind.into(), detail, }, ) .unwrap(); entry.id = id; Frame::Known { entry } } fn invocation(root: EntryId, id: EntryId) -> Frame { let mut frame = record( id, evidence::INVOCATION_INTENT, encode(&evidence::InvocationIntent { root_entry_id: root, invocation_id: id, boundary: smith::lifecycle::Boundary::PreSettlement, round_index: 0, handler: "fixture", component: &component(), }) .unwrap(), ); if let Frame::Known { entry } = &mut frame { entry.parent = Some(root); } frame } fn effect(root: EntryId, parent: EntryId, id: EntryId, ordinal: u16) -> Frame { record( id, evidence::EFFECT_INTENT, encode(&evidence::EffectIntent { root_entry_id: root, invocation_id: parent, effect_id: id, ordinal, operation: "http", input: "{}", }) .unwrap(), ) } fn completion(root: EntryId, parent: EntryId, id: EntryId, ordinal: u16) -> Frame { record( EntryId::new(), evidence::EFFECT_COMPLETION, encode(&evidence::EffectCompletion { root_entry_id: root, invocation_id: parent, effect_id: id, ordinal, ok: true, mutation_state: smith::error::MutationState::Applied, output: "ok", }) .unwrap(), ) } #[test] fn metadata_routing_never_bypasses_payload_validation() { let path = std::env::temp_dir().join(format!("metadata-routing-{}.smh", SessionId::new())); let mut opened = create_session(&path, &Session::new(), smith::Config::default_valid()).unwrap(); let before = std::fs::read(&path).unwrap(); let content = EntryContent::Meta { kind: "ordinary".into(), detail: encode(&[1u8, 2, 3]).unwrap(), }; // Both append boundaries reject a valid name with a truncated structured payload. let mut session = Session::new(); let entry = *session.append(&content).unwrap(); let mut bytes = session.bytes(&entry).to_vec(); bytes.pop(); assert!(opened.writer.append_entry(&entry, &bytes).is_err()); let mut frame_entry = EntryFrame::new(None, &content).unwrap(); frame_entry.content.pop(); assert!( opened .writer .append_frame(&Frame::Known { entry: frame_entry }) .is_err() ); assert_eq!(std::fs::read(&path).unwrap(), before); std::fs::remove_file(path).unwrap(); } #[test] fn lifecycle_wrong_root_parent_duplicates_and_premature_completion_reject_before_write() { let path = std::env::temp_dir().join(format!("lifecycle-ledger-{}.smh", SessionId::new())); let mut opened = create_session(&path, &Session::new(), smith::Config::default_valid()).unwrap(); let user = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "root")), ) .unwrap(); let root = user.id; opened .writer .append_frame(&Frame::Known { entry: user }) .unwrap(); let parent = EntryId::new(); assert!( opened .writer .append_frame(&invocation(EntryId::new(), parent)) .is_err() ); opened .writer .append_frame(&invocation(root, parent)) .unwrap(); assert!( opened .writer .append_frame(&invocation(root, parent)) .is_err() ); let primitive = EntryId::new(); assert!( opened .writer .append_frame(&effect(root, EntryId::new(), primitive, 0)) .is_err() ); assert!( opened .writer .append_frame(&completion(root, parent, primitive, 0)) .is_err() ); opened .writer .append_frame(&effect(root, parent, primitive, 0)) .unwrap(); assert!( opened .writer .append_frame(&effect(root, parent, primitive, 0)) .is_err() ); let handler_done = || { record( EntryId::new(), evidence::INVOCATION_COMPLETION, encode(&evidence::InvocationCompletion { root_entry_id: root, invocation_id: parent, ok: true, output: "[]", }) .unwrap(), ) }; assert!(opened.writer.append_frame(&handler_done()).is_err()); let ledger = SessionReader::open(&path) .unwrap() .work_ledger(opened.writer.config.frame_bytes_max, None) .unwrap(); assert!( ledger.unresolved(), "reopen retains unknown incomplete effect, never retries" ); assert_eq!(ledger.lifecycle_effect, Some(primitive)); let mut visible = Vec::new(); crate::trace::replay(&SessionReader::open(&path).unwrap(), opened.writer.config.frame_bytes_max, |record| { if matches!(record.kind, crate::trace::TraceKind::LifecycleEffectStarted | crate::trace::TraceKind::LifecycleEffectIncomplete | crate::trace::TraceKind::LifecycleInvocationIncomplete) { visible.push(serde_json::json!({ "kind": record.kind, "event_ref": record.event_ref.replace(&root.to_string(), "") .replace(&parent.to_string(), "").replace(&primitive.to_string(), ""), })); } Ok(()) }).unwrap(); insta::assert_snapshot!(serde_json::to_string_pretty(&visible).unwrap(), @r#" [ { "kind": "LifecycleEffectStarted", "event_ref": "root::invocation::effect::entry:" }, { "kind": "LifecycleEffectIncomplete", "event_ref": "root::invocation::effect::mutation:unknown" }, { "kind": "LifecycleInvocationIncomplete", "event_ref": "root::invocation::outcome:unknown" } ] "#); opened .writer .append_frame(&completion(root, parent, primitive, 0)) .unwrap(); assert!( opened .writer .append_frame(&completion(root, parent, primitive, 0)) .is_err() ); opened.writer.append_frame(&handler_done()).unwrap(); let reader = SessionReader::open(&path).unwrap(); reader .validate_work(opened.writer.config.frame_bytes_max) .unwrap(); assert!( !reader .work_ledger(opened.writer.config.frame_bytes_max, None) .unwrap() .unresolved() ); drop(opened); std::fs::remove_file(path).unwrap(); } #[test] fn lifecycle_open_invocation_prevents_root_settlement_and_memory_publication() { let root = EntryId::new(); let parent = EntryId::new(); let mut ledger = WorkLedger { lifecycle_root: Some(root), live: vec![(root, WorkStatus::Running)], ..Default::default() }; ledger.apply(&invocation(root, parent), None).unwrap(); assert!( ledger .apply( &Frame::Settlement { submission_id: root, reason: Some(smith::StopReason::EndTurn), output: None }, None ) .is_err() ); let primitive = EntryId::new(); ledger .apply(&effect(root, parent, primitive, 0), None) .unwrap(); assert!( ledger .apply(&completion(root, EntryId::new(), primitive, 0), None) .is_err() ); assert!( ledger .apply(&completion(root, parent, primitive, 1), None) .is_err() ); } #[test] fn lifecycle_simple_root_remains_the_original_durable_user_after_steering() { let user = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "root")), ) .unwrap(); let root = user.id; let steering = EntryFrame::new( Some(root), &EntryContent::Message(Message::with_text(Role::User, "steering")), ) .unwrap(); let mut intent = invocation(root, EntryId::new()); if let Frame::Known { entry } = &mut intent { entry.parent = Some(steering.id); } let frames = [ Frame::Known { entry: user }, Frame::Known { entry: steering }, intent, ]; validate_memory_work(&frames).unwrap(); } #[test] fn automatic_checkpoint_defers_open_lifecycle_evidence_until_invocation_completion() { fn append_entry(writer: &mut SessionWriter, frames: &mut Vec, frame: Frame) { let Frame::Known { entry } = &frame else { panic!("fixture entry frame"); }; writer .append_entry( &Entry { id: entry.id, parent: entry.parent, timestamp_ms: entry.timestamp_ms, kind: entry.kind, content: crate::session::Span { offset: 0, len: 0 }, }, &entry.content, ) .unwrap(); frames.push(frame); } for filler_end in 60..=64 { let mut frames = Vec::new(); let path = std::env::temp_dir().join(format!("lifecycle-checkpoint-{}.smh", SessionId::new())); let mut opened = create_session(&path, &Session::new(), smith::Config::default_valid()).unwrap(); let root_frame = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "root")), ) .unwrap(); let root = root_frame.id; append_entry( &mut opened.writer, &mut frames, Frame::Known { entry: root_frame }, ); for _ in 1..filler_end { let entry = EntryFrame::new( None, &EntryContent::Message(Message::with_text(Role::User, "filler")), ) .unwrap(); append_entry(&mut opened.writer, &mut frames, Frame::Known { entry }); } let invocation_id = EntryId::new(); append_entry( &mut opened.writer, &mut frames, invocation(root, invocation_id), ); let effect_id = EntryId::new(); append_entry( &mut opened.writer, &mut frames, effect(root, invocation_id, effect_id, 0), ); append_entry( &mut opened.writer, &mut frames, completion(root, invocation_id, effect_id, 0), ); append_entry( &mut opened.writer, &mut frames, record( EntryId::new(), evidence::INVOCATION_COMPLETION, encode(&evidence::InvocationCompletion { root_entry_id: root, invocation_id, ok: true, output: "[]", }) .unwrap(), ), ); validate_memory_work(&frames).unwrap(); drop(opened); let reader = SessionReader::open(&path).unwrap(); reader .validate_work(smith::Config::default_valid().frame_bytes_max) .unwrap(); drop(reader); drop(open_session(&path, smith::Config::default_valid()).unwrap()); std::fs::remove_file(path).unwrap(); } }