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, SpawnContext, 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: infinity_protocol::ThreadRef::local(child_id.clone()),
569                        parent_thread_id: infinity_protocol::ThreadRef::local(pid.clone()),
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: &rap_protocol::ToolCallId<str>,
813        is_for_subscription_event: bool,
814        context: SpawnContext,
815    ) -> Result<ThreadId, MemoryError> {
816        self.ensure_thread_loaded(parent_thread_id);
817        let new_id = 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                context,
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 is_fresh_context_thread(
880        &self,
881        thread_id: &ThreadId<str>,
882    ) -> Result<bool, MemoryError> {
883        self.ensure_thread_metadata_loaded(thread_id);
884        Ok(self.core.is_fresh_context_thread(thread_id).await?)
885    }
886
887    async fn get_thread_parent_info(
888        &self,
889        thread_id: &ThreadId<str>,
890    ) -> Result<Option<(ThreadId, rap_protocol::ToolCallId)>, MemoryError> {
891        self.ensure_thread_metadata_loaded(thread_id);
892        Ok(self.core.get_thread_parent_info(thread_id).await?)
893    }
894
895    async fn get_ancestor_chain(
896        &self,
897        thread_id: &ThreadId<str>,
898    ) -> Result<Vec<(ThreadId, i64)>, MemoryError> {
899        // Lazily load the metadata of every ancestor, then delegate the walk
900        // (and its ordering semantics) to the core store.
901        let mut current = thread_id.to_owned();
902        loop {
903            self.ensure_thread_metadata_loaded(&current);
904            match self
905                .core
906                .thread_info(&current)
907                .and_then(|t| t.parent_thread_id)
908            {
909                Some(parent) => current = parent,
910                None => break,
911            }
912        }
913        Ok(self.core.get_ancestor_chain(thread_id).await?)
914    }
915
916    async fn save_compaction_summary(
917        &self,
918        thread_id: &ThreadId<str>,
919        summary: &str,
920        up_to_order: i64,
921    ) -> Result<(), MemoryError> {
922        self.ensure_thread_loaded(thread_id);
923        self.core
924            .save_compaction_summary(thread_id, summary, up_to_order)
925            .await?;
926        self.save_thread(thread_id);
927        Ok(())
928    }
929
930    async fn load_latest_compaction_summary_up_to(
931        &self,
932        thread_id: &ThreadId<str>,
933        up_to_order: Option<i64>,
934    ) -> Result<Option<(String, i64)>, MemoryError> {
935        self.ensure_thread_loaded(thread_id);
936        Ok(self
937            .core
938            .load_latest_compaction_summary_up_to(thread_id, up_to_order)
939            .await?)
940    }
941
942    async fn is_compaction_thread(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
943        self.ensure_thread_metadata_loaded(thread_id);
944        Ok(self.core.is_compaction_thread(thread_id).await?)
945    }
946
947    async fn mark_thread_as_compaction(
948        &self,
949        thread_id: &ThreadId<str>,
950    ) -> Result<(), MemoryError> {
951        self.ensure_thread_metadata_loaded(thread_id);
952        self.core.mark_thread_as_compaction(thread_id).await?;
953        self.save_thread_metadata(thread_id);
954        Ok(())
955    }
956
957    async fn get_thread_spawn_order(
958        &self,
959        thread_id: &ThreadId<str>,
960    ) -> Result<Option<i64>, MemoryError> {
961        self.ensure_thread_metadata_loaded(thread_id);
962        Ok(self.core.get_thread_spawn_order(thread_id).await?)
963    }
964}
965
966// ── Persistent state store backed by shared in-memory semantics ──
967
968#[derive(Clone)]
969pub struct PersistentStateStore {
970    /// The shared store semantics (processed IDs, metadata, subscriptions).
971    core: core_stores::InMemoryStateStore,
972    /// Directory where per-thread state JSON files are stored.
973    dir: PathBuf,
974    /// Tracks which keys have already been loaded (or attempted) from disk.
975    loaded: Arc<Mutex<HashSet<ThreadId>>>,
976    // Used to resolve child threads for stopped-session policy.
977    conversation_store: PersistentConversationStore,
978    session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
979}
980
981impl PersistentStateStore {
982    pub fn new(
983        dir: impl AsRef<Path>,
984        conversation_store: PersistentConversationStore,
985        session_store: Arc<tokio::sync::Mutex<crate::session_store::SessionStore>>,
986    ) -> Self {
987        let dir = dir.as_ref().to_path_buf();
988        std::fs::create_dir_all(&dir).ok();
989        Self {
990            core: core_stores::InMemoryStateStore::new(),
991            dir,
992            loaded: Arc::new(Mutex::new(HashSet::new())),
993            conversation_store,
994            session_store,
995        }
996    }
997
998    pub fn has_pending_choices(&self, thread_id: &ThreadId<str>) -> bool {
999        self.ensure_loaded(thread_id);
1000        !self
1001            .core
1002            .thread_state(thread_id)
1003            .pending_user_choices
1004            .is_empty()
1005    }
1006
1007    /// Whether any thread in the session rooted at `session_id` has a pending
1008    /// user choice. The exact-thread query above remains available for routing
1009    /// choice responses to the thread that requested them.
1010    pub fn has_pending_choices_for_session(&self, session_id: &ThreadId<str>) -> bool {
1011        self.conversation_store
1012            .get_session_thread_ids(session_id)
1013            .iter()
1014            .any(|thread_id| self.has_pending_choices(thread_id))
1015    }
1016
1017    pub fn pending_choice(
1018        &self,
1019        thread_id: &ThreadId<str>,
1020        choice_id: &rap_protocol::ChoiceId<str>,
1021    ) -> Option<UserChoice> {
1022        self.ensure_loaded(thread_id);
1023        self.core
1024            .thread_state(thread_id)
1025            .pending_user_choices
1026            .into_iter()
1027            .find(|choice| choice.id == *choice_id)
1028    }
1029
1030    pub async fn clear_pending_choices(
1031        &self,
1032        thread_id: &ThreadId<str>,
1033    ) -> Result<(), MemoryError> {
1034        let choices = self.get_pending_user_choices(thread_id).await?;
1035        for choice in choices {
1036            self.remove_pending_user_choice(thread_id, &choice.id)
1037                .await?;
1038        }
1039        Ok(())
1040    }
1041
1042    /// Clear pending choices from the root and every descendant, including
1043    /// closed and compaction threads that are not shown in the session UI.
1044    pub async fn clear_pending_choices_for_session(
1045        &self,
1046        session_id: &ThreadId<str>,
1047    ) -> Result<(), MemoryError> {
1048        for thread_id in self.conversation_store.get_session_thread_ids(session_id) {
1049            self.clear_pending_choices(&thread_id).await?;
1050        }
1051        Ok(())
1052    }
1053
1054    /// Write a single key's state data to `{dir}/{key}.state.json`. The file
1055    /// is the serialized core [`ThreadState`] snapshot.
1056    fn save_key(&self, key: &ThreadId<str>) {
1057        let snapshot = self.core.thread_state(key);
1058        let path = self.dir.join(format!("{}.state.json", key));
1059        if let Ok(json) = serde_json::to_string_pretty(&snapshot) {
1060            std::fs::write(path, json).ok();
1061        }
1062    }
1063
1064    /// Ensure a key's data is loaded from disk into the core store.
1065    fn ensure_loaded(&self, key: &ThreadId<str>) {
1066        let mut loaded = self.loaded.lock().expect("bug: mutex poisoned");
1067        if loaded.contains(key) {
1068            return;
1069        }
1070
1071        let path = self.dir.join(format!("{}.state.json", key));
1072        if let Ok(json) = std::fs::read_to_string(&path)
1073            && let Ok(snapshot) = serde_json::from_str::<ThreadState>(&json)
1074        {
1075            self.core.set_thread_state(key, snapshot);
1076        }
1077
1078        loaded.insert(key.to_owned());
1079    }
1080}
1081
1082#[async_trait]
1083impl StateStore for PersistentStateStore {
1084    type Error = MemoryError;
1085
1086    async fn get_processed_ids(
1087        &self,
1088        thread_id: &ThreadId<str>,
1089    ) -> Result<HashSet<String>, MemoryError> {
1090        self.ensure_loaded(thread_id);
1091        Ok(self.core.get_processed_ids(thread_id).await?)
1092    }
1093
1094    async fn add_processed_message_ids(
1095        &self,
1096        thread_id: &ThreadId<str>,
1097        message_ids: Vec<String>,
1098    ) -> Result<(), MemoryError> {
1099        self.ensure_loaded(thread_id);
1100        self.core
1101            .add_processed_message_ids(thread_id, message_ids)
1102            .await?;
1103        self.save_key(thread_id);
1104        Ok(())
1105    }
1106
1107    async fn get_metadata(
1108        &self,
1109        root_thread_id: &ThreadId<str>,
1110    ) -> Result<Option<serde_json::Value>, MemoryError> {
1111        self.ensure_loaded(root_thread_id);
1112        Ok(self.core.get_metadata(root_thread_id).await?)
1113    }
1114
1115    async fn set_metadata(
1116        &self,
1117        root_thread_id: &ThreadId<str>,
1118        metadata: serde_json::Value,
1119    ) -> Result<(), MemoryError> {
1120        self.ensure_loaded(root_thread_id);
1121        self.core.set_metadata(root_thread_id, metadata).await?;
1122        self.save_key(root_thread_id);
1123        Ok(())
1124    }
1125
1126    async fn get_active_subscriptions(
1127        &self,
1128        thread_id: &ThreadId<str>,
1129    ) -> Result<Vec<rap_protocol::ToolCallId>, MemoryError> {
1130        self.ensure_loaded(thread_id);
1131        Ok(self.core.get_active_subscriptions(thread_id).await?)
1132    }
1133
1134    async fn add_active_subscription(
1135        &self,
1136        thread_id: &ThreadId<str>,
1137        tool_call_id: &rap_protocol::ToolCallId<str>,
1138    ) -> Result<(), MemoryError> {
1139        self.ensure_loaded(thread_id);
1140        self.core
1141            .add_active_subscription(thread_id, tool_call_id)
1142            .await?;
1143        self.save_key(thread_id);
1144        Ok(())
1145    }
1146
1147    async fn remove_active_subscription(
1148        &self,
1149        thread_id: &ThreadId<str>,
1150        tool_call_id: &rap_protocol::ToolCallId<str>,
1151    ) -> Result<(), MemoryError> {
1152        self.ensure_loaded(thread_id);
1153        self.core
1154            .remove_active_subscription(thread_id, tool_call_id)
1155            .await?;
1156        self.save_key(thread_id);
1157        Ok(())
1158    }
1159
1160    async fn add_pending_user_choice(
1161        &self,
1162        thread_id: &ThreadId<str>,
1163        choice: UserChoice,
1164    ) -> Result<(), MemoryError> {
1165        self.ensure_loaded(thread_id);
1166        self.core.add_pending_user_choice(thread_id, choice).await?;
1167        self.save_key(thread_id);
1168        self.conversation_store.notify_session(thread_id);
1169        Ok(())
1170    }
1171
1172    async fn remove_pending_user_choice(
1173        &self,
1174        thread_id: &ThreadId<str>,
1175        choice_id: &rap_protocol::ChoiceId<str>,
1176    ) -> Result<(), MemoryError> {
1177        self.ensure_loaded(thread_id);
1178        self.core
1179            .remove_pending_user_choice(thread_id, choice_id)
1180            .await?;
1181        self.save_key(thread_id);
1182        self.conversation_store.notify_session(thread_id);
1183        Ok(())
1184    }
1185
1186    async fn get_pending_user_choices(
1187        &self,
1188        thread_id: &ThreadId<str>,
1189    ) -> Result<Vec<UserChoice>, MemoryError> {
1190        self.ensure_loaded(thread_id);
1191        Ok(self.core.get_pending_user_choices(thread_id).await?)
1192    }
1193
1194    async fn is_thread_stopped(&self, thread_id: &ThreadId<str>) -> Result<bool, MemoryError> {
1195        let session_id = self.conversation_store.get_root_thread_id(thread_id);
1196        Ok(self.session_store.lock().await.is_shut_down(&session_id))
1197    }
1198}
1199
1200#[cfg(test)]
1201mod tests {
1202    use super::*;
1203    use infinity_agent_core::traits::ConversationStore;
1204    use infinity_provider_protocol::message::{AssistantContent, Message, UserContent};
1205
1206    fn test_model() -> ModelRef {
1207        ModelRef {
1208            provider_id: "test".to_owned(),
1209            model_id: "test-model".to_owned(),
1210        }
1211    }
1212
1213    fn user_msg(text: &str) -> InfinityMessage {
1214        InfinityMessage::from_message(Message::User {
1215            content: vec![UserContent::text(text)],
1216        })
1217    }
1218
1219    /// The `.meta.json` format written before the core/daemon store split
1220    /// (all fields in one flat object) must keep deserializing, and the
1221    /// flattened [`ThreadMeta`] must serialize the same flat key set.
1222    #[test]
1223    fn thread_meta_format_is_flat_and_backward_compatible() {
1224        let old_json = serde_json::json!({
1225            "parent_thread_id": "p",
1226            "root_thread_id": "r",
1227            "spawn_message_order": 3,
1228            "spawn_tool_call_id": "tc",
1229            "closed": false,
1230            "is_subscription_event": false,
1231            "title": "t",
1232            "is_compaction": false,
1233            "children": ["c1"],
1234            "total_tokens_used": 42,
1235            "last_updated": "2024",
1236            "selected_model": {"provider_id": "prov", "model_id": "m"}
1237        });
1238        let meta: ThreadMeta =
1239            serde_json::from_value(old_json.clone()).expect("old flat format parses");
1240        assert_eq!(meta.info.root_thread_id.as_str(), "r");
1241        assert_eq!(meta.info.spawn_message_order, Some(3));
1242        assert!(!meta.info.fresh_context, "missing fresh_context defaults");
1243        assert_eq!(meta.extras.total_tokens_used, 42);
1244        assert_eq!(meta.extras.selected_model.provider_id, "prov");
1245        let round = serde_json::to_value(&meta).expect("serialize ThreadMeta");
1246        // Re-serialization keeps the flat key set, plus later-added fields
1247        // (with their defaults).
1248        let mut expected = old_json;
1249        expected["fresh_context"] = serde_json::json!(false);
1250        assert_eq!(
1251            round, expected,
1252            "flattened ThreadMeta must keep the flat on-disk format"
1253        );
1254    }
1255    fn asst_msg(text: &str) -> InfinityMessage {
1256        InfinityMessage::from_message(Message::Assistant {
1257            content: vec![AssistantContent::text(text)],
1258        })
1259    }
1260
1261    /// Parent has messages, child spawned at index 2. load_history_with_ancestors
1262    /// should return parent[0..2] + child messages.
1263    #[tokio::test]
1264    async fn ancestors_basic_cutoff() {
1265        let dir = tempfile::tempdir().expect("create temp dir");
1266        let store = PersistentConversationStore::new_with_dir(
1267            dir.path(),
1268            test_model(),
1269            Arc::new(crate::ids::UuidIdSource),
1270        );
1271        store
1272            .ensure_root_thread(ThreadId::from_ref("root"))
1273            .await
1274            .expect("ensure root thread");
1275        store
1276            .append_messages(
1277                ThreadId::from_ref("root"),
1278                vec![(user_msg("p1"), "m1".into()), (asst_msg("p2"), "m2".into())],
1279            )
1280            .await
1281            .expect("append root messages");
1282
1283        let child = store
1284            .spawn_thread(
1285                ThreadId::from_ref("root"),
1286                rap_protocol::ToolCallId::from_ref("tc-1"),
1287                false,
1288                SpawnContext::InheritUpTo(2),
1289            )
1290            .await
1291            .expect("spawn child thread");
1292
1293        store
1294            .append_messages(
1295                ThreadId::from_ref("root"),
1296                vec![(user_msg("p3"), "m3".into()), (asst_msg("p4"), "m4".into())],
1297            )
1298            .await
1299            .expect("append root messages after spawn");
1300
1301        store
1302            .append_messages(&child, vec![(user_msg("c1"), "m5".into())])
1303            .await
1304            .expect("append child messages");
1305
1306        let (history, _, _) = store
1307            .load_history_with_ancestors(&child)
1308            .await
1309            .expect("load history with ancestors");
1310        assert_eq!(history.len(), 3);
1311        if let InfinityMessage::User {
1312            content: UserContent::Text(t),
1313        } = &history[0]
1314        {
1315            assert_eq!(t.text, "p1");
1316        }
1317        if let InfinityMessage::User {
1318            content: UserContent::Text(t),
1319        } = &history[2]
1320        {
1321            assert_eq!(t.text, "c1");
1322        }
1323    }
1324
1325    /// Three-level chain: root → child → grandchild.
1326    #[tokio::test]
1327    async fn ancestors_three_levels() {
1328        let dir = tempfile::tempdir().expect("create temp dir");
1329        let store = PersistentConversationStore::new_with_dir(
1330            dir.path(),
1331            test_model(),
1332            Arc::new(crate::ids::UuidIdSource),
1333        );
1334        store
1335            .ensure_root_thread(ThreadId::from_ref("root"))
1336            .await
1337            .expect("ensure root thread");
1338        store
1339            .append_messages(
1340                ThreadId::from_ref("root"),
1341                vec![(user_msg("r1"), "m1".into())],
1342            )
1343            .await
1344            .expect("append root messages");
1345
1346        let child = store
1347            .spawn_thread(
1348                ThreadId::from_ref("root"),
1349                rap_protocol::ToolCallId::from_ref("tc-1"),
1350                false,
1351                SpawnContext::InheritUpTo(1),
1352            )
1353            .await
1354            .expect("spawn child thread");
1355        store
1356            .append_messages(
1357                &child,
1358                vec![(user_msg("c1"), "m2".into()), (asst_msg("c2"), "m3".into())],
1359            )
1360            .await
1361            .expect("append child messages");
1362
1363        let grandchild = store
1364            .spawn_thread(
1365                &child,
1366                rap_protocol::ToolCallId::from_ref("tc-2"),
1367                false,
1368                SpawnContext::InheritUpTo(2),
1369            )
1370            .await
1371            .expect("spawn grandchild thread");
1372        store
1373            .append_messages(&grandchild, vec![(user_msg("g1"), "m4".into())])
1374            .await
1375            .expect("append grandchild messages");
1376
1377        let (history, _, _) = store
1378            .load_history_with_ancestors(&grandchild)
1379            .await
1380            .expect("load history with ancestors");
1381        assert_eq!(history.len(), 4);
1382    }
1383
1384    /// Compaction on root: should return [summary] + messages after compaction point.
1385    #[tokio::test]
1386    async fn ancestors_with_compaction_on_self() {
1387        let dir = tempfile::tempdir().expect("create temp dir");
1388        let store = PersistentConversationStore::new_with_dir(
1389            dir.path(),
1390            test_model(),
1391            Arc::new(crate::ids::UuidIdSource),
1392        );
1393        store
1394            .ensure_root_thread(ThreadId::from_ref("root"))
1395            .await
1396            .expect("ensure root thread");
1397        store
1398            .append_messages(
1399                ThreadId::from_ref("root"),
1400                vec![
1401                    (user_msg("old1"), "m1".into()),
1402                    (asst_msg("old2"), "m2".into()),
1403                    (user_msg("new1"), "m3".into()),
1404                    (asst_msg("new2"), "m4".into()),
1405                ],
1406            )
1407            .await
1408            .expect("append root messages");
1409
1410        store
1411            .save_compaction_summary(ThreadId::from_ref("root"), "summary of old stuff", 2)
1412            .await
1413            .expect("save compaction summary");
1414
1415        let (history, compacted_up_to, _) = store
1416            .load_history_with_ancestors(ThreadId::from_ref("root"))
1417            .await
1418            .expect("load history with ancestors");
1419        assert_eq!(history.len(), 3);
1420        assert_eq!(compacted_up_to, Some(2));
1421        if let InfinityMessage::Assistant {
1422            content: AssistantContent::Text(t),
1423        } = &history[0]
1424        {
1425            assert!(t.text.contains("summary of old stuff"));
1426        }
1427    }
1428
1429    /// Compaction on parent: child should use parent's compaction summary.
1430    #[tokio::test]
1431    async fn ancestors_with_compaction_on_parent() {
1432        let dir = tempfile::tempdir().expect("create temp dir");
1433        let store = PersistentConversationStore::new_with_dir(
1434            dir.path(),
1435            test_model(),
1436            Arc::new(crate::ids::UuidIdSource),
1437        );
1438        store
1439            .ensure_root_thread(ThreadId::from_ref("root"))
1440            .await
1441            .expect("ensure root thread");
1442        store
1443            .append_messages(
1444                ThreadId::from_ref("root"),
1445                vec![
1446                    (user_msg("old1"), "m1".into()),
1447                    (asst_msg("old2"), "m2".into()),
1448                    (user_msg("recent"), "m3".into()),
1449                ],
1450            )
1451            .await
1452            .expect("append root messages");
1453
1454        store
1455            .save_compaction_summary(ThreadId::from_ref("root"), "compacted root", 2)
1456            .await
1457            .expect("save compaction summary");
1458
1459        let child = store
1460            .spawn_thread(
1461                ThreadId::from_ref("root"),
1462                rap_protocol::ToolCallId::from_ref("tc-1"),
1463                false,
1464                SpawnContext::InheritUpTo(3),
1465            )
1466            .await
1467            .expect("spawn child thread");
1468        store
1469            .append_messages(&child, vec![(user_msg("c1"), "m4".into())])
1470            .await
1471            .expect("append child messages");
1472
1473        let (history, _, _) = store
1474            .load_history_with_ancestors(&child)
1475            .await
1476            .expect("load history with ancestors");
1477        assert_eq!(history.len(), 3);
1478        if let InfinityMessage::Assistant {
1479            content: AssistantContent::Text(t),
1480        } = &history[0]
1481        {
1482            assert!(t.text.contains("compacted root"));
1483        }
1484    }
1485
1486    /// Two compactions on root — should pick the latest that fits within cutoff.
1487    #[tokio::test]
1488    async fn ancestors_multiple_compactions_picks_latest() {
1489        let dir = tempfile::tempdir().expect("create temp dir");
1490        let store = PersistentConversationStore::new_with_dir(
1491            dir.path(),
1492            test_model(),
1493            Arc::new(crate::ids::UuidIdSource),
1494        );
1495        store
1496            .ensure_root_thread(ThreadId::from_ref("root"))
1497            .await
1498            .expect("ensure root thread");
1499        store
1500            .append_messages(
1501                ThreadId::from_ref("root"),
1502                vec![
1503                    (user_msg("a"), "m1".into()),
1504                    (asst_msg("b"), "m2".into()),
1505                    (user_msg("c"), "m3".into()),
1506                    (asst_msg("d"), "m4".into()),
1507                    (user_msg("e"), "m5".into()),
1508                ],
1509            )
1510            .await
1511            .expect("append root messages");
1512
1513        store
1514            .save_compaction_summary(ThreadId::from_ref("root"), "early summary", 2)
1515            .await
1516            .expect("save early compaction summary");
1517        store
1518            .save_compaction_summary(ThreadId::from_ref("root"), "later summary", 4)
1519            .await
1520            .expect("save later compaction summary");
1521
1522        let child = store
1523            .spawn_thread(
1524                ThreadId::from_ref("root"),
1525                rap_protocol::ToolCallId::from_ref("tc-1"),
1526                false,
1527                SpawnContext::InheritUpTo(5),
1528            )
1529            .await
1530            .expect("spawn child thread");
1531        store
1532            .append_messages(&child, vec![(user_msg("c1"), "m6".into())])
1533            .await
1534            .expect("append child messages");
1535
1536        let (history, _, _) = store
1537            .load_history_with_ancestors(&child)
1538            .await
1539            .expect("load history with ancestors");
1540        assert_eq!(history.len(), 3);
1541        if let InfinityMessage::Assistant {
1542            content: AssistantContent::Text(t),
1543        } = &history[0]
1544        {
1545            assert!(t.text.contains("later summary"));
1546        }
1547    }
1548
1549    /// Both parent and leaf have compactions. The leaf's compaction should be
1550    /// used exclusively — ancestors are skipped entirely.
1551    #[tokio::test]
1552    async fn leaf_compaction_takes_priority_over_ancestor() {
1553        let dir = tempfile::tempdir().expect("create temp dir");
1554        let store = PersistentConversationStore::new_with_dir(
1555            dir.path(),
1556            test_model(),
1557            Arc::new(crate::ids::UuidIdSource),
1558        );
1559        store
1560            .ensure_root_thread(ThreadId::from_ref("root"))
1561            .await
1562            .expect("ensure root thread");
1563        store
1564            .append_messages(
1565                ThreadId::from_ref("root"),
1566                vec![(user_msg("r1"), "m1".into()), (asst_msg("r2"), "m2".into())],
1567            )
1568            .await
1569            .expect("append root messages");
1570        store
1571            .save_compaction_summary(ThreadId::from_ref("root"), "root compaction", 2)
1572            .await
1573            .expect("save root compaction summary");
1574
1575        let child = store
1576            .spawn_thread(
1577                ThreadId::from_ref("root"),
1578                rap_protocol::ToolCallId::from_ref("tc-1"),
1579                false,
1580                SpawnContext::InheritUpTo(2),
1581            )
1582            .await
1583            .expect("spawn child thread");
1584        store
1585            .append_messages(
1586                &child,
1587                vec![
1588                    (user_msg("c1"), "m3".into()),
1589                    (asst_msg("c2"), "m4".into()),
1590                    (user_msg("c3"), "m5".into()),
1591                    (asst_msg("c4"), "m6".into()),
1592                ],
1593            )
1594            .await
1595            .expect("append child messages");
1596        store
1597            .save_compaction_summary(&child, "child compaction", 2)
1598            .await
1599            .expect("save child compaction summary");
1600
1601        let (history, compacted_up_to, _) = store
1602            .load_history_with_ancestors(&child)
1603            .await
1604            .expect("load history with ancestors");
1605        // Should be: [child compaction summary] + c3 + c4 = 3
1606        // No ancestor messages at all — leaf compaction short-circuits.
1607        assert_eq!(history.len(), 3);
1608        assert_eq!(compacted_up_to, Some(2));
1609        if let InfinityMessage::Assistant {
1610            content: AssistantContent::Text(t),
1611        } = &history[0]
1612        {
1613            assert!(
1614                t.text.contains("child compaction"),
1615                "should use child's compaction, got: {}",
1616                t.text
1617            );
1618            assert!(
1619                !t.text.contains("root compaction"),
1620                "should NOT contain root compaction"
1621            );
1622        }
1623        // The remaining messages should be the child's post-compaction messages
1624        if let InfinityMessage::User {
1625            content: UserContent::Text(t),
1626        } = &history[1]
1627        {
1628            assert_eq!(t.text, "c3");
1629        }
1630    }
1631}