chore: Last big refactoring

11 files changed, 65 insertions, 2472 deletions

diff --git a/crates/daemon/src/aclient/api_client.rs b/crates/daemon/src/aclient/api_client.rs
index 954426b4..1eba51bd 100644
--- a/crates/daemon/src/aclient/api_client.rs
+++ b/crates/daemon/src/aclient/api_client.rs
@@ -141,17 +141,6 @@ impl<'a> Client<'a> {
         })
     }
 
-    async fn delete_store(&self) -> Result<()> {
-        let url = make_url(self.sync_addr, "/store", self.user_id)?;
-        let url = Url::parse(url.as_str())?;
-
-        let resp = self.inner.delete(url).send().await?;
-
-        handle_resp_error(resp).await?;
-
-        Ok(())
-    }
-
     pub(crate) async fn post_records(&self, records: &[Record<EncryptedData>]) -> Result<()> {
         let url = make_url(self.sync_addr, "/record", self.user_id)?;
         let url = Url::parse(url.as_str())?;
diff --git a/crates/daemon/src/aclient/database/mod.rs b/crates/daemon/src/aclient/database/mod.rs
index 9da943ca..b112b076 100644
--- a/crates/daemon/src/aclient/database/mod.rs
+++ b/crates/daemon/src/aclient/database/mod.rs
@@ -1,11 +1,7 @@
-use std::{
-    path::{Path, PathBuf},
-    str::FromStr,
-};
+use std::{path::Path, str::FromStr};
 
 use fs_err::{self as fs};
-use itertools::Itertools;
-use sql_builder::{SqlBuilder, SqlName, bind::Bind, esc, quote};
+use sql_builder::{SqlBuilder, SqlName};
 use sqlx::{
     Result, Row,
     sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePool, SqliteRow, SqliteSynchronous},
@@ -13,60 +9,9 @@ use sqlx::{
 use time::OffsetDateTime;
 use tracing::debug;
 use turtle::history::{History, HistoryId};
-use turtle_common::utils::{self, get_host_user};
-use uuid::Uuid;
+use turtle_common::utils;
 
-use crate::aclient::{
-    history::HistoryStats,
-    ordering,
-    settings::{FilterMode, SearchMode},
-};
-use crate::aclient::{settings::Settings, utils::setup_db};
-
-#[derive(Clone)]
-pub(crate) struct Context {
-    session: String,
-    cwd: String,
-    hostname: String,
-    host_id: String,
-    git_root: Option<PathBuf>,
-}
-
-#[derive(Default, Clone)]
-struct OptFilters {
-    exit: Option<i64>,
-    exclude_exit: Option<i64>,
-    cwd: Option<String>,
-    exclude_cwd: Option<String>,
-    before: Option<String>,
-    after: Option<String>,
-    limit: Option<i64>,
-    offset: Option<i64>,
-    reverse: bool,
-    include_duplicates: bool,
-}
-
-impl Context {
-    fn from_history(entry: &History) -> Self {
-        Self {
-            session: entry.session.clone(),
-            cwd: entry.cwd.clone(),
-            hostname: entry.hostname.clone(),
-            host_id: String::new(),
-            git_root: utils::in_git_repo(entry.cwd.as_str()),
-        }
-    }
-}
-
-fn get_session_start_time(session_id: &str) -> Option<i64> {
-    if let Ok(uuid) = Uuid::parse_str(session_id)
-        && let Some(timestamp) = uuid.get_timestamp()
-    {
-        let (seconds, nanos) = timestamp.to_unix();
-        return Some(seconds as i64 * 1_000_000_000 + i64::from(nanos));
-    }
-    None
-}
+use crate::aclient::utils::setup_db;
 
 // Intended for use on a developer machine and not a sync server.
 // TODO: implement IntoIterator
@@ -189,36 +134,9 @@ impl ClientSqlite {
         Ok(())
     }
 
-    pub(crate) async fn save_bulk(&self, h: &[History]) -> Result<()> {
-        debug!("saving history to sqlite");
-
-        let mut tx = self.pool.begin().await?;
-
-        for i in h {
-            Self::save_raw(&mut tx, i).await?;
-        }
-
-        tx.commit().await?;
-
-        Ok(())
-    }
-
-    async fn load(&self, id: &str) -> Result<Option<History>> {
-        debug!("loading history item {}", id);
-
-        let res = sqlx::query("select * from history where id = ?1")
-            .bind(id)
-            .map(Self::query_history_inner)
-            .fetch_optional(&self.pool)
-            .await?;
-
-        Ok(res)
-    }
-
     /// make a unique list, that only shows the *newest* version of things
     pub(crate) async fn list(
         &self,
-        filters: Option<(&Context, &[FilterMode])>,
         max: Option<usize>,
         unique: bool,
         include_deleted: bool,
@@ -231,32 +149,6 @@ impl ClientSqlite {
             query.and_where_is_null("deleted_at");
         }
 
-        if let Some((context, filters)) = filters {
-            let git_root = context.git_root.clone().map_or_else(
-                || context.cwd.clone(),
-                |git_root| git_root.to_str().unwrap_or("/").to_string(),
-            );
-
-            let session_start = get_session_start_time(&context.session);
-
-            for filter in filters {
-                match filter {
-                    FilterMode::Global => &mut query,
-                    FilterMode::Host => query.and_where_eq("hostname", quote(&context.hostname)),
-                    FilterMode::Session => query.and_where_eq("session", quote(&context.session)),
-                    FilterMode::SessionPreload => {
-                        query.and_where_eq("session", quote(&context.session));
-                        if let Some(session_start) = session_start {
-                            query.or_where_lt("timestamp", session_start);
-                        }
-                        &mut query
-                    }
-                    FilterMode::Directory => query.and_where_eq("cwd", quote(&context.cwd)),
-                    FilterMode::Workspace => query.and_where_like_left("cwd", &git_root),
-                };
-            }
-        }
-
         if unique {
             query.group_by("command").having("max(timestamp)");
         }
@@ -294,239 +186,6 @@ impl ClientSqlite {
         Ok(res)
     }
 
-    async fn last(&self) -> Result<Option<History>> {
-        let res = sqlx::query(
-            "select * from history where duration >= 0 order by timestamp desc limit 1",
-        )
-        .map(Self::query_history_inner)
-        .fetch_optional(&self.pool)
-        .await?;
-
-        Ok(res)
-    }
-
-    async fn history_count(&self, include_deleted: bool) -> Result<i64> {
-        let query = if include_deleted {
-            "select count(1) from history"
-        } else {
-            "select count(1) from history where deleted_at is null"
-        };
-
-        let res: (i64,) = sqlx::query_as(query).fetch_one(&self.pool).await?;
-        Ok(res.0)
-    }
-
-    // Yes I know, it's a lot.
-    // Could maybe break it down to a searchparams struct or smth but that feels a little... pointless.
-    // Been debating maybe a DSL for search? eg "before:time limit:1 the query"
-    #[expect(clippy::too_many_lines)]
-    async fn search(
-        &self,
-        search_mode: SearchMode,
-        filter: FilterMode,
-        context: &Context,
-        query: &str,
-        filter_options: OptFilters,
-    ) -> Result<Vec<History>> {
-        let mut sql = SqlBuilder::select_from("history");
-
-        if !filter_options.include_duplicates {
-            sql.group_by("command").having("max(timestamp)");
-        }
-
-        if let Some(limit) = filter_options.limit {
-            sql.limit(limit);
-        }
-
-        if let Some(offset) = filter_options.offset {
-            sql.offset(offset);
-        }
-
-        if filter_options.reverse {
-            sql.order_asc("timestamp");
-        } else {
-            sql.order_desc("timestamp");
-        }
-
-        let git_root = context.git_root.clone().map_or_else(
-            || context.cwd.clone(),
-            |git_root| git_root.to_str().unwrap_or("/").to_string(),
-        );
-
-        let session_start = get_session_start_time(&context.session);
-
-        match filter {
-            FilterMode::Global => &mut sql,
-            FilterMode::Host => {
-                sql.and_where_eq("lower(hostname)", quote(context.hostname.to_lowercase()))
-            }
-            FilterMode::Session => sql.and_where_eq("session", quote(&context.session)),
-            FilterMode::SessionPreload => {
-                sql.and_where_eq("session", quote(&context.session));
-                if let Some(session_start) = session_start {
-                    sql.or_where_lt("timestamp", session_start);
-                }
-                &mut sql
-            }
-            FilterMode::Directory => sql.and_where_eq("cwd", quote(&context.cwd)),
-            FilterMode::Workspace => sql.and_where_like_left("cwd", git_root),
-        };
-
-        let orig_query = query;
-
-        let mut regexes = Vec::new();
-        if search_mode == SearchMode::Prefix {
-            sql.and_where_like_left("command", query.replace('*', "%"))
-        } else {
-            let mut is_or = false;
-            for token in QueryTokenizer::new(query) {
-                // TODO smart case mode could be made configurable like in fzf
-                let (is_glob, glob) = if token.has_uppercase() {
-                    (true, "*")
-                } else {
-                    (false, "%")
-                };
-                let param = match token {
-                    QueryToken::Regex(r) => {
-                        regexes.push(String::from(r));
-                        continue;
-                    }
-                    QueryToken::Or => {
-                        if !is_or {
-                            is_or = true;
-                            continue;
-                        }
-
-                        format!("{glob}|{glob}")
-                    }
-                    QueryToken::MatchStart(term, _) => {
-                        format!("{term}{glob}")
-                    }
-                    QueryToken::MatchEnd(term, _) => {
-                        format!("{glob}{term}")
-                    }
-                    QueryToken::MatchFull(term, _) => {
-                        format!("{glob}{term}{glob}")
-                    }
-                    QueryToken::Match(term, _) => {
-                        if search_mode == SearchMode::FullText {
-                            format!("{glob}{term}{glob}")
-                        } else {
-                            term.split("").join(glob)
-                        }
-                    }
-                };
-
-                sql.fuzzy_condition("command", param, token.is_inverse(), is_glob, is_or);
-                is_or = false;
-            }
-
-            &mut sql
-        };
-
-        for regex in regexes {
-            sql.and_where("command regexp ?".bind(&regex));
-        }
-
-        filter_options
-            .exit
-            .map(|exit| sql.and_where_eq("exit", exit));
-
-        filter_options
-            .exclude_exit
-            .map(|exclude_exit| sql.and_where_ne("exit", exclude_exit));
-
-        filter_options
-            .cwd
-            .map(|cwd| sql.and_where_eq("cwd", quote(cwd)));
-
-        filter_options
-            .exclude_cwd
-            .map(|exclude_cwd| sql.and_where_ne("cwd", quote(exclude_cwd)));
-
-        filter_options.before.map(|before| {
-            interim::parse_date_string(
-                before.as_str(),
-                OffsetDateTime::now_utc(),
-                interim::Dialect::Uk,
-            )
-            .map(|before| {
-                sql.and_where_lt("timestamp", quote(before.unix_timestamp_nanos() as i64))
-            })
-        });
-
-        filter_options.after.map(|after| {
-            interim::parse_date_string(
-                after.as_str(),
-                OffsetDateTime::now_utc(),
-                interim::Dialect::Uk,
-            )
-            .map(|after| sql.and_where_gt("timestamp", quote(after.unix_timestamp_nanos() as i64)))
-        });
-
-        sql.and_where_is_null("deleted_at");
-
-        let query = sql.sql().expect("bug in search query. please report");
-
-        let res = sqlx::query(&query)
-            .map(Self::query_history_inner)
-            .fetch_all(&self.pool)
-            .await?;
-
-        Ok(ordering::reorder_fuzzy(search_mode, orig_query, res))
-    }
-
-    async fn query_history(&self, query: &str) -> Result<Vec<History>> {
-        let res = sqlx::query(query)
-            .map(Self::query_history_inner)
-            .fetch_all(&self.pool)
-            .await?;
-
-        Ok(res)
-    }
-
-    async fn all_with_count(&self) -> Result<Vec<(History, i32)>> {
-        debug!("listing history");
-
-        let mut query = SqlBuilder::select_from(SqlName::new("history").alias("h").baquoted());
-
-        query
-            .fields(&[
-                "id",
-                "max(timestamp) as timestamp",
-                "max(duration) as duration",
-                "exit",
-                "command",
-                "deleted_at",
-                "null as author",
-                "null as intent",
-                "group_concat(cwd, ':') as cwd",
-                "group_concat(session) as session",
-                "group_concat(hostname, ',') as hostname",
-                "count(*) as count",
-            ])
-            .group_by("command")
-            .group_by("exit")
-            .and_where("deleted_at is null")
-            .order_desc("timestamp");
-
-        let query = query.sql().expect("bug in list query. please report");
-
-        let res = sqlx::query(&query)
-            .map(|row: SqliteRow| {
-                let count: i32 = row.get("count");
-                (Self::query_history_inner(row), count)
-            })
-            .fetch_all(&self.pool)
-            .await?;
-
-        Ok(res)
-    }
-
-    fn all_paged(&self, page_size: usize, include_deleted: bool, unique: bool) -> Paged {
-        Paged::new(self.clone(), page_size, include_deleted, unique)
-    }
-
     pub(crate) async fn delete_rows(&self, ids: &[HistoryId]) -> Result<()> {
         let mut tx = self.pool.begin().await?;
 
@@ -538,755 +197,4 @@ impl ClientSqlite {
 
         Ok(())
     }
-
-    async fn stats(&self, h: &History) -> Result<HistoryStats> {
-        // We select the previous in the session by time
-        let mut prev = SqlBuilder::select_from("history");
-        prev.field("*")
-            .and_where("timestamp < ?1")
-            .and_where("session = ?2")
-            .order_by("timestamp", true)
-            .limit(1);
-
-        let mut next = SqlBuilder::select_from("history");
-        next.field("*")
-            .and_where("timestamp > ?1")
-            .and_where("session = ?2")
-            .order_by("timestamp", false)
-            .limit(1);
-
-        let mut total = SqlBuilder::select_from("history");
-        total.field("count(1)").and_where("command = ?1");
-
-        let mut average = SqlBuilder::select_from("history");
-        average.field("avg(duration)").and_where("command = ?1");
-
-        let mut exits = SqlBuilder::select_from("history");
-        exits
-            .fields(&["exit", "count(1) as count"])
-            .and_where("command = ?1")
-            .group_by("exit");
-
-        // rewrite the following with sqlbuilder
-        let mut day_of_week = SqlBuilder::select_from("history");
-        day_of_week
-            .fields(&[
-                "strftime('%w', ROUND(timestamp / 1000000000), 'unixepoch') AS day_of_week",
-                "count(1) as count",
-            ])
-            .and_where("command = ?1")
-            .group_by("day_of_week");
-
-        // Intentionally format the string with 01 hardcoded. We want the average runtime for the
-        // _entire month_, but will later parse it as a datetime for sorting
-        // Sqlite has no datetime so we cannot do it there, and otherwise sorting will just be a
-        // string sort, which won't be correct.
-        let mut duration_over_time = SqlBuilder::select_from("history");
-        duration_over_time
-            .fields(&[
-                "strftime('01-%m-%Y', ROUND(timestamp / 1000000000), 'unixepoch') AS month_year",
-                "avg(duration) as duration",
-            ])
-            .and_where("command = ?1")
-            .group_by("month_year")
-            .having("duration > 0");
-
-        let prev = prev.sql().expect("issue in stats previous query");
-        let next = next.sql().expect("issue in stats next query");
-        let total = total.sql().expect("issue in stats average query");
-        let average = average.sql().expect("issue in stats previous query");
-        let exits = exits.sql().expect("issue in stats exits query");
-        let day_of_week = day_of_week.sql().expect("issue in stats day of week query");
-        let duration_over_time = duration_over_time
-            .sql()
-            .expect("issue in stats duration over time query");
-
-        let prev = sqlx::query(&prev)
-            .bind(h.timestamp.unix_timestamp_nanos() as i64)
-            .bind(&h.session)
-            .map(Self::query_history_inner)
-            .fetch_optional(&self.pool)
-            .await?;
-
-        let next = sqlx::query(&next)
-            .bind(h.timestamp.unix_timestamp_nanos() as i64)
-            .bind(&h.session)
-            .map(Self::query_history_inner)
-            .fetch_optional(&self.pool)
-            .await?;
-
-        let total: (i64,) = sqlx::query_as(&total)
-            .bind(&h.command)
-            .fetch_one(&self.pool)
-            .await?;
-
-        let average: (f64,) = sqlx::query_as(&average)
-            .bind(&h.command)
-            .fetch_one(&self.pool)
-            .await?;
-
-        let exits: Vec<(i64, i64)> = sqlx::query_as(&exits)
-            .bind(&h.command)
-            .fetch_all(&self.pool)
-            .await?;
-
-        let day_of_week: Vec<(String, i64)> = sqlx::query_as(&day_of_week)
-            .bind(&h.command)
-            .fetch_all(&self.pool)
-            .await?;
-
-        let duration_over_time: Vec<(String, f64)> = sqlx::query_as(&duration_over_time)
-            .bind(&h.command)
-            .fetch_all(&self.pool)
-            .await?;
-
-        let duration_over_time = duration_over_time
-            .iter()
-            .map(|f| (f.0.clone(), f.1.round() as i64))
-            .collect();
-
-        Ok(HistoryStats {
-            next,
-            previous: prev,
-            total: total.0 as u64,
-            average_duration: average.0 as u64,
-            exits,
-            day_of_week,
-            duration_over_time,
-        })
-    }
-
-    async fn get_dups(&self, before: i64, dupkeep: u32) -> Result<Vec<History>> {
-        let res = sqlx::query(
-            "SELECT * FROM (
-                SELECT *, ROW_NUMBER()
-                  OVER (PARTITION BY command, cwd, hostname ORDER BY timestamp DESC)
-                  AS rn
-                  FROM history
-                ) sub
-              WHERE rn > ?1 and timestamp < ?2;
-            ",
-        )
-        .bind(dupkeep)
-        .bind(before)
-        .map(Self::query_history_inner)
-        .fetch_all(&self.pool)
-        .await?;
-
-        Ok(res)
-    }
-}
-
-struct Paged {
-    database: ClientSqlite,
-    page_size: usize,
-    last_id: Option<String>,
-    include_deleted: bool,
-    unique: bool,
-}
-
-impl Paged {
-    fn new(database: ClientSqlite, page_size: usize, include_deleted: bool, unique: bool) -> Self {
-        Self {
-            database,
-            page_size,
-            last_id: None,
-            include_deleted,
-            unique,
-        }
-    }
-
-    async fn next(&mut self) -> Result<Option<Vec<History>>> {
-        let mut query = SqlBuilder::select_from(SqlName::new("history").alias("h").baquoted());
-
-        query.field("*").order_desc("id");
-
-        if !self.include_deleted {
-            query.and_where_is_null("deleted_at");
-        }
-
-        if self.unique {
-            // We want to deduplicate on command, but the user can search via cwd, hostname, and session.
-            // Without those fields, filter modes won't work right. With those fields, we get duplicates.
-            // This must be handled upstream.
-            query
-                .group_by("command, cwd, hostname, session")
-                .having("max(timestamp)");
-        }
-
-        query.limit(self.page_size);
-
-        if let Some(last_id) = &self.last_id {
-            query.and_where_lt("id", quote(last_id));
-        }
-
-        let query = query.sql().expect("bug in list query. please report");
-        let res = self.database.query_history(&query).await?;
-
-        if res.is_empty() {
-            Ok(None)
-        } else {
-            self.last_id = Some(res.last().unwrap().id.0.clone());
-            Ok(Some(res))
-        }
-    }
-}
-
-trait SqlBuilderExt {
-    fn fuzzy_condition<S: ToString, T: ToString>(
-        &mut self,
-        field: S,
-        mask: T,
-        inverse: bool,
-        glob: bool,
-        is_or: bool,
-    ) -> &mut Self;
-}
-
-impl SqlBuilderExt for SqlBuilder {
-    /// adapted from the sql-builder *like functions
-    fn fuzzy_condition<S: ToString, T: ToString>(
-        &mut self,
-        field: S,
-        mask: T,
-        inverse: bool,
-        glob: bool,
-        is_or: bool,
-    ) -> &mut Self {
-        let mut cond = field.to_string();
-        if inverse {
-            cond.push_str(" NOT");
-        }
-        if glob {
-            cond.push_str(" GLOB '");
-        } else {
-            cond.push_str(" LIKE '");
-        }
-        cond.push_str(&esc(mask.to_string()));
-        cond.push('\'');
-        if is_or {
-            self.or_where(cond)
-        } else {
-            self.and_where(cond)
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::aclient::settings::test_local_timeout;
-
-    use super::{
-        ClientSqlite, Context, FilterMode, History, OffsetDateTime, OptFilters, Result, SearchMode,
-    };
-    use std::time::{Duration, Instant};
-
-    async fn assert_search_eq(
-        db: &ClientSqlite,
-        mode: SearchMode,
-        filter_mode: FilterMode,
-        query: &str,
-        expected: usize,
-    ) -> Result<Vec<History>> {
-        let context = Context {
-            hostname: "test:host".to_string(),
-            session: "beepboopiamasession".to_string(),
-            cwd: "/home/ellie".to_string(),
-            host_id: "test-host".to_string(),
-            git_root: None,
-        };
-
-        let results = db
-            .search(
-                mode,
-                filter_mode,
-                &context,
-                query,
-                OptFilters {
-                    ..Default::default()
-                },
-            )
-            .await?;
-
-        assert_eq!(
-            results.len(),
-            expected,
-            "query \"{}\", commands: {:?}",
-            query,
-            results.iter().map(|a| &a.command).collect::<Vec<&String>>()
-        );
-        Ok(results)
-    }
-
-    async fn assert_search_commands(
-        db: &ClientSqlite,
-        mode: SearchMode,
-        filter_mode: FilterMode,
-        query: &str,
-        expected_commands: Vec<&str>,
-    ) {
-        let results = assert_search_eq(db, mode, filter_mode, query, expected_commands.len())
-            .await
-            .unwrap();
-        let commands: Vec<&str> = results.iter().map(|a| a.command.as_str()).collect();
-        assert_eq!(commands, expected_commands);
-    }
-
-    async fn new_history_item(db: &mut ClientSqlite, cmd: &str) -> Result<()> {
-        const SESSION: &str = "test";
-        const HOSTNAME: &str = "test.host";
-
-        let mut captured: History = History::daemon()
-            .timestamp(OffsetDateTime::now_utc())
-            .command(cmd)
-            .cwd("/home/ellie")
-            .session(SESSION)
-            .hostname(HOSTNAME)
-            .build()
-            .into();
-
-        captured.exit = 0;
-        captured.duration = 1;
-        captured.session = "beep boop".to_string();
-        captured.hostname = "booop".to_string();
-
-        db.save(&captured).await
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_search_prefix() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-        new_history_item(&mut db, "ls /home/ellie").await.unwrap();
-
-        assert_search_eq(&db, SearchMode::Prefix, FilterMode::Global, "ls", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Prefix, FilterMode::Global, "/home", 0)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Prefix, FilterMode::Global, "ls  ", 0)
-            .await
-            .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_search_fulltext() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-        new_history_item(&mut db, "ls /home/ellie").await.unwrap();
-
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "ls", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "/home", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "ls ho", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "hm", 0)
-            .await
-            .unwrap();
-
-        // regex
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "r/^ls ", 1)
-            .await
-            .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "r/ls / ie$",
-            1,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "r/ls / !ie",
-            0,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "meow r/ls/",
-            0,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "r//hom/", 1)
-            .await
-            .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "r//home//",
-            1,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "r//home///",
-            0,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(&db, SearchMode::FullText, FilterMode::Global, "/home.*e", 0)
-            .await
-            .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::FullText,
-            FilterMode::Global,
-            "r/home.*e",
-            1,
-        )
-        .await
-        .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_search_fuzzy() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-        new_history_item(&mut db, "ls /home/ellie").await.unwrap();
-        new_history_item(&mut db, "ls /home/frank").await.unwrap();
-        new_history_item(&mut db, "cd /home/Ellie").await.unwrap();
-        new_history_item(&mut db, "/home/ellie/.bin/rustup")
-            .await
-            .unwrap();
-
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "ls /", 3)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "ls/", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "l/h/", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "/h/e", 3)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "/hmoe/", 0)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "ellie/home", 0)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "lsellie", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, " ", 4)
-            .await
-            .unwrap();
-
-        // single term operators
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "^ls", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "'ls", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "ellie$", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "!^ls", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "!ellie", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "!ellie$", 2)
-            .await
-            .unwrap();
-
-        // multiple terms
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "ls !ellie", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "^ls !e$", 1)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "home !^ls", 2)
-            .await
-            .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::Fuzzy,
-            FilterMode::Global,
-            "'frank | 'rustup",
-            2,
-        )
-        .await
-        .unwrap();
-        assert_search_eq(
-            &db,
-            SearchMode::Fuzzy,
-            FilterMode::Global,
-            "'frank | 'rustup 'ls",
-            1,
-        )
-        .await
-        .unwrap();
-
-        // case matching
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "Ellie", 1)
-            .await
-            .unwrap();
-
-        // regex
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "r/^ls ", 2)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "r/[Ee]llie", 3)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "/h/e r/^ls ", 1)
-            .await
-            .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_search_reordered_fuzzy() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-        // test ordering of results: we should choose the first, even though it happened longer ago.
-
-        new_history_item(&mut db, "curl").await.unwrap();
-        new_history_item(&mut db, "corburl").await.unwrap();
-
-        // if fuzzy reordering is on, it should come back in a more sensible order
-        assert_search_commands(
-            &db,
-            SearchMode::Fuzzy,
-            FilterMode::Global,
-            "curl",
-            vec!["curl", "corburl"],
-        )
-        .await;
-
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "xxxx", 0)
-            .await
-            .unwrap();
-        assert_search_eq(&db, SearchMode::Fuzzy, FilterMode::Global, "", 2)
-            .await
-            .unwrap();
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    #[expect(clippy::similar_names)]
-    async fn test_paged_basic() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-
-        // Add 5 history items
-        for i in 0..5 {
-            new_history_item(&mut db, &format!("command{}", i))
-                .await
-                .unwrap();
-        }
-
-        // Create a paged iterator with page_size of 2
-        let mut paged = db.all_paged(2, false, false);
-
-        // First page should have 2 items
-        let page1 = paged.next().await.unwrap();
-        assert!(page1.is_some());
-        assert_eq!(page1.unwrap().len(), 2);
-
-        // Second page should have 2 items
-        let page2 = paged.next().await.unwrap();
-        assert!(page2.is_some());
-        assert_eq!(page2.unwrap().len(), 2);
-
-        // Third page should have 1 item
-        let page3 = paged.next().await.unwrap();
-        assert!(page3.is_some());
-        assert_eq!(page3.unwrap().len(), 1);
-
-        // Fourth page should be None (exhausted)
-        let page4 = paged.next().await.unwrap();
-        assert!(page4.is_none());
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_paged_empty() {
-        let db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-
-        // Create a paged iterator on empty database
-        let mut paged = db.all_paged(10, false, false);
-
-        // Should return None immediately
-        let page = paged.next().await.unwrap();
-        assert!(page.is_none());
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_paged_unique() {
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-
-        // Add duplicate commands
-        new_history_item(&mut db, "duplicate").await.unwrap();
-        new_history_item(&mut db, "duplicate").await.unwrap();
-        new_history_item(&mut db, "unique1").await.unwrap();
-        new_history_item(&mut db, "unique2").await.unwrap();
-
-        // Without unique flag - should get all 4
-        let mut paged = db.all_paged(10, false, false);
-        let page = paged.next().await.unwrap().unwrap();
-        assert_eq!(page.len(), 4);
-
-        // With unique flag - should get 3 (duplicates collapsed)
-        let mut paged_unique = db.all_paged(10, false, true);
-        let paged_unique = paged_unique.next().await.unwrap().unwrap();
-        assert_eq!(paged_unique.len(), 3);
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_search_bench_dupes() {
-        let context = Context {
-            hostname: "test:host".to_string(),
-            session: "beepboopiamasession".to_string(),
-            cwd: "/home/ellie".to_string(),
-            host_id: "test-host".to_string(),
-            git_root: None,
-        };
-
-        let mut db = ClientSqlite::new("sqlite::memory:", test_local_timeout())
-            .await
-            .unwrap();
-        for _i in 1..10000 {
-            new_history_item(&mut db, "i am a duplicated command")
-                .await
-                .unwrap();
-        }
-        let start = Instant::now();
-        let _results = db
-            .search(
-                SearchMode::Fuzzy,
-                FilterMode::Global,
-                &context,
-                "",
-                OptFilters {
-                    ..Default::default()
-                },
-            )
-            .await
-            .unwrap();
-        let duration = start.elapsed();
-
-        assert!(duration < Duration::from_secs(15));
-    }
-}
-
-struct QueryTokenizer<'a> {
-    query: &'a str,
-    last_pos: usize,
-}
-
-enum QueryToken<'a> {
-    Match(&'a str, bool),
-    MatchStart(&'a str, bool),
-    MatchEnd(&'a str, bool),
-    MatchFull(&'a str, bool),
-    Or,
-    Regex(&'a str),
-}
-
-impl QueryToken<'_> {
-    fn has_uppercase(&self) -> bool {
-        match self {
-            Self::Match(term, _)
-            | Self::MatchStart(term, _)
-            | Self::MatchEnd(term, _)
-            | Self::MatchFull(term, _) => term.contains(char::is_uppercase),
-            _ => false,
-        }
-    }
-
-    fn is_inverse(&self) -> bool {
-        match self {
-            Self::Match(_, inv)
-            | Self::MatchStart(_, inv)
-            | Self::MatchEnd(_, inv)
-            | Self::MatchFull(_, inv) => *inv,
-            _ => false,
-        }
-    }
-}
-
-impl<'a> QueryTokenizer<'a> {
-    fn new(query: &'a str) -> Self {
-        Self { query, last_pos: 0 }
-    }
-}
-
-impl<'a> Iterator for QueryTokenizer<'a> {
-    type Item = QueryToken<'a>;
-    fn next(&mut self) -> Option<Self::Item> {
-        let remaining = &self.query[self.last_pos..];
-        if remaining.is_empty() {
-            return None;
-        }
-
-        if let Some(remaining) = remaining.strip_prefix("r/") {
-            let (regex, next_pos) = if let Some(end) = remaining.find("/ ") {
-                (&remaining[..end], self.last_pos + 2 + end + 2)
-            } else if let Some(remaining) = remaining.strip_suffix('/') {
-                (remaining, self.query.len())
-            } else {
-                (remaining, self.query.len())
-            };
-            self.last_pos = next_pos;
-            Some(QueryToken::Regex(regex))
-        } else {
-            let (mut part, next_pos) = if let Some(sp) = remaining.find(' ') {
-                (&remaining[..sp], self.last_pos + sp + 1)
-            } else {
-                (remaining, self.query.len())
-            };
-            self.last_pos = next_pos;
-
-            if part == "|" {
-                return Some(QueryToken::Or);
-            }
-
-            let is_inverse = part.strip_prefix('!').is_some_and(|s| {
-                part = s;
-                true
-            });
-
-            #[expect(clippy::option_if_let_else, reason = "It's too ugly")]
-            let token = if let Some(s) = part.strip_prefix('^') {
-                QueryToken::MatchStart(s, is_inverse)
-            } else if let Some(s) = part.strip_suffix('$') {
-                QueryToken::MatchEnd(s, is_inverse)
-            } else if let Some(s) = part.strip_prefix('\'') {
-                QueryToken::MatchFull(s, is_inverse)
-            } else {
-                QueryToken::Match(part, is_inverse)
-            };
-            Some(token)
-        }
-    }
 }
diff --git a/crates/daemon/src/aclient/history/mod.rs b/crates/daemon/src/aclient/history/mod.rs
index f9afa5e9..ae7654a6 100644
--- a/crates/daemon/src/aclient/history/mod.rs
+++ b/crates/daemon/src/aclient/history/mod.rs
@@ -1,4 +1,3 @@
-use regex::RegexSet;
 use rmp::decode::DecodeStringError;
 use rmp::decode::ValueReadError;
 use rmp::{Marker, decode::Bytes};
@@ -18,28 +17,6 @@ const HISTORY_RECORD_VERSION_V0: u16 = 0;
 const HISTORY_RECORD_VERSION_V1: u16 = 1;
 const HISTORY_VERSION: &str = HISTORY_VERSION_V1;
 const HISTORY_TAG: &str = "history";
-const HISTORY_AUTHOR_ENV: &str = "ATUIN_HISTORY_AUTHOR";
-const HISTORY_INTENT_ENV: &str = "ATUIN_HISTORY_INTENT";
-
-#[derive(Debug, Clone, PartialEq, Eq, sqlx::FromRow)]
-pub(crate) struct HistoryStats {
-    /// The command that was ran after this one in the session
-    pub(crate) next: Option<History>,
-
-    /// The command that was ran before this one in the session
-    pub(crate) previous: Option<History>,
-
-    /// How many times has this command been ran?
-    pub(crate) total: u64,
-
-    pub(crate) average_duration: u64,
-
-    pub(crate) exits: Vec<(i64, i64)>,
-
-    pub(crate) day_of_week: Vec<(String, i64)>,
-
-    pub(crate) duration_over_time: Vec<(String, i64)>,
-}
 
 trait HistoryExt: Sized {
     fn serialize(&self) -> Result<DecryptedData>;
@@ -47,7 +24,6 @@ trait HistoryExt: Sized {
     fn deserialize_v0(bytes: &[u8]) -> Result<Self>;
     fn deserialize_v1(bytes: &[u8]) -> Result<Self>;
     fn deserialize(bytes: &[u8], version: &str) -> Result<Self>;
-    fn success(&self) -> bool;
 }
 
 impl HistoryExt for History {
@@ -248,18 +224,6 @@ impl HistoryExt for History {
             _ => bail!("unknown version {version:?}"),
         }
     }
-
-    #[expect(unused)]
-    fn success(&self) -> bool {
-        self.exit == 0 || self.duration == -1
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-struct SettingsFilter<'a> {
-    pub history: &'a RegexSet,
-    pub cwd: &'a RegexSet,
-    pub secrets: bool,
 }
 
 #[cfg(test)]
diff --git a/crates/daemon/src/aclient/history/store.rs b/crates/daemon/src/aclient/history/store.rs
index 244725eb..952f2070 100644
--- a/crates/daemon/src/aclient/history/store.rs
+++ b/crates/daemon/src/aclient/history/store.rs
@@ -1,5 +1,3 @@
-use std::collections::HashSet;
-
 use eyre::{Result, bail, eyre};
 use rmp::decode::Bytes;
 use turtle::history::{History, HistoryId};
@@ -143,58 +141,6 @@ impl HistoryStore {
         Ok((id, idx))
     }
 
-    async fn push_batch(&self, records: impl Iterator<Item = HistoryRecord>) -> Result<()> {
-        let mut ret = Vec::new();
-
-        let idx = self
-            .store
-            .last(self.host_id, HISTORY_TAG)
-            .await?
-            .map_or(0, |p| p.idx + 1);
-
-        // Could probably _also_ do this as an iterator, but let's see how this is for now.
-        // optimizing for minimal sqlite transactions, this code can be optimised later
-        for (n, record) in records.enumerate() {
-            let bytes = record.serialize()?;
-
-            let record = Record::builder()
-                .host(Host::new(self.host_id))
-                .version(HISTORY_VERSION.to_string())
-                .tag(HISTORY_TAG.to_string())
-                .idx(idx + n as u64)
-                .data(bytes)
-                .build();
-
-            let record = record.encrypt::<PASETO_V4>(&self.encryption_key);
-
-            ret.push(record);
-        }
-
-        self.store.push_batch(ret.iter()).await?;
-
-        Ok(())
-    }
-
-    async fn delete(&self, id: HistoryId) -> Result<(RecordId, RecordIdx)> {
-        let record = HistoryRecord::Delete(id);
-
-        self.push_record(record).await
-    }
-
-    /// Delete a batch of history entries via the record store.
-    /// Returns the record IDs so the caller can run `incremental_build` when ready.
-    async fn delete_entries(
-        &self,
-        entries: impl IntoIterator<Item = History>,
-    ) -> Result<Vec<RecordId>> {
-        let mut record_ids = Vec::new();
-        for entry in entries {
-            let (id, _) = self.delete(entry.id).await?;
-            record_ids.push(id);
-        }
-        Ok(record_ids)
-    }
-
     pub(crate) async fn push(&self, history: History) -> Result<(RecordId, RecordIdx)> {
         // TODO(ellie): move the history store to its own file
         // it's tiny rn so fine as is
@@ -203,60 +149,37 @@ impl HistoryStore {
         self.push_record(record).await
     }
 
-    async fn history(&self) -> Result<Vec<HistoryRecord>> {
-        // Atm this loads all history into memory
-        // Not ideal as that is potentially quite a lot, although history will be small.
-        let records = self.store.all_tagged(HISTORY_TAG).await?;
-        let mut ret = Vec::with_capacity(records.len());
-
-        for record in records {
-            let hist = match record.version.as_str() {
-                HISTORY_VERSION_V0 | HISTORY_VERSION => {
-                    let version = record.version.clone();
-                    let decrypted = record.decrypt::<PASETO_V4>(&self.encryption_key)?;
-
-                    HistoryRecord::deserialize(&decrypted.data, version.as_str())
-                }
-                version => bail!("unknown history version {version:?}"),
-            }?;
-
-            ret.push(hist);
-        }
-
-        Ok(ret)
-    }
-
-    async fn build(&self, database: &ClientSqlite) -> Result<()> {
-        // I'd like to change how we rebuild and not couple this with the database, but need to
-        // consider the structure more deeply. This will be easy to change.
-
-        // TODO(ellie): page or iterate this
-        let history = self.history().await?;
-
-        // In theory we could flatten this here
-        // The current issue is that the database may have history in it already, from the old sync
-        // This didn't actually delete old history
-        // If we're sure we have a DB only maintained by the new store, we can flatten
-        // create/delete before we even get to sqlite
-        let mut creates = Vec::new();
-        let mut deletes = Vec::new();
-
-        for i in history {
-            match i {
-                HistoryRecord::Create(h) => {
-                    creates.push(h);
-                }
-                HistoryRecord::Delete(id) => {
-                    deletes.push(id);
-                }
-            }
-        }
-
-        database.save_bulk(&creates).await?;
-        database.delete_rows(&deletes).await?;
-
-        Ok(())
-    }
+    // async fn build(&self, database: &ClientSqlite) -> Result<()> {
+    //     // I'd like to change how we rebuild and not couple this with the database, but need to
+    //     // consider the structure more deeply. This will be easy to change.
+    //
+    //     // TODO(ellie): page or iterate this
+    //     let history = self.history().await?;
+    //
+    //     // In theory we could flatten this here
+    //     // The current issue is that the database may have history in it already, from the old sync
+    //     // This didn't actually delete old history
+    //     // If we're sure we have a DB only maintained by the new store, we can flatten
+    //     // create/delete before we even get to sqlite
+    //     let mut creates = Vec::new();
+    //     let mut deletes = Vec::new();
+    //
+    //     for i in history {
+    //         match i {
+    //             HistoryRecord::Create(h) => {
+    //                 creates.push(h);
+    //             }
+    //             HistoryRecord::Delete(id) => {
+    //                 deletes.push(id);
+    //             }
+    //         }
+    //     }
+    //
+    //     database.save_bulk(&creates).await?;
+    //     database.delete_rows(&deletes).await?;
+    //
+    //     Ok(())
+    // }
 
     pub(crate) async fn incremental_build(
         &self,
@@ -294,74 +217,6 @@ impl HistoryStore {
 
         Ok(())
     }
-
-    /// Get a list of history IDs that exist in the store
-    /// Note: This currently involves loading all history into memory. This is not going to be a
-    /// large amount in absolute terms, but do not all it in a hot loop.
-    async fn history_ids(&self) -> Result<HashSet<HistoryId>> {
-        let history = self.history().await?;
-
-        let ret = history
-            .iter()
-            .map(|h| match h {
-                HistoryRecord::Create(h) => h.id.clone(),
-                HistoryRecord::Delete(id) => id.clone(),
-            })
-            .collect::<HashSet<_>>();
-
-        Ok(ret)
-    }
-
-    async fn init_store(&self, db: &ClientSqlite) -> Result<()> {
-        todo!();
-
-        // let pb = ProgressBar::new_spinner();
-        // pb.set_style(
-        //     ProgressStyle::with_template("{spinner:.blue} {msg}")
-        //         .unwrap()
-        //         .with_key("eta", |state: &ProgressState, w: &mut dyn Write| {
-        //             write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap();
-        //         })
-        //         .progress_chars("#>-"),
-        // );
-        // pb.enable_steady_tick(Duration::from_millis(500));
-        //
-        // pb.set_message("Fetching history from old database");
-        //
-        // let context = current_context().await?;
-        // let history = db.list(&[], &context, None, false, true).await?;
-        //
-        // pb.set_message("Fetching history already in store");
-        // let store_ids = self.history_ids().await?;
-        //
-        // pb.set_message("Converting old history to new store");
-        // let mut records = Vec::new();
-        //
-        // for i in history {
-        //     debug!("loaded {}", i.id);
-        //
-        //     if store_ids.contains(&i.id) {
-        //         debug!("skipping {} - already exists", i.id);
-        //         continue;
-        //     }
-        //
-        //     if i.deleted_at.is_some() {
-        //         records.push(HistoryRecord::Delete(i.id));
-        //     } else {
-        //         records.push(HistoryRecord::Create(i));
-        //     }
-        // }
-        //
-        // pb.set_message("Writing to db");
-        //
-        // if !records.is_empty() {
-        //     self.push_batch(records.into_iter()).await?;
-        // }
-        //
-        // pb.finish_with_message("Import complete");
-
-        Ok(())
-    }
 }
 
 #[cfg(test)]
diff --git a/crates/daemon/src/aclient/mod.rs b/crates/daemon/src/aclient/mod.rs
index fdadb81b..2c445945 100644
--- a/crates/daemon/src/aclient/mod.rs
+++ b/crates/daemon/src/aclient/mod.rs
@@ -6,5 +6,4 @@ pub(crate) mod settings;
 
 mod api_client;
 mod meta;
-mod ordering;
 mod utils;
diff --git a/crates/daemon/src/aclient/ordering.rs b/crates/daemon/src/aclient/ordering.rs
deleted file mode 100644
index 8fa6498e..00000000
--- a/crates/daemon/src/aclient/ordering.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use minspan::minspan;
-use turtle::history::History;
-
-use super::settings::SearchMode;
-
-pub(crate) fn reorder_fuzzy(mode: SearchMode, query: &str, res: Vec<History>) -> Vec<History> {
-    match mode {
-        SearchMode::Fuzzy => reorder(query, |x| &x.command, res),
-        _ => res,
-    }
-}
-
-#[expect(clippy::needless_pass_by_value, reason = "makes things easier")]
-fn reorder<F, A>(query: &str, f: F, res: Vec<A>) -> Vec<A>
-where
-    F: Fn(&A) -> &String,
-    A: Clone,
-{
-    let mut r = res.clone();
-    let qvec = &query.chars().collect();
-    r.sort_by_cached_key(|h| {
-        // TODO for fzf search we should sum up scores for each matched term
-        //
-        // The fallback is a little unfortunate: when we are asked to match a query that is found nowhere,
-        // we don't want to return a None, as the comparison behaviour would put the worst matches
-        // at the front. Therefore, we'll return a set of indices that are one larger than the longest
-        // possible legitimate match. This is meaningless except as a comparison.
-        let (from, to) = minspan::span(qvec, &(f(h).chars().collect())).unwrap_or((0, res.len()));
-        1 + to - from
-    });
-    r
-}
diff --git a/crates/daemon/src/aclient/record/sqlite_store.rs b/crates/daemon/src/aclient/record/sqlite_store.rs
index 2186da54..0026690b 100644
--- a/crates/daemon/src/aclient/record/sqlite_store.rs
+++ b/crates/daemon/src/aclient/record/sqlite_store.rs
@@ -21,8 +21,6 @@ use turtle_common::record::{
 use turtle_common::utils;
 use uuid::Uuid;
 
-use super::encryption::PASETO_V4;
-
 #[derive(Debug, Clone)]
 pub(crate) struct SqliteStore {
     pool: SqlitePool,
@@ -110,15 +108,6 @@ impl SqliteStore {
             },
         }
     }
-
-    async fn load_all(&self) -> Result<Vec<Record<EncryptedData>>> {
-        let res = sqlx::query("select * from store ")
-            .map(Self::query_row)
-            .fetch_all(&self.pool)
-            .await?;
-
-        Ok(res)
-    }
 }
 
 /// A record store stores records
@@ -157,21 +146,6 @@ impl SqliteStore {
         Ok(res)
     }
 
-    async fn delete(&self, id: RecordId) -> Result<()> {
-        sqlx::query("delete from store where id = ?1")
-            .bind(id.0.as_hyphenated().to_string())
-            .execute(&self.pool)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn delete_all(&self) -> Result<()> {
-        sqlx::query("delete from store").execute(&self.pool).await?;
-
-        Ok(())
-    }
-
     pub(crate) async fn last(
         &self,
         host: HostId,
@@ -192,22 +166,6 @@ impl SqliteStore {
         }
     }
 
-    async fn first(&self, host: HostId, tag: &str) -> Result<Option<Record<EncryptedData>>> {
-        self.idx(host, tag, 0).await
-    }
-
-    async fn len_tag(&self, tag: &str) -> Result<u64> {
-        let res: Result<(i64,), sqlx::Error> =
-            sqlx::query_as("select count(*) from store where tag=?1")
-                .bind(tag)
-                .fetch_one(&self.pool)
-                .await;
-        match res {
-            Err(e) => Err(eyre!("failed to fetch local store len: {}", e)),
-            Ok(v) => Ok(v.0 as u64),
-        }
-    }
-
     /// Get the next `limit` records, after and including the given index
     pub(crate) async fn next(
         &self,
@@ -230,28 +188,6 @@ impl SqliteStore {
         Ok(res)
     }
 
-    /// Get the first record for a given host and tag
-    async fn idx(
-        &self,
-        host: HostId,
-        tag: &str,
-        idx: RecordIdx,
-    ) -> Result<Option<Record<EncryptedData>>> {
-        let res = sqlx::query("select * from store where idx = ?1 and host = ?2 and tag = ?3")
-            .bind(idx as i64)
-            .bind(host.0.as_hyphenated().to_string())
-            .bind(tag)
-            .map(Self::query_row)
-            .fetch_one(&self.pool)
-            .await;
-
-        match res {
-            Err(sqlx::Error::RowNotFound) => Ok(None),
-            Err(e) => Err(eyre!("an error occurred: {}", e)),
-            Ok(v) => Ok(Some(v)),
-        }
-    }
-
     pub(crate) async fn status(&self) -> Result<RecordStatus> {
         let mut status = RecordStatus::new();
 
@@ -275,89 +211,6 @@ impl SqliteStore {
 
         Ok(status)
     }
-
-    /// Get all records for a given tag
-    pub(crate) async fn all_tagged(&self, tag: &str) -> Result<Vec<Record<EncryptedData>>> {
-        let res = sqlx::query("select * from store where tag = ?1 order by timestamp asc")
-            .bind(tag)
-            .map(Self::query_row)
-            .fetch_all(&self.pool)
-            .await?;
-
-        Ok(res)
-    }
-
-    /// Reencrypt every single item in this store with a new key
-    /// Be careful - this may mess with sync.
-    async fn re_encrypt(&self, old_key: &[u8; 32], new_key: &[u8; 32]) -> Result<()> {
-        // Load all the records
-        // In memory like some of the other code here
-        // This will never be called in a hot loop, and only under the following circumstances
-        // 1. The user has logged into a new account, with a new key. They are unlikely to have a
-        //    lot of data
-        // 2. The user has encountered some sort of issue, and runs a maintenance command that
-        //    invokes this
-        let all = self.load_all().await?;
-
-        let re_encrypted = all
-            .into_iter()
-            .map(|record| record.re_encrypt::<PASETO_V4>(old_key, new_key))
-            .collect::<Result<Vec<_>>>()?;
-
-        // next up, we delete all the old data and reinsert the new stuff
-        // do it in one transaction, so if anything fails we rollback OK
-
-        let mut tx = self.pool.begin().await?;
-
-        let res = sqlx::query("delete from store").execute(&mut *tx).await?;
-
-        let rows = res.rows_affected();
-        debug!("deleted {rows} rows");
-
-        // don't call push_batch, as it will start its own transaction
-        // call the underlying save_raw
-
-        for record in re_encrypted {
-            Self::save_raw(&mut tx, &record).await?;
-        }
-
-        tx.commit().await?;
-
-        Ok(())
-    }
-
-    /// Verify that every record in this store can be decrypted with the current key
-    /// Someday maybe also check each tag/record can be deserialized, but not for now.
-    async fn verify(&self, key: &[u8; 32]) -> Result<()> {
-        let all = self.load_all().await?;
-
-        all.into_iter()
-            .map(|record| record.decrypt::<PASETO_V4>(key))
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(())
-    }
-
-    /// Verify that every record in this store can be decrypted with the current key
-    /// Someday maybe also check each tag/record can be deserialized, but not for now.
-    async fn purge(&self, key: &[u8; 32]) -> Result<()> {
-        let all = self.load_all().await?;
-
-        for record in &all {
-            if record.clone().decrypt::<PASETO_V4>(key).is_ok() {
-                continue;
-            }
-
-            println!(
-                "Failed to decrypt {}, deleting",
-                record.id.0.as_hyphenated()
-            );
-
-            self.delete(record.id).await?;
-        }
-
-        Ok(())
-    }
 }
 
 #[cfg(test)]
diff --git a/crates/daemon/src/aclient/settings/mod.rs b/crates/daemon/src/aclient/settings/mod.rs
index 10c84f50..ef3f1dd0 100644
--- a/crates/daemon/src/aclient/settings/mod.rs
+++ b/crates/daemon/src/aclient/settings/mod.rs
@@ -1,7 +1,5 @@
 use crypto_secretbox::Key;
-use std::{
-    collections::HashMap, fmt, fs::read_to_string, path::PathBuf, str::FromStr, sync::OnceLock,
-};
+use std::{collections::HashMap, fs::read_to_string, path::PathBuf, sync::OnceLock};
 use tokio::sync::OnceCell;
 use tracing::info;
 use uuid::Uuid;
@@ -11,12 +9,10 @@ use clap::ValueEnum;
 use config::{
     Config, ConfigBuilder, Environment, File as ConfigFile, FileFormat, builder::DefaultState,
 };
-use eyre::{Context, Error, Result, bail, eyre};
+use eyre::{Context, Result, eyre};
 use fs_err::create_dir_all;
-use regex::RegexSet;
 use serde::{Deserialize, Serialize};
-use serde_with::DeserializeFromStr;
-use time::{OffsetDateTime, UtcOffset, format_description::FormatItem, macros::format_description};
+use time::OffsetDateTime;
 use turtle_common::record::HostId;
 use turtle_common::utils;
 
@@ -26,93 +22,6 @@ static META_STORE: OnceCell<crate::aclient::meta::MetaStore> = OnceCell::const_n
 
 mod meta;
 
-#[derive(Clone, Debug, Deserialize, Copy, ValueEnum, PartialEq, Serialize)]
-pub(crate) enum SearchMode {
-    #[serde(rename = "prefix")]
-    Prefix,
-
-    #[serde(rename = "fulltext")]
-    #[clap(aliases = &["fulltext"])]
-    FullText,
-
-    #[serde(rename = "fuzzy")]
-    Fuzzy,
-
-    #[serde(rename = "skim")]
-    Skim,
-
-    #[serde(rename = "daemon-fuzzy")]
-    #[clap(aliases = &["daemon-fuzzy"])]
-    DaemonFuzzy,
-}
-
-impl SearchMode {
-    fn as_str(self) -> &'static str {
-        match self {
-            Self::Prefix => "PREFIX",
-            Self::FullText => "FULLTXT",
-            Self::Fuzzy => "FUZZY",
-            Self::Skim => "SKIM",
-            Self::DaemonFuzzy => "DAEMON",
-        }
-    }
-    fn next(self, settings: &Settings) -> Self {
-        match self {
-            Self::Prefix => Self::FullText,
-            // if the user is using skim, we go to skim
-            Self::FullText if settings.search_mode == Self::Skim => Self::Skim,
-            // if the user is using daemon-fuzzy, we go to daemon-fuzzy
-            Self::FullText if settings.search_mode == Self::DaemonFuzzy => Self::DaemonFuzzy,
-            // otherwise fuzzy.
-            Self::FullText => Self::Fuzzy,
-            Self::Fuzzy | Self::Skim | Self::DaemonFuzzy => Self::Prefix,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Copy, PartialEq, Eq, ValueEnum, Serialize)]
-pub(crate) enum FilterMode {
-    #[serde(rename = "global")]
-    Global = 0,
-
-    #[serde(rename = "host")]
-    Host = 1,
-
-    #[serde(rename = "session")]
-    Session = 2,
-
-    #[serde(rename = "directory")]
-    Directory = 3,
-
-    #[serde(rename = "workspace")]
-    Workspace = 4,
-
-    #[serde(rename = "session-preload")]
-    SessionPreload = 5,
-}
-
-impl FilterMode {
-    fn as_str(self) -> &'static str {
-        match self {
-            Self::Global => "GLOBAL",
-            Self::Host => "HOST",
-            Self::Session => "SESSION",
-            Self::Directory => "DIRECTORY",
-            Self::Workspace => "WORKSPACE",
-            Self::SessionPreload => "SESSION+",
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Copy, Serialize)]
-enum ExitMode {
-    #[serde(rename = "return-original")]
-    ReturnOriginal,
-
-    #[serde(rename = "return-query")]
-    ReturnQuery,
-}
-
 // FIXME: Can use upstream Dialect enum if https://github.com/stevedonovan/chrono-english/pull/16 is merged
 // FIXME: Above PR was merged, but dependency was changed to interim (fork of chrono-english) in the ... interim
 #[derive(Clone, Debug, Deserialize, Copy, Serialize)]
@@ -133,77 +42,6 @@ impl From<Dialect> for interim::Dialect {
     }
 }
 
-/// Type wrapper around `time::UtcOffset` to support a wider variety of timezone formats.
-///
-/// Note that the parsing of this struct needs to be done before starting any
-/// multithreaded runtime, otherwise it will fail on most Unix systems.
-///
-/// See: <https://github.com/atuinsh/atuin/pull/1517#discussion_r1447516426>
-#[derive(Clone, Copy, Debug, Eq, PartialEq, DeserializeFromStr, Serialize)]
-struct Timezone(UtcOffset);
-impl fmt::Display for Timezone {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-/// format: <+|-><hour>[:<minute>[:<second>]]
-static OFFSET_FMT: &[FormatItem<'_>] = format_description!(
-    "[offset_hour sign:mandatory padding:none][optional [:[offset_minute padding:none][optional [:[offset_second padding:none]]]]]"
-);
-impl FromStr for Timezone {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self> {
-        // local timezone
-        if matches!(s.to_lowercase().as_str(), "l" | "local") {
-            // There have been some timezone issues, related to errors fetching it on some
-            // platforms
-            // Rather than fail to start, fallback to UTC. The user should still be able to specify
-            // their timezone manually in the config file.
-            let offset = UtcOffset::current_local_offset().unwrap_or(UtcOffset::UTC);
-            return Ok(Self(offset));
-        }
-
-        if matches!(s.to_lowercase().as_str(), "0" | "utc") {
-            let offset = UtcOffset::UTC;
-            return Ok(Self(offset));
-        }
-
-        // offset from UTC
-        if let Ok(offset) = UtcOffset::parse(s, OFFSET_FMT) {
-            return Ok(Self(offset));
-        }
-
-        // IDEA: Currently named timezones are not supported, because the well-known crate
-        // for this is `chrono_tz`, which is not really interoperable with the datetime crate
-        // that we currently use - `time`. If ever we migrate to using `chrono`, this would
-        // be a good feature to add.
-
-        bail!(r#""{s}" is not a valid timezone spec"#)
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Copy, Serialize)]
-enum Style {
-    #[serde(rename = "auto")]
-    Auto,
-
-    #[serde(rename = "full")]
-    Full,
-
-    #[serde(rename = "compact")]
-    Compact,
-}
-
-#[derive(Clone, Debug, Deserialize, Copy, Serialize)]
-enum WordJumpMode {
-    #[serde(rename = "emacs")]
-    Emacs,
-
-    #[serde(rename = "subl")]
-    Subl,
-}
-
 #[derive(Clone, Debug, Deserialize, Copy, PartialEq, Eq, ValueEnum, Serialize)]
 enum KeymapMode {
     #[serde(rename = "emacs")]
@@ -249,144 +87,6 @@ enum CursorStyle {
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-struct Stats {
-    #[serde(default = "Stats::common_prefix_default")]
-    common_prefix: Vec<String>, // sudo, etc. commands we want to strip off
-    #[serde(default = "Stats::common_subcommands_default")]
-    common_subcommands: Vec<String>, // kubectl, commands we should consider subcommands for
-    #[serde(default = "Stats::ignored_commands_default")]
-    ignored_commands: Vec<String>, // cd, ls, etc. commands we want to completely hide from stats
-}
-
-impl Stats {
-    fn common_prefix_default() -> Vec<String> {
-        vec!["sudo", "doas"].into_iter().map(String::from).collect()
-    }
-
-    fn common_subcommands_default() -> Vec<String> {
-        vec![
-            "apt",
-            "cargo",
-            "composer",
-            "dnf",
-            "docker",
-            "dotnet",
-            "git",
-            "go",
-            "ip",
-            "jj",
-            "kubectl",
-            "nix",
-            "nmcli",
-            "npm",
-            "pecl",
-            "pnpm",
-            "podman",
-            "port",
-            "systemctl",
-            "tmux",
-            "yarn",
-        ]
-        .into_iter()
-        .map(String::from)
-        .collect()
-    }
-
-    fn ignored_commands_default() -> Vec<String> {
-        vec![]
-    }
-}
-
-impl Default for Stats {
-    fn default() -> Self {
-        Self {
-            common_prefix: Self::common_prefix_default(),
-            common_subcommands: Self::common_subcommands_default(),
-            ignored_commands: Self::ignored_commands_default(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Default, Serialize)]
-#[expect(clippy::struct_excessive_bools)]
-struct Keys {
-    scroll_exits: bool,
-    exit_past_line_start: bool,
-    accept_past_line_end: bool,
-    accept_past_line_start: bool,
-    accept_with_backspace: bool,
-    prefix: String,
-}
-
-impl Keys {
-    /// The standard default values for all `[keys]` options.
-    /// These match the config defaults set in `builder_with_data_dir()`.
-    fn standard_defaults() -> Self {
-        Self {
-            scroll_exits: true,
-            exit_past_line_start: true,
-            accept_past_line_end: true,
-            accept_past_line_start: false,
-            accept_with_backspace: false,
-            prefix: "a".to_string(),
-        }
-    }
-}
-
-/// A single rule within a conditional keybinding config.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct KeyRuleConfig {
-    /// Optional condition expression (e.g. "cursor-at-start", "input-empty && no-results").
-    /// If absent, the rule always matches.
-    #[serde(default)]
-    when: Option<String>,
-    /// The action to perform (e.g. "exit", "cursor-left", "accept").
-    action: String,
-}
-
-/// A keybinding config value: either a simple action string or an ordered list of conditional rules.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(untagged)]
-enum KeyBindingConfig {
-    /// Simple unconditional binding: `"ctrl-c" = "return-original"`
-    Simple(String),
-    /// Conditional binding: `"left" = [{ when = "cursor-at-start", action = "exit" }, { action = "cursor-left" }]`
-    Rules(Vec<KeyRuleConfig>),
-}
-
-/// User-facing keymap configuration. Each mode maps key strings to bindings.
-/// Keys present here override the defaults for that key; unmentioned keys keep defaults.
-#[derive(Clone, Debug, Deserialize, Serialize, Default)]
-struct KeymapConfig {
-    #[serde(default)]
-    emacs: HashMap<String, KeyBindingConfig>,
-    #[serde(default, rename = "vim-normal")]
-    vim_normal: HashMap<String, KeyBindingConfig>,
-    #[serde(default, rename = "vim-insert")]
-    vim_insert: HashMap<String, KeyBindingConfig>,
-    #[serde(default)]
-    inspector: HashMap<String, KeyBindingConfig>,
-    #[serde(default)]
-    prefix: HashMap<String, KeyBindingConfig>,
-}
-
-impl KeymapConfig {
-    /// Returns true if no keybinding overrides are configured in any mode.
-    fn is_empty(&self) -> bool {
-        self.emacs.is_empty()
-            && self.vim_normal.is_empty()
-            && self.vim_insert.is_empty()
-            && self.inspector.is_empty()
-            && self.prefix.is_empty()
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct Preview {
-    strategy: PreviewStrategy,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct Daemon {
     /// The daemon will handle sync on an interval. How often to sync, in seconds.
     pub(crate) sync_frequency: u64,
@@ -404,100 +104,6 @@ pub(crate) struct Daemon {
     tcp_port: u64,
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct Search {
-    /// The list of enabled filter modes, in order of priority.
-    filters: Vec<FilterMode>,
-
-    /// The recency score multiplier for the search index (default: 1.0).
-    /// Values < 1.0 reduce weight, > 1.0 increase weight, 0.0 disables.
-    recency_score_multiplier: f64,
-
-    /// The frequency score multiplier for the search index (default: 1.0).
-    /// Values < 1.0 reduce weight, > 1.0 increase weight, 0.0 disables.
-    frequency_score_multiplier: f64,
-
-    /// The overall frecency score multiplier for the search index (default: 1.0).
-    /// Applied after combining recency and frequency scores.
-    frecency_score_multiplier: f64,
-}
-
-/// Log level for file logging. Maps to tracing's [`LevelFilter`].
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-enum LogLevel {
-    Trace,
-    Debug,
-    #[default]
-    Info,
-    Warn,
-    Error,
-}
-
-impl LogLevel {
-    /// Convert to a tracing directive string for use with [`EnvFilter`].
-    fn as_directive(self) -> &'static str {
-        match self {
-            Self::Trace => "trace",
-            Self::Debug => "debug",
-            Self::Info => "info",
-            Self::Warn => "warn",
-            Self::Error => "error",
-        }
-    }
-}
-
-/// Configuration for a specific log type (search or daemon).
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
-struct LogConfig {
-    /// Log file name (relative to dir) or absolute path.
-    file: String,
-
-    /// Override global enabled setting for this log type.
-    enabled: Option<bool>,
-
-    /// Override global level setting for this log type.
-    level: Option<LogLevel>,
-
-    /// Override global retention days setting for this log type.
-    retention: Option<u64>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct Logs {
-    /// Enable file logging globally. Defaults to true.
-    #[serde(default = "Logs::default_enabled")]
-    enabled: bool,
-
-    /// Directory for log files. Defaults to ~/.atuin/logs
-    dir: String,
-
-    /// Default log level for file logging. Defaults to "info".
-    /// Note: [`ATUIN_LOG`] environment variable overrides this.
-    #[serde(default)]
-    level: LogLevel,
-
-    /// Default retention days for log files. Defaults to 4.
-    #[serde(default = "Logs::default_retention")]
-    retention: u64,
-
-    /// Search log settings
-    #[serde(default)]
-    search: LogConfig,
-
-    /// Daemon log settings
-    #[serde(default)]
-    daemon: LogConfig,
-}
-
-impl Default for Preview {
-    fn default() -> Self {
-        Self {
-            strategy: PreviewStrategy::Auto,
-        }
-    }
-}
-
 impl Default for Daemon {
     fn default() -> Self {
         Self {
@@ -510,90 +116,6 @@ impl Default for Daemon {
     }
 }
 
-impl Default for Logs {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            dir: String::new(),
-            level: LogLevel::default(),
-            retention: Self::default_retention(),
-            search: LogConfig {
-                file: "search.log".to_string(),
-                ..Default::default()
-            },
-            daemon: LogConfig {
-                file: "daemon.log".to_string(),
-                ..Default::default()
-            },
-        }
-    }
-}
-
-impl Logs {
-    fn default_enabled() -> bool {
-        true
-    }
-
-    fn default_retention() -> u64 {
-        4
-    }
-
-    /// Returns whether search logging is enabled.
-    /// Uses search-specific setting if set, otherwise falls back to global.
-    fn search_enabled(&self) -> bool {
-        self.search.enabled.unwrap_or(self.enabled)
-    }
-
-    /// Returns whether daemon logging is enabled.
-    /// Uses daemon-specific setting if set, otherwise falls back to global.
-    fn daemon_enabled(&self) -> bool {
-        self.daemon.enabled.unwrap_or(self.enabled)
-    }
-
-    /// Returns the log level for search logging.
-    /// Uses search-specific setting if set, otherwise falls back to global.
-    fn search_level(&self) -> LogLevel {
-        self.search.level.unwrap_or(self.level)
-    }
-
-    /// Returns the log level for daemon logging.
-    /// Uses daemon-specific setting if set, otherwise falls back to global.
-    fn daemon_level(&self) -> LogLevel {
-        self.daemon.level.unwrap_or(self.level)
-    }
-
-    /// Returns the retention days for search logging.
-    /// Uses search-specific setting if set, otherwise falls back to global.
-    fn search_retention(&self) -> u64 {
-        self.search.retention.unwrap_or(self.retention)
-    }
-
-    /// Returns the retention days for daemon logging.
-    /// Uses daemon-specific setting if set, otherwise falls back to global.
-    fn daemon_retention(&self) -> u64 {
-        self.daemon.retention.unwrap_or(self.retention)
-    }
-}
-
-impl Default for Search {
-    fn default() -> Self {
-        Self {
-            filters: vec![
-                FilterMode::Global,
-                FilterMode::Host,
-                FilterMode::Session,
-                FilterMode::SessionPreload,
-                FilterMode::Workspace,
-                FilterMode::Directory,
-            ],
-
-            recency_score_multiplier: 1.0,
-            frequency_score_multiplier: 1.0,
-            frecency_score_multiplier: 1.0,
-        }
-    }
-}
-
 // The preview height strategy also takes max_preview_height into account.
 #[derive(Clone, Debug, Deserialize, Copy, PartialEq, Eq, ValueEnum, Serialize)]
 enum PreviewStrategy {
@@ -610,182 +132,6 @@ enum PreviewStrategy {
     Fixed,
 }
 
-/// Column types available for the interactive search UI.
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "lowercase")]
-enum UiColumnType {
-    /// Command execution duration (e.g., "123ms")
-    Duration,
-    /// Relative time since execution (e.g., "59s ago")
-    Time,
-    /// Absolute timestamp (e.g., "2025-01-22 14:35")
-    Datetime,
-    /// Working directory
-    Directory,
-    /// Hostname
-    Host,
-    /// Username
-    User,
-    /// Exit code
-    Exit,
-    /// The command itself (should be last, expands to fill)
-    Command,
-}
-
-impl UiColumnType {
-    /// Returns the default width for this column type (in characters).
-    /// The Command column returns 0 as it expands to fill remaining space.
-    fn default_width(self) -> u16 {
-        match self {
-            Self::Duration => 5,  // "814ms"
-            Self::Time => 9,      // "459ms ago"
-            Self::Datetime => 16, // "2025-01-22 14:35"
-            Self::Directory => 20,
-            Self::Host => 15,
-            Self::User => 10,
-            Self::Exit => {
-                if cfg!(windows) {
-                    11 // 32-bit integer on Windows: "-1978335212"
-                } else {
-                    3 // Usually a byte on Unix
-                }
-            }
-            Self::Command => 0, // Expands to fill
-        }
-    }
-}
-
-/// A column configuration with type and optional custom width.
-/// Can be specified as just a string (uses default width) or as an object with type and width.
-#[derive(Clone, Debug, Serialize)]
-struct UiColumn {
-    column_type: UiColumnType,
-    width: u16,
-    /// If true, this column expands to fill remaining space. Only one column should expand.
-    expand: bool,
-}
-
-impl UiColumn {
-    fn new(column_type: UiColumnType) -> Self {
-        Self {
-            width: column_type.default_width(),
-            expand: column_type == UiColumnType::Command,
-            column_type,
-        }
-    }
-}
-
-// Custom deserialize to handle both string and object formats:
-// "duration" or { type = "duration", width = 8, expand = true }
-impl<'de> Deserialize<'de> for UiColumn {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        use serde::de::{self, MapAccess, Visitor};
-
-        struct UiColumnVisitor;
-
-        impl<'de> Visitor<'de> for UiColumnVisitor {
-            type Value = UiColumn;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str(
-                    "a column type string or an object with 'type' and optional 'width'/'expand'",
-                )
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<UiColumn, E>
-            where
-                E: de::Error,
-            {
-                let column_type: UiColumnType =
-                    Deserialize::deserialize(de::value::StrDeserializer::new(value))?;
-                Ok(UiColumn::new(column_type))
-            }
-
-            fn visit_map<M>(self, mut map: M) -> Result<UiColumn, M::Error>
-            where
-                M: MapAccess<'de>,
-            {
-                let mut column_type: Option<UiColumnType> = None;
-                let mut width: Option<u16> = None;
-                let mut expand: Option<bool> = None;
-
-                while let Some(key) = map.next_key::<String>()? {
-                    match key.as_str() {
-                        "type" => {
-                            column_type = Some(map.next_value()?);
-                        }
-                        "width" => {
-                            width = Some(map.next_value()?);
-                        }
-                        "expand" => {
-                            expand = Some(map.next_value()?);
-                        }
-                        _ => {
-                            let _: de::IgnoredAny = map.next_value()?;
-                        }
-                    }
-                }
-
-                let column_type = column_type.ok_or_else(|| de::Error::missing_field("type"))?;
-                let width = width.unwrap_or_else(|| column_type.default_width());
-                let expand = expand.unwrap_or(column_type == UiColumnType::Command);
-                Ok(UiColumn {
-                    column_type,
-                    width,
-                    expand,
-                })
-            }
-        }
-
-        deserializer.deserialize_any(UiColumnVisitor)
-    }
-}
-
-/// UI-specific settings for the interactive search.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-struct Ui {
-    /// Columns to display in interactive search, from left to right.
-    /// The indicator column (" > ") is always shown first implicitly.
-    /// The "command" column should be last as it expands to fill remaining space.
-    /// Can be simple strings or objects with type and width.
-    #[serde(default = "Ui::default_columns")]
-    columns: Vec<UiColumn>,
-}
-
-impl Ui {
-    fn default_columns() -> Vec<UiColumn> {
-        vec![
-            UiColumn::new(UiColumnType::Duration),
-            UiColumn::new(UiColumnType::Time),
-            UiColumn::new(UiColumnType::Command),
-        ]
-    }
-
-    /// Validate the UI configuration.
-    /// Returns an error if more than one column has expand = true.
-    fn validate(&self) -> Result<()> {
-        let expand_count = self.columns.iter().filter(|c| c.expand).count();
-        if expand_count > 1 {
-            bail!(
-                "Only one column can have expand = true, but {} columns are set to expand",
-                expand_count
-            );
-        }
-        Ok(())
-    }
-}
-
-impl Default for Ui {
-    fn default() -> Self {
-        Self {
-            columns: Self::default_columns(),
-        }
-    }
-}
-
 /// Sync-specific settings.
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub(crate) struct Sync {
@@ -851,87 +197,21 @@ impl Sync {
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-#[expect(clippy::struct_excessive_bools)]
 pub(crate) struct Settings {
-    data_dir: Option<String>,
-    dialect: Dialect,
-    timezone: Timezone,
-    style: Style,
-
     pub(crate) db_path: String,
     pub(crate) record_store_path: String,
-    search_mode: SearchMode,
-    filter_mode: Option<FilterMode>,
-    filter_mode_shell_up_key_binding: Option<FilterMode>,
-    search_mode_shell_up_key_binding: Option<SearchMode>,
-    shell_up_key_binding: bool,
-    inline_height: u16,
-    inline_height_shell_up_key_binding: Option<u16>,
-    invert: bool,
-    show_preview: bool,
-    max_preview_height: u16,
-    show_help: bool,
-    show_tabs: bool,
-    show_numeric_shortcuts: bool,
-    auto_hide_height: u16,
-    exit_mode: ExitMode,
-    keymap_mode: KeymapMode,
-    keymap_mode_shell: KeymapMode,
-    keymap_cursor: HashMap<String, CursorStyle>,
-    word_jump_mode: WordJumpMode,
-    word_chars: String,
-    scroll_context_lines: usize,
-    history_format: String,
-    strip_trailing_whitespace: bool,
-    prefers_reduced_motion: bool,
-    store_failed: bool,
-    no_mouse: bool,
-
-    #[serde(with = "serde_regex", default = "RegexSet::empty", skip_serializing)]
-    history_filter: RegexSet,
-
-    #[serde(with = "serde_regex", default = "RegexSet::empty", skip_serializing)]
-    cwd_filter: RegexSet,
-
-    secrets_filter: bool,
-    workspaces: bool,
-    ctrl_n_shortcuts: bool,
 
     pub(crate) network_connect_timeout: u64,
     pub(crate) network_timeout: u64,
     pub(crate) local_timeout: f64,
-    enter_accept: bool,
-    smart_sort: bool,
-    command_chaining: bool,
 
     #[serde(default)]
     pub(crate) sync: Sync,
 
     #[serde(default)]
-    stats: Stats,
-
-    #[serde(default)]
-    keys: Keys,
-
-    #[serde(default)]
-    keymap: KeymapConfig,
-
-    #[serde(default)]
-    preview: Preview,
-
-    #[serde(default)]
     pub(crate) daemon: Daemon,
 
     #[serde(default)]
-    search: Search,
-
-    #[serde(default)]
-    ui: Ui,
-
-    #[serde(default)]
-    logs: Logs,
-
-    #[serde(default)]
     meta: meta::Settings,
 }
 
@@ -961,23 +241,6 @@ impl Settings {
         Self::meta_store().await?.save_sync_time().await
     }
 
-    fn default_filter_mode(&self, git_root: bool) -> FilterMode {
-        self.filter_mode
-            .filter(|x| self.search.filters.contains(x))
-            .or_else(|| {
-                self.search
-                    .filters
-                    .iter()
-                    .find(|x| match (x, git_root, self.workspaces) {
-                        (FilterMode::Workspace, true, true) => true,
-                        (FilterMode::Workspace, _, _) => false,
-                        (_, _, _) => true,
-                    })
-                    .copied()
-            })
-            .unwrap_or(FilterMode::Global)
-    }
-
     fn builder() -> Result<ConfigBuilder<DefaultState>> {
         Self::builder_with_data_dir(&utils::data_dir())
     }
@@ -1224,79 +487,12 @@ impl Settings {
         config_builder.build().map_err(Into::into)
     }
 
-    /// Look up a single config value by dotted key (e.g. `"daemon.sync_frequency"`).
-    ///
-    /// Returns the effective value after merging defaults, config file, and
-    /// environment — without the side-effects of full `Settings` construction
-    /// (meta store init, path expansion, etc.).
-    fn get_config_value(key: &str) -> Result<String> {
-        let config = Self::build_config()?;
-        let value: config::Value = config
-            .get(key)
-            .map_err(|e| eyre!("failed to get config value '{}': {}", key, e))?;
-        Ok(Self::format_resolved_value(&value, key))
-    }
-
-    fn format_resolved_value(value: &config::Value, prefix: &str) -> String {
-        use config::ValueKind;
-
-        match &value.kind {
-            ValueKind::Nil => String::new(),
-            ValueKind::Boolean(b) => b.to_string(),
-            ValueKind::I64(i) => i.to_string(),
-            ValueKind::I128(i) => i.to_string(),
-            ValueKind::U64(u) => u.to_string(),
-            ValueKind::U128(u) => u.to_string(),
-            ValueKind::Float(f) => f.to_string(),
-            ValueKind::String(s) => s.clone(),
-            ValueKind::Array(arr) => {
-                let items: Vec<String> = arr
-                    .iter()
-                    .map(|v| Self::format_resolved_value(v, ""))
-                    .collect();
-                format!("[{}]", items.join(", "))
-            }
-            ValueKind::Table(map) => {
-                let mut lines = Vec::new();
-                let mut keys: Vec<_> = map.keys().collect();
-                keys.sort();
-
-                for k in keys {
-                    let v = &map[k];
-                    let full_key = if prefix.is_empty() {
-                        k.clone()
-                    } else {
-                        format!("{prefix}.{k}")
-                    };
-
-                    match &v.kind {
-                        ValueKind::Table(_) => {
-                            lines.push(Self::format_resolved_value(v, &full_key));
-                        }
-                        _ => {
-                            lines.push(format!(
-                                "{} = {}",
-                                full_key,
-                                Self::format_resolved_value(v, "")
-                            ));
-                        }
-                    }
-                }
-
-                lines.join("\n")
-            }
-        }
-    }
-
     pub(crate) fn new() -> Result<Self> {
         let config = Self::build_config()?;
         let settings: Self = config
             .try_deserialize()
             .map_err(|e| eyre!("failed to deserialize: {}", e))?;
 
-        // Validate UI settings
-        settings.ui.validate()?;
-
         // Register meta store config for lazy initialization on first access
         META_CONFIG
             .set((settings.meta.db_path.clone(), settings.local_timeout))
@@ -1311,9 +507,21 @@ impl Settings {
             .map_err(|e| eyre!("failed to expand path: {}", e))
     }
 
-    fn paths_ok(&self) -> bool {
-        // TODO(@bpeetz): Add the `sync.*` paths <2026-06-11>
-        let paths = [&self.db_path, &self.record_store_path, &self.meta.db_path];
+    pub(crate) fn paths_ok(&self) -> bool {
+        let mut paths: Vec<&str> = vec![
+            &self.db_path,
+            &self.record_store_path,
+            &self.meta.db_path,
+            &self.daemon.socket_path,
+        ];
+
+        if let Some(path) = &self.sync.encryption_key_path {
+            paths.push(path.to_str().unwrap());
+        }
+        if let Some(path) = &self.sync.user_id_path {
+            paths.push(path.to_str().unwrap());
+        }
+
         paths.iter().all(|p| !utils::broken_symlink(p))
     }
 }
@@ -1343,96 +551,8 @@ pub(crate) fn test_local_timeout() -> f64 {
 
 #[cfg(test)]
 mod tests {
-    use std::str::FromStr;
-
     use eyre::Result;
 
-    use super::Timezone;
-
-    #[test]
-    fn can_parse_offset_timezone_spec() -> Result<()> {
-        assert_eq!(Timezone::from_str("+02")?.0.as_hms(), (2, 0, 0));
-        assert_eq!(Timezone::from_str("-04")?.0.as_hms(), (-4, 0, 0));
-        assert_eq!(Timezone::from_str("+05:30")?.0.as_hms(), (5, 30, 0));
-        assert_eq!(Timezone::from_str("-09:30")?.0.as_hms(), (-9, -30, 0));
-
-        // single digit hours are allowed
-        assert_eq!(Timezone::from_str("+2")?.0.as_hms(), (2, 0, 0));
-        assert_eq!(Timezone::from_str("-4")?.0.as_hms(), (-4, 0, 0));
-        assert_eq!(Timezone::from_str("+5:30")?.0.as_hms(), (5, 30, 0));
-        assert_eq!(Timezone::from_str("-9:30")?.0.as_hms(), (-9, -30, 0));
-
-        // fully qualified form
-        assert_eq!(Timezone::from_str("+09:30:00")?.0.as_hms(), (9, 30, 0));
-        assert_eq!(Timezone::from_str("-09:30:00")?.0.as_hms(), (-9, -30, 0));
-
-        // these offsets don't really exist but are supported anyway
-        assert_eq!(Timezone::from_str("+0:5")?.0.as_hms(), (0, 5, 0));
-        assert_eq!(Timezone::from_str("-0:5")?.0.as_hms(), (0, -5, 0));
-        assert_eq!(Timezone::from_str("+01:23:45")?.0.as_hms(), (1, 23, 45));
-        assert_eq!(Timezone::from_str("-01:23:45")?.0.as_hms(), (-1, -23, -45));
-
-        // require a leading sign for clarity
-        assert!(Timezone::from_str("5").is_err());
-        assert!(Timezone::from_str("10:30").is_err());
-
-        Ok(())
-    }
-
-    #[test]
-    fn can_choose_workspace_filters_when_in_git_context() -> Result<()> {
-        let mut settings = super::Settings::default();
-        settings.search.filters = vec![
-            super::FilterMode::Workspace,
-            super::FilterMode::Host,
-            super::FilterMode::Directory,
-            super::FilterMode::Session,
-            super::FilterMode::Global,
-        ];
-        settings.workspaces = true;
-
-        assert_eq!(
-            settings.default_filter_mode(true),
-            super::FilterMode::Workspace,
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn wont_choose_workspace_filters_when_not_in_git_context() -> Result<()> {
-        let mut settings = super::Settings::default();
-        settings.search.filters = vec![
-            super::FilterMode::Workspace,
-            super::FilterMode::Host,
-            super::FilterMode::Directory,
-            super::FilterMode::Session,
-            super::FilterMode::Global,
-        ];
-        settings.workspaces = true;
-
-        assert_eq!(settings.default_filter_mode(false), super::FilterMode::Host,);
-
-        Ok(())
-    }
-
-    #[test]
-    fn wont_choose_workspace_filters_when_workspaces_disabled() -> Result<()> {
-        let mut settings = super::Settings::default();
-        settings.search.filters = vec![
-            super::FilterMode::Workspace,
-            super::FilterMode::Host,
-            super::FilterMode::Directory,
-            super::FilterMode::Session,
-            super::FilterMode::Global,
-        ];
-        settings.workspaces = false;
-
-        assert_eq!(settings.default_filter_mode(true), super::FilterMode::Host,);
-
-        Ok(())
-    }
-
     #[test]
     fn builder_with_data_dir_uses_custom_paths() -> Result<()> {
         use std::path::PathBuf;
@@ -1476,68 +596,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[test]
-    fn keymap_config_deserializes_simple_binding() {
-        let json = r#"{"emacs": {"ctrl-c": "exit"}}"#;
-        let config: super::KeymapConfig = serde_json::from_str(json).unwrap();
-        assert_eq!(config.emacs.len(), 1);
-        match &config.emacs["ctrl-c"] {
-            super::KeyBindingConfig::Simple(s) => assert_eq!(s, "exit"),
-            _ => panic!("expected Simple variant"),
-        }
-    }
-
-    #[test]
-    fn keymap_config_deserializes_conditional_binding() {
-        let json = r#"{
-            "emacs": {
-                "left": [
-                    {"when": "cursor-at-start", "action": "exit"},
-                    {"action": "cursor-left"}
-                ]
-            }
-        }"#;
-        let config: super::KeymapConfig = serde_json::from_str(json).unwrap();
-        match &config.emacs["left"] {
-            super::KeyBindingConfig::Rules(rules) => {
-                assert_eq!(rules.len(), 2);
-                assert_eq!(rules[0].when.as_deref(), Some("cursor-at-start"));
-                assert_eq!(rules[0].action, "exit");
-                assert!(rules[1].when.is_none());
-                assert_eq!(rules[1].action, "cursor-left");
-            }
-            _ => panic!("expected Rules variant"),
-        }
-    }
-
-    #[test]
-    fn keymap_config_deserializes_vim_normal() {
-        let json = r#"{"vim-normal": {"j": "select-next", "k": "select-previous"}}"#;
-        let config: super::KeymapConfig = serde_json::from_str(json).unwrap();
-        assert_eq!(config.vim_normal.len(), 2);
-        assert!(config.emacs.is_empty());
-    }
-
-    #[test]
-    fn keymap_config_is_empty_when_default() {
-        let config = super::KeymapConfig::default();
-        assert!(config.is_empty());
-    }
-
-    #[test]
-    fn keymap_config_mixed_modes() {
-        let json = r#"{
-            "emacs": {"ctrl-c": "exit"},
-            "vim-normal": {"q": "exit"},
-            "inspector": {"d": "delete"}
-        }"#;
-        let config: super::KeymapConfig = serde_json::from_str(json).unwrap();
-        assert!(!config.is_empty());
-        assert_eq!(config.emacs.len(), 1);
-        assert_eq!(config.vim_normal.len(), 1);
-        assert_eq!(config.inspector.len(), 1);
-        assert!(config.vim_insert.is_empty());
-        assert!(config.prefix.is_empty());
-    }
 }
diff --git a/crates/daemon/src/api/control.rs b/crates/daemon/src/api/control.rs
index 94fb7ce9..ff19f593 100644
--- a/crates/daemon/src/api/control.rs
+++ b/crates/daemon/src/api/control.rs
@@ -37,18 +37,14 @@ enum SyncState {
 /// It's not a component - it's part of the daemon's core infrastructure.
 pub(crate) struct ControlService {
     handle: DaemonHandle,
-    task_handle: tokio::task::JoinHandle<()>,
 }
 
 impl ControlService {
     /// Create a new control service with the given daemon handle.
     pub(crate) fn new(handle: DaemonHandle) -> Self {
-        let task_handle = tokio::spawn(sync_loop(handle.clone()));
+        tokio::spawn(sync_loop(handle.clone()));
 
-        Self {
-            handle,
-            task_handle,
-        }
+        Self { handle }
     }
 
     /// Get a tonic server for this service.
diff --git a/crates/daemon/src/api/history.rs b/crates/daemon/src/api/history.rs
index d024ea92..6165464d 100644
--- a/crates/daemon/src/api/history.rs
+++ b/crates/daemon/src/api/history.rs
@@ -90,10 +90,7 @@ impl HistorySvc for HistoryService {
 
             self.handle.history_db().range(from, to).await
         } else {
-            self.handle
-                .history_db()
-                .list(None, None, false, false)
-                .await
+            self.handle.history_db().list(None, false, false).await
         }
         .map_err(|e| Status::internal(format!("failed to read db: {e:?}")))?
         .into_iter()
diff --git a/crates/daemon/src/main.rs b/crates/daemon/src/main.rs
index 1d94b5fa..9d5a5333 100644
--- a/crates/daemon/src/main.rs
+++ b/crates/daemon/src/main.rs
@@ -1,4 +1,8 @@
-#![expect(unused_crate_dependencies)]
+#![expect(
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss
+)]
 
 use std::{
     fs::{self, File, OpenOptions},
@@ -44,6 +48,10 @@ async fn main() -> Result<()> {
     }
 
     let settings = Settings::new().wrap_err("could not load client settings")?;
+    if !settings.paths_ok() {
+        bail!("Failed to verify all paths :(");
+    }
+
     let db_path = PathBuf::from(settings.db_path.as_str());
     let record_store_path = PathBuf::from(settings.record_store_path.as_str());