style: run cargo fmt

crates/session-store/src/fs_store.rs

@@ -74,7 +74,10 @@ impl FsStore {
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent)?;
         }
-        let mut file = fs::OpenOptions::new().create(true).append(true).open(path)?;
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(path)?;
         file.write_all(line.as_bytes())?;
         file.write_all(b"\n")?;
         // Append-mode write is the durability boundary; an explicit

crates/session-store/src/lib.rs

@@ -56,8 +56,8 @@ pub use segment_log::{
     LogEntry, POD_SCOPE_EXTENSION_DOMAIN, PodScopeSnapshot, RestoredState, SegmentOrigin,
     collect_state,
 };
-pub use system_item::{SystemItem, render_pod_event};
 pub use store::{Store, StoreError};
+pub use system_item::{SystemItem, render_pod_event};
 
 /// Session identifier — the fork-tree root. UUID v7 (time-ordered).
 ///

crates/session-store/src/segment.rs

@@ -4,11 +4,11 @@
 //! The caller (typically Pod) holds the Worker directly and calls these
 //! functions after state-mutating operations.
 
-use crate::{SegmentId, SessionId};
 use crate::logged_item::{LoggedItem, to_logged};
 use crate::segment_log::{self, LogEntry, PodScopeSnapshot, SegmentOrigin};
 use crate::store::{Store, StoreError};
 use crate::system_item::SystemItem;
+use crate::{SegmentId, SessionId};
 use llm_worker::WorkerResult;
 use llm_worker::llm_client::RequestConfig;
 use llm_worker::llm_client::types::Item;

crates/session-store/tests/fs_store_test.rs

@@ -112,9 +112,15 @@ fn list_sessions_and_segments() {
     let seg_a2 = new_segment_id();
     let seg_b1 = new_segment_id();
 
-    store.append(sid_a, seg_a1, &nil_session_start(1, sid_a)).unwrap();
-    store.append(sid_a, seg_a2, &nil_session_start(2, sid_a)).unwrap();
-    store.append(sid_b, seg_b1, &nil_session_start(3, sid_b)).unwrap();
+    store
+        .append(sid_a, seg_a1, &nil_session_start(1, sid_a))
+        .unwrap();
+    store
+        .append(sid_a, seg_a2, &nil_session_start(2, sid_a))
+        .unwrap();
+    store
+        .append(sid_b, seg_b1, &nil_session_start(3, sid_b))
+        .unwrap();
 
     let sessions = store.list_sessions().unwrap();
     assert_eq!(sessions, vec![sid_b, sid_a]); // newest first
@@ -136,7 +142,9 @@ fn exists_returns_correct_state() {
 
     assert!(!store.exists(sid, segid).unwrap());
 
-    store.append(sid, segid, &nil_session_start(1000, sid)).unwrap();
+    store
+        .append(sid, segid, &nil_session_start(1000, sid))
+        .unwrap();
 
     assert!(store.exists(sid, segid).unwrap());
 }
@@ -159,7 +167,9 @@ fn trace_entries_in_separate_file() {
     let sid = new_session_id();
     let segid = new_segment_id();
 
-    store.append(sid, segid, &nil_session_start(1000, sid)).unwrap();
+    store
+        .append(sid, segid, &nil_session_start(1000, sid))
+        .unwrap();
 
     let trace = TraceEntry {
         ts: 1500,
@@ -221,7 +231,9 @@ fn lookup_session_of_finds_owning_session() {
 
     assert_eq!(store.lookup_session_of(segid).unwrap(), None);
 
-    store.append(sid, segid, &nil_session_start(1, sid)).unwrap();
+    store
+        .append(sid, segid, &nil_session_start(1, sid))
+        .unwrap();
 
     assert_eq!(store.lookup_session_of(segid).unwrap(), Some(sid));
 }

crates/session-store/tests/session_test.rs

@@ -475,7 +475,11 @@ async fn session_auto_forks_on_conflict() {
     let fork_entries = store.read_all(sid, segment_id).unwrap();
     assert!(!fork_entries.is_empty());
     let fork_state = collect_state(&fork_entries);
-    assert_eq!(fork_state.session_id, Some(sid), "auto-fork inherits Session");
+    assert_eq!(
+        fork_state.session_id,
+        Some(sid),
+        "auto-fork inherits Session"
+    );
 
     // The new segment records its lineage forward via forked_from; the
     // source segment is left immutable (no terminal marker written back).
@@ -542,9 +546,16 @@ async fn nested_past_fork_leaves_ancestors_immutable() {
     }
 
     // The root and fork1 are untouched by forking their descendants.
-    assert_eq!(store.read_all(sid, root_segid).unwrap().len(), root_before.len());
+    assert_eq!(
+        store.read_all(sid, root_segid).unwrap().len(),
+        root_before.len()
+    );
     let fork1_entries = store.read_all(sid, fork1).unwrap();
-    assert_eq!(fork1_entries.len(), 1, "fork1 is just its SegmentStart seed");
+    assert_eq!(
+        fork1_entries.len(),
+        1,
+        "fork1 is just its SegmentStart seed"
+    );
 
     // fork2's lineage points at fork1, not the root.
     match &store.read_all(sid, fork2).unwrap()[0] {