Skip to main content

infinity_daemon/
memory_store.rs

1//! The daemon's stores: the core in-memory stores wrapped with per-thread
2//! JSON-file persistence and daemon-only bookkeeping.
3//!
4//! All shared [`ConversationStore`] / [`StateStore`] semantics (spawn orders,
5//! ancestor chains, compaction cutoffs, dedup sets, subscriptions, metadata)
6//! live in `infinity_agent_core::stores` — the trait impls here are pure
7//! delegation. This module layers on top:
8//!
9//! - lazy per-thread loading from and saving to `{dir}/{thread_id}*.json`,
10//! - daemon-only per-thread extras ([`ThreadExtras`]: title, children,
11//!   token totals, timestamps, the selected model),
12//! - transient and persisted views,
13//! - session serialization for migration.
14
15use async_trait::async_trait;
16use infinity_agent_core::ThreadId;
17use infinity_agent_core::message::InfinityMessage;
18use infinity_agent_core::stores::{
19    self as core_stores, CompactionSummary, ThreadInfo, ThreadState,
20};
21use infinity_agent_core::system::UserChoice;
22use infinity_agent_core::traits::{ConversationStore, StateStore};
23use infinity_protocol::ModelRef;
24use infinity_provider_protocol::message::Message;
25use serde::{Deserialize, Serialize};
26use std::collections::{HashMap, HashSet};
27use std::path::{Path, PathBuf};
28use std::sync::{Arc, Mutex};
29
30// ── Error type ──
31
32#[derive(Debug)]
33pub struct MemoryError(pub String);
34impl std::fmt::Display for MemoryError {
35    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36        write!(f, "{}", self.0)
37    }
38}
39impl std::error::Error for MemoryError {}
40
41impl From<core_stores::InMemoryStoreError> for MemoryError {
42    fn from(e: core_stores::InMemoryStoreError) -> Self {
43        MemoryError(e.to_string())
44    }
45}
46
47// ── Persistent conversation store backed by shared in-memory semantics ──
48
49#[derive(Clone)]
50pub struct PersistentConversationStore {
51    /// The shared store semantics (threads, messages, compaction summaries).
52    core: core_stores::InMemoryConversationStore,
53    /// Daemon-only per-thread bookkeeping. Invariant: a thread has an entry
54    /// here iff it has one in `core` (both are created together by the
55    /// spawn/load/import paths of this wrapper).
56    extras: Arc<Mutex<HashMap<ThreadId, ThreadExtras>>>,
57    /// Directory where per-thread JSON files are stored. `None` disables persistence.
58    dir: Option<PathBuf>,
59    /// Tracks which thread IDs have had their full data loaded from disk.
60    loaded: Arc<Mutex<HashSet<ThreadId>>>,
61    /// Tracks which thread IDs have had their metadata loaded from disk.
62    metadata_loaded: Arc<Mutex<HashSet<ThreadId>>>,
63    /// Optional sender to notify session store of changes (for SessionsUpdated broadcasts).
64    change_tx: Option<tokio::sync::mpsc::UnboundedSender<ThreadId>>,
65    /// Per-thread active views, keyed by thread_id → (view_type → content).
66    /// Persisted separately to `{thread_id}.views.json`.
67    views: Arc<Mutex<HashMap<ThreadId, HashMap<String, serde_json::Value>>>>,
68    /// The global default model, used for new threads and backfilled into
69    /// metadata serialized before models were tracked per-thread.
70    default_model: ModelRef,
71    /// Source of new thread ids (deterministic in tests).
72    id_source: Arc<dyn crate::ids::IdSource>,
73}
74
75/// Daemon-only per-thread bookkeeping, layered on top of the core store's
76/// [`ThreadInfo`].
77#[derive(Clone, Serialize, Deserialize)]
78pub(crate) struct ThreadExtras {
79    #[serde(default)]
80    title: Option<String>,
81    #[serde(default)]
82    children: Vec<ThreadId>,
83    #[serde(default)]
84    total_tokens_used: usize,
85    #[serde(default)]
86    last_updated: String,
87    /// The model selected for this specific thread. There is no parent-thread
88    /// fallback: every thread gets the global default at creation time.
89    /// Metadata serialized before models were tracked per-thread lacks this
90    /// field; it is backfilled with the store's default model on load (see
91    /// [`PersistentConversationStore::backfill_selected_model`]).
92    #[serde(default = "unset_model_ref")]
93    selected_model: ModelRef,
94}
95
96impl ThreadExtras {
97    fn new(selected_model: ModelRef) -> Self {
98        Self {
99            title: None,
100            children: Vec::new(),
101            total_tokens_used: 0,
102            last_updated: String::new(),
103            selected_model,
104        }
105    }
106}
107
108/// The serialization shape of a thread's metadata (`{thread_id}.meta.json`
109/// and the `metadata` field of [`SerializedThread`]): the core
110/// [`ThreadInfo`] and the daemon's [`ThreadExtras`] flattened into one
111/// object, byte-compatible with the format written before the core/daemon
112/// store split.
113#[derive(Clone, Serialize, Deserialize)]
114pub(crate) struct ThreadMeta {
115    #[serde(flatten)]
116    pub(crate) info: ThreadInfo,
117    #[serde(flatten)]
118    pub(crate) extras: ThreadExtras,
119}
120
121/// Serde default marking `selected_model` as absent in old serialized
122/// metadata; replaced with the store's default model on load. The empty
123/// provider id is a safe sentinel because the daemon's `ModelCatalog` asserts
124/// that registered provider ids are never empty.
125fn unset_model_ref() -> ModelRef {
126    ModelRef {
127        provider_id: String::new(),
128        model_id: String::new(),
129    }
130}
131
132/// Per-thread snapshot written to `{dir}/{thread_id}.json`.
133#[derive(Serialize)]
134pub(crate) struct ThreadSnapshot {
135    messages: Vec<(InfinityMessage, String)>,
136    #[serde(default)]
137    compaction_summaries: Vec<CompactionSummary>,
138}
139
140/// Helper struct for deserializing the new format directly.
141#[derive(Deserialize)]
142struct NewThreadSnapshot {
143    messages: Vec<(InfinityMessage, String)>,
144    #[serde(default)]
145    compaction_summaries: Vec<CompactionSummary>,
146}
147
148/// Helper struct for deserializing the old format (legacy bare Messages + display_as sidecar).
149#[derive(Deserialize)]
150struct OldThreadSnapshot {
151    #[serde(default)]
152    messages: Vec<(Message, String)>,
153    #[serde(default, deserialize_with = "deserialize_legacy_display_as_map")]
154    display_as: HashMap<String, Vec<rap_protocol::DisplaySegment>>,
155    #[serde(default)]
156    compaction_summaries: Vec<CompactionSummary>,
157}
158
159/// Custom deserializer for ThreadSnapshot that handles both old format
160/// (legacy bare Messages + display_as map) and new format (InfinityMessage).
161impl<'de> Deserialize<'de> for ThreadSnapshot {
162    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
163    where
164        D: serde::Deserializer<'de>,
165    {
166        let raw: serde_json::Value = Deserialize::deserialize(deserializer)?;
167
168        // Try new format first, fall back to old format
169        if let Ok(new) = serde_json::from_value::<NewThreadSnapshot>(raw.clone()) {
170            return Ok(ThreadSnapshot {
171                messages: new.messages,
172                compaction_summaries: new.compaction_summaries,
173            });
174        }
175
176        let old: OldThreadSnapshot =
177            serde_json::from_value(raw).map_err(serde::de::Error::custom)?;
178
179        let messages = old
180            .messages
181            .into_iter()
182            .map(|(msg, id)| {
183                let mut inf = InfinityMessage::from_message(msg);
184                if let InfinityMessage::ToolResult {
185                    ref result,
186                    ref mut display_segments,
187                } = inf
188                    && let Some(segs) = old.display_as.get(&result.id)
189                {
190                    *display_segments = Some(segs.clone());
191                }
192                (inf, id)
193            })
194            .collect();
195
196        Ok(ThreadSnapshot {
197            messages,
198            compaction_summaries: old.compaction_summaries,
199        })
200    }
201}
202
203/// Deserialize the legacy display_as map, handling both old String and new Vec<DisplaySegment> formats.
204fn deserialize_legacy_display_as_map<'de, D>(
205    deserializer: D,
206) -> Result<HashMap<String, Vec<rap_protocol::DisplaySegment>>, D::Error>
207where
208    D: serde::Deserializer<'de>,
209{
210    let raw: HashMap<String, serde_json::Value> = HashMap::deserialize(deserializer)?;
211    let mut result = HashMap::new();
212    for (k, v) in raw {
213        let segments = match v {
214            serde_json::Value::String(s) => vec![rap_protocol::DisplaySegment::Text(s)],
215            serde_json::Value::Array(_) => {
216                serde_json::from_value(v).map_err(serde::de::Error::custom)?
217            }
218            _ => continue,
219        };
220        result.insert(k, segments);
221    }
222    Ok(result)
223}
224
225#[derive(Serialize, Deserialize)]
226pub(crate) struct SerializedThread {
227    pub metadata: ThreadMeta,
228    pub snapshot: ThreadSnapshot,
229    #[serde(default)]
230    pub views: HashMap<String, serde_json::Value>,
231}
232
233impl PersistentConversationStore {
234    /// Create a store that persists each thread to its own JSON file under `dir`.
235    /// `default_model` is assigned to new threads and backfilled into metadata
236    /// that predates per-thread model tracking. `id_source` generates ids for
237    /// newly spawned threads (deterministic in tests).
238    pub fn new_with_dir(
239        dir: impl AsRef<Path>,
240        default_model: ModelRef,
241        id_source: Arc<dyn crate::ids::IdSource>,
242    ) -> Self {
243        let dir = dir.as_ref().to_path_buf();
244        std::fs::create_dir_all(&dir).ok();
245        Self {
246            core: core_stores::InMemoryConversationStore::new(),
247            extras: Arc::new(Mutex::new(HashMap::new())),
248            dir: Some(dir),
249            loaded: Arc::new(Mutex::new(HashSet::new())),
250            metadata_loaded: Arc::new(Mutex::new(HashSet::new())),
251            change_tx: None,
252            views: Arc::new(Mutex::new(HashMap::new())),
253            default_model,
254            id_source,
255        }
256    }
257
258    /// Replace an unset `selected_model` (from metadata serialized before
259    /// models were tracked per-thread) with the store's default model.
260    fn backfill_selected_model(&self, extras: &mut ThreadExtras) {
261        if extras.selected_model.provider_id.is_empty() {
262            extras.selected_model = self.default_model.clone();
263        }
264    }
265
266    /// Set the change notification sender. Called after construction.
267    pub fn set_change_tx(&mut self, tx: tokio::sync::mpsc::UnboundedSender<ThreadId>) {
268        self.change_tx = Some(tx);
269    }
270
271    /// Migration: if a thread's last_updated / total_tokens_used is empty, try to
272    /// restore them from the legacy `sessions.json` (parent of the threads dir).
273    fn migrate_from_session_store(&self, thread_id: &ThreadId<str>, threads_dir: &Path) {
274        {
275            let extras = self.extras.lock().expect("bug: mutex poisoned");
276            match extras.get(thread_id) {
277                Some(e) if e.last_updated.is_empty() => {}
278                _ => return,
279            }
280        }
281
282        let sessions_path = threads_dir.join("../sessions.json");
283        let Ok(json) = std::fs::read_to_string(&sessions_path) else {
284            return;
285        };
286        let Ok(val) = serde_json::from_str::<serde_json::Value>(&json) else {
287            return;
288        };
289        let Some(entry) = val.get("sessions").and_then(|s| s.get(thread_id.as_str())) else {
290            return;
291        };
292
293        let last_updated = entry
294            .get("last_updated")
295            .and_then(|v| v.as_str())
296            .unwrap_or("")
297            .to_owned();
298        let total_tokens_used = entry
299            .get("total_tokens_used")
300            .and_then(|v| v.as_u64())
301            .unwrap_or(0) as usize;
302
303        if last_updated.is_empty() && total_tokens_used == 0 {
304            return;
305        }
306
307        {
308            let mut extras = self.extras.lock().expect("bug: mutex poisoned");
309            if let Some(e) = extras.get_mut(thread_id) {
310                e.last_updated = last_updated;
311                e.total_tokens_used = total_tokens_used;
312            }
313        }
314        self.save_thread_metadata(thread_id);
315    }
316
317    /// Notify that a session's thread tree changed.
318    fn notify_session(&self, thread_id: &ThreadId<str>) {
319        if let Some(ref tx) = self.change_tx {
320            let root = self.get_root_thread_id(thread_id);
321            let _ = tx.send(root);
322        }
323    }
324
325    /// Combine the core store's info and the daemon extras into the
326    /// serialization shape, if the thread exists in both.
327    fn thread_meta(&self, thread_id: &ThreadId<str>) -> Option<ThreadMeta> {
328        let info = self.core.thread_info(thread_id)?;
329        let extras = self
330            .extras
331            .lock()
332            .expect("bug: mutex poisoned")
333            .get(thread_id)
334            .cloned()?;
335        Some(ThreadMeta { info, extras })
336    }
337
338    /// Restore a thread's metadata from its serialization shape (splitting
339    /// it between the core store and the daemon extras).
340    fn restore_thread_meta(&self, thread_id: &ThreadId<str>, mut meta: ThreadMeta) {
341        self.backfill_selected_model(&mut meta.extras);
342        self.core.set_thread_info(thread_id, meta.info);
343        self.extras
344            .lock()
345            .expect("bug: mutex poisoned")
346            .insert(thread_id.to_owned(), meta.extras);
347    }
348
349    /// Write a single thread's metadata to `{dir}/{thread_id}.meta.json`.
350    fn save_thread_metadata(&self, thread_id: &ThreadId<str>) {
351        let Some(ref dir) = self.dir else { return };
352        if let Some(meta) = self.thread_meta(thread_id) {
353            let path = dir.join(format!("{}.meta.json", thread_id));
354            if let Ok(json) = serde_json::to_string_pretty(&meta) {
355                std::fs::write(path, json).ok();
356            }
357        }
358    }
359
360    /// Write a single thread's data to `{dir}/{thread_id}.json` and metadata to `.meta.json`.
361    /// No-op when persistence is disabled.
362    fn save_thread(&self, thread_id: &ThreadId<str>) {
363        let Some(ref dir) = self.dir else { return };
364        let snapshot = ThreadSnapshot {
365            messages: self.core.thread_messages(thread_id).unwrap_or_default(),
366            compaction_summaries: self.core.thread_compaction_summaries(thread_id),
367        };
368
369        let path = dir.join(format!("{}.json", thread_id));
370        if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
371            std::fs::write(path, json).ok();
372        }
373        self.save_thread_metadata(thread_id);
374    }
375
376    /// Ensure a thread's metadata (core info + extras) is loaded from disk.
377    /// Tries `.meta.json` first; falls back to extracting from the full `.json` snapshot
378    /// and writes the `.meta.json` for future fast loads.
379    fn ensure_thread_metadata_loaded(&self, thread_id: &ThreadId<str>) {
380        let Some(ref dir) = self.dir else { return };
381
382        let mut meta_loaded = self.metadata_loaded.lock().expect("bug: mutex poisoned");
383        if meta_loaded.contains(thread_id) {
384            return;
385        }
386
387        // Never overwrite a thread that already exists in memory (e.g. it
388        // was created via ensure_root_thread before anything was persisted).
389        let already_in_memory = self.core.thread_info(thread_id).is_some();
390
391        // Try the fast metadata file first.
392        let meta_path = dir.join(format!("{}.meta.json", thread_id));
393        if let Ok(json) = std::fs::read_to_string(&meta_path)
394            && let Ok(meta) = serde_json::from_str::<ThreadMeta>(&json)
395        {
396            if !already_in_memory {
397                self.restore_thread_meta(thread_id, meta);
398            }
399        } else {
400            // Fall back: extract thread_info from the full snapshot file.
401            let full_path = dir.join(format!("{}.json", thread_id));
402            if let Ok(json) = std::fs::read_to_string(&full_path)
403                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json)
404                && let Some(info_val) = val.get("thread_info")
405                && let Ok(meta) = serde_json::from_value::<ThreadMeta>(info_val.clone())
406                && !already_in_memory
407            {
408                self.restore_thread_meta(thread_id, meta);
409                // Migrate: write the .meta.json for next time.
410                self.save_thread_metadata(thread_id);
411            }
412        }
413
414        // Migration: restore title/last_updated from legacy sessions.json
415        self.migrate_from_session_store(thread_id, dir);
416
417        meta_loaded.insert(thread_id.to_owned());
418    }
419
420    /// Ensure a thread's full data (messages, compaction summaries) is loaded.
421    /// Calls `ensure_thread_metadata_loaded` first.
422    fn ensure_thread_loaded(&self, thread_id: &ThreadId<str>) {
423        self.ensure_thread_metadata_loaded(thread_id);
424
425        let Some(ref dir) = self.dir else { return };
426
427        let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
428        if loaded.contains(thread_id) {
429            return;
430        }
431
432        let path = dir.join(format!("{}.json", thread_id));
433        if let Ok(json) = std::fs::read_to_string(&path)
434            && let Ok(snapshot) = serde_json::from_str::<ThreadSnapshot>(&json)
435        {
436            assert!(
437                !self.core.set_thread_messages(thread_id, snapshot.messages),
438                "bug: thread {thread_id} messages loaded twice"
439            );
440            assert!(
441                !self
442                    .core
443                    .set_thread_compaction_summaries(thread_id, snapshot.compaction_summaries),
444                "bug: thread {thread_id} compaction summaries loaded twice"
445            );
446        }
447
448        loaded.insert(thread_id.to_owned());
449
450        self.load_views(thread_id);
451    }
452
453    /// Whether metadata exists for this thread (in memory or on disk).
454    pub fn has_thread(&self, thread_id: &ThreadId<str>) -> bool {
455        self.ensure_thread_metadata_loaded(thread_id);
456        self.core.thread_info(thread_id).is_some()
457    }
458
459    /// Resolve a thread ID to its root thread ID (i.e. the session ID).
460    pub fn get_root_thread_id(&self, thread_id: &ThreadId<str>) -> ThreadId {
461        self.ensure_thread_metadata_loaded(thread_id);
462        self.core
463            .thread_info(thread_id)
464            .map(|t| t.root_thread_id)
465            .unwrap_or_else(|| thread_id.to_owned())
466    }
467
468    /// Get the parent thread ID, if any.
469    pub fn get_thread_parent_id(&self, thread_id: &ThreadId<str>) -> Option<ThreadId> {
470        self.ensure_thread_metadata_loaded(thread_id);
471        self.core
472            .thread_info(thread_id)
473            .and_then(|t| t.parent_thread_id)
474    }
475
476    /// Set the title for a thread.
477    pub fn set_thread_title(&self, thread_id: &ThreadId<str>, title: &str) {
478        self.ensure_thread_metadata_loaded(thread_id);
479        {
480            let mut extras = self.extras.lock().expect("bug: mutex poisoned");
481            if let Some(e) = extras.get_mut(thread_id) {
482                e.title = Some(title.to_owned());
483            }
484        }
485        self.save_thread_metadata(thread_id);
486        self.notify_session(thread_id);
487    }
488
489    /// Get the model selected for this specific thread. Does NOT fall back to
490    /// the parent thread — every thread is assigned a model at creation time.
491    pub fn get_thread_model(&self, thread_id: &ThreadId<str>) -> ModelRef {
492        self.ensure_thread_metadata_loaded(thread_id);
493        let extras = self.extras.lock().expect("bug: mutex poisoned");
494        extras
495            .get(thread_id)
496            .map(|e| e.selected_model.clone())
497            .expect("bug: thread metadata missing in get_thread_model")
498    }
499
500    /// Set the model selected for a thread.
501    pub fn set_thread_model(&self, thread_id: &ThreadId<str>, model: ModelRef) {
502        self.ensure_thread_metadata_loaded(thread_id);
503        {
504            let mut extras = self.extras.lock().expect("bug: mutex poisoned");
505            if let Some(e) = extras.get_mut(thread_id) {
506                e.selected_model = model;
507            }
508        }
509        self.save_thread_metadata(thread_id);
510    }
511
512    /// List every thread in a session, including the root and descendants that
513    /// are closed or used for compaction. Session-level state must still account
514    /// for those threads even though they are omitted from the visible thread
515    /// list.
516    pub fn get_session_thread_ids(&self, root_id: &ThreadId<str>) -> Vec<ThreadId> {
517        let mut result = Vec::new();
518        let mut queue = vec![root_id.to_owned()];
519        let mut visited = HashSet::new();
520
521        while let Some(thread_id) = queue.pop() {
522            if !visited.insert(thread_id.to_owned()) {
523                continue;
524            }
525            self.ensure_thread_metadata_loaded(&thread_id);
526            let children = {
527                let extras = self.extras.lock().expect("bug: mutex poisoned");
528                extras
529                    .get(&thread_id)
530                    .map(|entry| entry.children.clone())
531                    .unwrap_or_default()
532            };
533            result.push(thread_id);
534            queue.extend(children);
535        }
536
537        result
538    }
539
540    /// List open (non-closed) subthreads that are descendants of `parent_id`
541    /// within the given session. Walks the children tree via metadata.
542    pub fn get_open_subthreads(
543        &self,
544        parent_id: &ThreadId<str>,
545    ) -> Vec<infinity_protocol::SubthreadInfo> {
546        self.ensure_thread_metadata_loaded(parent_id);
547        let mut result = Vec::new();
548        let mut queue = vec![parent_id.to_owned()];
549        while let Some(pid) = queue.pop() {
550            let children = {
551                let extras = self.extras.lock().expect("bug: mutex poisoned");
552                extras
553                    .get(&pid)
554                    .map(|e| e.children.clone())
555                    .unwrap_or_default()
556            };
557            for child_id in children {
558                self.ensure_thread_metadata_loaded(&child_id);
559                let Some(info) = self.core.thread_info(&child_id) else {
560                    continue;
561                };
562                if !info.closed && !info.is_compaction {
563                    let title = {
564                        let extras = self.extras.lock().expect("bug: mutex poisoned");
565                        extras.get(&child_id).and_then(|e| e.title.clone())
566                    };
567                    result.push(infinity_protocol::SubthreadInfo {
568                        thread_id: child_id.to_string(),
569                        parent_thread_id: pid.to_string(),
570                        title,
571                    });
572                    queue.push(child_id);
573                }
574            }
575        }
576        result
577    }
578
579    pub fn get_total_tokens_used(&self, thread_id: &ThreadId<str>) -> usize {
580        self.ensure_thread_metadata_loaded(thread_id);
581        self.extras
582            .lock()
583            .expect("bug: mutex poisoned")
584            .get(thread_id)
585            .map(|e| e.total_tokens_used)
586            .unwrap_or(0)
587    }
588
589    pub fn set_total_tokens_used(&self, thread_id: &ThreadId<str>, tokens: usize) {
590        self.ensure_thread_metadata_loaded(thread_id);
591        if let Some(e) = self
592            .extras
593            .lock()
594            .expect("bug: mutex poisoned")
595            .get_mut(thread_id)
596        {
597            e.total_tokens_used = tokens;
598        }
599        self.save_thread_metadata(thread_id);
600        self.notify_session(thread_id);
601    }
602
603    pub fn get_last_updated(&self, thread_id: &ThreadId<str>) -> String {
604        self.ensure_thread_metadata_loaded(thread_id);
605        self.extras
606            .lock()
607            .expect("bug: mutex poisoned")
608            .get(thread_id)
609            .map(|e| e.last_updated.clone())
610            .unwrap_or_default()
611    }
612
613    pub fn set_last_updated(&self, thread_id: &ThreadId<str>, ts: &str) {
614        self.ensure_thread_metadata_loaded(thread_id);
615        if let Some(e) = self
616            .extras
617            .lock()
618            .expect("bug: mutex poisoned")
619            .get_mut(thread_id)
620        {
621            e.last_updated = ts.to_owned();
622        }
623        self.save_thread_metadata(thread_id);
624    }
625
626    /// Write views to `{dir}/{thread_id}.views.json`.
627    fn save_views(&self, thread_id: &ThreadId<str>) {
628        let Some(ref dir) = self.dir else { return };
629        let views = self.views.lock().expect("bug: mutex poisoned");
630        let path = dir.join(format!("{}.views.json", thread_id));
631        match views.get(thread_id) {
632            Some(v) if !v.is_empty() => {
633                if let Ok(json) = serde_json::to_string_pretty(v) {
634                    std::fs::write(path, json).ok();
635                }
636            }
637            _ => {
638                let _ = std::fs::remove_file(path); // file might already not exist
639            }
640        }
641    }
642
643    /// Load views from `{dir}/{thread_id}.views.json`.
644    fn load_views(&self, thread_id: &ThreadId<str>) {
645        tracing::info!("Loading views for thread {thread_id}");
646        let Some(ref dir) = self.dir else { return };
647        let path = dir.join(format!("{}.views.json", thread_id));
648        match std::fs::read_to_string(&path) {
649            Ok(json) => match serde_json::from_str::<HashMap<String, serde_json::Value>>(&json) {
650                Ok(v) => {
651                    self.views
652                        .lock()
653                        .expect("bug: mutex poisoned")
654                        .insert(thread_id.to_owned(), v);
655                }
656                Err(e) => {
657                    tracing::error!("Failed to deserialize views: {e}");
658                }
659            },
660            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {} // file does not exist, okay
661            Err(e) => {
662                tracing::error!("Failed to load views file: {e}");
663            }
664        }
665    }
666
667    /// Update a view for a thread and persist.
668    pub fn set_view(&self, thread_id: &ThreadId<str>, view_type: &str, content: serde_json::Value) {
669        {
670            let mut views = self.views.lock().expect("bug: mutex poisoned");
671            views
672                .entry(thread_id.to_owned())
673                .or_default()
674                .insert(view_type.to_owned(), content);
675        }
676        self.save_views(thread_id);
677    }
678
679    /// Get all views for a thread.
680    pub fn get_views(&self, thread_id: &ThreadId<str>) -> HashMap<String, serde_json::Value> {
681        self.ensure_thread_loaded(thread_id);
682        self.views
683            .lock()
684            .expect("bug: mutex poisoned")
685            .get(thread_id)
686            .cloned()
687            .unwrap_or_default()
688    }
689
690    pub fn get_thread_title(&self, thread_id: &ThreadId<str>) -> Option<String> {
691        self.ensure_thread_metadata_loaded(thread_id);
692        self.extras
693            .lock()
694            .expect("bug: mutex poisoned")
695            .get(thread_id)
696            .and_then(|e| e.title.clone())
697    }
698
699    /// Serialize all threads in a session tree to a JSON string.
700    pub fn serialize_session(&self, root_thread_id: &ThreadId<str>) -> String {
701        let mut threads: HashMap<ThreadId, SerializedThread> = HashMap::new();
702        let mut queue = vec![root_thread_id.to_owned()];
703        while let Some(tid) = queue.pop() {
704            self.ensure_thread_loaded(&tid);
705            let Some(metadata) = self.thread_meta(&tid) else {
706                continue;
707            };
708            queue.extend(metadata.extras.children.clone());
709            let snapshot = ThreadSnapshot {
710                messages: self.core.thread_messages(&tid).unwrap_or_default(),
711                compaction_summaries: self.core.thread_compaction_summaries(&tid),
712            };
713            let views = self
714                .views
715                .lock()
716                .expect("bug: mutex poisoned")
717                .get(&tid)
718                .cloned()
719                .unwrap_or_default();
720            threads.insert(
721                tid,
722                SerializedThread {
723                    metadata,
724                    snapshot,
725                    views,
726                },
727            );
728        }
729        serde_json::to_string(&threads).expect("bug: serde serialization failed")
730    }
731
732    /// Import a serialized session into the store.
733    pub fn import_session(&self, data: &str) -> Result<(), MemoryError> {
734        let threads: HashMap<ThreadId, SerializedThread> = serde_json::from_str(data)
735            .map_err(|e| MemoryError(format!("failed to deserialize session: {e}")))?;
736        for (tid, st) in threads {
737            self.restore_thread_meta(&tid, st.metadata);
738            self.core.set_thread_messages(&tid, st.snapshot.messages);
739            self.core
740                .set_thread_compaction_summaries(&tid, st.snapshot.compaction_summaries);
741            if !st.views.is_empty() {
742                self.views
743                    .lock()
744                    .expect("bug: mutex poisoned")
745                    .insert(tid.clone(), st.views);
746            }
747            self.loaded
748                .lock()
749                .expect("bug: mutex poisoned")
750                .insert(tid.clone());
751            self.metadata_loaded
752                .lock()
753                .expect("bug: mutex poisoned")
754                .insert(tid.clone());
755            self.save_thread(&tid);
756            self.save_views(&tid);
757        }
758        Ok(())
759    }
760}
761
762#[async_trait]
763impl ConversationStore for PersistentConversationStore {
764    type Error = MemoryError;
765
766    async fn ensure_root_thread(&self, thread_id: &ThreadId<str>) -> Result<(), MemoryError> {
767        self.ensure_thread_loaded(thread_id);
768        let inserted = self.core.thread_info(thread_id).is_none();
769        if inserted {
770            self.core.ensure_root_thread(thread_id).await?;
771            self.extras.lock().expect("bug: mutex poisoned").insert(
772                thread_id.to_owned(),
773                ThreadExtras::new(self.default_model.clone()),
774            );
775            self.save_thread(thread_id);
776        }
777        Ok(())
778    }
779
780    async fn thread_exists(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
781        Ok(self.has_thread(thread_id))
782    }
783
784    async fn load_history_up_to(
785        &self,
786        session_id: &ThreadId<str>,
787        start_from: Option<i64>,
788        up_to: Option<i64>,
789    ) -> Result<Vec<InfinityMessage>, MemoryError> {
790        self.ensure_thread_loaded(session_id);
791        Ok(self
792            .core
793            .load_history_up_to(session_id, start_from, up_to)
794            .await?)
795    }
796
797    async fn append_messages(
798        &self,
799        session_id: &ThreadId<str>,
800        messages: Vec<(InfinityMessage, String)>,
801    ) -> Result<(), MemoryError> {
802        self.ensure_thread_loaded(session_id);
803        tracing::trace!("Appending messages to store");
804        self.core.append_messages(session_id, messages).await?;
805        self.save_thread(session_id);
806        Ok(())
807    }
808
809    async fn spawn_thread(
810        &self,
811        parent_thread_id: &ThreadId<str>,
812        spawn_tool_call_id: &str,
813        is_for_subscription_event: bool,
814        spawn_order_override: Option<usize>,
815    ) -> Result<ThreadId, MemoryError> {
816        self.ensure_thread_loaded(parent_thread_id);
817        let new_id = ThreadId::from(self.id_source.generate());
818        {
819            // Hold the load-tracking locks while creating the thread so a
820            // concurrent load cannot interleave with the creation.
821            let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
822            let mut meta_loaded = self.metadata_loaded.lock().expect("bug: mutex poisoned");
823
824            // The spawn-order and root-resolution semantics live in the core
825            // store; the daemon only picks the ID and layers its extras.
826            self.core.spawn_thread_with_id(
827                &new_id,
828                parent_thread_id,
829                spawn_tool_call_id,
830                is_for_subscription_event,
831                spawn_order_override,
832            );
833            self.core.set_thread_messages(&new_id, Vec::new());
834
835            {
836                let mut extras = self.extras.lock().expect("bug: mutex poisoned");
837                // The child inherits the parent's model selection.
838                let parent_model = extras
839                    .get(parent_thread_id)
840                    .map(|e| e.selected_model.clone())
841                    .unwrap_or_else(|| self.default_model.clone());
842                extras.insert(new_id.clone(), ThreadExtras::new(parent_model));
843                if let Some(parent) = extras.get_mut(parent_thread_id) {
844                    parent.children.push(new_id.clone());
845                }
846            }
847
848            loaded.insert(new_id.clone());
849            meta_loaded.insert(new_id.clone());
850        }
851
852        self.save_thread(&new_id);
853        self.save_thread_metadata(parent_thread_id);
854        self.notify_session(parent_thread_id);
855        Ok(new_id)
856    }
857
858    async fn is_thread_closed(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
859        self.ensure_thread_metadata_loaded(thread_id);
860        Ok(self.core.is_thread_closed(thread_id).await?)
861    }
862
863    async fn close_thread(&self, thread_id: &ThreadId<str>) -> Result<(), MemoryError> {
864        self.ensure_thread_metadata_loaded(thread_id);
865        self.core.close_thread(thread_id).await?;
866        self.save_thread_metadata(thread_id);
867        self.notify_session(thread_id);
868        Ok(())
869    }
870
871    async fn is_subscription_event_thread(
872        &self,
873        thread_id: &ThreadId<str>,
874    ) -> Result<bool, MemoryError> {
875        self.ensure_thread_metadata_loaded(thread_id);
876        Ok(self.core.is_subscription_event_thread(thread_id).await?)
877    }
878
879    async fn get_thread_parent_info(
880        &self,
881        thread_id: &ThreadId<str>,
882    ) -> Result<Option<(ThreadId, String)>, MemoryError> {
883        self.ensure_thread_metadata_loaded(thread_id);
884        Ok(self.core.get_thread_parent_info(thread_id).await?)
885    }
886
887    async fn get_ancestor_chain(
888        &self,
889        thread_id: &ThreadId<str>,
890    ) -> Result<Vec<(ThreadId, i64)>, MemoryError> {
891        // Lazily load the metadata of every ancestor, then delegate the walk
892        // (and its ordering semantics) to the core store.
893        let mut current = thread_id.to_owned();
894        loop {
895            self.ensure_thread_metadata_loaded(&current);
896            match self
897                .core
898                .thread_info(&current)
899                .and_then(|t| t.parent_thread_id)
900            {
901                Some(parent) => current = parent,
902                None => break,
903            }
904        }
905        Ok(self.core.get_ancestor_chain(thread_id).await?)
906    }
907
908    async fn save_compaction_summary(
909        &self,
910        thread_id: &ThreadId<str>,
911        summary: &str,
912        up_to_order: i64,
913    ) -> Result<(), MemoryError> {
914        self.ensure_thread_loaded(thread_id);
915        self.core
916            .save_compaction_summary(thread_id, summary, up_to_order)
917            .await?;
918        self.save_thread(thread_id);
919        Ok(())
920    }
921
922    async fn load_latest_compaction_summary_up_to(
923        &self,
924        thread_id: &ThreadId<str>,
925        up_to_order: Option<i64>,
926    ) -> Result<Option<(String, i64)>, MemoryError> {
927        self.ensure_thread_loaded(thread_id);
928        Ok(self
929            .core
930            .load_latest_compaction_summary_up_to(thread_id, up_to_order)
931            .await?)
932    }
933
934    async fn is_compaction_thread(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
935        self.ensure_thread_metadata_loaded(thread_id);
936        Ok(self.core.is_compaction_thread(thread_id).await?)
937    }
938
939    async fn mark_thread_as_compaction(
940        &self,
941        thread_id: &ThreadId<str>,
942    ) -> Result<(), MemoryError> {
943        self.ensure_thread_metadata_loaded(thread_id);
944        self.core.mark_thread_as_compaction(thread_id).await?;
945        self.save_thread_metadata(thread_id);
946        Ok(())
947    }
948
949    async fn get_thread_spawn_order(
950        &self,
951        thread_id: &ThreadId<str>,
952    ) -> Result<Option<i64>, MemoryError> {
953        self.ensure_thread_metadata_loaded(thread_id);
954        Ok(self.core.get_thread_spawn_order(thread_id).await?)
955    }
956}
957
958// ── Persistent state store backed by shared in-memory semantics ──
959
960#[derive(Clone)]
961pub struct PersistentStateStore {
962    /// The shared store semantics (processed IDs, metadata, subscriptions).
963    core: core_stores::InMemoryStateStore,
964    /// Directory where per-thread state JSON files are stored.
965    dir: PathBuf,
966    /// Tracks which keys have already been loaded (or attempted) from disk.
967    loaded: Arc<Mutex<HashSet<ThreadId>>>,
968    // Used to resolve child threads for stopped-session policy.
969    conversation_store: PersistentConversationStore,
970    session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
971}
972
973impl PersistentStateStore {
974    pub fn new(
975        dir: impl AsRef<Path>,
976        conversation_store: PersistentConversationStore,
977        session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
978    ) -> Self {
979        let dir = dir.as_ref().to_path_buf();
980        std::fs::create_dir_all(&dir).ok();
981        Self {
982            core: core_stores::InMemoryStateStore::new(),
983            dir,
984            loaded: Arc::new(Mutex::new(HashSet::new())),
985            conversation_store,
986            session_store,
987        }
988    }
989
990    pub fn has_pending_choices(&self, thread_id: &ThreadId<str>) -> bool {
991        self.ensure_loaded(thread_id);
992        !self
993            .core
994            .thread_state(thread_id)
995            .pending_user_choices
996            .is_empty()
997    }
998
999    /// Whether any thread in the session rooted at `session_id` has a pending
1000    /// user choice. The exact-thread query above remains available for routing
1001    /// choice responses to the thread that requested them.
1002    pub fn has_pending_choices_for_session(&self, session_id: &ThreadId<str>) -> bool {
1003        self.conversation_store
1004            .get_session_thread_ids(session_id)
1005            .iter()
1006            .any(|thread_id| self.has_pending_choices(thread_id))
1007    }
1008
1009    pub fn pending_choice(&self, thread_id: &ThreadId<str>, choice_id: &str) -> Option<UserChoice> {
1010        self.ensure_loaded(thread_id);
1011        self.core
1012            .thread_state(thread_id)
1013            .pending_user_choices
1014            .into_iter()
1015            .find(|choice| choice.id == choice_id)
1016    }
1017
1018    pub async fn clear_pending_choices(
1019        &self,
1020        thread_id: &ThreadId<str>,
1021    ) -> Result<(), MemoryError> {
1022        let choices = self.get_pending_user_choices(thread_id).await?;
1023        for choice in choices {
1024            self.remove_pending_user_choice(thread_id, &choice.id)
1025                .await?;
1026        }
1027        Ok(())
1028    }
1029
1030    /// Clear pending choices from the root and every descendant, including
1031    /// closed and compaction threads that are not shown in the session UI.
1032    pub async fn clear_pending_choices_for_session(
1033        &self,
1034        session_id: &ThreadId<str>,
1035    ) -> Result<(), MemoryError> {
1036        for thread_id in self.conversation_store.get_session_thread_ids(session_id) {
1037            self.clear_pending_choices(&thread_id).await?;
1038        }
1039        Ok(())
1040    }
1041
1042    /// Write a single key's state data to `{dir}/{key}.state.json`. The file
1043    /// is the serialized core [`ThreadState`] snapshot.
1044    fn save_key(&self, key: &ThreadId<str>) {
1045        let snapshot = self.core.thread_state(key);
1046        let path = self.dir.join(format!("{}.state.json", key));
1047        if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
1048            std::fs::write(path, json).ok();
1049        }
1050    }
1051
1052    /// Ensure a key's data is loaded from disk into the core store.
1053    fn ensure_loaded(&self, key: &ThreadId<str>) {
1054        let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
1055        if loaded.contains(key) {
1056            return;
1057        }
1058
1059        let path = self.dir.join(format!("{}.state.json", key));
1060        if let Ok(json) = std::fs::read_to_string(&path)
1061            && let Ok(snapshot) = serde_json::from_str::<ThreadState>(&json)
1062        {
1063            self.core.set_thread_state(key, snapshot);
1064        }
1065
1066        loaded.insert(key.to_owned());
1067    }
1068}
1069
1070#[async_trait]
1071impl StateStore for PersistentStateStore {
1072    type Error = MemoryError;
1073
1074    async fn get_processed_ids(
1075        &self,
1076        thread_id: &ThreadId<str>,
1077    ) -> Result<HashSet<String>, MemoryError> {
1078        self.ensure_loaded(thread_id);
1079        Ok(self.core.get_processed_ids(thread_id).await?)
1080    }
1081
1082    async fn add_processed_message_ids(
1083        &self,
1084        thread_id: &ThreadId<str>,
1085        message_ids: Vec<String>,
1086    ) -> Result<(), MemoryError> {
1087        self.ensure_loaded(thread_id);
1088        self.core
1089            .add_processed_message_ids(thread_id, message_ids)
1090            .await?;
1091        self.save_key(thread_id);
1092        Ok(())
1093    }
1094
1095    async fn get_metadata(
1096        &self,
1097        root_thread_id: &ThreadId<str>,
1098    ) -> Result<Option<serde_json::Value>, MemoryError> {
1099        self.ensure_loaded(root_thread_id);
1100        Ok(self.core.get_metadata(root_thread_id).await?)
1101    }
1102
1103    async fn set_metadata(
1104        &self,
1105        root_thread_id: &ThreadId<str>,
1106        metadata: serde_json::Value,
1107    ) -> Result<(), MemoryError> {
1108        self.ensure_loaded(root_thread_id);
1109        self.core.set_metadata(root_thread_id, metadata).await?;
1110        self.save_key(root_thread_id);
1111        Ok(())
1112    }
1113
1114    async fn get_active_subscriptions(
1115        &self,
1116        thread_id: &ThreadId<str>,
1117    ) -> Result<Vec<String>, MemoryError> {
1118        self.ensure_loaded(thread_id);
1119        Ok(self.core.get_active_subscriptions(thread_id).await?)
1120    }
1121
1122    async fn add_active_subscription(
1123        &self,
1124        thread_id: &ThreadId<str>,
1125        tool_call_id: &str,
1126    ) -> Result<(), MemoryError> {
1127        self.ensure_loaded(thread_id);
1128        self.core
1129            .add_active_subscription(thread_id, tool_call_id)
1130            .await?;
1131        self.save_key(thread_id);
1132        Ok(())
1133    }
1134
1135    async fn remove_active_subscription(
1136        &self,
1137        thread_id: &ThreadId<str>,
1138        tool_call_id: &str,
1139    ) -> Result<(), MemoryError> {
1140        self.ensure_loaded(thread_id);
1141        self.core
1142            .remove_active_subscription(thread_id, tool_call_id)
1143            .await?;
1144        self.save_key(thread_id);
1145        Ok(())
1146    }
1147
1148    async fn add_pending_user_choice(
1149        &self,
1150        thread_id: &ThreadId<str>,
1151        choice: UserChoice,
1152    ) -> Result<(), MemoryError> {
1153        self.ensure_loaded(thread_id);
1154        self.core.add_pending_user_choice(thread_id, choice).await?;
1155        self.save_key(thread_id);
1156        self.conversation_store.notify_session(thread_id);
1157        Ok(())
1158    }
1159
1160    async fn remove_pending_user_choice(
1161        &self,
1162        thread_id: &ThreadId<str>,
1163        choice_id: &str,
1164    ) -> Result<(), MemoryError> {
1165        self.ensure_loaded(thread_id);
1166        self.core
1167            .remove_pending_user_choice(thread_id, choice_id)
1168            .await?;
1169        self.save_key(thread_id);
1170        self.conversation_store.notify_session(thread_id);
1171        Ok(())
1172    }
1173
1174    async fn get_pending_user_choices(
1175        &self,
1176        thread_id: &ThreadId<str>,
1177    ) -> Result<Vec<UserChoice>, MemoryError> {
1178        self.ensure_loaded(thread_id);
1179        Ok(self.core.get_pending_user_choices(thread_id).await?)
1180    }
1181
1182    async fn is_thread_stopped(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
1183        let session_id = self.conversation_store.get_root_thread_id(thread_id);
1184        Ok(self.session_store.lock().await.is_shut_down(&session_id))
1185    }
1186}
1187
1188#[cfg(test)]
1189mod tests {
1190    use super::*;
1191    use infinity_agent_core::traits::ConversationStore;
1192    use infinity_provider_protocol::message::{AssistantContent, Message, UserContent};
1193
1194    fn test_model() -> ModelRef {
1195        ModelRef {
1196            provider_id: "test".to_owned(),
1197            model_id: "test-model".to_owned(),
1198        }
1199    }
1200
1201    fn user_msg(text: &str) -> InfinityMessage {
1202        InfinityMessage::from_message(Message::User {
1203            content: vec![UserContent::text(text)],
1204        })
1205    }
1206
1207    /// The `.meta.json` format written before the core/daemon store split
1208    /// (all fields in one flat object) must keep deserializing, and the
1209    /// flattened [`ThreadMeta`] must serialize the same flat key set.
1210    #[test]
1211    fn thread_meta_format_is_flat_and_backward_compatible() {
1212        let old_json = serde_json::json!({
1213            "parent_thread_id": "p",
1214            "root_thread_id": "r",
1215            "spawn_message_order": 3,
1216            "spawn_tool_call_id": "tc",
1217            "closed": false,
1218            "is_subscription_event": false,
1219            "title": "t",
1220            "is_compaction": false,
1221            "children": ["c1"],
1222            "total_tokens_used": 42,
1223            "last_updated": "2024",
1224            "selected_model": {"provider_id": "prov", "model_id": "m"}
1225        });
1226        let meta: ThreadMeta =
1227            serde_json::from_value(old_json.clone()).expect("old flat format parses");
1228        assert_eq!(meta.info.root_thread_id.as_str(), "r");
1229        assert_eq!(meta.info.spawn_message_order, Some(3));
1230        assert_eq!(meta.extras.total_tokens_used, 42);
1231        assert_eq!(meta.extras.selected_model.provider_id, "prov");
1232        let round = serde_json::to_value(&meta).expect("serialize ThreadMeta");
1233        assert_eq!(
1234            round, old_json,
1235            "flattened ThreadMeta must keep the flat on-disk format"
1236        );
1237    }
1238    fn asst_msg(text: &str) -> InfinityMessage {
1239        InfinityMessage::from_message(Message::Assistant {
1240            content: vec![AssistantContent::text(text)],
1241        })
1242    }
1243
1244    /// Parent has messages, child spawned at index 2. load_history_with_ancestors
1245    /// should return parent[0..2] + child messages.
1246    #[tokio::test]
1247    async fn ancestors_basic_cutoff() {
1248        let dir = tempfile::tempdir().expect("create temp dir");
1249        let store = PersistentConversationStore::new_with_dir(
1250            dir.path(),
1251            test_model(),
1252            Arc::new(crate::ids::UuidIdSource),
1253        );
1254        store
1255            .ensure_root_thread(ThreadId::from_ref("root"))
1256            .await
1257            .expect("ensure root thread");
1258        store
1259            .append_messages(
1260                ThreadId::from_ref("root"),
1261                vec![(user_msg("p1"), "m1".into()), (asst_msg("p2"), "m2".into())],
1262            )
1263            .await
1264            .expect("append root messages");
1265
1266        let child = store
1267            .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1268            .await
1269            .expect("spawn child thread");
1270
1271        store
1272            .append_messages(
1273                ThreadId::from_ref("root"),
1274                vec![(user_msg("p3"), "m3".into()), (asst_msg("p4"), "m4".into())],
1275            )
1276            .await
1277            .expect("append root messages after spawn");
1278
1279        store
1280            .append_messages(&child, vec![(user_msg("c1"), "m5".into())])
1281            .await
1282            .expect("append child messages");
1283
1284        let (history, _, _) = store
1285            .load_history_with_ancestors(&child)
1286            .await
1287            .expect("load history with ancestors");
1288        assert_eq!(history.len(), 3);
1289        if let InfinityMessage::User {
1290            content: UserContent::Text(t),
1291        } = &history[0]
1292        {
1293            assert_eq!(t.text, "p1");
1294        }
1295        if let InfinityMessage::User {
1296            content: UserContent::Text(t),
1297        } = &history[2]
1298        {
1299            assert_eq!(t.text, "c1");
1300        }
1301    }
1302
1303    /// Three-level chain: root → child → grandchild.
1304    #[tokio::test]
1305    async fn ancestors_three_levels() {
1306        let dir = tempfile::tempdir().expect("create temp dir");
1307        let store = PersistentConversationStore::new_with_dir(
1308            dir.path(),
1309            test_model(),
1310            Arc::new(crate::ids::UuidIdSource),
1311        );
1312        store
1313            .ensure_root_thread(ThreadId::from_ref("root"))
1314            .await
1315            .expect("ensure root thread");
1316        store
1317            .append_messages(
1318                ThreadId::from_ref("root"),
1319                vec![(user_msg("r1"), "m1".into())],
1320            )
1321            .await
1322            .expect("append root messages");
1323
1324        let child = store
1325            .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1326            .await
1327            .expect("spawn child thread");
1328        store
1329            .append_messages(
1330                &child,
1331                vec![(user_msg("c1"), "m2".into()), (asst_msg("c2"), "m3".into())],
1332            )
1333            .await
1334            .expect("append child messages");
1335
1336        let grandchild = store
1337            .spawn_thread(&child, "tc-2", false, None)
1338            .await
1339            .expect("spawn grandchild thread");
1340        store
1341            .append_messages(&grandchild, vec![(user_msg("g1"), "m4".into())])
1342            .await
1343            .expect("append grandchild messages");
1344
1345        let (history, _, _) = store
1346            .load_history_with_ancestors(&grandchild)
1347            .await
1348            .expect("load history with ancestors");
1349        assert_eq!(history.len(), 4);
1350    }
1351
1352    /// Compaction on root: should return [summary] + messages after compaction point.
1353    #[tokio::test]
1354    async fn ancestors_with_compaction_on_self() {
1355        let dir = tempfile::tempdir().expect("create temp dir");
1356        let store = PersistentConversationStore::new_with_dir(
1357            dir.path(),
1358            test_model(),
1359            Arc::new(crate::ids::UuidIdSource),
1360        );
1361        store
1362            .ensure_root_thread(ThreadId::from_ref("root"))
1363            .await
1364            .expect("ensure root thread");
1365        store
1366            .append_messages(
1367                ThreadId::from_ref("root"),
1368                vec![
1369                    (user_msg("old1"), "m1".into()),
1370                    (asst_msg("old2"), "m2".into()),
1371                    (user_msg("new1"), "m3".into()),
1372                    (asst_msg("new2"), "m4".into()),
1373                ],
1374            )
1375            .await
1376            .expect("append root messages");
1377
1378        store
1379            .save_compaction_summary(ThreadId::from_ref("root"), "summary of old stuff", 2)
1380            .await
1381            .expect("save compaction summary");
1382
1383        let (history, compacted_up_to, _) = store
1384            .load_history_with_ancestors(ThreadId::from_ref("root"))
1385            .await
1386            .expect("load history with ancestors");
1387        assert_eq!(history.len(), 3);
1388        assert_eq!(compacted_up_to, Some(2));
1389        if let InfinityMessage::Assistant {
1390            content: AssistantContent::Text(t),
1391        } = &history[0]
1392        {
1393            assert!(t.text.contains("summary of old stuff"));
1394        }
1395    }
1396
1397    /// Compaction on parent: child should use parent's compaction summary.
1398    #[tokio::test]
1399    async fn ancestors_with_compaction_on_parent() {
1400        let dir = tempfile::tempdir().expect("create temp dir");
1401        let store = PersistentConversationStore::new_with_dir(
1402            dir.path(),
1403            test_model(),
1404            Arc::new(crate::ids::UuidIdSource),
1405        );
1406        store
1407            .ensure_root_thread(ThreadId::from_ref("root"))
1408            .await
1409            .expect("ensure root thread");
1410        store
1411            .append_messages(
1412                ThreadId::from_ref("root"),
1413                vec![
1414                    (user_msg("old1"), "m1".into()),
1415                    (asst_msg("old2"), "m2".into()),
1416                    (user_msg("recent"), "m3".into()),
1417                ],
1418            )
1419            .await
1420            .expect("append root messages");
1421
1422        store
1423            .save_compaction_summary(ThreadId::from_ref("root"), "compacted root", 2)
1424            .await
1425            .expect("save compaction summary");
1426
1427        let child = store
1428            .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1429            .await
1430            .expect("spawn child thread");
1431        store
1432            .append_messages(&child, vec![(user_msg("c1"), "m4".into())])
1433            .await
1434            .expect("append child messages");
1435
1436        let (history, _, _) = store
1437            .load_history_with_ancestors(&child)
1438            .await
1439            .expect("load history with ancestors");
1440        assert_eq!(history.len(), 3);
1441        if let InfinityMessage::Assistant {
1442            content: AssistantContent::Text(t),
1443        } = &history[0]
1444        {
1445            assert!(t.text.contains("compacted root"));
1446        }
1447    }
1448
1449    /// Two compactions on root — should pick the latest that fits within cutoff.
1450    #[tokio::test]
1451    async fn ancestors_multiple_compactions_picks_latest() {
1452        let dir = tempfile::tempdir().expect("create temp dir");
1453        let store = PersistentConversationStore::new_with_dir(
1454            dir.path(),
1455            test_model(),
1456            Arc::new(crate::ids::UuidIdSource),
1457        );
1458        store
1459            .ensure_root_thread(ThreadId::from_ref("root"))
1460            .await
1461            .expect("ensure root thread");
1462        store
1463            .append_messages(
1464                ThreadId::from_ref("root"),
1465                vec![
1466                    (user_msg("a"), "m1".into()),
1467                    (asst_msg("b"), "m2".into()),
1468                    (user_msg("c"), "m3".into()),
1469                    (asst_msg("d"), "m4".into()),
1470                    (user_msg("e"), "m5".into()),
1471                ],
1472            )
1473            .await
1474            .expect("append root messages");
1475
1476        store
1477            .save_compaction_summary(ThreadId::from_ref("root"), "early summary", 2)
1478            .await
1479            .expect("save early compaction summary");
1480        store
1481            .save_compaction_summary(ThreadId::from_ref("root"), "later summary", 4)
1482            .await
1483            .expect("save later compaction summary");
1484
1485        let child = store
1486            .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1487            .await
1488            .expect("spawn child thread");
1489        store
1490            .append_messages(&child, vec![(user_msg("c1"), "m6".into())])
1491            .await
1492            .expect("append child messages");
1493
1494        let (history, _, _) = store
1495            .load_history_with_ancestors(&child)
1496            .await
1497            .expect("load history with ancestors");
1498        assert_eq!(history.len(), 3);
1499        if let InfinityMessage::Assistant {
1500            content: AssistantContent::Text(t),
1501        } = &history[0]
1502        {
1503            assert!(t.text.contains("later summary"));
1504        }
1505    }
1506
1507    /// Both parent and leaf have compactions. The leaf's compaction should be
1508    /// used exclusively — ancestors are skipped entirely.
1509    #[tokio::test]
1510    async fn leaf_compaction_takes_priority_over_ancestor() {
1511        let dir = tempfile::tempdir().expect("create temp dir");
1512        let store = PersistentConversationStore::new_with_dir(
1513            dir.path(),
1514            test_model(),
1515            Arc::new(crate::ids::UuidIdSource),
1516        );
1517        store
1518            .ensure_root_thread(ThreadId::from_ref("root"))
1519            .await
1520            .expect("ensure root thread");
1521        store
1522            .append_messages(
1523                ThreadId::from_ref("root"),
1524                vec![(user_msg("r1"), "m1".into()), (asst_msg("r2"), "m2".into())],
1525            )
1526            .await
1527            .expect("append root messages");
1528        store
1529            .save_compaction_summary(ThreadId::from_ref("root"), "root compaction", 2)
1530            .await
1531            .expect("save root compaction summary");
1532
1533        let child = store
1534            .spawn_thread(ThreadId::from_ref("root"), "tc-1", false, None)
1535            .await
1536            .expect("spawn child thread");
1537        store
1538            .append_messages(
1539                &child,
1540                vec![
1541                    (user_msg("c1"), "m3".into()),
1542                    (asst_msg("c2"), "m4".into()),
1543                    (user_msg("c3"), "m5".into()),
1544                    (asst_msg("c4"), "m6".into()),
1545                ],
1546            )
1547            .await
1548            .expect("append child messages");
1549        store
1550            .save_compaction_summary(&child, "child compaction", 2)
1551            .await
1552            .expect("save child compaction summary");
1553
1554        let (history, compacted_up_to, _) = store
1555            .load_history_with_ancestors(&child)
1556            .await
1557            .expect("load history with ancestors");
1558        // Should be: [child compaction summary] + c3 + c4 = 3
1559        // No ancestor messages at all — leaf compaction short-circuits.
1560        assert_eq!(history.len(), 3);
1561        assert_eq!(compacted_up_to, Some(2));
1562        if let InfinityMessage::Assistant {
1563            content: AssistantContent::Text(t),
1564        } = &history[0]
1565        {
1566            assert!(
1567                t.text.contains("child compaction"),
1568                "should use child's compaction, got: {}",
1569                t.text
1570            );
1571            assert!(
1572                !t.text.contains("root compaction"),
1573                "should NOT contain root compaction"
1574            );
1575        }
1576        // The remaining messages should be the child's post-compaction messages
1577        if let InfinityMessage::User {
1578            content: UserContent::Text(t),
1579        } = &history[1]
1580        {
1581            assert_eq!(t.text, "c3");
1582        }
1583    }
1584}