Render history from the native agent

Cargo.lock

@@ -197,6 +197,7 @@ dependencies = [
  "agent_servers",
  "agent_settings",
  "anyhow",
+ "assistant_context",
  "assistant_tool",
  "assistant_tools",
  "chrono",

crates/acp_thread/src/acp_thread.rs

@@ -634,8 +634,12 @@ impl PlanEntry {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct AgentServerName(pub SharedString);
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AcpThreadMetadata {
+    pub agent: AgentServerName,
     pub id: acp::SessionId,
     pub title: SharedString,
     pub updated_at: DateTime<Utc>,
@@ -2309,10 +2313,6 @@ mod tests {
             Task::ready(Ok(thread))
         }
 
-        fn list_threads(&self, _: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
-            unimplemented!()
-        }
-
         fn authenticate(&self, method: acp::AuthMethodId, _cx: &mut App) -> Task<gpui::Result<()>> {
             if self.auth_methods().iter().any(|m| m.id == method) {
                 Task::ready(Ok(()))

crates/acp_thread/src/connection.rs

@@ -2,6 +2,7 @@ use crate::{AcpThread, AcpThreadMetadata};
 use agent_client_protocol::{self as acp};
 use anyhow::Result;
 use collections::IndexMap;
+use futures::channel::mpsc::UnboundedReceiver;
 use gpui::{Entity, SharedString, Task};
 use project::Project;
 use serde::{Deserialize, Serialize};
@@ -26,7 +27,9 @@ pub trait AgentConnection {
         cx: &mut App,
     ) -> Task<Result<Entity<AcpThread>>>;
 
-    fn list_threads(&self, _cx: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>>;
+    fn list_threads(&self, _cx: &mut App) -> Option<UnboundedReceiver<Vec<AcpThreadMetadata>>> {
+        return None;
+    }
 
     fn auth_methods(&self) -> &[acp::AuthMethod];
 
@@ -266,10 +269,6 @@ mod test_support {
             unimplemented!()
         }
 
-        fn list_threads(&self, _: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
-            unimplemented!()
-        }
-
         fn prompt(
             &self,
             _id: Option<UserMessageId>,

crates/agent/src/history_store.rs

@@ -62,7 +62,7 @@ enum SerializedRecentOpen {
 
 pub struct HistoryStore {
     thread_store: Entity<ThreadStore>,
-    context_store: Entity<assistant_context::ContextStore>,
+    pub context_store: Entity<assistant_context::ContextStore>,
     recently_opened_entries: VecDeque<HistoryEntryId>,
     _subscriptions: Vec<gpui::Subscription>,
     _save_recently_opened_entries_task: Task<()>,

crates/agent2/Cargo.toml

@@ -61,6 +61,7 @@ web_search.workspace = true
 which.workspace = true
 workspace-hack.workspace = true
 zstd.workspace = true
+assistant_context.workspace = true
 
 [dev-dependencies]
 agent = { workspace = true, "features" = ["test-support"] }

crates/agent2/src/agent.rs

@@ -1,4 +1,5 @@
 use crate::ThreadsDatabase;
+use crate::native_agent_server::NATIVE_AGENT_SERVER_NAME;
 use crate::{
     AgentResponseEvent, ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DeletePathTool,
     DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool, ListDirectoryTool,
@@ -11,9 +12,9 @@ use agent_settings::AgentSettings;
 use anyhow::{Context as _, Result, anyhow};
 use collections::{HashSet, IndexMap};
 use fs::Fs;
-use futures::channel::mpsc;
+use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use futures::future::Shared;
-use futures::{StreamExt, future};
+use futures::{SinkExt, StreamExt, future};
 use gpui::{
     App, AppContext, AsyncApp, Context, Entity, SharedString, Subscription, Task, WeakEntity,
 };
@@ -169,6 +170,7 @@ pub struct NativeAgent {
     project: Entity<Project>,
     prompt_store: Option<Entity<PromptStore>>,
     thread_database: Shared<Task<Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>>,
+    history_listeners: Vec<UnboundedSender<Vec<AcpThreadMetadata>>>,
     fs: Arc<dyn Fs>,
     _subscriptions: Vec<Subscription>,
 }
@@ -217,6 +219,7 @@ impl NativeAgent {
                 project,
                 prompt_store,
                 fs,
+                history_listeners: Vec::new(),
                 _subscriptions: subscriptions,
             }
         })
@@ -755,21 +758,36 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
         Task::ready(Ok(()))
     }
 
-    fn list_threads(&self, cx: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
+    fn list_threads(&self, cx: &mut App) -> Option<UnboundedReceiver<Vec<AcpThreadMetadata>>> {
-        let database = self.0.read(cx).thread_database.clone();
+        dbg!("listing!");
-        cx.background_executor().spawn(async move {
+        let (mut tx, rx) = futures::channel::mpsc::unbounded();
-            let database = database.await.map_err(|e| anyhow!(e))?;
+        let database = self.0.update(cx, |this, _| {
-            let results = database.list_threads().await?;
+            this.history_listeners.push(tx.clone());
+            this.thread_database.clone()
+        });
+        cx.background_executor()
+            .spawn(async move {
+                dbg!("listing!");
+                let database = database.await.map_err(|e| anyhow!(e))?;
+                let results = database.list_threads().await?;
 
-            Ok(results
+                dbg!(&results);
-                .into_iter()
+                tx.send(
-                .map(|thread| AcpThreadMetadata {
+                    results
-                    id: thread.id,
+                        .into_iter()
-                    title: thread.title,
+                        .map(|thread| AcpThreadMetadata {
-                    updated_at: thread.updated_at,
+                            agent: NATIVE_AGENT_SERVER_NAME.clone(),
-                })
+                            id: thread.id,
-                .collect())
+                            title: thread.title,
-        })
+                            updated_at: thread.updated_at,
+                        })
+                        .collect(),
+                )
+                .await?;
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+        Some(rx)
     }
 
     fn model_selector(&self) -> Option<Rc<dyn AgentModelSelector>> {

crates/agent2/src/agent2.rs

@@ -1,5 +1,6 @@
 mod agent;
 mod db;
+pub mod history_store;
 mod native_agent_server;
 mod templates;
 mod thread;

crates/agent2/src/history_store.rs

@@ -0,0 +1,141 @@
+use acp_thread::{AcpThreadMetadata, AgentConnection, AgentServerName};
+use agent::{ThreadId, thread_store::ThreadStore};
+use agent_client_protocol as acp;
+use anyhow::{Context as _, Result};
+use assistant_context::SavedContextMetadata;
+use chrono::{DateTime, Utc};
+use collections::HashMap;
+use gpui::{App, AsyncApp, Entity, SharedString, Task, prelude::*};
+use itertools::Itertools;
+use paths::contexts_dir;
+use serde::{Deserialize, Serialize};
+use smol::stream::StreamExt;
+use std::{collections::VecDeque, path::Path, sync::Arc, time::Duration};
+use util::ResultExt as _;
+
+const MAX_RECENTLY_OPENED_ENTRIES: usize = 6;
+const NAVIGATION_HISTORY_PATH: &str = "agent-navigation-history.json";
+const SAVE_RECENTLY_OPENED_ENTRIES_DEBOUNCE: Duration = Duration::from_millis(50);
+
+#[derive(Clone, Debug)]
+pub enum HistoryEntry {
+    Thread(AcpThreadMetadata),
+    Context(SavedContextMetadata),
+}
+
+impl HistoryEntry {
+    pub fn updated_at(&self) -> DateTime<Utc> {
+        match self {
+            HistoryEntry::Thread(thread) => thread.updated_at,
+            HistoryEntry::Context(context) => context.mtime.to_utc(),
+        }
+    }
+
+    pub fn id(&self) -> HistoryEntryId {
+        match self {
+            HistoryEntry::Thread(thread) => {
+                HistoryEntryId::Thread(thread.agent.clone(), thread.id.clone())
+            }
+            HistoryEntry::Context(context) => HistoryEntryId::Context(context.path.clone()),
+        }
+    }
+
+    pub fn title(&self) -> &SharedString {
+        match self {
+            HistoryEntry::Thread(thread) => &thread.title,
+            HistoryEntry::Context(context) => &context.title,
+        }
+    }
+}
+
+/// Generic identifier for a history entry.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum HistoryEntryId {
+    Thread(AgentServerName, acp::SessionId),
+    Context(Arc<Path>),
+}
+
+#[derive(Serialize, Deserialize)]
+enum SerializedRecentOpen {
+    Thread(String),
+    ContextName(String),
+    /// Old format which stores the full path
+    Context(String),
+}
+
+pub struct AgentHistory {
+    entries: HashMap<acp::SessionId, AcpThreadMetadata>,
+    _task: Task<Result<()>>,
+}
+
+pub struct HistoryStore {
+    agents: HashMap<AgentServerName, AgentHistory>,
+}
+
+impl HistoryStore {
+    pub fn new(cx: &mut Context<Self>) -> Self {
+        Self {
+            agents: HashMap::default(),
+        }
+    }
+
+    pub fn register_agent(
+        &mut self,
+        agent_name: AgentServerName,
+        connection: &dyn AgentConnection,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(mut history) = connection.list_threads(cx) else {
+            return;
+        };
+        let task = cx.spawn(async move |this, cx| {
+            while let Some(updated_history) = history.next().await {
+                dbg!(&updated_history);
+                this.update(cx, |this, cx| {
+                    for entry in updated_history {
+                        let agent = this
+                            .agents
+                            .get_mut(&entry.agent)
+                            .context("agent not found")?;
+                        agent.entries.insert(entry.id.clone(), entry);
+                    }
+                    cx.notify();
+                    anyhow::Ok(())
+                })??
+            }
+            Ok(())
+        });
+        self.agents.insert(
+            agent_name,
+            AgentHistory {
+                entries: Default::default(),
+                _task: task,
+            },
+        );
+    }
+
+    pub fn entries(&self, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
+        let mut history_entries = Vec::new();
+
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return history_entries;
+        }
+
+        history_entries.extend(
+            self.agents
+                .values()
+                .flat_map(|agent| agent.entries.values())
+                .cloned()
+                .map(HistoryEntry::Thread),
+        );
+        // todo!() include the text threads in here.
+
+        history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
+        dbg!(history_entries)
+    }
+
+    pub fn recent_entries(&self, limit: usize, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
+        self.entries(cx).into_iter().take(limit).collect()
+    }
+}

crates/agent2/src/native_agent_server.rs

@@ -1,11 +1,13 @@
 use std::{path::Path, rc::Rc, sync::Arc};
 
+use acp_thread::AgentServerName;
 use agent_servers::AgentServer;
 use anyhow::Result;
 use fs::Fs;
 use gpui::{App, Entity, Task};
 use project::Project;
 use prompt_store::PromptStore;
+use ui::SharedString;
 
 use crate::{NativeAgent, NativeAgentConnection, templates::Templates};
 
@@ -20,9 +22,12 @@ impl NativeAgentServer {
     }
 }
 
+pub const NATIVE_AGENT_SERVER_NAME: AgentServerName =
+    AgentServerName(SharedString::new_static("Native Agent"));
+
 impl AgentServer for NativeAgentServer {
-    fn name(&self) -> &'static str {
+    fn name(&self) -> AgentServerName {
-        "Native Agent"
+        NATIVE_AGENT_SERVER_NAME.clone()
     }
 
     fn empty_state_headline(&self) -> &'static str {

crates/agent_servers/src/acp.rs

@@ -1,7 +1,7 @@
 use std::{path::Path, rc::Rc};
 
 use crate::AgentServerCommand;
-use acp_thread::AgentConnection;
+use acp_thread::{AgentConnection, AgentServerName};
 use anyhow::Result;
 use gpui::AsyncApp;
 use thiserror::Error;
@@ -14,12 +14,12 @@ mod v1;
 pub struct UnsupportedVersion;
 
 pub async fn connect(
-    server_name: &'static str,
+    server_name: AgentServerName,
     command: AgentServerCommand,
     root_dir: &Path,
     cx: &mut AsyncApp,
 ) -> Result<Rc<dyn AgentConnection>> {
-    let conn = v1::AcpConnection::stdio(server_name, command.clone(), &root_dir, cx).await;
+    let conn = v1::AcpConnection::stdio(server_name.clone(), command.clone(), &root_dir, cx).await;
 
     match conn {
         Ok(conn) => Ok(Rc::new(conn) as _),

crates/agent_servers/src/acp/v0.rs

@@ -10,7 +10,7 @@ use ui::App;
 use util::ResultExt as _;
 
 use crate::AgentServerCommand;
-use acp_thread::{AcpThread, AcpThreadMetadata, AgentConnection, AuthRequired};
+use acp_thread::{AcpThread, AgentConnection, AgentServerName, AuthRequired};
 
 #[derive(Clone)]
 struct OldAcpClientDelegate {
@@ -354,7 +354,7 @@ fn into_new_plan_status(status: acp_old::PlanEntryStatus) -> acp::PlanEntryStatu
 }
 
 pub struct AcpConnection {
-    pub name: &'static str,
+    pub name: AgentServerName,
     pub connection: acp_old::AgentConnection,
     pub _child_status: Task<Result<()>>,
     pub current_thread: Rc<RefCell<WeakEntity<AcpThread>>>,
@@ -362,7 +362,7 @@ pub struct AcpConnection {
 
 impl AcpConnection {
     pub fn stdio(
-        name: &'static str,
+        name: AgentServerName,
         command: AgentServerCommand,
         root_dir: &Path,
         cx: &mut AsyncApp,
@@ -443,7 +443,7 @@ impl AgentConnection for AcpConnection {
             cx.update(|cx| {
                 let thread = cx.new(|cx| {
                     let session_id = acp::SessionId("acp-old-no-id".into());
-                    AcpThread::new(self.name, self.clone(), project, session_id, cx)
+                    AcpThread::new(self.name.0.clone(), self.clone(), project, session_id, cx)
                 });
                 current_thread.replace(thread.downgrade());
                 thread
@@ -451,10 +451,6 @@ impl AgentConnection for AcpConnection {
         })
     }
 
-    fn list_threads(&self, _cx: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
-        Task::ready(Ok(Vec::default()))
-    }
-
     fn auth_methods(&self) -> &[acp::AuthMethod] {
         &[]
     }

crates/agent_servers/src/acp/v1.rs

@@ -11,10 +11,10 @@ use anyhow::{Context as _, Result};
 use gpui::{App, AppContext as _, AsyncApp, Entity, Task, WeakEntity};
 
 use crate::{AgentServerCommand, acp::UnsupportedVersion};
-use acp_thread::{AcpThread, AcpThreadMetadata, AgentConnection, AuthRequired};
+use acp_thread::{AcpThread, AgentConnection, AgentServerName, AuthRequired};
 
 pub struct AcpConnection {
-    server_name: &'static str,
+    server_name: AgentServerName,
     connection: Rc<acp::ClientSideConnection>,
     sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
     auth_methods: Vec<acp::AuthMethod>,
@@ -29,7 +29,7 @@ const MINIMUM_SUPPORTED_VERSION: acp::ProtocolVersion = acp::V1;
 
 impl AcpConnection {
     pub async fn stdio(
-        server_name: &'static str,
+        server_name: AgentServerName,
         command: AgentServerCommand,
         root_dir: &Path,
         cx: &mut AsyncApp,
@@ -135,7 +135,7 @@ impl AgentConnection for AcpConnection {
 
             let thread = cx.new(|cx| {
                 AcpThread::new(
-                    self.server_name,
+                    self.server_name.0.clone(),
                     self.clone(),
                     project,
                     session_id.clone(),
@@ -169,10 +169,6 @@ impl AgentConnection for AcpConnection {
         })
     }
 
-    fn list_threads(&self, _cx: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
-        Task::ready(Ok(Vec::default()))
-    }
-
     fn prompt(
         &self,
         _id: Option<acp_thread::UserMessageId>,

crates/agent_servers/src/agent_servers.rs

@@ -10,7 +10,7 @@ pub use claude::*;
 pub use gemini::*;
 pub use settings::*;
 
-use acp_thread::AgentConnection;
+use acp_thread::{AgentConnection, AgentServerName};
 use anyhow::Result;
 use collections::HashMap;
 use gpui::{App, AsyncApp, Entity, SharedString, Task};
@@ -30,7 +30,7 @@ pub fn init(cx: &mut App) {
 
 pub trait AgentServer: Send {
     fn logo(&self) -> ui::IconName;
-    fn name(&self) -> &'static str;
+    fn name(&self) -> AgentServerName;
     fn empty_state_headline(&self) -> &'static str;
     fn empty_state_message(&self) -> &'static str;
 

crates/agent_servers/src/claude.rs

@@ -30,18 +30,18 @@ use util::{ResultExt, debug_panic};
 use crate::claude::mcp_server::{ClaudeZedMcpServer, McpConfig};
 use crate::claude::tools::ClaudeTool;
 use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings};
-use acp_thread::{AcpThread, AcpThreadMetadata, AgentConnection};
+use acp_thread::{AcpThread, AgentConnection, AgentServerName};
 
 #[derive(Clone)]
 pub struct ClaudeCode;
 
 impl AgentServer for ClaudeCode {
-    fn name(&self) -> &'static str {
+    fn name(&self) -> AgentServerName {
-        "Claude Code"
+        AgentServerName("Claude Code".into())
     }
 
     fn empty_state_headline(&self) -> &'static str {
-        self.name()
+        "Claude Code"
     }
 
     fn empty_state_message(&self) -> &'static str {
@@ -209,10 +209,6 @@ impl AgentConnection for ClaudeAgentConnection {
         Task::ready(Err(anyhow!("Authentication not supported")))
     }
 
-    fn list_threads(&self, _cx: &mut App) -> Task<Result<Vec<AcpThreadMetadata>>> {
-        Task::ready(Ok(Vec::default()))
-    }
-
     fn prompt(
         &self,
         _id: Option<acp_thread::UserMessageId>,

crates/agent_servers/src/gemini.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 use std::rc::Rc;
 
 use crate::{AgentServer, AgentServerCommand};
-use acp_thread::{AgentConnection, LoadError};
+use acp_thread::{AgentConnection, AgentServerName, LoadError};
 use anyhow::Result;
 use gpui::{Entity, Task};
 use project::Project;
@@ -17,8 +17,8 @@ pub struct Gemini;
 const ACP_ARG: &str = "--experimental-acp";
 
 impl AgentServer for Gemini {
-    fn name(&self) -> &'static str {
+    fn name(&self) -> AgentServerName {
-        "Gemini"
+        AgentServerName("Gemini".into())
     }
 
     fn empty_state_headline(&self) -> &'static str {

crates/agent_ui/src/acp.rs

@@ -3,8 +3,10 @@ mod entry_view_state;
 mod message_editor;
 mod model_selector;
 mod model_selector_popover;
+mod thread_history;
 mod thread_view;
 
 pub use model_selector::AcpModelSelector;
 pub use model_selector_popover::AcpModelSelectorPopover;
+pub use thread_history::AcpThreadHistory;
 pub use thread_view::AcpThreadView;

crates/agent_ui/src/acp/thread_history.rs

@@ -0,0 +1,944 @@
+use crate::{AgentPanel, RemoveSelectedThread};
+use agent_servers::AgentServer;
+use agent2::{
+    NativeAgentServer,
+    history_store::{HistoryEntry, HistoryStore},
+};
+use chrono::{Datelike as _, Local, NaiveDate, TimeDelta};
+use editor::{Editor, EditorEvent};
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    App, ClickEvent, Empty, Entity, FocusHandle, Focusable, ScrollStrategy, Stateful, Task,
+    UniformListScrollHandle, WeakEntity, Window, uniform_list,
+};
+use project::Project;
+use std::{fmt::Display, ops::Range, sync::Arc};
+use time::{OffsetDateTime, UtcOffset};
+use ui::{
+    HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Scrollbar, ScrollbarState,
+    Tooltip, prelude::*,
+};
+use util::ResultExt;
+
+pub struct AcpThreadHistory {
+    agent_panel: WeakEntity<AgentPanel>,
+    history_store: Entity<HistoryStore>,
+    scroll_handle: UniformListScrollHandle,
+    selected_index: usize,
+    hovered_index: Option<usize>,
+    search_editor: Entity<Editor>,
+    all_entries: Arc<Vec<HistoryEntry>>,
+    // When the search is empty, we display date separators between history entries
+    // This vector contains an enum of either a separator or an actual entry
+    separated_items: Vec<ListItemType>,
+    // Maps entry indexes to list item indexes
+    separated_item_indexes: Vec<u32>,
+    _separated_items_task: Option<Task<()>>,
+    search_state: SearchState,
+    scrollbar_visibility: bool,
+    scrollbar_state: ScrollbarState,
+    _subscriptions: Vec<gpui::Subscription>,
+}
+
+enum SearchState {
+    Empty,
+    Searching {
+        query: SharedString,
+        _task: Task<()>,
+    },
+    Searched {
+        query: SharedString,
+        matches: Vec<StringMatch>,
+    },
+}
+
+enum ListItemType {
+    BucketSeparator(TimeBucket),
+    Entry {
+        index: usize,
+        format: EntryTimeFormat,
+    },
+}
+
+impl ListItemType {
+    fn entry_index(&self) -> Option<usize> {
+        match self {
+            ListItemType::BucketSeparator(_) => None,
+            ListItemType::Entry { index, .. } => Some(*index),
+        }
+    }
+}
+
+impl AcpThreadHistory {
+    pub(crate) fn new(
+        agent_panel: WeakEntity<AgentPanel>,
+        project: &Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let history_store = cx.new(|cx| agent2::history_store::HistoryStore::new(cx));
+
+        let agent = NativeAgentServer::new(project.read(cx).fs().clone());
+
+        let root_dir = project
+            .read(cx)
+            .visible_worktrees(cx)
+            .next()
+            .map(|worktree| worktree.read(cx).abs_path())
+            .unwrap_or_else(|| paths::home_dir().as_path().into());
+
+        // todo!() reuse this connection for sending messages
+        let connect = agent.connect(&root_dir, project, cx);
+        cx.spawn(async move |this, cx| {
+            let connection = connect.await?;
+            this.update(cx, |this, cx| {
+                this.history_store.update(cx, |this, cx| {
+                    this.register_agent(agent.name(), connection.as_ref(), cx)
+                })
+            })?;
+            // todo!() we must keep it alive
+            std::mem::forget(connection);
+            anyhow::Ok(())
+        })
+        .detach();
+
+        dbg!("hello!");
+        let search_editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_placeholder_text("Search threads...", cx);
+            editor
+        });
+
+        let search_editor_subscription =
+            cx.subscribe(&search_editor, |this, search_editor, event, cx| {
+                if let EditorEvent::BufferEdited = event {
+                    let query = search_editor.read(cx).text(cx);
+                    this.search(query.into(), cx);
+                }
+            });
+
+        let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
+            this.update_all_entries(cx);
+        });
+
+        let scroll_handle = UniformListScrollHandle::default();
+        let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
+
+        let mut this = Self {
+            agent_panel,
+            history_store,
+            scroll_handle,
+            selected_index: 0,
+            hovered_index: None,
+            search_state: SearchState::Empty,
+            all_entries: Default::default(),
+            separated_items: Default::default(),
+            separated_item_indexes: Default::default(),
+            search_editor,
+            scrollbar_visibility: true,
+            scrollbar_state,
+            _subscriptions: vec![search_editor_subscription, history_store_subscription],
+            _separated_items_task: None,
+        };
+        this.update_all_entries(cx);
+        this
+    }
+
+    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
+        let new_entries: Arc<Vec<HistoryEntry>> = self
+            .history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+
+        self._separated_items_task.take();
+
+        let mut items = Vec::with_capacity(new_entries.len() + 1);
+        let mut indexes = Vec::with_capacity(new_entries.len() + 1);
+
+        let bg_task = cx.background_spawn(async move {
+            let mut bucket = None;
+            let today = Local::now().naive_local().date();
+
+            for (index, entry) in new_entries.iter().enumerate() {
+                let entry_date = entry
+                    .updated_at()
+                    .with_timezone(&Local)
+                    .naive_local()
+                    .date();
+                let entry_bucket = TimeBucket::from_dates(today, entry_date);
+
+                if Some(entry_bucket) != bucket {
+                    bucket = Some(entry_bucket);
+                    items.push(ListItemType::BucketSeparator(entry_bucket));
+                }
+
+                indexes.push(items.len() as u32);
+                items.push(ListItemType::Entry {
+                    index,
+                    format: entry_bucket.into(),
+                });
+            }
+            (new_entries, items, indexes)
+        });
+
+        let task = cx.spawn(async move |this, cx| {
+            let (new_entries, items, indexes) = bg_task.await;
+            this.update(cx, |this, cx| {
+                let previously_selected_entry =
+                    this.all_entries.get(this.selected_index).map(|e| e.id());
+
+                this.all_entries = new_entries;
+                this.separated_items = items;
+                this.separated_item_indexes = indexes;
+
+                match &this.search_state {
+                    SearchState::Empty => {
+                        if this.selected_index >= this.all_entries.len() {
+                            this.set_selected_entry_index(
+                                this.all_entries.len().saturating_sub(1),
+                                cx,
+                            );
+                        } else if let Some(prev_id) = previously_selected_entry {
+                            if let Some(new_ix) = this
+                                .all_entries
+                                .iter()
+                                .position(|probe| probe.id() == prev_id)
+                            {
+                                this.set_selected_entry_index(new_ix, cx);
+                            }
+                        }
+                    }
+                    SearchState::Searching { query, .. } | SearchState::Searched { query, .. } => {
+                        this.search(query.clone(), cx);
+                    }
+                }
+
+                cx.notify();
+            })
+            .log_err();
+        });
+        self._separated_items_task = Some(task);
+    }
+
+    fn search(&mut self, query: SharedString, cx: &mut Context<Self>) {
+        if query.is_empty() {
+            self.search_state = SearchState::Empty;
+            cx.notify();
+            return;
+        }
+
+        let all_entries = self.all_entries.clone();
+
+        let fuzzy_search_task = cx.background_spawn({
+            let query = query.clone();
+            let executor = cx.background_executor().clone();
+            async move {
+                let mut candidates = Vec::with_capacity(all_entries.len());
+
+                for (idx, entry) in all_entries.iter().enumerate() {
+                    match entry {
+                        HistoryEntry::Thread(thread) => {
+                            candidates.push(StringMatchCandidate::new(idx, &thread.title));
+                        }
+                        HistoryEntry::Context(context) => {
+                            candidates.push(StringMatchCandidate::new(idx, &context.title));
+                        }
+                    }
+                }
+
+                const MAX_MATCHES: usize = 100;
+
+                fuzzy::match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    true,
+                    MAX_MATCHES,
+                    &Default::default(),
+                    executor,
+                )
+                .await
+            }
+        });
+
+        let task = cx.spawn({
+            let query = query.clone();
+            async move |this, cx| {
+                let matches = fuzzy_search_task.await;
+
+                this.update(cx, |this, cx| {
+                    let SearchState::Searching {
+                        query: current_query,
+                        _task,
+                    } = &this.search_state
+                    else {
+                        return;
+                    };
+
+                    if &query == current_query {
+                        this.search_state = SearchState::Searched {
+                            query: query.clone(),
+                            matches,
+                        };
+
+                        this.set_selected_entry_index(0, cx);
+                        cx.notify();
+                    };
+                })
+                .log_err();
+            }
+        });
+
+        self.search_state = SearchState::Searching { query, _task: task };
+        cx.notify();
+    }
+
+    fn matched_count(&self) -> usize {
+        match &self.search_state {
+            SearchState::Empty => self.all_entries.len(),
+            SearchState::Searching { .. } => 0,
+            SearchState::Searched { matches, .. } => matches.len(),
+        }
+    }
+
+    fn list_item_count(&self) -> usize {
+        match &self.search_state {
+            SearchState::Empty => self.separated_items.len(),
+            SearchState::Searching { .. } => 0,
+            SearchState::Searched { matches, .. } => matches.len(),
+        }
+    }
+
+    fn search_produced_no_matches(&self) -> bool {
+        match &self.search_state {
+            SearchState::Empty => false,
+            SearchState::Searching { .. } => false,
+            SearchState::Searched { matches, .. } => matches.is_empty(),
+        }
+    }
+
+    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
+        match &self.search_state {
+            SearchState::Empty => self.all_entries.get(ix),
+            SearchState::Searching { .. } => None,
+            SearchState::Searched { matches, .. } => matches
+                .get(ix)
+                .and_then(|m| self.all_entries.get(m.candidate_id)),
+        }
+    }
+
+    pub fn select_previous(
+        &mut self,
+        _: &menu::SelectPrevious,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
+        if count > 0 {
+            if self.selected_index == 0 {
+                self.set_selected_entry_index(count - 1, cx);
+            } else {
+                self.set_selected_entry_index(self.selected_index - 1, cx);
+            }
+        }
+    }
+
+    pub fn select_next(
+        &mut self,
+        _: &menu::SelectNext,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
+        if count > 0 {
+            if self.selected_index == count - 1 {
+                self.set_selected_entry_index(0, cx);
+            } else {
+                self.set_selected_entry_index(self.selected_index + 1, cx);
+            }
+        }
+    }
+
+    fn select_first(
+        &mut self,
+        _: &menu::SelectFirst,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
+        if count > 0 {
+            self.set_selected_entry_index(0, cx);
+        }
+    }
+
+    fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
+        let count = self.matched_count();
+        if count > 0 {
+            self.set_selected_entry_index(count - 1, cx);
+        }
+    }
+
+    fn set_selected_entry_index(&mut self, entry_index: usize, cx: &mut Context<Self>) {
+        self.selected_index = entry_index;
+
+        let scroll_ix = match self.search_state {
+            SearchState::Empty | SearchState::Searching { .. } => self
+                .separated_item_indexes
+                .get(entry_index)
+                .map(|ix| *ix as usize)
+                .unwrap_or(entry_index + 1),
+            SearchState::Searched { .. } => entry_index,
+        };
+
+        self.scroll_handle
+            .scroll_to_item(scroll_ix, ScrollStrategy::Top);
+
+        cx.notify();
+    }
+
+    fn render_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        if !(self.scrollbar_visibility || self.scrollbar_state.is_dragging()) {
+            return None;
+        }
+
+        Some(
+            div()
+                .occlude()
+                .id("thread-history-scroll")
+                .h_full()
+                .bg(cx.theme().colors().panel_background.opacity(0.8))
+                .border_l_1()
+                .border_color(cx.theme().colors().border_variant)
+                .absolute()
+                .right_1()
+                .top_0()
+                .bottom_0()
+                .w_4()
+                .pl_1()
+                .cursor_default()
+                .on_mouse_move(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                    cx.stop_propagation()
+                }))
+                .on_hover(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_any_mouse_down(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_scroll_wheel(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                }))
+                .children(Scrollbar::vertical(self.scrollbar_state.clone())),
+        )
+    }
+
+    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => {
+                    self.agent_panel.update(cx, move |agent_panel, cx| todo!())
+                }
+                HistoryEntry::Context(context) => {
+                    self.agent_panel.update(cx, move |agent_panel, cx| {
+                        agent_panel.open_saved_prompt_editor(context.path.clone(), window, cx)
+                    })
+                }
+            };
+
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
+
+            cx.notify();
+        }
+    }
+
+    fn remove_selected_thread(
+        &mut self,
+        _: &RemoveSelectedThread,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => todo!(),
+                HistoryEntry::Context(context) => self
+                    .agent_panel
+                    .update(cx, |this, cx| this.delete_context(context.path.clone(), cx)),
+            };
+
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
+
+            cx.notify();
+        }
+    }
+
+    fn list_items(
+        &mut self,
+        range: Range<usize>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Vec<AnyElement> {
+        let range_start = range.start;
+
+        match &self.search_state {
+            SearchState::Empty => self
+                .separated_items
+                .get(range)
+                .iter()
+                .flat_map(|items| {
+                    items
+                        .iter()
+                        .map(|item| self.render_list_item(item.entry_index(), item, vec![], cx))
+                })
+                .collect(),
+            SearchState::Searched { matches, .. } => matches[range]
+                .iter()
+                .enumerate()
+                .map(|(ix, m)| {
+                    self.render_list_item(
+                        Some(range_start + ix),
+                        &ListItemType::Entry {
+                            index: m.candidate_id,
+                            format: EntryTimeFormat::DateAndTime,
+                        },
+                        m.positions.clone(),
+                        cx,
+                    )
+                })
+                .collect(),
+            SearchState::Searching { .. } => {
+                vec![]
+            }
+        }
+    }
+
+    fn render_list_item(
+        &self,
+        list_entry_ix: Option<usize>,
+        item: &ListItemType,
+        highlight_positions: Vec<usize>,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        match item {
+            ListItemType::Entry { index, format } => match self.all_entries.get(*index) {
+                Some(entry) => h_flex()
+                    .w_full()
+                    .pb_1()
+                    .child(
+                        HistoryEntryElement::new(entry.clone(), self.agent_panel.clone())
+                            .highlight_positions(highlight_positions)
+                            .timestamp_format(*format)
+                            .selected(list_entry_ix == Some(self.selected_index))
+                            .hovered(list_entry_ix == self.hovered_index)
+                            .on_hover(cx.listener(move |this, is_hovered, _window, cx| {
+                                if *is_hovered {
+                                    this.hovered_index = list_entry_ix;
+                                } else if this.hovered_index == list_entry_ix {
+                                    this.hovered_index = None;
+                                }
+
+                                cx.notify();
+                            }))
+                            .into_any_element(),
+                    )
+                    .into_any(),
+                None => Empty.into_any_element(),
+            },
+            ListItemType::BucketSeparator(bucket) => div()
+                .px(DynamicSpacing::Base06.rems(cx))
+                .pt_2()
+                .pb_1()
+                .child(
+                    Label::new(bucket.to_string())
+                        .size(LabelSize::XSmall)
+                        .color(Color::Muted),
+                )
+                .into_any_element(),
+        }
+    }
+}
+
+impl Focusable for AcpThreadHistory {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.search_editor.focus_handle(cx)
+    }
+}
+
+impl Render for AcpThreadHistory {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("ThreadHistory")
+            .size_full()
+            .on_action(cx.listener(Self::select_previous))
+            .on_action(cx.listener(Self::select_next))
+            .on_action(cx.listener(Self::select_first))
+            .on_action(cx.listener(Self::select_last))
+            .on_action(cx.listener(Self::confirm))
+            .on_action(cx.listener(Self::remove_selected_thread))
+            .when(!self.all_entries.is_empty(), |parent| {
+                parent.child(
+                    h_flex()
+                        .h(px(41.)) // Match the toolbar perfectly
+                        .w_full()
+                        .py_1()
+                        .px_2()
+                        .gap_2()
+                        .justify_between()
+                        .border_b_1()
+                        .border_color(cx.theme().colors().border)
+                        .child(
+                            Icon::new(IconName::MagnifyingGlass)
+                                .color(Color::Muted)
+                                .size(IconSize::Small),
+                        )
+                        .child(self.search_editor.clone()),
+                )
+            })
+            .child({
+                let view = v_flex()
+                    .id("list-container")
+                    .relative()
+                    .overflow_hidden()
+                    .flex_grow();
+
+                if self.all_entries.is_empty() {
+                    view.justify_center()
+                        .child(
+                            h_flex().w_full().justify_center().child(
+                                Label::new("You don't have any past threads yet.")
+                                    .size(LabelSize::Small),
+                            ),
+                        )
+                } else if self.search_produced_no_matches() {
+                    view.justify_center().child(
+                        h_flex().w_full().justify_center().child(
+                            Label::new("No threads match your search.").size(LabelSize::Small),
+                        ),
+                    )
+                } else {
+                    view.pr_5()
+                        .child(
+                            uniform_list(
+                                "thread-history",
+                                self.list_item_count(),
+                                cx.processor(|this, range: Range<usize>, window, cx| {
+                                    this.list_items(range, window, cx)
+                                }),
+                            )
+                            .p_1()
+                            .track_scroll(self.scroll_handle.clone())
+                            .flex_grow(),
+                        )
+                        .when_some(self.render_scrollbar(cx), |div, scrollbar| {
+                            div.child(scrollbar)
+                        })
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct HistoryEntryElement {
+    entry: HistoryEntry,
+    agent_panel: WeakEntity<AgentPanel>,
+    selected: bool,
+    hovered: bool,
+    highlight_positions: Vec<usize>,
+    timestamp_format: EntryTimeFormat,
+    on_hover: Box<dyn Fn(&bool, &mut Window, &mut App) + 'static>,
+}
+
+impl HistoryEntryElement {
+    pub fn new(entry: HistoryEntry, agent_panel: WeakEntity<AgentPanel>) -> Self {
+        Self {
+            entry,
+            agent_panel,
+            selected: false,
+            hovered: false,
+            highlight_positions: vec![],
+            timestamp_format: EntryTimeFormat::DateAndTime,
+            on_hover: Box::new(|_, _, _| {}),
+        }
+    }
+
+    pub fn selected(mut self, selected: bool) -> Self {
+        self.selected = selected;
+        self
+    }
+
+    pub fn hovered(mut self, hovered: bool) -> Self {
+        self.hovered = hovered;
+        self
+    }
+
+    pub fn highlight_positions(mut self, positions: Vec<usize>) -> Self {
+        self.highlight_positions = positions;
+        self
+    }
+
+    pub fn on_hover(mut self, on_hover: impl Fn(&bool, &mut Window, &mut App) + 'static) -> Self {
+        self.on_hover = Box::new(on_hover);
+        self
+    }
+
+    pub fn timestamp_format(mut self, format: EntryTimeFormat) -> Self {
+        self.timestamp_format = format;
+        self
+    }
+}
+
+impl RenderOnce for HistoryEntryElement {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let (id, summary, timestamp) = match &self.entry {
+            HistoryEntry::Thread(thread) => (
+                thread.id.to_string(),
+                thread.title.clone(),
+                thread.updated_at.timestamp(),
+            ),
+            HistoryEntry::Context(context) => (
+                context.path.to_string_lossy().to_string(),
+                context.title.clone(),
+                context.mtime.timestamp(),
+            ),
+        };
+
+        let thread_timestamp =
+            self.timestamp_format
+                .format_timestamp(&self.agent_panel, timestamp, cx);
+
+        ListItem::new(SharedString::from(id))
+            .rounded()
+            .toggle_state(self.selected)
+            .spacing(ListItemSpacing::Sparse)
+            .start_slot(
+                h_flex()
+                    .w_full()
+                    .gap_2()
+                    .justify_between()
+                    .child(
+                        HighlightedLabel::new(summary, self.highlight_positions)
+                            .size(LabelSize::Small)
+                            .truncate(),
+                    )
+                    .child(
+                        Label::new(thread_timestamp)
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    ),
+            )
+            .on_hover(self.on_hover)
+            .end_slot::<IconButton>(if self.hovered || self.selected {
+                Some(
+                    IconButton::new("delete", IconName::Trash)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::XSmall)
+                        .icon_color(Color::Muted)
+                        .tooltip(move |window, cx| {
+                            Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
+                        })
+                        .on_click({
+                            let agent_panel = self.agent_panel.clone();
+
+                            let f: Box<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static> =
+                                match &self.entry {
+                                    HistoryEntry::Thread(thread) => {
+                                        let id = thread.id.clone();
+
+                                        Box::new(move |_event, _window, cx| {
+                                            agent_panel
+                                                .update(cx, |agent_panel, cx| {
+                                                    todo!()
+                                                    // this.delete_thread(&id, cx)
+                                                    //     .detach_and_log_err(cx);
+                                                })
+                                                .ok();
+                                        })
+                                    }
+                                    HistoryEntry::Context(context) => {
+                                        let path = context.path.clone();
+
+                                        Box::new(move |_event, _window, cx| {
+                                            agent_panel
+                                                .update(cx, |this, cx| {
+                                                    this.delete_context(path.clone(), cx)
+                                                        .detach_and_log_err(cx);
+                                                })
+                                                .ok();
+                                        })
+                                    }
+                                };
+                            f
+                        }),
+                )
+            } else {
+                None
+            })
+            .on_click({
+                let agent_panel = self.agent_panel.clone();
+
+                let f: Box<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static> = match &self.entry
+                {
+                    HistoryEntry::Thread(thread) => {
+                        let id = thread.id.clone();
+                        Box::new(move |_event, window, cx| {
+                            agent_panel
+                                .update(cx, |agent_panel, cx| {
+                                    // todo!()
+                                })
+                                .ok();
+                        })
+                    }
+                    HistoryEntry::Context(context) => {
+                        let path = context.path.clone();
+                        Box::new(move |_event, window, cx| {
+                            agent_panel
+                                .update(cx, |this, cx| {
+                                    this.open_saved_prompt_editor(path.clone(), window, cx)
+                                        .detach_and_log_err(cx);
+                                })
+                                .ok();
+                        })
+                    }
+                };
+                f
+            })
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum EntryTimeFormat {
+    DateAndTime,
+    TimeOnly,
+}
+
+impl EntryTimeFormat {
+    fn format_timestamp(
+        &self,
+        agent_panel: &WeakEntity<AgentPanel>,
+        timestamp: i64,
+        cx: &App,
+    ) -> String {
+        let timestamp = OffsetDateTime::from_unix_timestamp(timestamp).unwrap();
+        let timezone = agent_panel
+            .read_with(cx, |this, _cx| this.local_timezone())
+            .unwrap_or(UtcOffset::UTC);
+
+        match &self {
+            EntryTimeFormat::DateAndTime => time_format::format_localized_timestamp(
+                timestamp,
+                OffsetDateTime::now_utc(),
+                timezone,
+                time_format::TimestampFormat::EnhancedAbsolute,
+            ),
+            EntryTimeFormat::TimeOnly => time_format::format_time(timestamp),
+        }
+    }
+}
+
+impl From<TimeBucket> for EntryTimeFormat {
+    fn from(bucket: TimeBucket) -> Self {
+        match bucket {
+            TimeBucket::Today => EntryTimeFormat::TimeOnly,
+            TimeBucket::Yesterday => EntryTimeFormat::TimeOnly,
+            TimeBucket::ThisWeek => EntryTimeFormat::DateAndTime,
+            TimeBucket::PastWeek => EntryTimeFormat::DateAndTime,
+            TimeBucket::All => EntryTimeFormat::DateAndTime,
+        }
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+enum TimeBucket {
+    Today,
+    Yesterday,
+    ThisWeek,
+    PastWeek,
+    All,
+}
+
+impl TimeBucket {
+    fn from_dates(reference: NaiveDate, date: NaiveDate) -> Self {
+        if date == reference {
+            return TimeBucket::Today;
+        }
+
+        if date == reference - TimeDelta::days(1) {
+            return TimeBucket::Yesterday;
+        }
+
+        let week = date.iso_week();
+
+        if reference.iso_week() == week {
+            return TimeBucket::ThisWeek;
+        }
+
+        let last_week = (reference - TimeDelta::days(7)).iso_week();
+
+        if week == last_week {
+            return TimeBucket::PastWeek;
+        }
+
+        TimeBucket::All
+    }
+}
+
+impl Display for TimeBucket {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TimeBucket::Today => write!(f, "Today"),
+            TimeBucket::Yesterday => write!(f, "Yesterday"),
+            TimeBucket::ThisWeek => write!(f, "This Week"),
+            TimeBucket::PastWeek => write!(f, "Past Week"),
+            TimeBucket::All => write!(f, "All"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::NaiveDate;
+
+    #[test]
+    fn test_time_bucket_from_dates() {
+        let today = NaiveDate::from_ymd_opt(2023, 1, 15).unwrap();
+
+        let date = today;
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::Today);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 14).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::Yesterday);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 13).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::ThisWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 11).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::ThisWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 8).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::PastWeek);
+
+        let date = NaiveDate::from_ymd_opt(2023, 1, 5).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::PastWeek);
+
+        // All: not in this week or last week
+        let date = NaiveDate::from_ymd_opt(2023, 1, 1).unwrap();
+        assert_eq!(TimeBucket::from_dates(today, date), TimeBucket::All);
+
+        // Test year boundary cases
+        let new_year = NaiveDate::from_ymd_opt(2023, 1, 1).unwrap();
+
+        let date = NaiveDate::from_ymd_opt(2022, 12, 31).unwrap();
+        assert_eq!(
+            TimeBucket::from_dates(new_year, date),
+            TimeBucket::Yesterday
+        );
+
+        let date = NaiveDate::from_ymd_opt(2022, 12, 28).unwrap();
+        assert_eq!(TimeBucket::from_dates(new_year, date), TimeBucket::ThisWeek);
+    }
+}

crates/agent_ui/src/acp/thread_view.rs

@@ -3583,7 +3583,7 @@ fn terminal_command_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use acp_thread::{AcpThreadMetadata, StubAgentConnection};
+    use acp_thread::{AgentServerName, StubAgentConnection};
     use agent::{TextThreadStore, ThreadStore};
     use agent_client_protocol::SessionId;
     use editor::EditorSettings;
@@ -3764,7 +3764,7 @@ pub(crate) mod tests {
             unimplemented!()
         }
 
-        fn name(&self) -> &'static str {
+        fn name(&self) -> AgentServerName {
             unimplemented!()
         }
 
@@ -3819,10 +3819,6 @@ pub(crate) mod tests {
             unimplemented!()
         }
 
-        fn list_threads(&self, _cx: &mut App) -> Task<gpui::Result<Vec<AcpThreadMetadata>>> {
-            Task::ready(Ok(vec![]))
-        }
-
         fn prompt(
             &self,
             _id: Option<acp_thread::UserMessageId>,

crates/agent_ui/src/agent_panel.rs

@@ -5,10 +5,12 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use agent_servers::AgentServer;
+use agent2::NativeAgentServer;
 use db::kvp::{Dismissable, KEY_VALUE_STORE};
 use serde::{Deserialize, Serialize};
 
 use crate::NewExternalAgentThread;
+use crate::acp::AcpThreadHistory;
 use crate::agent_diff::AgentDiffThread;
 use crate::{
     AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode,
@@ -478,6 +480,7 @@ pub struct AgentPanel {
     previous_view: Option<ActiveView>,
     history_store: Entity<HistoryStore>,
     history: Entity<ThreadHistory>,
+    acp_history: Entity<AcpThreadHistory>,
     hovered_recent_history_item: Option<usize>,
     new_thread_menu_handle: PopoverMenuHandle<ContextMenu>,
     agent_panel_menu_handle: PopoverMenuHandle<ContextMenu>,
@@ -743,6 +746,9 @@ impl AgentPanel {
             )
         });
 
+        let acp_history =
+            cx.new(|cx| AcpThreadHistory::new(weak_self.clone(), &project, window, cx));
+
         Self {
             active_view,
             workspace,
@@ -764,6 +770,7 @@ impl AgentPanel {
             previous_view: None,
             history_store: history_store.clone(),
             history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, window, cx)),
+            acp_history,
             hovered_recent_history_item: None,
             new_thread_menu_handle: PopoverMenuHandle::default(),
             agent_panel_menu_handle: PopoverMenuHandle::default(),
@@ -1652,7 +1659,14 @@ impl Focusable for AgentPanel {
         match &self.active_view {
             ActiveView::Thread { message_editor, .. } => message_editor.focus_handle(cx),
             ActiveView::ExternalAgentThread { thread_view, .. } => thread_view.focus_handle(cx),
-            ActiveView::History => self.history.focus_handle(cx),
+            ActiveView::History => {
+                if cx.has_flag::<feature_flags::AcpFeatureFlag>() {
+                    self.acp_history.focus_handle(cx)
+                } else {
+                    self.history.focus_handle(cx)
+                }
+            }
+
             ActiveView::TextThread { context_editor, .. } => context_editor.focus_handle(cx),
             ActiveView::Configuration => {
                 if let Some(configuration) = self.configuration.as_ref() {
@@ -3499,7 +3513,13 @@ impl Render for AgentPanel {
                 ActiveView::ExternalAgentThread { thread_view, .. } => parent
                     .child(thread_view.clone())
                     .child(self.render_drag_target(cx)),
-                ActiveView::History => parent.child(self.history.clone()),
+                ActiveView::History => {
+                    if cx.has_flag::<feature_flags::AcpFeatureFlag>() {
+                        parent.child(self.acp_history.clone())
+                    } else {
+                        parent.child(self.history.clone())
+                    }
+                }
                 ActiveView::TextThread {
                     context_editor,
                     buffer_search_bar,

crates/agent_ui/src/agent_ui.rs

@@ -21,7 +21,6 @@ mod terminal_codegen;
 mod terminal_inline_assistant;
 mod text_thread_editor;
 mod thread_history;
-mod thread_history2;
 mod tool_compatibility;
 mod ui;