refactor: require annotated session log history

crates/worker/tests/compact_events_test.rs

@@ -25,6 +25,17 @@ use worker::{Worker, WorkerController};
 
 type TestStore = CombinedStore<FsStore, FsWorkerStore>;
 
+fn annotated(item: Item) -> session_store::LoggedHistoryEntry {
+    session_store::LoggedHistoryEntry {
+        item: session_store::LoggedItem::from(item),
+        metadata: session_store::LoggedSessionHistoryMetadata {
+            entry_id: session_store::LoggedSessionHistoryEntryId::new(),
+            origin: session_store::LoggedSessionHistoryOrigin::LegacyUnknown,
+            derivation: None,
+        },
+    }
+}
+
 #[derive(Clone)]
 struct MockClient {
     responses: Arc<Vec<Vec<LlmEvent>>>,
@@ -210,7 +221,6 @@ fn system_texts_in_sink_session_start(
                 .into_iter()
                 .map(|entry| entry.item)
                 .collect::<Vec<_>>(),
-            session_store::LogEntry::SegmentStart { history, .. } => history,
             _ => continue,
         };
         return history
@@ -310,17 +320,14 @@ permission = "write"
     // Simulate a foreign writer appending to the same segment. This bumps
     // the on-disk entry count past the Worker's own append tally without
     // updating the Worker's `entries_written`.
-    store
-        .append(
-            session_id,
-            source_segment_id,
-            &LogEntry::UserInput {
-                ts: 9999,
-                segments: vec![protocol::Segment::text("interloper")],
-                extensions: vec![],
-            },
-        )
-        .unwrap();
+    session_store::save_user_input(
+        &store,
+        session_id,
+        source_segment_id,
+        vec![protocol::Segment::text("interloper")],
+        vec![annotated(Item::user_message("interloper"))],
+    )
+    .unwrap();
 
     // Next run triggers ensure_segment_head, which sees the drift.
     worker.run_text("second").await.unwrap();
@@ -348,11 +355,6 @@ permission = "write"
             session_id: seg_session,
             forked_from: Some(origin),
             ..
-        }
-        | LogEntry::SegmentStart {
-            session_id: seg_session,
-            forked_from: Some(origin),
-            ..
         } => {
             assert_eq!(*seg_session, session_id);
             assert_eq!(origin.segment_id, source_segment_id);
@@ -366,7 +368,7 @@ permission = "write"
     assert_eq!(source_after.len(), source_len_before + 1);
     assert!(matches!(
         source_after.last(),
-        Some(LogEntry::UserInput { .. })
+        Some(LogEntry::AnnotatedUserInput { .. })
     ));
 }
 

crates/worker/tests/controller_test.rs

@@ -35,29 +35,16 @@ fn history_from_sink(handle: &WorkerHandle) -> Vec<Item> {
             LogEntry::AnnotatedSegmentStart { history, .. } => {
                 items.extend(history.into_iter().map(|entry| Item::from(entry.item)));
             }
-            LogEntry::SegmentStart { history, .. } => {
-                items.extend(history.into_iter().map(Item::from));
-            }
             LogEntry::AnnotatedUserInput { history, .. } => {
                 items.extend(history.into_iter().map(|entry| Item::from(entry.item)));
             }
-            LogEntry::UserInput { segments, .. } => {
-                let text = protocol::Segment::flatten_to_text(&segments);
-                items.push(Item::user_message(text));
-            }
             LogEntry::AnnotatedAssistantItem { entry, .. }
             | LogEntry::AnnotatedToolResult { entry, .. } => {
                 items.push(Item::from(entry.item));
             }
-            LogEntry::AssistantItem { item, .. } | LogEntry::ToolResult { item, .. } => {
-                items.push(Item::from(item));
-            }
             LogEntry::AnnotatedSystemItem { entry, .. } => {
                 items.push(entry.item.to_history_item());
             }
-            LogEntry::SystemItem { item, .. } => {
-                items.push(item.to_history_item());
-            }
             _ => {}
         }
     }
@@ -67,7 +54,6 @@ fn history_from_sink(handle: &WorkerHandle) -> Vec<Item> {
 fn system_item(entry: &LogEntry) -> Option<&session_store::SystemItem> {
     match entry {
         LogEntry::AnnotatedSystemItem { entry, .. } => Some(&entry.item),
-        LogEntry::SystemItem { item, .. } => Some(item),
         _ => None,
     }
 }
@@ -1095,7 +1081,7 @@ async fn run_with_paste_segment_inlines_content_and_emits_typed_user_message() {
     // Mixed input: plain text + a paste chip + trailing text. Worker must
     // flatten this into one user-message string (paste content inlined,
     // no `[Clipboard ...]` label leaking to the LLM); the committed
-    // `LogEntry::UserInput` must carry the typed segments unchanged so
+    // `LogEntry::AnnotatedUserInput` must carry the typed segments unchanged so
     // socket clients can derive `Event::UserMessage` and re-render the chip.
     let segments = vec![
         protocol::Segment::text("see "),
@@ -1130,7 +1116,7 @@ async fn run_with_paste_segment_inlines_content_and_emits_typed_user_message() {
                 _ => {}
             },
             entry = entry_rx.recv() => match entry {
-                Ok(session_store::LogEntry::UserInput { segments, .. } | session_store::LogEntry::AnnotatedUserInput { segments, .. }) => {
+                Ok(session_store::LogEntry::AnnotatedUserInput { segments, .. }) => {
                     user_input_segments = Some(segments);
                     if saw_turn_end {
                         break;