@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/agent/memory/sources.rs

@@ -0,0 +1,240 @@
+use super::{MemoryError, MemoryStore};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct SourceAttachment {
+    pub name: String,
+    pub kind: String,
+    pub mime_type: String,
+    pub thumbnail_data_uri: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionAttachment {
+    pub id: i64,
+    pub interaction_id: Option<i64>,
+    pub library_item_id: Option<String>,
+    pub availability: Option<String>,
+    pub trashed: bool,
+    #[serde(flatten)]
+    pub attachment: SourceAttachment,
+}
+
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConversationSources {
+    pub attachments: Vec<SessionAttachment>,
+    pub web_search_progress: Vec<serde_json::Value>,
+}
+
+impl MemoryStore {
+    /// Store only names and bounded thumbnails; original attachment bytes never enter history.
+    pub fn save_source_attachments(
+        &self,
+        chat_id: &str,
+        interaction_id: i64,
+        attachments: &[SourceAttachment],
+    ) -> Result<(), String> {
+        use base64::Engine;
+        if attachments.len() > 64 {
+            return Err("Too many source attachments".into());
+        }
+        for attachment in attachments {
+            if attachment.name.trim().is_empty()
+                || attachment.name.len() > 1024
+                || attachment.mime_type.len() > 256
+                || !matches!(attachment.kind.as_str(), "image" | "video" | "file")
+            {
+                return Err("Invalid source attachment metadata".into());
+            }
+            if let Some(thumbnail) = &attachment.thumbnail_data_uri {
+                let valid = attachment.kind == "image"
+                    && thumbnail.len() <= 262_144
+                    && [
+                        "data:image/png;base64,",
+                        "data:image/jpeg;base64,",
+                        "data:image/webp;base64,",
+                    ]
+                    .iter()
+                    .any(|prefix| thumbnail.starts_with(prefix))
+                    && thumbnail.split_once(',').is_some_and(|(_, data)| {
+                        base64::engine::general_purpose::STANDARD
+                            .decode(data)
+                            .is_ok()
+                    });
+                if !valid {
+                    return Err("Invalid source thumbnail".into());
+                }
+            }
+        }
+        let mut connection = self.connection().map_err(|e| e.to_string())?;
+        let transaction = connection.transaction().map_err(|e| e.to_string())?;
+        let owns_turn: bool = transaction
+            .query_row(
+                "SELECT EXISTS(SELECT 1 FROM interaction_memories WHERE id = ?1 AND chat_id = ?2)",
+                rusqlite::params![interaction_id, super::normalized_chat_id(chat_id)],
+                |row| row.get(0),
+            )
+            .map_err(|e| e.to_string())?;
+        if !owns_turn {
+            return Err("Interaction does not belong to this conversation".into());
+        }
+        for attachment in attachments {
+            let metadata = serde_json::to_string(attachment).map_err(|e| e.to_string())?;
+            transaction.execute("INSERT OR IGNORE INTO conversation_source_attachments (interaction_id, metadata) VALUES (?1, ?2)", rusqlite::params![interaction_id, metadata]).map_err(|e| e.to_string())?;
+        }
+        transaction.commit().map_err(|e| e.to_string())
+    }
+
+    pub fn conversation_sources(&self, chat_id: &str) -> Result<ConversationSources, MemoryError> {
+        let connection = self.connection()?;
+        let chat_id = super::normalized_chat_id(chat_id);
+        let mut result = ConversationSources::default();
+        let mut statement = connection.prepare("SELECT s.id, s.interaction_id, s.metadata FROM conversation_source_attachments s JOIN interaction_memories m ON m.id = s.interaction_id WHERE m.chat_id = ?1 ORDER BY s.id")?;
+        let rows = statement.query_map([&chat_id], |row| {
+            Ok((
+                row.get::<_, i64>(0)?,
+                row.get::<_, i64>(1)?,
+                row.get::<_, String>(2)?,
+            ))
+        })?;
+        for row in rows {
+            let (id, interaction_id, metadata) = row?;
+            if let Ok(attachment) = serde_json::from_str(&metadata) {
+                result.attachments.push(SessionAttachment {
+                    id,
+                    interaction_id: Some(interaction_id),
+                    library_item_id: None,
+                    availability: None,
+                    trashed: false,
+                    attachment,
+                });
+            }
+        }
+        let library = crate::library::LibraryStore::for_memory(self.clone())
+            .map_err(|e| MemoryError::Library(e.to_string()))?;
+        let indexed = library
+            .session_attachments(&chat_id)
+            .map_err(|e| MemoryError::Library(e.to_string()))?;
+        result.attachments.retain(|legacy| {
+            !indexed.iter().any(|item| {
+                item.interaction_id == legacy.interaction_id
+                    && item.attachment.name == legacy.attachment.name
+                    && item.attachment.kind == legacy.attachment.kind
+            })
+        });
+        result.attachments.extend(indexed);
+        // Query every turn, independently of the chat UI's 50-message history window.
+        let mut statement = connection.prepare("SELECT agent_activity_json FROM interaction_memories WHERE chat_id = ?1 AND agent_activity_json IS NOT NULL ORDER BY id")?;
+        for row in statement.query_map([&chat_id], |row| row.get::<_, String>(0))? {
+            if let Ok(events) = serde_json::from_str::<Vec<serde_json::Value>>(&row?) {
+                result
+                    .web_search_progress
+                    .extend(events.into_iter().filter(|event| {
+                        event["type"] == "ToolEnd" && event["data"]["action"] == "web_search"
+                    }));
+            }
+        }
+        Ok(result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn session_sources_survive_reopen_are_scoped_and_follow_history_deletion() {
+        let dir =
+            std::env::temp_dir().join(format!("mint-session-sources-{}", uuid::Uuid::new_v4()));
+        let path = dir.as_path().join("memory.db");
+        let store = MemoryStore::open(&path);
+        let first = store
+            .add_interaction_for_chat("A", "image", "reply", "test", "test")
+            .unwrap();
+        let other = store
+            .add_interaction_for_chat("B", "document", "reply", "test", "test")
+            .unwrap();
+        let attachment = SourceAttachment {
+            name: "photo.png".into(),
+            kind: "image".into(),
+            mime_type: "image/png".into(),
+            thumbnail_data_uri: Some("data:image/png;base64,aGVsbG8=".into()),
+        };
+        store
+            .save_source_attachments("A", first, std::slice::from_ref(&attachment))
+            .unwrap();
+        store
+            .save_source_attachments("A", first, &[attachment])
+            .unwrap();
+        assert!(store.save_source_attachments("B", first, &[]).is_err());
+        store.set_interaction_agent_activity_json(first, r#"[{"type":"ToolEnd","data":{"action":"web_search","result":"1. Docs\nURL: https://example.com/docs"}},{"type":"ToolEnd","data":{"action":"read_file","result":"private"}}]"#).unwrap();
+        let reopened = MemoryStore::open(path);
+        let a = reopened.conversation_sources("A").unwrap();
+        assert_eq!(a.attachments.len(), 1);
+        assert_eq!(a.attachments[0].interaction_id, Some(first));
+        assert_eq!(a.attachments[0].attachment.name, "photo.png");
+        assert_eq!(a.web_search_progress.len(), 1);
+        assert_eq!(a.web_search_progress[0]["data"]["action"], "web_search");
+        assert!(
+            reopened
+                .conversation_sources("B")
+                .unwrap()
+                .attachments
+                .is_empty()
+        );
+        assert!(reopened.save_source_attachments("A", other, &[]).is_err());
+        reopened.clear_interactions_for_chat("A").unwrap();
+        assert!(
+            reopened
+                .conversation_sources("A")
+                .unwrap()
+                .attachments
+                .is_empty()
+        );
+        assert!(
+            reopened
+                .conversation_sources("A")
+                .unwrap()
+                .web_search_progress
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn attachment_metadata_rejects_external_thumbnails_and_oversized_values() {
+        let dir =
+            std::env::temp_dir().join(format!("mint-session-sources-{}", uuid::Uuid::new_v4()));
+        let store = MemoryStore::open(dir.as_path().join("memory.db"));
+        let id = store
+            .add_interaction_for_chat("A", "hello", "reply", "test", "test")
+            .unwrap();
+        let mut attachment = SourceAttachment {
+            name: "photo.png".into(),
+            kind: "image".into(),
+            mime_type: "image/png".into(),
+            thumbnail_data_uri: Some("https://external.example/image.png".into()),
+        };
+        assert!(
+            store
+                .save_source_attachments("A", id, std::slice::from_ref(&attachment))
+                .is_err()
+        );
+        attachment.thumbnail_data_uri =
+            Some(format!("data:image/png;base64,{}", "A".repeat(300_000)));
+        assert!(
+            store
+                .save_source_attachments("A", id, &[attachment])
+                .is_err()
+        );
+        assert!(
+            store
+                .conversation_sources("A")
+                .unwrap()
+                .attachments
+                .is_empty()
+        );
+    }
+}

package/crates/mint-core/src/agent/memory.rs

@@ -5,6 +5,8 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use crate::search::text_embedding::{encode_embedding, fact_embedding_backend};
+mod sources;
+pub use sources::{ConversationSources, SessionAttachment, SourceAttachment};
 
 pub const CHAT_CLI_ID: &str = "cli";
 pub const DEFAULT_CONVERSATION_ID: &str = "conversation-default";
@@ -51,6 +53,10 @@ pub fn subagent_name(chat_id: &str) -> Option<&str> {
 
 #[derive(Debug, Error)]
 pub enum MemoryError {
+    #[error("library error: {0}")]
+    Library(String),
+    #[error("trajectory error: {0}")]
+    Trajectory(String),
     #[error("unable to determine the user config directory")]
     ConfigDirectoryUnavailable,
     #[error("unable to create database directory {path}: {source}")]
@@ -332,8 +338,8 @@ impl MemoryStore {
         Ok(())
     }
 
-    fn expire_abandoned_turns(&self, chat_id: &str) -> Result<(), MemoryError> {
-        self.connection()?.execute(
+    fn expire_abandoned_turns(connection: &Connection, chat_id: &str) -> Result<(), MemoryError> {
+        connection.execute(
             "UPDATE interaction_memories SET status = 'interrupted', lease_until = 0
              WHERE chat_id = ?1 AND status IN ('queued', 'running') AND lease_until < unixepoch()",
             params![normalized_chat_id(chat_id)],
@@ -381,8 +387,8 @@ impl MemoryStore {
         limit: usize,
     ) -> Result<ConversationChanges, MemoryError> {
         let chat_id = normalized_chat_id(chat_id);
-        self.expire_abandoned_turns(&chat_id)?;
         let connection = self.connection()?;
+        Self::expire_abandoned_turns(&connection, &chat_id)?;
         let mut statement = connection.prepare(
             "SELECT c.sequence, c.interaction_id,
                     m.id, m.chat_id, m.user_text, m.ai_text, m.provider, m.model,
@@ -437,8 +443,8 @@ impl MemoryStore {
     }
 
     pub fn latest_conversation_sequence(&self, chat_id: &str) -> Result<i64, MemoryError> {
-        self.expire_abandoned_turns(chat_id)?;
         let connection = self.connection()?;
+        Self::expire_abandoned_turns(&connection, chat_id)?;
         Ok(connection.query_row(
             "SELECT coalesce(max(sequence), 0) FROM conversation_changes WHERE chat_id = ?1",
             params![normalized_chat_id(chat_id)],
@@ -453,8 +459,8 @@ impl MemoryStore {
         limit: usize,
     ) -> Result<ConversationSnapshot, MemoryError> {
         let chat_id = normalized_chat_id(chat_id);
-        self.expire_abandoned_turns(&chat_id)?;
         let mut connection = self.connection()?;
+        Self::expire_abandoned_turns(&connection, &chat_id)?;
         let tx = connection.transaction()?;
         let cursor: i64 = tx.query_row(
             "SELECT coalesce(max(sequence), 0) FROM conversation_changes WHERE chat_id = ?1",
@@ -549,6 +555,68 @@ impl MemoryStore {
         rows.collect::<Result<Vec<_>, _>>().map_err(Into::into)
     }
 
+    /// Exports the execution trajectory for a given chat and optional run/interaction ID
+    /// formatted according to the SWE-bench / Agent Protocol StandardTrajectoryRun v1.0.
+    pub fn export_trajectory_json(
+        &self,
+        chat_id: &str,
+        run_id_or_interaction_id: Option<&str>,
+    ) -> Result<String, MemoryError> {
+        let interactions = self.recent_interactions_for_chat(chat_id, 50)?;
+        if interactions.is_empty() {
+            return Err(MemoryError::Trajectory(format!(
+                "No interactions found for chat '{chat_id}'"
+            )));
+        }
+
+        let target = if let Some(id_query) = run_id_or_interaction_id {
+            interactions.into_iter().find(|im| {
+                if im.id.to_string() == id_query {
+                    return true;
+                }
+                if let Some(act) = &im.agent_activity {
+                    let act_str = act.to_string();
+                    if act_str.contains(id_query) {
+                        return true;
+                    }
+                }
+                false
+            })
+        } else {
+            interactions.into_iter().next()
+        };
+
+        let interaction = target.ok_or_else(|| {
+            MemoryError::Trajectory(format!(
+                "No interaction matching identifier '{:?}' found for chat '{}'",
+                run_id_or_interaction_id, chat_id
+            ))
+        })?;
+
+        let activity_val = interaction.agent_activity.as_ref().ok_or_else(|| {
+            MemoryError::Trajectory("No agent activity recorded for this interaction".into())
+        })?;
+
+        let events: Vec<crate::orchestration::AgentProgress> =
+            serde_json::from_value(activity_val.clone()).map_err(|e| {
+                MemoryError::Trajectory(format!("Failed to parse agent activity events: {e}"))
+            })?;
+
+        let fallback_run_id = format!("run-{}", interaction.id);
+        let run =
+            crate::orchestration::trajectory_schema::StandardTrajectoryRun::from_agent_activity(
+                &interaction.chat_id,
+                &fallback_run_id,
+                &interaction.user_text,
+                &interaction.model,
+                &interaction.provider,
+                &events,
+            );
+
+        run.to_json_pretty()
+            .map_err(|e| MemoryError::Trajectory(format!("Failed to serialize trajectory: {e}")))
+    }
+
     /// Full-text search over `chat_id`'s past interactions for the turns most
     /// relevant to `query` (BM25 ranked), skipping the `exclude_recent` newest
     /// rows since those are already injected verbatim elsewhere. Returns
@@ -595,6 +663,7 @@ impl MemoryStore {
             "DELETE FROM chat_sessions
              WHERE id != ?1
                AND id != ?2
+               AND kind = 'conversation'
                AND id NOT LIKE 'cron::%'
                AND (SELECT COUNT(*) FROM interaction_memories WHERE interaction_memories.chat_id = chat_sessions.id) = 0",
             params![DEFAULT_CONVERSATION_ID, CHAT_CLI_ID],
@@ -750,6 +819,14 @@ impl MemoryStore {
     pub fn clear_interactions_for_chat(&self, chat_id: &str) -> Result<usize, MemoryError> {
         let chat_id = normalized_chat_id(chat_id);
         let connection = self.connection()?;
+        connection.execute(
+            "DELETE FROM library_references WHERE chat_id = ?1",
+            params![chat_id],
+        )?;
+        connection.execute(
+            "DELETE FROM session_skill_reads WHERE chat_id = ?1",
+            params![chat_id],
+        )?;
         Ok(connection.execute(
             "DELETE FROM interaction_memories WHERE chat_id = ?1",
             params![chat_id],
@@ -763,6 +840,14 @@ impl MemoryStore {
         }
         let connection = self.connection()?;
         let transaction = connection.unchecked_transaction()?;
+        transaction.execute(
+            "DELETE FROM library_references WHERE chat_id = ?1",
+            params![chat_id],
+        )?;
+        transaction.execute(
+            "DELETE FROM session_skill_reads WHERE chat_id = ?1",
+            params![chat_id],
+        )?;
         transaction.execute(
             "DELETE FROM interaction_memories WHERE chat_id = ?1",
             params![chat_id],
@@ -775,6 +860,9 @@ impl MemoryStore {
         let deleted =
             transaction.execute("DELETE FROM chat_sessions WHERE id = ?1", params![chat_id])?;
         transaction.commit()?;
+        if let Err(error) = crate::mcp_result::delete_chat_artifacts(&chat_id) {
+            eprintln!("Could not remove conversation artifacts: {error}");
+        }
         Ok(deleted)
     }
 
@@ -894,6 +982,14 @@ impl MemoryStore {
         )?)
     }
 
+    /// Source lookup for edit policy without loading every skill's full body.
+    pub(crate) fn learned_skill_sources(&self) -> Result<Vec<String>, MemoryError> {
+        let connection = self.connection()?;
+        let mut statement = connection.prepare("SELECT source_path FROM learned_skills")?;
+        let rows = statement.query_map([], |row| row.get(0))?;
+        Ok(rows.collect::<Result<Vec<_>, _>>()?)
+    }
+
     pub fn learned_skills(&self, limit: usize) -> Result<Vec<LearnedSkill>, MemoryError> {
         let connection = self.connection()?;
         let mut statement = connection.prepare(
@@ -904,6 +1000,37 @@ impl MemoryStore {
         rows.collect::<Result<Vec<_>, _>>().map_err(Into::into)
     }
 
+    /// A receipt contains the exact bytes returned by a successful full skill read.
+    /// It is not a claim that the model still has those bytes in its context.
+    pub fn record_skill_read(
+        &self,
+        chat_id: &str,
+        path: &str,
+        content: &str,
+    ) -> Result<(), MemoryError> {
+        self.connection()?.execute(
+            "INSERT INTO session_skill_reads (chat_id, path, content) VALUES (?1, ?2, ?3)
+             ON CONFLICT(chat_id, path) DO UPDATE SET content = excluded.content",
+            params![normalized_chat_id(chat_id), path, content],
+        )?;
+        Ok(())
+    }
+
+    pub fn skill_read_content(
+        &self,
+        chat_id: &str,
+        path: &str,
+    ) -> Result<Option<String>, MemoryError> {
+        Ok(self
+            .connection()?
+            .query_row(
+                "SELECT content FROM session_skill_reads WHERE chat_id = ?1 AND path = ?2",
+                params![normalized_chat_id(chat_id), path],
+                |row| row.get(0),
+            )
+            .optional()?)
+    }
+
     pub fn delete_learned_skill(&self, identifier: &str) -> Result<usize, MemoryError> {
         let connection = self.connection()?;
         Ok(connection.execute(
@@ -1115,7 +1242,11 @@ impl MemoryStore {
         )?)
     }
 
-    fn connection(&self) -> Result<Connection, MemoryError> {
+    pub(crate) fn path(&self) -> &std::path::Path {
+        &self.path
+    }
+
+    pub(crate) fn connection(&self) -> Result<Connection, MemoryError> {
         if let Some(directory) = self.path.parent() {
             std::fs::create_dir_all(directory).map_err(|source| MemoryError::CreateDirectory {
                 path: directory.to_path_buf(),
@@ -1135,24 +1266,22 @@ impl MemoryStore {
             std::sync::Mutex<std::collections::HashSet<PathBuf>>,
         > = std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashSet::new()));
 
-        let needs_init = {
-            let mut set = INITIALIZED_DATABASES.lock().unwrap();
-            set.insert(self.path.clone())
-        };
-
-        if needs_init {
+        // Publish readiness only after initialization succeeds. Companion and API
+        // reads may open the same database concurrently during startup.
+        let mut initialized = INITIALIZED_DATABASES
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        if !initialized.contains(&self.path) {
             initialize(
                 &connection,
                 memory_path().is_ok_and(|default_path| default_path == self.path),
             )?;
-            // This database holds OAuth tokens (see `oauth::save_oauth_tokens`,
-            // stored in `user_profile`) alongside chat history — restrict it
-            // to owner-only rather than leaving it at default (typically
-            // world-readable) permissions. `needs_init` already gates this to
-            // once per path per process, and any pre-existing database from
-            // before this fix gets tightened the same way on its first open.
+            // OAuth tokens live beside chat history; restrict the file once per
+            // path per process, including databases created by older versions.
             restrict_to_owner(&self.path);
+            initialized.insert(self.path.clone());
         }
+        drop(initialized);
         Ok(connection)
     }
 }
@@ -1312,6 +1441,16 @@ fn initialize(
            chat_id TEXT NOT NULL,
            interaction_id INTEGER NOT NULL
          );
+         CREATE TABLE IF NOT EXISTS conversation_source_attachments (
+           id INTEGER PRIMARY KEY AUTOINCREMENT,
+           interaction_id INTEGER NOT NULL,
+           metadata TEXT NOT NULL,
+           UNIQUE(interaction_id, metadata)
+         );
+         CREATE TRIGGER IF NOT EXISTS trg_interaction_sources_delete
+         AFTER DELETE ON interaction_memories BEGIN
+           DELETE FROM conversation_source_attachments WHERE interaction_id = OLD.id;
+         END;
          CREATE INDEX IF NOT EXISTS idx_conversation_changes_chat_sequence
            ON conversation_changes(chat_id, sequence);
           CREATE TABLE IF NOT EXISTS chat_sessions (
@@ -1332,6 +1471,12 @@ fn initialize(
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
          );
+         CREATE TABLE IF NOT EXISTS session_skill_reads (
+           chat_id TEXT NOT NULL,
+           path TEXT NOT NULL,
+           content TEXT NOT NULL,
+           PRIMARY KEY(chat_id, path)
+         );
          CREATE TABLE IF NOT EXISTS workspace_sessions (
            workspace_path TEXT PRIMARY KEY,
            summary TEXT NOT NULL,
@@ -1384,6 +1529,7 @@ fn initialize(
            VALUES (new.id, new.user_text, new.ai_text);
          END;",
     )?;
+    crate::library::initialize(connection)?;
     ensure_column(
         connection,
         "interaction_memories",
@@ -1701,7 +1847,7 @@ fn interaction_row(row: &rusqlite::Row<'_>) -> Result<InteractionMemory, rusqlit
 
 fn normalized_chat_id(chat_id: &str) -> String {
     let trimmed = chat_id.trim();
-    if trimmed.is_empty() {
+    if trimmed.is_empty() || trimmed == "default" {
         DEFAULT_CONVERSATION_ID.to_owned()
     } else {
         trimmed.to_owned()
@@ -1746,6 +1892,37 @@ fn ensure_chat_session_row(connection: &Connection, chat_id: &str) -> Result<(),
 
 #[cfg(test)]
 mod conversation_sync_tests {
+    #[test]
+    fn concurrent_first_reads_wait_for_database_schema_initialization() {
+        use std::sync::{Arc, Barrier};
+        for _ in 0..3 {
+            let root =
+                std::env::temp_dir().join(format!("mint-schema-ordering-{}", uuid::Uuid::new_v4()));
+            let store = super::MemoryStore::open(root.join("memory.sqlite"));
+            let barrier = Arc::new(Barrier::new(16));
+            let results = std::thread::scope(|scope| {
+                let handles: Vec<_> = (0..16)
+                    .map(|_| {
+                        let barrier = Arc::clone(&barrier);
+                        let store = store.clone();
+                        scope.spawn(move || {
+                            barrier.wait();
+                            store.learned_skills(100)
+                        })
+                    })
+                    .collect();
+                handles
+                    .into_iter()
+                    .map(|handle| handle.join().unwrap())
+                    .collect::<Vec<_>>()
+            });
+            let _ = std::fs::remove_dir_all(root);
+            for result in results {
+                assert!(result.is_ok(), "concurrent inventory read: {result:?}");
+            }
+        }
+    }
+
     use super::*;
 
     fn store() -> MemoryStore {
@@ -1755,6 +1932,30 @@ mod conversation_sync_tests {
         )))
     }
 
+    #[test]
+    fn listing_sessions_removes_empty_project_chat_placeholders() {
+        let memory = store();
+        memory
+            .set_chat_session_workspace("conversation-empty", Some("/projects/demo"))
+            .unwrap();
+        memory
+            .start_turn("conversation-used", "first message")
+            .unwrap();
+
+        let sessions = memory.list_chat_sessions().unwrap();
+
+        assert!(
+            !sessions
+                .iter()
+                .any(|session| session.id == "conversation-empty")
+        );
+        assert!(
+            sessions
+                .iter()
+                .any(|session| session.id == "conversation-used")
+        );
+    }
+
     #[test]
     fn prompt_and_reply_use_one_id_and_emit_changes() {
         let memory = store();