chore: Move everything into one big crate

That helps remove duplicated code and rustc/cargo will now also show dead code correctly.
author: Benedikt Peetz <benedikt.peetz@b-peetz.de> 2026-06-11 00:54:30 +0200
committer: Benedikt Peetz <benedikt.peetz@b-peetz.de> 2026-06-11 00:54:30 +0200
commit: 5c39e7cf284a1f6e9a1657f2deb44e359fc47eb8 (patch)
tree: c64baa8d5866c8e339eaf660dd3f94f30a3f7d8a /crates/turtle/src
parent: chore: Somewhat simplify sync code (diff)
download: atuin-5c39e7cf284a1f6e9a1657f2deb44e359fc47eb8.zip
158 files changed, 483 insertions, 636 deletions
diff --git a/crates/atuin-client/src/api_client.rs b/crates/turtle/src/atuin_client/api_client.rs
index ca2fc661..7955c2da 100644
--- a/crates/atuin-client/src/api_client.rs
+++ b/crates/turtle/src/atuin_client/api_client.rs
@@ -7,13 +7,14 @@ use reqwest::{
     Response, StatusCode, Url,
     header::{AUTHORIZATION, HeaderMap, USER_AGENT},
 };
+use tracing::debug;
 
-use atuin_common::{
+use crate::atuin_common::{
     api::{ATUIN_CARGO_VERSION, ATUIN_HEADER_VERSION, ATUIN_VERSION},
     record::{EncryptedData, HostId, Record, RecordIdx},
     tls::ensure_crypto_provider,
 };
-use atuin_common::{
+use crate::atuin_common::{
     api::{
         AddHistoryRequest, ChangePasswordRequest, CountResponse, DeleteHistoryRequest,
         ErrorResponse, LoginRequest, LoginResponse, MeResponse, RegisterResponse, StatusResponse,
@@ -26,7 +27,7 @@ use semver::Version;
 use time::OffsetDateTime;
 use time::format_description::well_known::Rfc3339;
 
-use crate::{history::History, sync::hash_str, utils::get_host_user};
+use crate::atuin_client::{history::History, sync::hash_str, utils::get_host_user};
 
 static APP_USER_AGENT: &str = concat!("atuin/", env!("CARGO_PKG_VERSION"),);
 
diff --git a/crates/atuin-client/src/auth.rs b/crates/turtle/src/atuin_client/auth.rs
index 1031c11f..b770c488 100644
--- a/crates/atuin-client/src/auth.rs
+++ b/crates/turtle/src/atuin_client/auth.rs
@@ -2,12 +2,15 @@ use async_trait::async_trait;
 use eyre::{Context, Result, bail};
 use reqwest::{Url, header::USER_AGENT};
 
-use atuin_common::{
-    api::{ATUIN_CARGO_VERSION, ATUIN_HEADER_VERSION, ChangePasswordRequest, LoginRequest},
-    tls::ensure_crypto_provider,
+use crate::{
+    atuin_client::api_client,
+    atuin_common::{
+        api::{ATUIN_CARGO_VERSION, ATUIN_HEADER_VERSION, ChangePasswordRequest, LoginRequest},
+        tls::ensure_crypto_provider,
+    },
 };
 
-use crate::settings::Settings;
+use crate::atuin_client::settings::Settings;
 
 static APP_USER_AGENT: &str = concat!("atuin/", env!("CARGO_PKG_VERSION"));
 
@@ -42,12 +45,7 @@ pub enum MutateResponse {
 #[async_trait]
 pub trait AuthClient: Send + Sync {
     /// Log in with username + password, optionally providing a TOTP code.
-    async fn login(
-        &self,
-        username: &str,
-        password: &str,
-        totp_code: Option<&str>,
-    ) -> Result<AuthResponse>;
+    async fn login(&self, username: &str, password: &str) -> Result<AuthResponse>;
 
     /// Register a new account.
     async fn register(&self, username: &str, email: &str, password: &str) -> Result<AuthResponse>;
@@ -129,14 +127,9 @@ impl LegacyAuthClient {
 
 #[async_trait]
 impl AuthClient for LegacyAuthClient {
-    async fn login(
-        &self,
-        username: &str,
-        password: &str,
-        _totp_code: Option<&str>,
-    ) -> Result<AuthResponse> {
+    async fn login(&self, username: &str, password: &str) -> Result<AuthResponse> {
         // The legacy server has no 2FA support; totp_code is ignored.
-        let resp = crate::api_client::login(
+        let resp = api_client::login(
             &self.address,
             LoginRequest {
                 username: username.to_string(),
@@ -152,7 +145,7 @@ impl AuthClient for LegacyAuthClient {
     }
 
     async fn register(&self, username: &str, email: &str, password: &str) -> Result<AuthResponse> {
-        let resp = crate::api_client::register(&self.address, username, email, password).await?;
+        let resp = api_client::register(&self.address, username, email, password).await?;
         Ok(AuthResponse::Success {
             session: resp.session,
             auth_type: resp.auth.or(Some("cli".into())),
diff --git a/crates/atuin-client/src/database.rs b/crates/turtle/src/atuin_client/database.rs
index 946c1eb0..75b1200c 100644
--- a/crates/atuin-client/src/database.rs
+++ b/crates/turtle/src/atuin_client/database.rs
@@ -5,9 +5,9 @@ use std::{
     time::Duration,
 };
 
-use crate::history::{AUTHOR_FILTER_ALL_AGENT, AUTHOR_FILTER_ALL_USER, KNOWN_AGENTS};
+use crate::atuin_client::history::{AUTHOR_FILTER_ALL_AGENT, AUTHOR_FILTER_ALL_USER, KNOWN_AGENTS};
+use crate::atuin_common::utils;
 use async_trait::async_trait;
-use atuin_common::utils;
 use fs_err as fs;
 use itertools::Itertools;
 use rand::{Rng, distributions::Alphanumeric};
@@ -20,9 +20,10 @@ use sqlx::{
     },
 };
 use time::OffsetDateTime;
+use tracing::debug;
 use uuid::Uuid;
 
-use crate::{
+use crate::atuin_client::{
     history::{HistoryId, HistoryStats},
     utils::get_host_user,
 };
@@ -969,7 +970,7 @@ impl SqlBuilderExt for SqlBuilder {
 
 #[cfg(test)]
 mod test {
-    use crate::settings::test_local_timeout;
+    use crate::atuin_client::settings::test_local_timeout;
 
     use super::*;
     use std::time::{Duration, Instant};
diff --git a/crates/atuin-client/src/distro.rs b/crates/turtle/src/atuin_client/distro.rs
index dead8355..dead8355 100644
--- a/crates/atuin-client/src/distro.rs
+++ b/crates/turtle/src/atuin_client/distro.rs
diff --git a/crates/atuin-client/src/encryption.rs b/crates/turtle/src/atuin_client/encryption.rs
index f2032482..20a0cd90 100644
--- a/crates/atuin-client/src/encryption.rs
+++ b/crates/turtle/src/atuin_client/encryption.rs
@@ -22,7 +22,7 @@ use rmp::{Marker, decode::Bytes};
 use serde::{Deserialize, Serialize};
 use time::{OffsetDateTime, format_description::well_known::Rfc3339, macros::format_description};
 
-use crate::{history::History, settings::Settings};
+use crate::atuin_client::{history::History, settings::Settings};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct EncryptedHistory {
diff --git a/crates/atuin-client/src/history.rs b/crates/turtle/src/atuin_client/history.rs
index aa0d84d5..cef65115 100644
--- a/crates/atuin-client/src/history.rs
+++ b/crates/turtle/src/atuin_client/history.rs
@@ -5,14 +5,14 @@ use rmp::{Marker, decode::Bytes};
 use std::env;
 use std::fmt::Display;
 
-use atuin_common::record::DecryptedData;
-use atuin_common::utils::uuid_v7;
+use crate::atuin_common::record::DecryptedData;
+use crate::atuin_common::utils::uuid_v7;
 
 use eyre::{Result, bail, eyre};
 
-use crate::secrets::SECRET_PATTERNS_RE;
-use crate::settings::Settings;
-use crate::utils::get_host_user;
+use crate::atuin_client::secrets::SECRET_PATTERNS_RE;
+use crate::atuin_client::settings::Settings;
+use crate::atuin_client::utils::get_host_user;
 use time::OffsetDateTime;
 
 mod builder;
@@ -381,7 +381,7 @@ impl History {
     ///
     /// ## Examples
     /// ```
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// let history: History = History::import()
     ///     .timestamp(time::OffsetDateTime::now_utc())
@@ -392,7 +392,7 @@ impl History {
     ///
     /// If shell history contains more information, it can be added to the builder:
     /// ```
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// let history: History = History::import()
     ///     .timestamp(time::OffsetDateTime::now_utc())
@@ -408,7 +408,7 @@ impl History {
     /// is forced at compile time:
     ///
     /// ```compile_fail
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// // this will not compile because timestamp is missing
     /// let history: History = History::import()
@@ -428,7 +428,7 @@ impl History {
     ///
     /// ## Examples
     /// ```rust
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// let history: History = History::capture()
     ///     .timestamp(time::OffsetDateTime::now_utc())
@@ -441,7 +441,7 @@ impl History {
     /// Command without any required info cannot be captured, which is forced at compile time:
     ///
     /// ```compile_fail
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// // this will not compile because `cwd` is missing
     /// let history: History = History::capture()
@@ -466,7 +466,7 @@ impl History {
     ///
     /// ## Examples
     /// ```rust
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// let history: History = History::daemon()
     ///     .timestamp(time::OffsetDateTime::now_utc())
@@ -481,7 +481,7 @@ impl History {
     /// Command without any required info cannot be captured, which is forced at compile time:
     ///
     /// ```compile_fail
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// // this will not compile because `hostname` is missing
     /// let history: History = History::daemon()
@@ -501,7 +501,7 @@ impl History {
     /// All fields are required, as they are all present in the database.
     ///
     /// ```compile_fail
-    /// use atuin_client::history::History;
+    /// use crate::atuin_client::history::History;
     ///
     /// // this will not compile because `id` field is missing
     /// let history: History = History::from_db()
diff --git a/crates/atuin-client/src/history/builder.rs b/crates/turtle/src/atuin_client/history/builder.rs
index 72a505fd..72a505fd 100644
--- a/crates/atuin-client/src/history/builder.rs
+++ b/crates/turtle/src/atuin_client/history/builder.rs
diff --git a/crates/atuin-client/src/history/store.rs b/crates/turtle/src/atuin_client/history/store.rs
index ce7b43a1..66d9db47 100644
--- a/crates/atuin-client/src/history/store.rs
+++ b/crates/turtle/src/atuin_client/history/store.rs
@@ -3,12 +3,13 @@ use std::{collections::HashSet, fmt::Write, time::Duration};
 use eyre::{Result, bail, eyre};
 use indicatif::{ProgressBar, ProgressState, ProgressStyle};
 use rmp::decode::Bytes;
+use tracing::debug;
 
-use crate::{
+use crate::atuin_client::{
     database::{Database, current_context},
     record::{encryption::PASETO_V4, sqlite_store::SqliteStore, store::Store},
 };
-use atuin_common::record::{DecryptedData, Host, HostId, Record, RecordId, RecordIdx};
+use crate::atuin_common::record::{DecryptedData, Host, HostId, Record, RecordId, RecordIdx};
 
 use super::{HISTORY_TAG, HISTORY_VERSION, HISTORY_VERSION_V0, History, HistoryId};
 
@@ -361,10 +362,10 @@ impl HistoryStore {
 
 #[cfg(test)]
 mod tests {
-    use atuin_common::record::DecryptedData;
+    use crate::atuin_common::record::DecryptedData;
     use time::macros::datetime;
 
-    use crate::history::{HISTORY_VERSION, store::HistoryRecord};
+    use crate::atuin_client::history::{HISTORY_VERSION, store::HistoryRecord};
 
     use super::History;
 
diff --git a/crates/atuin-client/src/import/bash.rs b/crates/turtle/src/atuin_client/import/bash.rs
index 99a44a58..d92fdfa0 100644
--- a/crates/atuin-client/src/import/bash.rs
+++ b/crates/turtle/src/atuin_client/import/bash.rs
@@ -5,10 +5,11 @@ use directories::UserDirs;
 use eyre::{Result, eyre};
 use itertools::Itertools;
 use time::{Duration, OffsetDateTime};
+use tracing::warn;
 
 use super::{Importer, Loader, get_histfile_path, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct Bash {
@@ -130,7 +131,7 @@ mod test {
 
     use itertools::{Itertools, assert_equal};
 
-    use crate::import::{Importer, tests::TestLoader};
+    use crate::atuin_client::import::{Importer, tests::TestLoader};
 
     use super::Bash;
 
@@ -183,7 +184,7 @@ cd ../
         );
         assert_equal(
             loader.buf.iter().map(|h| h.timestamp.unix_timestamp()),
-            [1672918999, 1672919006, 1672919020],
+            [1_672_918_999, 1_672_919_006, 1_672_919_020],
         )
     }
 
diff --git a/crates/atuin-client/src/import/fish.rs b/crates/turtle/src/atuin_client/import/fish.rs
index 9fcf624c..1375bdd6 100644
--- a/crates/atuin-client/src/import/fish.rs
+++ b/crates/turtle/src/atuin_client/import/fish.rs
@@ -9,8 +9,8 @@ use eyre::{Result, eyre};
 use time::OffsetDateTime;
 
 use super::{Importer, Loader, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct Fish {
diff --git a/crates/atuin-client/src/import/mod.rs b/crates/turtle/src/atuin_client/import/mod.rs
index 4a1c6af6..7726ead7 100644
--- a/crates/atuin-client/src/import/mod.rs
+++ b/crates/turtle/src/atuin_client/import/mod.rs
@@ -6,7 +6,7 @@ use async_trait::async_trait;
 use eyre::{Result, bail};
 use memchr::Memchr;
 
-use crate::history::History;
+use crate::atuin_client::history::History;
 
 pub mod bash;
 pub mod fish;
diff --git a/crates/atuin-client/src/import/nu.rs b/crates/turtle/src/atuin_client/import/nu.rs
index cae90ac4..c93789b8 100644
--- a/crates/atuin-client/src/import/nu.rs
+++ b/crates/turtle/src/atuin_client/import/nu.rs
@@ -9,8 +9,8 @@ use eyre::{Result, eyre};
 use time::OffsetDateTime;
 
 use super::{Importer, Loader, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct Nu {
diff --git a/crates/atuin-client/src/import/nu_histdb.rs b/crates/turtle/src/atuin_client/import/nu_histdb.rs
index a13cb2b4..7de18369 100644
--- a/crates/atuin-client/src/import/nu_histdb.rs
+++ b/crates/turtle/src/atuin_client/import/nu_histdb.rs
@@ -10,8 +10,8 @@ use sqlx::{Pool, sqlite::SqlitePool};
 use time::{Duration, OffsetDateTime};
 
 use super::Importer;
-use crate::history::History;
-use crate::import::Loader;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::Loader;
 
 #[derive(sqlx::FromRow, Debug)]
 pub struct HistDbEntry {
diff --git a/crates/atuin-client/src/import/powershell.rs b/crates/turtle/src/atuin_client/import/powershell.rs
index 86fd007d..8adcc850 100644
--- a/crates/atuin-client/src/import/powershell.rs
+++ b/crates/turtle/src/atuin_client/import/powershell.rs
@@ -5,8 +5,8 @@ use std::path::PathBuf;
 use time::{Duration, OffsetDateTime};
 
 use super::{Importer, Loader, count_lines, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct PowerShell {
diff --git a/crates/atuin-client/src/import/replxx.rs b/crates/turtle/src/atuin_client/import/replxx.rs
index 47d566cf..42f84df5 100644
--- a/crates/atuin-client/src/import/replxx.rs
+++ b/crates/turtle/src/atuin_client/import/replxx.rs
@@ -6,8 +6,8 @@ use eyre::{Result, eyre};
 use time::{OffsetDateTime, PrimitiveDateTime, macros::format_description};
 
 use super::{Importer, Loader, get_histfile_path, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct Replxx {
diff --git a/crates/atuin-client/src/import/resh.rs b/crates/turtle/src/atuin_client/import/resh.rs
index df15f5b4..c5980c44 100644
--- a/crates/atuin-client/src/import/resh.rs
+++ b/crates/turtle/src/atuin_client/import/resh.rs
@@ -5,12 +5,12 @@ use directories::UserDirs;
 use eyre::{Result, eyre};
 use serde::Deserialize;
 
-use atuin_common::utils::uuid_v7;
+use crate::atuin_common::utils::uuid_v7;
 use time::OffsetDateTime;
 
 use super::{Importer, Loader, get_histfile_path, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
diff --git a/crates/atuin-client/src/import/xonsh.rs b/crates/turtle/src/atuin_client/import/xonsh.rs
index 6f38de68..a7217826 100644
--- a/crates/atuin-client/src/import/xonsh.rs
+++ b/crates/turtle/src/atuin_client/import/xonsh.rs
@@ -11,8 +11,8 @@ use uuid::Uuid;
 use uuid::timestamp::{Timestamp, context::NoContext};
 
 use super::{Importer, Loader, get_histdir_path};
-use crate::history::History;
-use crate::utils::get_host_user;
+use crate::atuin_client::history::History;
+use crate::atuin_client::utils::get_host_user;
 
 // Note: both HistoryFile and HistoryData have other keys present in the JSON, we don't
 // care about them so we leave them unspecified so as to avoid deserializing unnecessarily.
diff --git a/crates/atuin-client/src/import/xonsh_sqlite.rs b/crates/turtle/src/atuin_client/import/xonsh_sqlite.rs
index 7d50ac84..ceedf7e9 100644
--- a/crates/atuin-client/src/import/xonsh_sqlite.rs
+++ b/crates/turtle/src/atuin_client/import/xonsh_sqlite.rs
@@ -11,8 +11,8 @@ use uuid::Uuid;
 use uuid::timestamp::{Timestamp, context::NoContext};
 
 use super::{Importer, Loader, get_histfile_path};
-use crate::history::History;
-use crate::utils::get_host_user;
+use crate::atuin_client::history::History;
+use crate::atuin_client::utils::get_host_user;
 
 #[derive(Debug, FromRow)]
 struct HistDbEntry {
diff --git a/crates/atuin-client/src/import/zsh.rs b/crates/turtle/src/atuin_client/import/zsh.rs
index 11e2f371..e1fd813a 100644
--- a/crates/atuin-client/src/import/zsh.rs
+++ b/crates/turtle/src/atuin_client/import/zsh.rs
@@ -10,8 +10,8 @@ use eyre::{Result, eyre};
 use time::OffsetDateTime;
 
 use super::{Importer, Loader, get_histfile_path, unix_byte_lines};
-use crate::history::History;
-use crate::import::read_to_end;
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::read_to_end;
 
 #[derive(Debug)]
 pub struct Zsh {
diff --git a/crates/atuin-client/src/import/zsh_histdb.rs b/crates/turtle/src/atuin_client/import/zsh_histdb.rs
index bf44c3ad..f61bb74f 100644
--- a/crates/atuin-client/src/import/zsh_histdb.rs
+++ b/crates/turtle/src/atuin_client/import/zsh_histdb.rs
@@ -36,16 +36,16 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use async_trait::async_trait;
-use atuin_common::utils::uuid_v7;
+use crate::atuin_common::utils::uuid_v7;
 use directories::UserDirs;
 use eyre::{Result, eyre};
 use sqlx::{Pool, sqlite::SqlitePool};
 use time::PrimitiveDateTime;
 
 use super::Importer;
-use crate::history::History;
-use crate::import::Loader;
-use crate::utils::{get_hostname, get_username};
+use crate::atuin_client::history::History;
+use crate::atuin_client::import::Loader;
+use crate::atuin_client::utils::{get_hostname, get_username};
 
 #[derive(sqlx::FromRow, Debug)]
 pub struct HistDbEntryCount {
diff --git a/crates/atuin-client/src/login.rs b/crates/turtle/src/atuin_client/login.rs
index 2545e890..ca4e16fe 100644
--- a/crates/atuin-client/src/login.rs
+++ b/crates/turtle/src/atuin_client/login.rs
@@ -1,11 +1,11 @@
 use std::path::PathBuf;
 
-use atuin_common::api::LoginRequest;
+use crate::atuin_common::api::LoginRequest;
 use eyre::{Context, Result, bail};
 use tokio::fs::File;
 use tokio::io::AsyncWriteExt;
 
-use crate::{
+use crate::atuin_client::{
     api_client,
     encryption::{decode_key, load_key},
     record::{sqlite_store::SqliteStore, store::Store},
diff --git a/crates/atuin-client/src/logout.rs b/crates/turtle/src/atuin_client/logout.rs
index f720b302..343934b9 100644
--- a/crates/atuin-client/src/logout.rs
+++ b/crates/turtle/src/atuin_client/logout.rs
@@ -1,6 +1,6 @@
 use eyre::Result;
 
-use crate::settings::Settings;
+use crate::atuin_client::settings::Settings;
 
 pub async fn logout() -> Result<()> {
     let meta = Settings::meta_store().await?;
diff --git a/crates/atuin-client/src/meta.rs b/crates/turtle/src/atuin_client/meta.rs
index 870f36d0..1eea7061 100644
--- a/crates/atuin-client/src/meta.rs
+++ b/crates/turtle/src/atuin_client/meta.rs
@@ -2,11 +2,12 @@ use std::path::Path;
 use std::str::FromStr;
 use std::time::Duration;
 
-use atuin_common::record::HostId;
+use crate::atuin_common::record::HostId;
 use eyre::{Result, eyre};
 use sqlx::sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePool, SqlitePoolOptions};
 use time::{OffsetDateTime, format_description::well_known::Rfc3339};
 use tokio::sync::OnceCell;
+use tracing::{debug, warn};
 use uuid::Uuid;
 
 // Filenames for the legacy plain-text files that we migrate from.
@@ -125,7 +126,7 @@ impl MetaStore {
                     return Ok(HostId(parsed));
                 }
 
-                let uuid = atuin_common::utils::uuid_v7();
+                let uuid = crate::atuin_common::utils::uuid_v7();
                 self.set(KEY_HOST_ID, uuid.as_simple().to_string().as_ref())
                     .await?;
 
@@ -197,7 +198,7 @@ impl MetaStore {
             return Ok(());
         }
 
-        let data_dir = crate::settings::Settings::effective_data_dir();
+        let data_dir = crate::atuin_client::settings::Settings::effective_data_dir();
 
         // host_id — validate as UUID
         let host_id_path = data_dir.join(LEGACY_HOST_ID_FILENAME);
diff --git a/crates/atuin-client/src/lib.rs b/crates/turtle/src/atuin_client/mod.rs
index cd7785e1..7f07f2e2 100644
--- a/crates/atuin-client/src/lib.rs
+++ b/crates/turtle/src/atuin_client/mod.rs
@@ -1,8 +1,3 @@
-#![deny(unsafe_code)]
-
-#[macro_use]
-extern crate log;
-
 #[cfg(feature = "sync")]
 pub mod api_client;
 #[cfg(feature = "sync")]
diff --git a/crates/atuin-client/src/ordering.rs b/crates/turtle/src/atuin_client/ordering.rs
index 4e5ec84c..4e5ec84c 100644
--- a/crates/atuin-client/src/ordering.rs
+++ b/crates/turtle/src/atuin_client/ordering.rs
diff --git a/crates/atuin-client/src/plugin.rs b/crates/turtle/src/atuin_client/plugin.rs
index 6f351bf1..6f351bf1 100644
--- a/crates/atuin-client/src/plugin.rs
+++ b/crates/turtle/src/atuin_client/plugin.rs
diff --git a/crates/atuin-client/src/record/encryption.rs b/crates/turtle/src/atuin_client/record/encryption.rs
index 1e94d967..22dcdec3 100644
--- a/crates/atuin-client/src/record/encryption.rs
+++ b/crates/turtle/src/atuin_client/record/encryption.rs
@@ -1,4 +1,4 @@
-use atuin_common::record::{
+use crate::atuin_common::record::{
     AdditionalData, DecryptedData, EncryptedData, Encryption, HostId, RecordId, RecordIdx,
 };
 use base64::{Engine, engine::general_purpose};
@@ -197,7 +197,7 @@ impl Assertions<'_> {
 
 #[cfg(test)]
 mod tests {
-    use atuin_common::{
+    use crate::atuin_common::{
         record::{Host, Record},
         utils::uuid_v7,
     };
diff --git a/crates/atuin-client/src/record/mod.rs b/crates/turtle/src/atuin_client/record/mod.rs
index c40fd395..c40fd395 100644
--- a/crates/atuin-client/src/record/mod.rs
+++ b/crates/turtle/src/atuin_client/record/mod.rs
diff --git a/crates/atuin-client/src/record/sqlite_store.rs b/crates/turtle/src/atuin_client/record/sqlite_store.rs
index ed51f3fd..5fab999d 100644
--- a/crates/atuin-client/src/record/sqlite_store.rs
+++ b/crates/turtle/src/atuin_client/record/sqlite_store.rs
@@ -13,11 +13,12 @@ use sqlx::{
     Row,
     sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePool, SqlitePoolOptions, SqliteRow},
 };
+use tracing::debug;
 
-use atuin_common::record::{
+use crate::atuin_common::record::{
     EncryptedData, Host, HostId, Record, RecordId, RecordIdx, RecordStatus,
 };
-use atuin_common::utils;
+use crate::atuin_common::utils;
 use uuid::Uuid;
 
 use super::encryption::PASETO_V4;
@@ -371,7 +372,7 @@ impl Store for SqliteStore {
 
 #[cfg(test)]
 mod tests {
-    use atuin_common::{
+    use crate::atuin_common::{
         record::{DecryptedData, EncryptedData, Host, HostId, Record},
         utils::uuid_v7,
     };
diff --git a/crates/atuin-client/src/record/store.rs b/crates/turtle/src/atuin_client/record/store.rs
index 49ca4968..f99085d0 100644
--- a/crates/atuin-client/src/record/store.rs
+++ b/crates/turtle/src/atuin_client/record/store.rs
@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use eyre::Result;
 
-use atuin_common::record::{EncryptedData, HostId, Record, RecordId, RecordIdx, RecordStatus};
+use crate::atuin_common::record::{EncryptedData, HostId, Record, RecordId, RecordIdx, RecordStatus};
 
 /// A record store stores records
 /// In more detail - we tend to need to process this into _another_ format to actually query it.
diff --git a/crates/atuin-client/src/record/sync.rs b/crates/turtle/src/atuin_client/record/sync.rs
index b785b5dc..f831570b 100644
--- a/crates/atuin-client/src/record/sync.rs
+++ b/crates/turtle/src/atuin_client/record/sync.rs
@@ -3,11 +3,12 @@ use std::{cmp::Ordering, fmt::Write};
 
 use eyre::Result;
 use thiserror::Error;
+use tracing::error;
 
 use super::{encryption::PASETO_V4, store::Store};
-use crate::{api_client::Client, settings::Settings};
+use crate::atuin_client::{api_client::Client, settings::Settings};
 
-use atuin_common::record::{Diff, HostId, RecordId, RecordIdx, RecordStatus};
+use crate::atuin_common::record::{Diff, HostId, RecordId, RecordIdx, RecordStatus};
 use indicatif::{ProgressBar, ProgressState, ProgressStyle};
 
 #[derive(Error, Debug)]
@@ -372,10 +373,10 @@ pub async fn sync(
 
 #[cfg(test)]
 mod tests {
-    use atuin_common::record::{Diff, EncryptedData, HostId, Record};
+    use crate::atuin_common::record::{Diff, EncryptedData, HostId, Record};
     use pretty_assertions::assert_eq;
 
-    use crate::{
+    use crate::atuin_client::{
         record::{
             encryption::PASETO_V4,
             sqlite_store::SqliteStore,
@@ -387,11 +388,11 @@ mod tests {
 
     fn test_record() -> Record<EncryptedData> {
         Record::builder()
-            .host(atuin_common::record::Host::new(HostId(
-                atuin_common::utils::uuid_v7(),
+            .host(crate::atuin_common::record::Host::new(HostId(
+                crate::atuin_common::utils::uuid_v7(),
             )))
             .version("v1".into())
-            .tag(atuin_common::utils::uuid_v7().simple().to_string())
+            .tag(crate::atuin_common::utils::uuid_v7().simple().to_string())
             .data(EncryptedData {
                 data: String::new(),
                 content_encryption_key: String::new(),
diff --git a/crates/atuin-client/src/register.rs b/crates/turtle/src/atuin_client/register.rs
index ad077dd1..4b14c233 100644
--- a/crates/atuin-client/src/register.rs
+++ b/crates/turtle/src/atuin_client/register.rs
@@ -1,6 +1,6 @@
 use eyre::Result;
 
-use crate::{api_client, settings::Settings};
+use crate::atuin_client::{api_client, settings::Settings};
 
 pub async fn register_classic(
     settings: &Settings,
@@ -14,7 +14,7 @@ pub async fn register_classic(
     let meta = Settings::meta_store().await?;
     meta.save_session(&session.session).await?;
 
-    let _key = crate::encryption::load_key(settings)?;
+    let _key = crate::atuin_client::encryption::load_key(settings)?;
 
     Ok(session.session)
 }
diff --git a/crates/atuin-client/src/secrets.rs b/crates/turtle/src/atuin_client/secrets.rs
index e8a6ab62..e8a6ab62 100644
--- a/crates/atuin-client/src/secrets.rs
+++ b/crates/turtle/src/atuin_client/secrets.rs
diff --git a/crates/atuin-client/src/settings.rs b/crates/turtle/src/atuin_client/settings.rs
index 5fb65c17..b0ffc7c1 100644
--- a/crates/atuin-client/src/settings.rs
+++ b/crates/turtle/src/atuin_client/settings.rs
@@ -1,8 +1,8 @@
 use std::{collections::HashMap, fmt, io::prelude::*, path::PathBuf, str::FromStr, sync::OnceLock};
 use tokio::sync::OnceCell;
 
-use atuin_common::record::HostId;
-use atuin_common::utils;
+use crate::atuin_common::record::HostId;
+use crate::atuin_common::utils;
 use clap::ValueEnum;
 use config::{
     Config, ConfigBuilder, Environment, File as ConfigFile, FileFormat, builder::DefaultState,
@@ -16,11 +16,10 @@ use serde_with::DeserializeFromStr;
 use time::{OffsetDateTime, UtcOffset, format_description::FormatItem, macros::format_description};
 
 pub const HISTORY_PAGE_SIZE: i64 = 100;
-static EXAMPLE_CONFIG: &str = include_str!("../config.toml");
 
 static DATA_DIR: OnceLock<PathBuf> = OnceLock::new();
 static META_CONFIG: OnceLock<(String, f64)> = OnceLock::new();
-static META_STORE: OnceCell<crate::meta::MetaStore> = OnceCell::const_new();
+static META_STORE: OnceCell<crate::atuin_client::meta::MetaStore> = OnceCell::const_new();
 
 pub(crate) mod meta;
 pub mod watcher;
@@ -374,8 +373,8 @@ impl SyncAuth {
     /// Convert into the auth token type used by the API client.
     ///
     /// Returns an error with an actionable message for `NotLoggedIn`.
-    pub fn into_auth_token(self) -> Result<crate::api_client::AuthToken> {
-        use crate::api_client::AuthToken;
+    pub fn into_auth_token(self) -> Result<crate::atuin_client::api_client::AuthToken> {
+        use crate::atuin_client::api_client::AuthToken;
         match self {
             SyncAuth::Legacy { token } => Ok(AuthToken::Token(token)),
             SyncAuth::NotLoggedIn { reason } => Err(eyre!(reason)),
@@ -1038,7 +1037,6 @@ pub struct Settings {
     pub timezone: Timezone,
     pub style: Style,
     pub auto_sync: bool,
-    pub update_check: bool,
 
     /// The sync address for atuin.
     pub sync_address: String,
@@ -1144,18 +1142,18 @@ impl Settings {
         DATA_DIR
             .get()
             .cloned()
-            .unwrap_or_else(atuin_common::utils::data_dir)
+            .unwrap_or_else(crate::atuin_common::utils::data_dir)
     }
 
     // -- Meta store: lazily initialized on first access --
 
-    pub async fn meta_store() -> Result<&'static crate::meta::MetaStore> {
+    pub async fn meta_store() -> Result<&'static crate::atuin_client::meta::MetaStore> {
         META_STORE
             .get_or_try_init(|| async {
                 let (db_path, timeout) = META_CONFIG.get().ok_or_else(|| {
                     eyre!("meta store config not set — Settings::new() has not been called")
                 })?;
-                crate::meta::MetaStore::new(db_path, *timeout).await
+                crate::atuin_client::meta::MetaStore::new(db_path, *timeout).await
             })
             .await
     }
@@ -1240,7 +1238,7 @@ impl Settings {
     /// `AuthToken`. Callers that need to distinguish between auth states
     /// (e.g. to show different UI) should call `resolve_sync_auth` directly.
     #[cfg(feature = "sync")]
-    pub async fn sync_auth_token(&self) -> Result<crate::api_client::AuthToken> {
+    pub async fn sync_auth_token(&self) -> Result<crate::atuin_client::api_client::AuthToken> {
         self.resolve_sync_auth().await.into_auth_token()
     }
 
@@ -1262,7 +1260,7 @@ impl Settings {
     }
 
     pub fn builder() -> Result<ConfigBuilder<DefaultState>> {
-        Self::builder_with_data_dir(&atuin_common::utils::data_dir())
+        Self::builder_with_data_dir(&crate::atuin_common::utils::data_dir())
     }
 
     fn builder_with_data_dir(data_dir: &std::path::Path) -> Result<ConfigBuilder<DefaultState>> {
@@ -1271,9 +1269,9 @@ impl Settings {
         let kv_path = data_dir.join("kv.db");
         let scripts_path = data_dir.join("scripts.db");
         let ai_sessions_path = data_dir.join("ai_sessions.db");
-        let socket_path = atuin_common::utils::runtime_dir().join("atuin.sock");
+        let socket_path = crate::atuin_common::utils::runtime_dir().join("atuin.sock");
         let pidfile_path = data_dir.join("atuin-daemon.pid");
-        let logs_dir = atuin_common::utils::logs_dir();
+        let logs_dir = crate::atuin_common::utils::logs_dir();
 
         let key_path = data_dir.join("key");
         let meta_path = data_dir.join("meta.db");
@@ -1286,7 +1284,6 @@ impl Settings {
             .set_default("dialect", "us")?
             .set_default("timezone", "local")?
             .set_default("auto_sync", true)?
-            .set_default("update_check", cfg!(feature = "check-update"))?
             .set_default("sync_address", "https://api.atuin.sh")?
             .set_default("sync_frequency", "5m")?
             .set_default("search_mode", "fuzzy")?
@@ -1390,7 +1387,7 @@ impl Settings {
     }
 
     pub fn get_config_path() -> Result<PathBuf> {
-        let config_dir = atuin_common::utils::config_dir();
+        let config_dir = crate::atuin_common::utils::config_dir();
 
         create_dir_all(&config_dir)
             .wrap_err_with(|| format!("could not create dir {config_dir:?}"))?;
@@ -1447,10 +1444,10 @@ impl Settings {
                         .map_err(|e| eyre!("failed to expand data_dir path: {}", e))?;
                     PathBuf::from(expanded.as_ref())
                 }
-                None => atuin_common::utils::data_dir(),
+                None => crate::atuin_common::utils::data_dir(),
             }
         } else {
-            atuin_common::utils::data_dir()
+            crate::atuin_common::utils::data_dir()
         };
 
         DATA_DIR.set(effective_data_dir.clone()).ok();
@@ -1467,7 +1464,10 @@ impl Settings {
             config_builder.add_source(ConfigFile::new(config_file_str, FileFormat::Toml))
         } else {
             let mut file = File::create(config_file).wrap_err("could not create config file")?;
-            file.write_all(EXAMPLE_CONFIG.as_bytes())
+
+            let config = config_builder.build_cloned()?;
+            // TODO(@bpeetz): Not so sure about this <2026-06-10>
+            file.write_all(config.cache.to_string().as_bytes())
                 .wrap_err("could not write default config file")?;
 
             config_builder
@@ -1590,10 +1590,6 @@ impl Settings {
             .map_err(|e| eyre!("failed to expand path: {}", e))
     }
 
-    pub fn example_config() -> &'static str {
-        EXAMPLE_CONFIG
-    }
-
     pub fn paths_ok(&self) -> bool {
         let paths = [
             &self.db_path,
@@ -1766,7 +1762,7 @@ mod tests {
         assert_eq!(meta_db_path, custom_dir.join("meta.db").to_str().unwrap());
         assert_eq!(
             daemon_socket_path,
-            atuin_common::utils::runtime_dir()
+            crate::atuin_common::utils::runtime_dir()
                 .join("atuin.sock")
                 .to_str()
                 .unwrap()
@@ -1783,7 +1779,7 @@ mod tests {
     #[test]
     fn effective_data_dir_returns_default_when_not_set() {
         let effective = super::Settings::effective_data_dir();
-        let default = atuin_common::utils::data_dir();
+        let default = crate::atuin_common::utils::data_dir();
 
         assert!(effective.to_str().is_some());
         assert!(effective.ends_with("atuin") || effective == default);
diff --git a/crates/atuin-client/src/settings/meta.rs b/crates/turtle/src/atuin_client/settings/meta.rs
index 108d74ec..450d0432 100644
--- a/crates/atuin-client/src/settings/meta.rs
+++ b/crates/turtle/src/atuin_client/settings/meta.rs
@@ -7,7 +7,7 @@ pub struct Settings {
 
 impl Default for Settings {
     fn default() -> Self {
-        let dir = atuin_common::utils::data_dir();
+        let dir = crate::atuin_common::utils::data_dir();
         let path = dir.join("meta.db");
 
         Self {
diff --git a/crates/atuin-client/src/settings/watcher.rs b/crates/turtle/src/atuin_client/settings/watcher.rs
index 740b8d12..7548573e 100644
--- a/crates/atuin-client/src/settings/watcher.rs
+++ b/crates/turtle/src/atuin_client/settings/watcher.rs
@@ -6,7 +6,7 @@
 //! # Example
 //!
 //! ```no_run
-//! use atuin_client::settings::watcher::global_settings_watcher;
+//! use crate::atuin_client::settings::watcher::global_settings_watcher;
 //!
 //! async fn example() -> eyre::Result<()> {
 //!     let watcher = global_settings_watcher()?;
@@ -103,7 +103,7 @@ impl SettingsWatcher {
         let config_dir = if let Ok(p) = std::env::var("ATUIN_CONFIG_DIR") {
             PathBuf::from(p)
         } else {
-            atuin_common::utils::config_dir()
+            crate::atuin_common::utils::config_dir()
         };
         config_dir.join("config.toml")
     }
diff --git a/crates/atuin-client/src/sync.rs b/crates/turtle/src/atuin_client/sync.rs
index 2c902794..361b6636 100644
--- a/crates/atuin-client/src/sync.rs
+++ b/crates/turtle/src/atuin_client/sync.rs
@@ -2,12 +2,13 @@ use std::collections::HashSet;
 use std::iter::FromIterator;
 
 use eyre::Result;
+use tracing::{debug, info};
 
-use atuin_common::api::AddHistoryRequest;
+use crate::atuin_common::api::AddHistoryRequest;
 use crypto_secretbox::Key;
 use time::OffsetDateTime;
 
-use crate::{
+use crate::atuin_client::{
     api_client,
     database::Database,
     encryption::{decrypt, encrypt, load_key},
diff --git a/crates/atuin-client/src/theme.rs b/crates/turtle/src/atuin_client/theme.rs
index a277ac13..1d9c0b9e 100644
--- a/crates/atuin-client/src/theme.rs
+++ b/crates/turtle/src/atuin_client/theme.rs
@@ -395,7 +395,7 @@ impl ThemeManager {
             }
             PathBuf::from(p)
         } else {
-            let config_dir = atuin_common::utils::config_dir();
+            let config_dir = crate::atuin_common::utils::config_dir();
             let mut theme_file = if let Ok(p) = std::env::var("ATUIN_CONFIG_DIR") {
                 PathBuf::from(p)
             } else {
@@ -407,7 +407,7 @@ impl ThemeManager {
             theme_file
         };
 
-        let theme_toml = format!["{name}.toml"];
+        let theme_toml = format!("{name}.toml");
         theme_file.push(theme_toml);
 
         let mut config_builder = Config::builder();
diff --git a/crates/atuin-client/src/utils.rs b/crates/turtle/src/atuin_client/utils.rs
index 35d7db26..35d7db26 100644
--- a/crates/atuin-client/src/utils.rs
+++ b/crates/turtle/src/atuin_client/utils.rs
diff --git a/crates/atuin-common/src/api.rs b/crates/turtle/src/atuin_common/api.rs
index 1a9f348c..1a9f348c 100644
--- a/crates/atuin-common/src/api.rs
+++ b/crates/turtle/src/atuin_common/api.rs
diff --git a/crates/atuin-common/src/calendar.rs b/crates/turtle/src/atuin_common/calendar.rs
index d3b1d921..d3b1d921 100644
--- a/crates/atuin-common/src/calendar.rs
+++ b/crates/turtle/src/atuin_common/calendar.rs
diff --git a/crates/atuin-common/src/lib.rs b/crates/turtle/src/atuin_common/mod.rs
index 91164a82..d886520d 100644
--- a/crates/atuin-common/src/lib.rs
+++ b/crates/turtle/src/atuin_common/mod.rs
@@ -1,5 +1,3 @@
-#![deny(unsafe_code)]
-
 /// Defines a new UUID type wrapper
 macro_rules! new_uuid {
     ($name:ident) => {
diff --git a/crates/atuin-common/src/record.rs b/crates/turtle/src/atuin_common/record.rs
index e6ce2647..05c29338 100644
--- a/crates/atuin-common/src/record.rs
+++ b/crates/turtle/src/atuin_common/record.rs
@@ -46,7 +46,7 @@ pub type RecordIdx = u64;
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TypedBuilder)]
 pub struct Record<Data> {
     /// a unique ID
-    #[builder(default = RecordId(crate::utils::uuid_v7()))]
+    #[builder(default = RecordId(crate::atuin_common::utils::uuid_v7()))]
     pub id: RecordId,
 
     /// The integer record ID. This is only unique per (host, tag).
@@ -280,16 +280,16 @@ impl Record<EncryptedData> {
 
 #[cfg(test)]
 mod tests {
-    use crate::record::{Host, HostId};
+    use crate::atuin_common::record::{Host, HostId};
 
     use super::{DecryptedData, Diff, Record, RecordStatus};
     use pretty_assertions::assert_eq;
 
     fn test_record() -> Record<DecryptedData> {
         Record::builder()
-            .host(Host::new(HostId(crate::utils::uuid_v7())))
+            .host(Host::new(HostId(crate::atuin_common::utils::uuid_v7())))
             .version("v1".into())
-            .tag(crate::utils::uuid_v7().simple().to_string())
+            .tag(crate::atuin_common::utils::uuid_v7().simple().to_string())
             .data(DecryptedData(vec![0, 1, 2, 3]))
             .idx(0)
             .build()
diff --git a/crates/atuin-common/src/shell.rs b/crates/turtle/src/atuin_common/shell.rs
index 7f9a7b8f..7f9a7b8f 100644
--- a/crates/atuin-common/src/shell.rs
+++ b/crates/turtle/src/atuin_common/shell.rs
diff --git a/crates/atuin-common/src/tls.rs b/crates/turtle/src/atuin_common/tls.rs
index e8c840e0..e8c840e0 100644
--- a/crates/atuin-common/src/tls.rs
+++ b/crates/turtle/src/atuin_common/tls.rs
diff --git a/crates/atuin-common/src/utils.rs b/crates/turtle/src/atuin_common/utils.rs
index d7382fb2..d7382fb2 100644
--- a/crates/atuin-common/src/utils.rs
+++ b/crates/turtle/src/atuin_common/utils.rs
diff --git a/crates/atuin-daemon/src/client.rs b/crates/turtle/src/atuin_daemon/client.rs
index c18e0e46..45ef19e9 100644
--- a/crates/atuin-daemon/src/client.rs
+++ b/crates/turtle/src/atuin_daemon/client.rs
@@ -1,8 +1,6 @@
-use atuin_client::database::Context;
-use atuin_client::settings::{FilterMode, Settings};
+use crate::atuin_client::database::Context;
+use crate::atuin_client::settings::{FilterMode, Settings};
 use eyre::{Context as EyreContext, Result};
-#[cfg(windows)]
-use tokio::net::TcpStream;
 use tonic::Code;
 use tonic::transport::{Channel, Endpoint, Uri};
 use tower::service_fn;
@@ -12,25 +10,25 @@ use hyper_util::rt::TokioIo;
 #[cfg(unix)]
 use tokio::net::UnixStream;
 
-use atuin_client::history::History;
+use crate::atuin_client::history::History;
 use tracing::{Level, instrument, span};
 
-use crate::control::HistoryRebuiltEvent;
-use crate::control::{
+use crate::atuin_daemon::control::HistoryRebuiltEvent;
+use crate::atuin_daemon::control::{
     ForceSyncEvent, HistoryDeletedEvent, HistoryPrunedEvent, SendEventRequest,
     SettingsReloadedEvent, ShutdownEvent, control_client::ControlClient as ControlServiceClient,
 };
-use crate::events::DaemonEvent;
-use crate::history::{
+use crate::atuin_daemon::events::DaemonEvent;
+use crate::atuin_daemon::history::{
     EndHistoryReply, EndHistoryRequest, ShutdownRequest, StartHistoryReply, StartHistoryRequest,
     StatusReply, StatusRequest, TailHistoryReply, TailHistoryRequest,
     history_client::HistoryClient as HistoryServiceClient,
 };
-use crate::search::{
+use crate::atuin_daemon::search::{
     FilterMode as RpcFilterMode, SearchContext as RpcSearchContext, SearchRequest, SearchResponse,
     search_client::SearchClient as SearchServiceClient,
 };
-use crate::semantic::{
+use crate::atuin_daemon::semantic::{
     CommandCapture, CommandOutputReply, CommandOutputRequest, OutputRange, RecordCommandsReply,
     semantic_client::SemanticClient as SemanticServiceClient,
 };
@@ -94,28 +92,6 @@ impl HistoryClient {
         Ok(HistoryClient { client })
     }
 
-    #[cfg(not(unix))]
-    pub async fn new(port: u64) -> Result<Self> {
-        let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
-            .connect_with_connector(service_fn(move |_: Uri| {
-                let url = format!("127.0.0.1:{port}");
-
-                async move {
-                    Ok::<_, std::io::Error>(TokioIo::new(TcpStream::connect(url.clone()).await?))
-                }
-            }))
-            .await
-            .wrap_err_with(|| {
-                format!(
-                    "failed to connect to local atuin daemon at 127.0.0.1:{port}. Is it running?"
-                )
-            })?;
-
-        let client = HistoryServiceClient::new(channel);
-
-        Ok(HistoryClient { client })
-    }
-
     pub async fn start_history(&mut self, h: History) -> Result<StartHistoryReply> {
         let req = StartHistoryRequest {
             command: h.command,
@@ -188,28 +164,6 @@ impl SearchClient {
         Ok(SearchClient { client })
     }
 
-    #[cfg(not(unix))]
-    pub async fn new(port: u64) -> Result<Self> {
-        let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
-            .connect_with_connector(service_fn(move |_: Uri| {
-                let url = format!("127.0.0.1:{port}");
-
-                async move {
-                    Ok::<_, std::io::Error>(TokioIo::new(TcpStream::connect(url.clone()).await?))
-                }
-            }))
-            .await
-            .wrap_err_with(|| {
-                format!(
-                    "failed to connect to local atuin daemon at 127.0.0.1:{port}. Is it running?"
-                )
-            })?;
-
-        let client = SearchServiceClient::new(channel);
-
-        Ok(SearchClient { client })
-    }
-
     #[instrument(skip_all, level = Level::TRACE, name = "daemon_client_search", fields(query = %query, query_id = query_id))]
     pub async fn search(
         &mut self,
@@ -289,38 +243,11 @@ impl SemanticClient {
         Ok(SemanticClient { client })
     }
 
-    #[cfg(not(unix))]
-    pub async fn new(port: u64) -> Result<Self> {
-        let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
-            .connect_with_connector(service_fn(move |_: Uri| {
-                let url = format!("127.0.0.1:{port}");
-
-                async move {
-                    Ok::<_, std::io::Error>(TokioIo::new(TcpStream::connect(url.clone()).await?))
-                }
-            }))
-            .await
-            .wrap_err_with(|| {
-                format!(
-                    "failed to connect to local atuin daemon at 127.0.0.1:{port}. Is it running?"
-                )
-            })?;
-
-        let client = SemanticServiceClient::new(channel);
-
-        Ok(SemanticClient { client })
-    }
-
     #[cfg(unix)]
     pub async fn from_settings(settings: &Settings) -> Result<Self> {
         Self::new(settings.daemon.socket_path.clone()).await
     }
 
-    #[cfg(not(unix))]
-    pub async fn from_settings(settings: &Settings) -> Result<Self> {
-        Self::new(settings.daemon.tcp_port).await
-    }
-
     pub async fn record_commands(
         &mut self,
         captures: Vec<CommandCapture>,
@@ -383,41 +310,12 @@ impl ControlClient {
         Ok(ControlClient { client })
     }
 
-    /// Connect to the daemon's control service.
-    #[cfg(not(unix))]
-    pub async fn new(port: u64) -> Result<Self> {
-        let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
-            .connect_with_connector(service_fn(move |_: Uri| {
-                let url = format!("127.0.0.1:{port}");
-
-                async move {
-                    Ok::<_, std::io::Error>(TokioIo::new(TcpStream::connect(url.clone()).await?))
-                }
-            }))
-            .await
-            .wrap_err_with(|| {
-                format!(
-                    "failed to connect to local atuin daemon at 127.0.0.1:{port}. Is it running?"
-                )
-            })?;
-
-        let client = ControlServiceClient::new(channel);
-
-        Ok(ControlClient { client })
-    }
-
     /// Connect using settings.
     #[cfg(unix)]
     pub async fn from_settings(settings: &Settings) -> Result<Self> {
         Self::new(settings.daemon.socket_path.clone()).await
     }
 
-    /// Connect using settings.
-    #[cfg(not(unix))]
-    pub async fn from_settings(settings: &Settings) -> Result<Self> {
-        Self::new(settings.daemon.tcp_port).await
-    }
-
     /// Send an event to the daemon.
     pub async fn send_event(&mut self, event: DaemonEvent) -> Result<()> {
         let proto_event = daemon_event_to_proto(event);
@@ -430,8 +328,10 @@ impl ControlClient {
 }
 
 /// Convert a daemon event to its proto representation.
-fn daemon_event_to_proto(event: DaemonEvent) -> crate::control::send_event_request::Event {
-    use crate::control::send_event_request::Event;
+fn daemon_event_to_proto(
+    event: DaemonEvent,
+) -> crate::atuin_daemon::control::send_event_request::Event {
+    use crate::atuin_daemon::control::send_event_request::Event;
 
     match event {
         DaemonEvent::HistoryPruned => Event::HistoryPruned(HistoryPrunedEvent {}),
diff --git a/crates/atuin-daemon/src/components/history.rs b/crates/turtle/src/atuin_daemon/components/history.rs
index c82c8f94..95d34b69 100644
--- a/crates/atuin-daemon/src/components/history.rs
+++ b/crates/turtle/src/atuin_daemon/components/history.rs
@@ -4,7 +4,7 @@
 
 use std::{pin::Pin, sync::Arc};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     history::{History, HistoryId, store::HistoryStore},
     settings::Settings,
@@ -16,7 +16,7 @@ use tokio_stream::Stream;
 use tonic::{Request, Response, Status};
 use tracing::{Level, instrument};
 
-use crate::{
+use crate::atuin_daemon::{
     daemon::{Component, DaemonHandle},
     events::DaemonEvent,
     history::{
diff --git a/crates/atuin-daemon/src/components/mod.rs b/crates/turtle/src/atuin_daemon/components/mod.rs
index 447e31df..447e31df 100644
--- a/crates/atuin-daemon/src/components/mod.rs
+++ b/crates/turtle/src/atuin_daemon/components/mod.rs
diff --git a/crates/atuin-daemon/src/components/search.rs b/crates/turtle/src/atuin_daemon/components/search.rs
index 9fc87fae..85191cff 100644
--- a/crates/atuin-daemon/src/components/search.rs
+++ b/crates/turtle/src/atuin_daemon/components/search.rs
@@ -5,7 +5,7 @@
 
 use std::{pin::Pin, sync::Arc};
 
-use atuin_client::database::Database;
+use crate::atuin_client::database::Database;
 use eyre::Result;
 use tokio::sync::RwLock;
 use tokio_stream::Stream;
@@ -13,7 +13,7 @@ use tonic::{Request, Response, Status, Streaming};
 use tracing::{Level, debug, info, instrument, span, trace};
 use uuid::Uuid;
 
-use crate::{
+use crate::atuin_daemon::{
     daemon::{Component, DaemonHandle},
     events::DaemonEvent,
     search::{
@@ -368,7 +368,7 @@ impl SearchSvc for SearchGrpcService {
 /// Convert proto FilterMode and context to IndexFilterMode.
 fn convert_filter_mode(
     mode: FilterMode,
-    context: &Option<crate::search::SearchContext>,
+    context: &Option<crate::atuin_daemon::search::SearchContext>,
 ) -> IndexFilterMode {
     match (mode, context) {
         (FilterMode::Global, _) => IndexFilterMode::Global,
diff --git a/crates/atuin-daemon/src/components/semantic.rs b/crates/turtle/src/atuin_daemon/components/semantic.rs
index dff38fd3..a42fd5cb 100644
--- a/crates/atuin-daemon/src/components/semantic.rs
+++ b/crates/turtle/src/atuin_daemon/components/semantic.rs
@@ -8,13 +8,13 @@ use std::collections::{HashMap, VecDeque};
 use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 
-use atuin_client::history::{History, HistoryId};
+use crate::atuin_client::history::{History, HistoryId};
 use eyre::Result;
 use tokio::sync::Mutex;
 use tonic::{Request, Response, Status, Streaming};
 use tracing::{Level, instrument};
 
-use crate::{
+use crate::atuin_daemon::{
     daemon::{Component, DaemonHandle},
     events::DaemonEvent,
     semantic::{
@@ -244,7 +244,7 @@ impl SemanticState {
     fn command_output_for_ref(
         &self,
         capture_ref: &CaptureRef,
-        ranges: &[crate::semantic::OutputRange],
+        ranges: &[crate::atuin_daemon::semantic::OutputRange],
     ) -> Option<CommandOutputReply> {
         let stored = self
             .sessions
@@ -534,14 +534,17 @@ fn command_output_not_found() -> CommandOutputReply {
     }
 }
 
-fn select_output_ranges(output: &str, ranges: &[crate::semantic::OutputRange]) -> Vec<OutputLine> {
+fn select_output_ranges(
+    output: &str,
+    ranges: &[crate::atuin_daemon::semantic::OutputRange],
+) -> Vec<OutputLine> {
     let lines: Vec<&str> = output.lines().collect();
     if lines.is_empty() {
         return Vec::new();
     }
 
     let ranges = if ranges.is_empty() {
-        vec![crate::semantic::OutputRange { start: 0, end: 999 }]
+        vec![crate::atuin_daemon::semantic::OutputRange { start: 0, end: 999 }]
     } else {
         ranges.to_vec()
     };
@@ -816,8 +819,8 @@ mod tests {
     fn output_ranges_are_line_based_inclusive_and_support_negative_offsets() {
         let output = "zero\none\ntwo\nthree\nfour";
         let ranges = vec![
-            crate::semantic::OutputRange { start: 1, end: 2 },
-            crate::semantic::OutputRange { start: -2, end: -1 },
+            crate::atuin_daemon::semantic::OutputRange { start: 1, end: 2 },
+            crate::atuin_daemon::semantic::OutputRange { start: -2, end: -1 },
         ];
 
         assert_eq!(
@@ -838,8 +841,8 @@ mod tests {
             .collect::<Vec<_>>()
             .join("\n");
         let ranges = vec![
-            crate::semantic::OutputRange { start: 0, end: 100 },
-            crate::semantic::OutputRange {
+            crate::atuin_daemon::semantic::OutputRange { start: 0, end: 100 },
+            crate::atuin_daemon::semantic::OutputRange {
                 start: -100,
                 end: -1,
             },
@@ -856,8 +859,8 @@ mod tests {
     fn output_ranges_can_leave_gaps_for_client_formatting() {
         let output = "zero\none\ntwo\nthree\nfour";
         let ranges = vec![
-            crate::semantic::OutputRange { start: 0, end: 1 },
-            crate::semantic::OutputRange { start: 4, end: 4 },
+            crate::atuin_daemon::semantic::OutputRange { start: 0, end: 1 },
+            crate::atuin_daemon::semantic::OutputRange { start: 4, end: 4 },
         ];
 
         assert_eq!(
@@ -888,8 +891,8 @@ mod tests {
     fn output_ranges_skip_ranges_fully_outside_output() {
         let output = "zero\none\ntwo";
         let ranges = vec![
-            crate::semantic::OutputRange { start: 10, end: 20 },
-            crate::semantic::OutputRange {
+            crate::atuin_daemon::semantic::OutputRange { start: 10, end: 20 },
+            crate::atuin_daemon::semantic::OutputRange {
                 start: -20,
                 end: -10,
             },
diff --git a/crates/atuin-daemon/src/components/sync.rs b/crates/turtle/src/atuin_daemon/components/sync.rs
index 6e486250..c76fb71b 100644
--- a/crates/atuin-daemon/src/components/sync.rs
+++ b/crates/turtle/src/atuin_daemon/components/sync.rs
@@ -9,9 +9,9 @@ use rand::Rng;
 use tokio::sync::mpsc;
 use tokio::time::{self, MissedTickBehavior};
 
-use atuin_client::{history::store::HistoryStore, record::sync, settings::Settings};
+use crate::atuin_client::{history::store::HistoryStore, record::sync, settings::Settings};
 
-use crate::{
+use crate::atuin_daemon::{
     daemon::{Component, DaemonHandle},
     events::DaemonEvent,
 };
diff --git a/crates/atuin-daemon/src/control/mod.rs b/crates/turtle/src/atuin_daemon/control/mod.rs
index afb29c57..afb29c57 100644
--- a/crates/atuin-daemon/src/control/mod.rs
+++ b/crates/turtle/src/atuin_daemon/control/mod.rs
diff --git a/crates/atuin-daemon/src/control/service.rs b/crates/turtle/src/atuin_daemon/control/service.rs
index 2e7403ce..cb2ff74e 100644
--- a/crates/atuin-daemon/src/control/service.rs
+++ b/crates/turtle/src/atuin_daemon/control/service.rs
@@ -3,7 +3,7 @@
 //! This gRPC service allows external processes (like CLI commands) to inject
 //! events into the daemon's event bus.
 
-use atuin_client::history::HistoryId;
+use crate::atuin_client::history::HistoryId;
 use tonic::{Request, Response, Status};
 use tracing::{Level, info, instrument};
 
@@ -12,7 +12,7 @@ use super::{
     control_server::{Control, ControlServer},
     send_event_request::Event,
 };
-use crate::{daemon::DaemonHandle, events::DaemonEvent};
+use crate::atuin_daemon::{daemon::DaemonHandle, events::DaemonEvent};
 
 /// The Control gRPC service.
 ///
diff --git a/crates/atuin-daemon/src/daemon.rs b/crates/turtle/src/atuin_daemon/daemon.rs
index 625ca205..77c0d8a5 100644
--- a/crates/atuin-daemon/src/daemon.rs
+++ b/crates/turtle/src/atuin_daemon/daemon.rs
@@ -10,14 +10,14 @@
 
 use std::sync::Arc;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Sqlite as HistoryDatabase, encryption, record::sqlite_store::SqliteStore,
     settings::Settings,
 };
 use eyre::{Context, Result};
 use tokio::sync::{RwLock, broadcast};
 
-use crate::events::DaemonEvent;
+use crate::atuin_daemon::events::DaemonEvent;
 
 // ============================================================================
 // DaemonState
diff --git a/crates/atuin-daemon/src/events.rs b/crates/turtle/src/atuin_daemon/events.rs
index 4e6c6ff3..9a398925 100644
--- a/crates/atuin-daemon/src/events.rs
+++ b/crates/turtle/src/atuin_daemon/events.rs
@@ -7,8 +7,8 @@
 //! External processes (like CLI commands) can also inject events via the
 //! Control gRPC service.
 
-use atuin_client::history::{History, HistoryId};
-use atuin_common::record::RecordId;
+use crate::atuin_client::history::{History, HistoryId};
+use crate::atuin_common::record::RecordId;
 
 /// Events that flow through the daemon's event bus.
 ///
diff --git a/crates/atuin-daemon/src/history/mod.rs b/crates/turtle/src/atuin_daemon/history/mod.rs
index b71853df..b71853df 100644
--- a/crates/atuin-daemon/src/history/mod.rs
+++ b/crates/turtle/src/atuin_daemon/history/mod.rs
diff --git a/crates/atuin-daemon/src/lib.rs b/crates/turtle/src/atuin_daemon/mod.rs
index 27d3932b..b05eb95c 100644
--- a/crates/atuin-daemon/src/lib.rs
+++ b/crates/turtle/src/atuin_daemon/mod.rs
@@ -1,6 +1,6 @@
-use atuin_client::database::Sqlite as HistoryDatabase;
-use atuin_client::record::sqlite_store::SqliteStore;
-use atuin_client::settings::{Settings, watcher::global_settings_watcher};
+use crate::atuin_client::database::Sqlite as HistoryDatabase;
+use crate::atuin_client::record::sqlite_store::SqliteStore;
+use crate::atuin_client::settings::{Settings, watcher::global_settings_watcher};
 use eyre::Result;
 
 pub mod client;
@@ -126,11 +126,3 @@ async fn shutdown_signal() {
         _ = int.recv() => {},
     }
 }
-
-/// Wait for a shutdown signal (Ctrl+C).
-#[cfg(not(unix))]
-async fn shutdown_signal() {
-    tokio::signal::ctrl_c()
-        .await
-        .expect("failed to listen for ctrl+c");
-}
diff --git a/crates/atuin-daemon/src/search/index.rs b/crates/turtle/src/atuin_daemon/search/index.rs
index bb155979..df627e1b 100644
--- a/crates/atuin-daemon/src/search/index.rs
+++ b/crates/turtle/src/atuin_daemon/search/index.rs
@@ -12,8 +12,11 @@ use std::{
     sync::Arc,
 };
 
-use atuin_client::history::{History, is_known_agent};
-use atuin_client::settings::Search;
+use crate::atuin_client::settings::Search;
+use crate::{
+    atuin_client::history::{History, is_known_agent},
+    atuin_daemon::components::search::with_trailing_slash,
+};
 use atuin_nucleo::{Injector, Nucleo, pattern};
 use dashmap::DashMap;
 use lasso::{Spur, ThreadedRodeo};
@@ -22,8 +25,6 @@ use tokio::sync::RwLock;
 use tracing::{Level, instrument};
 use uuid::Uuid;
 
-use crate::components::search::with_trailing_slash;
-
 /// Parse a UUID string into a 16-byte array.
 /// Returns None if the string is not a valid UUID.
 fn parse_uuid_bytes(s: &str) -> Option<[u8; 16]> {
@@ -491,7 +492,7 @@ mod tests {
 
     #[test]
     fn frecency_data_compute() {
-        let now = 1000000i64;
+        let now = 1_000_000i64;
 
         // Recent command (with default multipliers of 1.0)
         let recent = FrecencyData {
@@ -518,7 +519,7 @@ mod tests {
 
     #[test]
     fn frecency_data_compute_with_multipliers() {
-        let now = 1000000i64;
+        let now = 1_000_000_i64;
 
         let data = FrecencyData {
             count: 5,
diff --git a/crates/atuin-daemon/src/search/mod.rs b/crates/turtle/src/atuin_daemon/search/mod.rs
index 4d261956..4d261956 100644
--- a/crates/atuin-daemon/src/search/mod.rs
+++ b/crates/turtle/src/atuin_daemon/search/mod.rs
diff --git a/crates/atuin-daemon/src/semantic/mod.rs b/crates/turtle/src/atuin_daemon/semantic/mod.rs
index c3511676..c3511676 100644
--- a/crates/atuin-daemon/src/semantic/mod.rs
+++ b/crates/turtle/src/atuin_daemon/semantic/mod.rs
diff --git a/crates/atuin-daemon/src/server.rs b/crates/turtle/src/atuin_daemon/server.rs
index b823cff2..23b04342 100644
--- a/crates/atuin-daemon/src/server.rs
+++ b/crates/turtle/src/atuin_daemon/server.rs
@@ -1,15 +1,15 @@
 use eyre::Result;
 
-use crate::components::history::HistoryGrpcService;
-use crate::components::search::SearchGrpcService;
-use crate::components::semantic::SemanticGrpcService;
-use crate::control::{ControlService, control_server::ControlServer};
-use crate::daemon::DaemonHandle;
-use crate::history::history_server::HistoryServer;
-use crate::search::search_server::SearchServer;
-use crate::semantic::semantic_server::SemanticServer;
+use crate::atuin_daemon::components::history::HistoryGrpcService;
+use crate::atuin_daemon::components::search::SearchGrpcService;
+use crate::atuin_daemon::components::semantic::SemanticGrpcService;
+use crate::atuin_daemon::control::{ControlService, control_server::ControlServer};
+use crate::atuin_daemon::daemon::DaemonHandle;
+use crate::atuin_daemon::history::history_server::HistoryServer;
+use crate::atuin_daemon::search::search_server::SearchServer;
+use crate::atuin_daemon::semantic::semantic_server::SemanticServer;
 
-use atuin_client::settings::Settings;
+use crate::atuin_client::settings::Settings;
 
 /// Run the gRPC server with the given services.
 ///
@@ -65,8 +65,6 @@ pub async fn run_grpc_server(
             }
             (UnixListener::from_std(listener)?, false)
         }
-        #[cfg(not(target_os = "linux"))]
-        unreachable!()
     } else {
         tracing::info!("listening on unix socket {socket_path:?}");
         (UnixListener::bind(socket_path.clone())?, true)
@@ -78,7 +76,7 @@ pub async fn run_grpc_server(
     let shutdown_signal = async move {
         let mut rx = handle.subscribe();
         loop {
-            use crate::DaemonEvent;
+            use crate::atuin_daemon::DaemonEvent;
 
             match rx.recv().await {
                 Ok(DaemonEvent::ShutdownRequested) => break,
@@ -115,56 +113,3 @@ pub async fn run_grpc_server(
 
     Ok(())
 }
-
-/// Run the gRPC server with the given services (Windows/TCP version).
-#[cfg(not(unix))]
-pub async fn run_grpc_server(
-    settings: Settings,
-    history_service: HistoryServer<HistoryGrpcService>,
-    search_service: SearchServer<SearchGrpcService>,
-    semantic_service: SemanticServer<SemanticGrpcService>,
-    control_service: ControlServer<ControlService>,
-    handle: DaemonHandle,
-) -> Result<()> {
-    use tokio::net::TcpListener;
-    use tokio_stream::wrappers::TcpListenerStream;
-    use tonic::transport::Server;
-
-    let port = settings.daemon.tcp_port;
-    let url = format!("127.0.0.1:{port}");
-    let tcp = TcpListener::bind(&url).await?;
-    let tcp_stream = TcpListenerStream::new(tcp);
-
-    tracing::info!("listening on tcp port {:?}", port);
-
-    // Create shutdown signal from daemon handle
-    let shutdown_signal = async move {
-        use crate::DaemonEvent;
-
-        let mut rx = handle.subscribe();
-        loop {
-            match rx.recv().await {
-                Ok(DaemonEvent::ShutdownRequested) => break,
-                Ok(_) => continue,
-                Err(_) => break, // Channel closed
-            }
-        }
-        eprintln!("Shutting down gRPC server...");
-    };
-
-    // Spawn the server in the background
-    tokio::spawn(async move {
-        if let Err(e) = Server::builder()
-            .add_service(history_service)
-            .add_service(search_service)
-            .add_service(semantic_service)
-            .add_service(control_service)
-            .serve_with_incoming_shutdown(tcp_stream, shutdown_signal)
-            .await
-        {
-            tracing::error!("gRPC server error: {e}");
-        }
-    });
-
-    Ok(())
-}
diff --git a/crates/atuin-history/src/lib.rs b/crates/turtle/src/atuin_history/mod.rs
index e7b33916..e7b33916 100644
--- a/crates/atuin-history/src/lib.rs
+++ b/crates/turtle/src/atuin_history/mod.rs
diff --git a/crates/atuin-history/src/sort.rs b/crates/turtle/src/atuin_history/sort.rs
index 022865a2..b162c810 100644
--- a/crates/atuin-history/src/sort.rs
+++ b/crates/turtle/src/atuin_history/sort.rs
@@ -1,4 +1,4 @@
-use atuin_client::history::History;
+use crate::atuin_client::history::History;
 
 type ScoredHistory = (f64, History);
 
diff --git a/crates/atuin-history/src/stats.rs b/crates/turtle/src/atuin_history/stats.rs
index fedb1487..e47d6c8e 100644
--- a/crates/atuin-history/src/stats.rs
+++ b/crates/turtle/src/atuin_history/stats.rs
@@ -4,7 +4,7 @@ use crossterm::style::{Color, ResetColor, SetAttribute, SetForegroundColor};
 use serde::{Deserialize, Serialize};
 use unicode_segmentation::UnicodeSegmentation;
 
-use atuin_client::{history::History, settings::Settings, theme::Meaning, theme::Theme};
+use crate::atuin_client::{history::History, settings::Settings, theme::Meaning, theme::Theme};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Stats {
@@ -299,8 +299,8 @@ pub fn compute(
 
 #[cfg(test)]
 mod tests {
-    use atuin_client::history::History;
-    use atuin_client::settings::Settings;
+    use crate::atuin_client::history::History;
+    use crate::atuin_client::settings::Settings;
     use time::OffsetDateTime;
 
     use super::compute;
diff --git a/crates/atuin-pty-proxy/src/capture.rs b/crates/turtle/src/atuin_pty_proxy/capture.rs
index 6426035b..97ac9b8f 100644
--- a/crates/atuin-pty-proxy/src/capture.rs
+++ b/crates/turtle/src/atuin_pty_proxy/capture.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU16, Ordering};
 
-use crate::osc133::{Event, Params, Parser, Zone};
+use crate::atuin_pty_proxy::osc133::{Event, Params, Parser, Zone};
 
 const HISTORY_ID_PARAM: &str = "history_id";
 const SESSION_ID_PARAM: &str = "session_id";
diff --git a/crates/atuin-pty-proxy/src/debug.rs b/crates/turtle/src/atuin_pty_proxy/debug.rs
index 806bde90..bf311281 100644
--- a/crates/atuin-pty-proxy/src/debug.rs
+++ b/crates/turtle/src/atuin_pty_proxy/debug.rs
@@ -1,4 +1,4 @@
-use crate::osc133::{Event, Parser};
+use crate::atuin_pty_proxy::osc133::{Event, Parser};
 
 pub(crate) const RESET: &[u8] = b"\x1b[0m";
 
diff --git a/crates/turtle/src/atuin_pty_proxy/mod.rs b/crates/turtle/src/atuin_pty_proxy/mod.rs
new file mode 100644
index 00000000..612943fa
--- /dev/null
+++ b/crates/turtle/src/atuin_pty_proxy/mod.rs
@@ -0,0 +1,17 @@
+#[cfg(unix)]
+mod capture;
+#[cfg(unix)]
+mod debug;
+#[cfg(unix)]
+mod osc133;
+#[cfg(unix)]
+mod pty_proxy;
+#[cfg(unix)]
+mod runtime;
+#[cfg(unix)]
+mod screen;
+
+#[cfg(unix)]
+pub use capture::{CommandCapture, CommandCaptureSink};
+#[cfg(unix)]
+pub use pty_proxy::PtyProxy;
diff --git a/crates/atuin-pty-proxy/src/osc133.rs b/crates/turtle/src/atuin_pty_proxy/osc133.rs
index 5b70f0aa..5b70f0aa 100644
--- a/crates/atuin-pty-proxy/src/osc133.rs
+++ b/crates/turtle/src/atuin_pty_proxy/osc133.rs
diff --git a/crates/atuin-pty-proxy/src/pty_proxy.rs b/crates/turtle/src/atuin_pty_proxy/pty_proxy.rs
index 19ccd274..8dde6f53 100644
--- a/crates/atuin-pty-proxy/src/pty_proxy.rs
+++ b/crates/turtle/src/atuin_pty_proxy/pty_proxy.rs
@@ -1,6 +1,6 @@
 use clap::{Args, Subcommand, ValueEnum};
 
-use crate::{CommandCaptureSink, runtime};
+use crate::atuin_pty_proxy::{CommandCaptureSink, runtime};
 
 #[derive(Args, Debug)]
 pub struct PtyProxy {
diff --git a/crates/atuin-pty-proxy/src/runtime.rs b/crates/turtle/src/atuin_pty_proxy/runtime.rs
index 2b34fbb7..37c77eef 100644
--- a/crates/atuin-pty-proxy/src/runtime.rs
+++ b/crates/turtle/src/atuin_pty_proxy/runtime.rs
@@ -6,10 +6,10 @@ use std::sync::mpsc;
 use crossterm::terminal;
 use portable_pty::{CommandBuilder, PtySize, native_pty_system};
 
-use crate::capture::CommandCaptureTracker;
-use crate::debug::{Osc133DebugHighlighter, RESET};
-use crate::pty_proxy::RuntimeOptions;
-use crate::screen::{self, Msg};
+use crate::atuin_pty_proxy::capture::CommandCaptureTracker;
+use crate::atuin_pty_proxy::debug::{Osc133DebugHighlighter, RESET};
+use crate::atuin_pty_proxy::pty_proxy::RuntimeOptions;
+use crate::atuin_pty_proxy::screen::{self, Msg};
 
 pub(crate) fn main(options: RuntimeOptions) {
     if let Err(e) = run(options) {
diff --git a/crates/atuin-pty-proxy/src/screen.rs b/crates/turtle/src/atuin_pty_proxy/screen.rs
index 5b892e21..5b892e21 100644
--- a/crates/atuin-pty-proxy/src/screen.rs
+++ b/crates/turtle/src/atuin_pty_proxy/screen.rs
diff --git a/crates/atuin-server/src/handlers/health.rs b/crates/turtle/src/atuin_server/handlers/health.rs
index aebd1e8f..aebd1e8f 100644
--- a/crates/atuin-server/src/handlers/health.rs
+++ b/crates/turtle/src/atuin_server/handlers/health.rs
diff --git a/crates/atuin-server/src/handlers/history.rs b/crates/turtle/src/atuin_server/handlers/history.rs
index bdafcc60..7f09161b 100644
--- a/crates/atuin-server/src/handlers/history.rs
+++ b/crates/turtle/src/atuin_server/handlers/history.rs
@@ -10,17 +10,17 @@ use time::{Month, UtcOffset};
 use tracing::{debug, error, instrument};
 
 use super::{ErrorResponse, ErrorResponseStatus, RespExt};
-use crate::{
+use crate::atuin_server::{
     router::{AppState, UserAuth},
     utils::client_version_min,
 };
-use atuin_server_database::{
+use crate::atuin_server_database::{
     Database,
     calendar::{TimePeriod, TimePeriodInfo},
     models::NewHistory,
 };
 
-use atuin_common::api::*;
+use crate::atuin_common::api::*;
 
 #[instrument(skip_all, fields(user.id = user.id))]
 pub async fn count<DB: Database>(
diff --git a/crates/atuin-server/src/handlers/mod.rs b/crates/turtle/src/atuin_server/handlers/mod.rs
index 2176ac5e..7722d03e 100644
--- a/crates/atuin-server/src/handlers/mod.rs
+++ b/crates/turtle/src/atuin_server/handlers/mod.rs
@@ -1,8 +1,8 @@
-use atuin_common::api::{ErrorResponse, IndexResponse};
-use atuin_server_database::Database;
+use crate::atuin_common::api::{ErrorResponse, IndexResponse};
+use crate::atuin_server_database::Database;
 use axum::{Json, extract::State, http, response::IntoResponse};
 
-use crate::router::AppState;
+use crate::atuin_server::router::AppState;
 
 pub mod health;
 pub mod history;
diff --git a/crates/atuin-server/src/handlers/record.rs b/crates/turtle/src/atuin_server/handlers/record.rs
index 410c54bd..63325606 100644
--- a/crates/atuin-server/src/handlers/record.rs
+++ b/crates/turtle/src/atuin_server/handlers/record.rs
@@ -3,9 +3,9 @@ use serde_json::json;
 use tracing::instrument;
 
 use super::{ErrorResponse, ErrorResponseStatus, RespExt};
-use crate::router::UserAuth;
+use crate::atuin_server::router::UserAuth;
 
-use atuin_common::record::{EncryptedData, Record};
+use crate::atuin_common::record::{EncryptedData, Record};
 
 #[instrument(skip_all, fields(user.id = user.id))]
 pub async fn post(UserAuth(user): UserAuth) -> Result<(), ErrorResponseStatus<'static>> {
diff --git a/crates/atuin-server/src/handlers/status.rs b/crates/turtle/src/atuin_server/handlers/status.rs
index 9c152d51..0cf2ca1e 100644
--- a/crates/atuin-server/src/handlers/status.rs
+++ b/crates/turtle/src/atuin_server/handlers/status.rs
@@ -2,10 +2,10 @@ use axum::{Json, extract::State, http::StatusCode};
 use tracing::instrument;
 
 use super::{ErrorResponse, ErrorResponseStatus, RespExt};
-use crate::router::{AppState, UserAuth};
-use atuin_server_database::Database;
+use crate::atuin_server::router::{AppState, UserAuth};
+use crate::atuin_server_database::Database;
 
-use atuin_common::api::*;
+use crate::atuin_common::api::*;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
diff --git a/crates/atuin-server/src/handlers/user.rs b/crates/turtle/src/atuin_server/handlers/user.rs
index dda7a381..01b72202 100644
--- a/crates/atuin-server/src/handlers/user.rs
+++ b/crates/turtle/src/atuin_server/handlers/user.rs
@@ -16,18 +16,18 @@ use metrics::counter;
 use rand::rngs::OsRng;
 use tracing::{debug, error, info, instrument};
 
-use atuin_common::tls::ensure_crypto_provider;
+use crate::atuin_common::tls::ensure_crypto_provider;
 
 use super::{ErrorResponse, ErrorResponseStatus, RespExt};
-use crate::router::{AppState, UserAuth};
-use atuin_server_database::{
+use crate::atuin_server::router::{AppState, UserAuth};
+use crate::atuin_server_database::{
     Database, DbError,
     models::{NewSession, NewUser},
 };
 
 use reqwest::header::CONTENT_TYPE;
 
-use atuin_common::{api::*, utils::crypto_random_string};
+use crate::atuin_common::{api::*, utils::crypto_random_string};
 
 pub fn verify_str(hash: &str, password: &str) -> bool {
     let arg2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, Params::default());
diff --git a/crates/atuin-server/src/handlers/v0/me.rs b/crates/turtle/src/atuin_server/handlers/v0/me.rs
index 7960b479..a1e2db46 100644
--- a/crates/atuin-server/src/handlers/v0/me.rs
+++ b/crates/turtle/src/atuin_server/handlers/v0/me.rs
@@ -1,10 +1,10 @@
 use axum::Json;
 use tracing::instrument;
 
-use crate::handlers::ErrorResponseStatus;
-use crate::router::UserAuth;
+use crate::atuin_server::handlers::ErrorResponseStatus;
+use crate::atuin_server::router::UserAuth;
 
-use atuin_common::api::*;
+use crate::atuin_common::api::*;
 
 #[instrument(skip_all, fields(user.id = user.id))]
 pub async fn get(
diff --git a/crates/atuin-server/src/handlers/v0/mod.rs b/crates/turtle/src/atuin_server/handlers/v0/mod.rs
index d6f880f2..d6f880f2 100644
--- a/crates/atuin-server/src/handlers/v0/mod.rs
+++ b/crates/turtle/src/atuin_server/handlers/v0/mod.rs
diff --git a/crates/atuin-server/src/handlers/v0/record.rs b/crates/turtle/src/atuin_server/handlers/v0/record.rs
index 5c57910b..9b147a52 100644
--- a/crates/atuin-server/src/handlers/v0/record.rs
+++ b/crates/turtle/src/atuin_server/handlers/v0/record.rs
@@ -3,13 +3,13 @@ use metrics::counter;
 use serde::Deserialize;
 use tracing::{error, instrument};
 
-use crate::{
+use crate::atuin_server::{
     handlers::{ErrorResponse, ErrorResponseStatus, RespExt},
     router::{AppState, UserAuth},
 };
-use atuin_server_database::Database;
+use crate::atuin_server_database::Database;
 
-use atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
+use crate::atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
 
 #[instrument(skip_all, fields(user.id = user.id))]
 pub async fn post<DB: Database>(
diff --git a/crates/atuin-server/src/handlers/v0/store.rs b/crates/turtle/src/atuin_server/handlers/v0/store.rs
index 6ca455d7..cd184546 100644
--- a/crates/atuin-server/src/handlers/v0/store.rs
+++ b/crates/turtle/src/atuin_server/handlers/v0/store.rs
@@ -3,11 +3,11 @@ use metrics::counter;
 use serde::Deserialize;
 use tracing::{error, instrument};
 
-use crate::{
+use crate::atuin_server::{
     handlers::{ErrorResponse, ErrorResponseStatus, RespExt},
     router::{AppState, UserAuth},
 };
-use atuin_server_database::Database;
+use crate::atuin_server_database::Database;
 
 #[derive(Deserialize)]
 pub struct DeleteParams {}
diff --git a/crates/atuin-server/src/metrics.rs b/crates/turtle/src/atuin_server/metrics.rs
index ebd0dd2d..ebd0dd2d 100644
--- a/crates/atuin-server/src/metrics.rs
+++ b/crates/turtle/src/atuin_server/metrics.rs
diff --git a/crates/atuin-server/src/lib.rs b/crates/turtle/src/atuin_server/mod.rs
index 02e50e1e..bd0f2168 100644
--- a/crates/atuin-server/src/lib.rs
+++ b/crates/turtle/src/atuin_server/mod.rs
@@ -1,9 +1,7 @@
-#![forbid(unsafe_code)]
-
 use std::future::Future;
 use std::net::SocketAddr;
 
-use atuin_server_database::Database;
+use crate::atuin_server_database::Database;
 use axum::{Router, serve};
 use eyre::{Context, Result};
 
@@ -13,7 +11,6 @@ mod router;
 mod utils;
 
 pub use settings::Settings;
-pub use settings::example_config;
 
 pub mod settings;
 
diff --git a/crates/atuin-server/src/router.rs b/crates/turtle/src/atuin_server/router.rs
index 2d679759..11a16148 100644
--- a/crates/atuin-server/src/router.rs
+++ b/crates/turtle/src/atuin_server/router.rs
@@ -1,4 +1,4 @@
-use atuin_common::api::{ATUIN_CARGO_VERSION, ATUIN_HEADER_VERSION, ErrorResponse};
+use crate::atuin_common::api::{ATUIN_CARGO_VERSION, ATUIN_HEADER_VERSION, ErrorResponse};
 use axum::{
     Router,
     extract::{FromRequestParts, Request},
@@ -12,12 +12,12 @@ use tower::ServiceBuilder;
 use tower_http::trace::TraceLayer;
 
 use super::handlers;
-use crate::{
+use crate::atuin_server::{
     handlers::{ErrorResponseStatus, RespExt},
     metrics,
     settings::Settings,
 };
-use atuin_server_database::{Database, DbError, models::User};
+use crate::atuin_server_database::{Database, DbError, models::User};
 
 pub struct UserAuth(pub User);
 
diff --git a/crates/atuin-server/src/settings.rs b/crates/turtle/src/atuin_server/settings.rs
index 3a612be9..f6650af0 100644
--- a/crates/atuin-server/src/settings.rs
+++ b/crates/turtle/src/atuin_server/settings.rs
@@ -1,13 +1,11 @@
 use std::{io::prelude::*, path::PathBuf};
 
-use atuin_server_database::DbSettings;
+use crate::atuin_server_database::DbSettings;
 use config::{Config, Environment, File as ConfigFile, FileFormat};
 use eyre::{Result, eyre};
 use fs_err::{File, create_dir_all};
 use serde::{Deserialize, Serialize};
 
-static EXAMPLE_CONFIG: &str = include_str!("../server.toml");
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Metrics {
     #[serde(alias = "enabled")]
@@ -60,7 +58,7 @@ impl Settings {
             PathBuf::from(p)
         } else {
             let mut config_file = PathBuf::new();
-            let config_dir = atuin_common::utils::config_dir();
+            let config_dir = crate::atuin_common::utils::config_dir();
             config_file.push(config_dir);
             config_file
         };
@@ -87,27 +85,26 @@ impl Settings {
                     .separator("__"),
             );
 
-        config_builder = if config_file.exists() {
-            config_builder.add_source(ConfigFile::new(
-                config_file.to_str().unwrap(),
-                FileFormat::Toml,
-            ))
+        let config = if config_file.exists() {
+            config_builder
+                .add_source(ConfigFile::new(
+                    config_file.to_str().unwrap(),
+                    FileFormat::Toml,
+                ))
+                .build()?
         } else {
             create_dir_all(config_file.parent().unwrap())?;
             let mut file = File::create(config_file)?;
-            file.write_all(EXAMPLE_CONFIG.as_bytes())?;
 
-            config_builder
-        };
+            let config = config_builder.build()?;
+            // TODO(@bpeetz): I'm quiet unsure, if this will work <2026-06-10>
+            file.write_all(config.cache.to_string().as_bytes())?;
 
-        let config = config_builder.build()?;
+            config
+        };
 
         config
             .try_deserialize()
             .map_err(|e| eyre!("failed to deserialize: {}", e))
     }
 }
-
-pub fn example_config() -> &'static str {
-    EXAMPLE_CONFIG
-}
diff --git a/crates/atuin-server/src/utils.rs b/crates/turtle/src/atuin_server/utils.rs
index 12e9ac1b..12e9ac1b 100644
--- a/crates/atuin-server/src/utils.rs
+++ b/crates/turtle/src/atuin_server/utils.rs
diff --git a/crates/atuin-server-database/src/calendar.rs b/crates/turtle/src/atuin_server_database/calendar.rs
index 2229667b..2229667b 100644
--- a/crates/atuin-server-database/src/calendar.rs
+++ b/crates/turtle/src/atuin_server_database/calendar.rs
diff --git a/crates/atuin-server-database/src/lib.rs b/crates/turtle/src/atuin_server_database/mod.rs
index 5437fc15..91077b84 100644
--- a/crates/atuin-server-database/src/lib.rs
+++ b/crates/turtle/src/atuin_server_database/mod.rs
@@ -1,5 +1,3 @@
-#![forbid(unsafe_code)]
-
 pub mod calendar;
 pub mod models;
 
@@ -14,7 +12,7 @@ use self::{
     models::{History, NewHistory, NewSession, NewUser, Session, User},
 };
 use async_trait::async_trait;
-use atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
+use crate::atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
 use serde::{Deserialize, Serialize};
 use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
 use tracing::instrument;
diff --git a/crates/atuin-server-database/src/models.rs b/crates/turtle/src/atuin_server_database/models.rs
index b71a9bc9..b71a9bc9 100644
--- a/crates/atuin-server-database/src/models.rs
+++ b/crates/turtle/src/atuin_server_database/models.rs
diff --git a/crates/atuin-server-postgres/src/lib.rs b/crates/turtle/src/atuin_server_postgres/mod.rs
index 2e69c7f2..f506cf25 100644
--- a/crates/atuin-server-postgres/src/lib.rs
+++ b/crates/turtle/src/atuin_server_postgres/mod.rs
@@ -3,10 +3,12 @@ use std::ops::Range;
 
 use rand::Rng;
 
+use crate::atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
+use crate::atuin_server_database::models::{
+    History, NewHistory, NewSession, NewUser, Session, User,
+};
+use crate::atuin_server_database::{Database, DbError, DbResult, DbSettings, into_utc};
 use async_trait::async_trait;
-use atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
-use atuin_server_database::models::{History, NewHistory, NewSession, NewUser, Session, User};
-use atuin_server_database::{Database, DbError, DbResult, DbSettings, into_utc};
 use futures_util::TryStreamExt;
 use sqlx::Row;
 use sqlx::postgres::PgPoolOptions;
@@ -289,7 +291,7 @@ impl Database for Postgres {
 
             sqlx::query(
                 "insert into history
-                    (client_id, user_id, hostname, timestamp, data) 
+                    (client_id, user_id, hostname, timestamp, data)
                 values ($1, $2, $3, $4, $5)
                 on conflict do nothing
                 ",
@@ -430,11 +432,11 @@ impl Database for Postgres {
         let mut heads = HashMap::<(HostId, &str), u64>::new();
 
         for i in records {
-            let id = atuin_common::utils::uuid_v7();
+            let id = crate::atuin_common::utils::uuid_v7();
 
             let result = sqlx::query(
                 "insert into store
-                    (id, client_id, host, idx, timestamp, version, tag, data, cek, user_id) 
+                    (id, client_id, host, idx, timestamp, version, tag, data, cek, user_id)
                 values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                 on conflict do nothing
                 ",
@@ -469,7 +471,7 @@ impl Database for Postgres {
         for ((host, tag), idx) in heads {
             sqlx::query(
                 "insert into store_idx_cache
-                    (user_id, host, tag, idx) 
+                    (user_id, host, tag, idx)
                 values ($1, $2, $3, $4)
                 on conflict(user_id, host, tag) do update set idx = greatest(store_idx_cache.idx, $4)
                 ",
diff --git a/crates/atuin-server-postgres/src/wrappers.rs b/crates/turtle/src/atuin_server_postgres/wrappers.rs
index cde4134c..214b255d 100644
--- a/crates/atuin-server-postgres/src/wrappers.rs
+++ b/crates/turtle/src/atuin_server_postgres/wrappers.rs
@@ -1,6 +1,6 @@
 use ::sqlx::{FromRow, Result};
-use atuin_common::record::{EncryptedData, Host, Record};
-use atuin_server_database::models::{History, Session, User};
+use crate::atuin_common::record::{EncryptedData, Host, Record};
+use crate::atuin_server_database::models::{History, Session, User};
 use sqlx::{Row, postgres::PgRow};
 use time::PrimitiveDateTime;
 
diff --git a/crates/atuin-server-sqlite/src/lib.rs b/crates/turtle/src/atuin_server_sqlite/mod.rs
index 56ed9b6c..3470a2f1 100644
--- a/crates/atuin-server-sqlite/src/lib.rs
+++ b/crates/turtle/src/atuin_server_sqlite/mod.rs
@@ -1,11 +1,11 @@
 use std::str::FromStr;
 
-use async_trait::async_trait;
-use atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
-use atuin_server_database::{
+use crate::atuin_common::record::{EncryptedData, HostId, Record, RecordIdx, RecordStatus};
+use crate::atuin_server_database::{
     Database, DbError, DbResult, DbSettings, into_utc,
     models::{History, NewHistory, NewSession, NewUser, Session, User},
 };
+use async_trait::async_trait;
 use futures_util::TryStreamExt;
 use sqlx::{
     Row,
@@ -203,7 +203,7 @@ impl Database for Sqlite {
         // edge case.
 
         let res = sqlx::query(
-            "select client_id from history 
+            "select client_id from history
             where user_id = $1
             and deleted_at is not null",
         )
@@ -233,11 +233,11 @@ impl Database for Sqlite {
         let mut tx = self.pool.begin().await?;
 
         for i in records {
-            let id = atuin_common::utils::uuid_v7();
+            let id = crate::atuin_common::utils::uuid_v7();
 
             sqlx::query(
                 "insert into store
-                    (id, client_id, host, idx, timestamp, version, tag, data, cek, user_id) 
+                    (id, client_id, host, idx, timestamp, version, tag, data, cek, user_id)
                 values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                 on conflict do nothing
                 ",
@@ -394,7 +394,7 @@ impl Database for Sqlite {
 
             sqlx::query(
                 "insert into history
-                    (client_id, user_id, hostname, timestamp, data) 
+                    (client_id, user_id, hostname, timestamp, data)
                 values ($1, $2, $3, $4, $5)
                 on conflict do nothing
                 ",
@@ -416,7 +416,7 @@ impl Database for Sqlite {
     #[instrument(skip_all)]
     async fn oldest_history(&self, user: &User) -> DbResult<History> {
         sqlx::query_as(
-            "select id, client_id, user_id, hostname, timestamp, data, created_at from history 
+            "select id, client_id, user_id, hostname, timestamp, data, created_at from history
             where user_id = $1
             order by timestamp asc
             limit 1",
diff --git a/crates/atuin-server-sqlite/src/wrappers.rs b/crates/turtle/src/atuin_server_sqlite/wrappers.rs
index 2f1230c2..5aa7a982 100644
--- a/crates/atuin-server-sqlite/src/wrappers.rs
+++ b/crates/turtle/src/atuin_server_sqlite/wrappers.rs
@@ -1,6 +1,6 @@
 use ::sqlx::{FromRow, Result};
-use atuin_common::record::{EncryptedData, Host, Record};
-use atuin_server_database::models::{History, Session, User};
+use crate::atuin_common::record::{EncryptedData, Host, Record};
+use crate::atuin_server_database::models::{History, Session, User};
 use sqlx::{Row, sqlite::SqliteRow};
 
 pub struct DbUser(pub User);
diff --git a/crates/atuin/src/command/CONTRIBUTORS b/crates/turtle/src/command/CONTRIBUTORS
index 1ca4115a..1ca4115a 120000
--- a/crates/atuin/src/command/CONTRIBUTORS
+++ b/crates/turtle/src/command/CONTRIBUTORS
diff --git a/crates/atuin/src/command/client.rs b/crates/turtle/src/command/client.rs
index 6c1bac29..20d85303 100644
--- a/crates/atuin/src/command/client.rs
+++ b/crates/turtle/src/command/client.rs
@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 use clap::Subcommand;
 use eyre::{Result, WrapErr};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Sqlite, record::sqlite_store::SqliteStore, settings::Settings, theme,
 };
 use tracing_appender::rolling::{RollingFileAppender, Rotation};
@@ -57,6 +57,7 @@ mod import;
 mod info;
 mod init;
 mod search;
+mod server;
 mod setup;
 mod stats;
 mod store;
@@ -87,6 +88,10 @@ pub enum Cmd {
     #[command(flatten)]
     Sync(sync::Cmd),
 
+    /// Manage the atuin server
+    #[command(subcommand)]
+    Server(server::Cmd),
+
     /// Manage your sync account
     #[cfg(feature = "sync")]
     Account(account::Cmd),
@@ -341,6 +346,8 @@ impl Cmd {
 
             Self::Store(store) => store.run(&settings, &db, sqlite_store).await,
 
+            Self::Server(server) => server.run().await,
+
             Self::Info => {
                 info::run(&settings);
                 Ok(())
diff --git a/crates/atuin/src/command/client/account.rs b/crates/turtle/src/command/client/account.rs
index fc1c9343..898f1ac4 100644
--- a/crates/atuin/src/command/client/account.rs
+++ b/crates/turtle/src/command/client/account.rs
@@ -1,8 +1,8 @@
 use clap::{Args, Subcommand};
 use eyre::Result;
 
-use atuin_client::record::sqlite_store::SqliteStore;
-use atuin_client::settings::Settings;
+use crate::atuin_client::record::sqlite_store::SqliteStore;
+use crate::atuin_client::settings::Settings;
 
 pub mod change_password;
 pub mod delete;
diff --git a/crates/atuin/src/command/client/account/change_password.rs b/crates/turtle/src/command/client/account/change_password.rs
index 234d4dc0..6112b0df 100644
--- a/crates/atuin/src/command/client/account/change_password.rs
+++ b/crates/turtle/src/command/client/account/change_password.rs
@@ -1,7 +1,7 @@
 use clap::Parser;
 use eyre::{Result, bail};
 
-use atuin_client::{
+use crate::atuin_client::{
     auth::{self, MutateResponse},
     settings::Settings,
 };
diff --git a/crates/atuin/src/command/client/account/delete.rs b/crates/turtle/src/command/client/account/delete.rs
index a5e7f0dd..bcb40bc3 100644
--- a/crates/atuin/src/command/client/account/delete.rs
+++ b/crates/turtle/src/command/client/account/delete.rs
@@ -1,4 +1,4 @@
-use atuin_client::{
+use crate::atuin_client::{
     auth::{self, MutateResponse},
     settings::Settings,
 };
diff --git a/crates/atuin/src/command/client/account/login.rs b/crates/turtle/src/command/client/account/login.rs
index e320e80b..0c5b66f5 100644
--- a/crates/atuin/src/command/client/account/login.rs
+++ b/crates/turtle/src/command/client/account/login.rs
@@ -4,7 +4,7 @@ use clap::Parser;
 use eyre::{Context, Result, bail};
 use tokio::{fs::File, io::AsyncWriteExt};
 
-use atuin_client::{
+use crate::atuin_client::{
     auth::{self, AuthResponse},
     encryption::{decode_key, load_key},
     record::sqlite_store::SqliteStore,
@@ -65,7 +65,7 @@ impl Cmd {
         self.prompt_and_store_key(settings, store).await?;
 
         let client = auth::auth_client(settings).await;
-        let response = client.login(&username, &password, None).await?;
+        let response = client.login(&username, &password).await?;
 
         match response {
             AuthResponse::Success { session, .. } => {
diff --git a/crates/atuin/src/command/client/account/logout.rs b/crates/turtle/src/command/client/account/logout.rs
index b958e65a..6150a52b 100644
--- a/crates/atuin/src/command/client/account/logout.rs
+++ b/crates/turtle/src/command/client/account/logout.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
 
 pub async fn run() -> Result<()> {
-    atuin_client::logout::logout().await
+    crate::atuin_client::logout::logout().await
 }
diff --git a/crates/atuin/src/command/client/account/register.rs b/crates/turtle/src/command/client/account/register.rs
index bd836e7b..548c2739 100644
--- a/crates/atuin/src/command/client/account/register.rs
+++ b/crates/turtle/src/command/client/account/register.rs
@@ -2,7 +2,7 @@ use clap::Parser;
 use eyre::{Result, bail};
 
 use super::login::or_user_input;
-use atuin_client::settings::{Settings, SyncAuth};
+use crate::atuin_client::settings::{Settings, SyncAuth};
 
 #[derive(Parser, Debug)]
 pub struct Cmd {
@@ -42,7 +42,7 @@ impl Cmd {
             bail!("please provide a password");
         }
 
-        let session = atuin_client::api_client::register(
+        let session = crate::atuin_client::api_client::register(
             settings.sync_address.as_str(),
             &username,
             &email,
@@ -53,7 +53,7 @@ impl Cmd {
         let meta = Settings::meta_store().await?;
         meta.save_session(&session.session).await?;
 
-        let _key = atuin_client::encryption::load_key(settings)?;
+        let _key = crate::atuin_client::encryption::load_key(settings)?;
 
         println!(
             "Registration successful! Please make a note of your key (run 'atuin key') and keep it safe."
diff --git a/crates/atuin/src/command/client/config.rs b/crates/turtle/src/command/client/config.rs
index 5ec5f7f3..1597a8d6 100644
--- a/crates/atuin/src/command/client/config.rs
+++ b/crates/turtle/src/command/client/config.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Settings;
+use crate::atuin_client::settings::Settings;
 use clap::{Args, Subcommand, ValueEnum};
 use eyre::Result;
 use toml_edit::{Document, DocumentMut, Item, Table, TableLike, Value};
diff --git a/crates/atuin/src/command/client/daemon.rs b/crates/turtle/src/command/client/daemon.rs
index c3dcf9d0..2ee9b759 100644
--- a/crates/atuin/src/command/client/daemon.rs
+++ b/crates/turtle/src/command/client/daemon.rs
@@ -6,11 +6,13 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::time::{Duration, Instant};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Sqlite, history::History, record::sqlite_store::SqliteStore, settings::Settings,
 };
-use atuin_daemon::DaemonEvent;
-use atuin_daemon::client::{ControlClient, DaemonClientErrorKind, HistoryClient, classify_error};
+use crate::atuin_daemon::DaemonEvent;
+use crate::atuin_daemon::client::{
+    ControlClient, DaemonClientErrorKind, HistoryClient, classify_error,
+};
 use clap::Subcommand;
 #[cfg(unix)]
 use daemonize::Daemonize;
@@ -218,8 +220,6 @@ async fn wait_for_pidfile_available(path: &Path, timeout: Duration) -> Result<()
 
 async fn connect_client(settings: &Settings) -> Result<HistoryClient> {
     HistoryClient::new(
-        #[cfg(not(unix))]
-        settings.daemon.tcp_port,
         #[cfg(unix)]
         settings.daemon.socket_path.clone(),
     )
@@ -339,8 +339,6 @@ fn ensure_autostart_supported(settings: &Settings) -> Result<()> {
             "daemon autostart is incompatible with `daemon.systemd_socket = true`; use systemd to manage the daemon"
         );
     }
-    #[cfg(not(unix))]
-    let _ = settings;
 
     Ok(())
 }
@@ -546,8 +544,6 @@ async fn status_cmd(settings: &Settings) -> Result<()> {
             println!("  Healthy:  {}", status.healthy);
             #[cfg(unix)]
             println!("  Socket:   {}", settings.daemon.socket_path);
-            #[cfg(not(unix))]
-            println!("  Port:     {}", settings.daemon.tcp_port);
         }
         Probe::NeedsRestart(reason) => {
             println!("Daemon running (needs restart)");
@@ -648,7 +644,7 @@ async fn run(
     let pidfile_path = PathBuf::from(&settings.daemon.pidfile_path);
     let _pidfile_guard = PidfileGuard::acquire(&pidfile_path)?;
 
-    atuin_daemon::boot(settings, store, history_db).await?;
+    crate::atuin_daemon::boot(settings, store, history_db).await?;
 
     Ok(())
 }
@@ -700,17 +696,6 @@ fn kill_process(pid: u32) {
         .status();
 }
 
-/// Kill a process by PID.
-#[cfg(not(unix))]
-fn kill_process(pid: u32) {
-    // On Windows, use taskkill
-    let _ = Command::new("taskkill")
-        .args(["/PID", &pid.to_string(), "/F"])
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status();
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/turtle/src/command/client/default_config.rs b/crates/turtle/src/command/client/default_config.rs
new file mode 100644
index 00000000..e8cc15f9
--- /dev/null
+++ b/crates/turtle/src/command/client/default_config.rs
@@ -0,0 +1,4 @@
+pub fn run() {
+    // TODO(@bpeetz): Re-add the default settings option back (Settings::example_config()) <2026-06-11>
+    println!("TODO");
+}
diff --git a/crates/atuin/src/command/client/doctor.rs b/crates/turtle/src/command/client/doctor.rs
index 1bf003db..09fa6e77 100644
--- a/crates/atuin/src/command/client/doctor.rs
+++ b/crates/turtle/src/command/client/doctor.rs
@@ -1,10 +1,10 @@
 use std::process::Command;
 use std::{env, str::FromStr};
 
-use atuin_client::database::Sqlite;
-use atuin_client::settings::Settings;
-use atuin_common::shell::{Shell, shell_name};
-use atuin_common::utils;
+use crate::atuin_client::database::Sqlite;
+use crate::atuin_client::settings::Settings;
+use crate::atuin_common::shell::{Shell, shell_name};
+use crate::atuin_common::utils;
 use colored::Colorize;
 use eyre::Result;
 use serde::Serialize;
@@ -168,7 +168,7 @@ impl ShellInfo {
     }
 
     pub fn new() -> Self {
-        // TODO: rework to use atuin_common::Shell
+        // TODO: rework to use crate::atuin_common::Shell
 
         let sys = System::new_all();
 
diff --git a/crates/atuin/src/command/client/history.rs b/crates/turtle/src/command/client/history.rs
index abf39cc2..0c61392c 100644
--- a/crates/atuin/src/command/client/history.rs
+++ b/crates/turtle/src/command/client/history.rs
@@ -5,7 +5,7 @@ use std::{
     time::Duration,
 };
 
-use atuin_common::utils::{self, Escapable as _};
+use crate::atuin_common::utils::{self, Escapable as _};
 use clap::Subcommand;
 use eyre::{Context, Result, bail};
 use runtime_format::{FormatKey, FormatKeyError, ParseSegment, ParsedFmt};
@@ -18,9 +18,9 @@ use colored::Colorize;
 use serde::Serialize;
 
 #[cfg(feature = "daemon")]
-use atuin_daemon::history::{HistoryEventKind, TailHistoryReply};
+use crate::atuin_daemon::history::{HistoryEventKind, TailHistoryReply};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::{Database, Sqlite, current_context},
     encryption,
     history::{History, store::HistoryStore},
@@ -32,7 +32,7 @@ use atuin_client::{
 };
 
 #[cfg(feature = "sync")]
-use atuin_client::{record, sync};
+use crate::atuin_client::record;
 
 use log::{debug, warn};
 use time::{OffsetDateTime, macros::format_description};
@@ -924,7 +924,7 @@ impl Cmd {
     async fn handle_list(
         db: &impl Database,
         settings: &Settings,
-        context: atuin_client::database::Context,
+        context: crate::atuin_client::database::Context,
         session: bool,
         cwd: bool,
         mode: ListMode,
@@ -967,7 +967,7 @@ impl Cmd {
         db: &impl Database,
         settings: &Settings,
         store: SqliteStore,
-        context: atuin_client::database::Context,
+        context: crate::atuin_client::database::Context,
         dry_run: bool,
     ) -> Result<()> {
         // Grab all executed commands and filter them using History::should_save.
@@ -1011,7 +1011,7 @@ impl Cmd {
             }
 
             #[cfg(feature = "daemon")]
-            daemon_cmd::emit_event(settings, atuin_daemon::DaemonEvent::HistoryPruned).await;
+            daemon_cmd::emit_event(settings, crate::atuin_daemon::DaemonEvent::HistoryPruned).await;
         }
         Ok(())
     }
@@ -1068,8 +1068,11 @@ impl Cmd {
             }
 
             #[cfg(feature = "daemon")]
-            daemon_cmd::emit_event(settings, atuin_daemon::DaemonEvent::HistoryDeleted { ids })
-                .await;
+            daemon_cmd::emit_event(
+                settings,
+                crate::atuin_daemon::DaemonEvent::HistoryDeleted { ids },
+            )
+            .await;
         }
         Ok(())
     }
diff --git a/crates/atuin/src/command/client/import.rs b/crates/turtle/src/command/client/import.rs
index 21ac76b4..363e6405 100644
--- a/crates/atuin/src/command/client/import.rs
+++ b/crates/turtle/src/command/client/import.rs
@@ -5,7 +5,7 @@ use clap::Parser;
 use eyre::Result;
 use indicatif::ProgressBar;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     history::History,
     import::{
diff --git a/crates/atuin/src/command/client/info.rs b/crates/turtle/src/command/client/info.rs
index a69f9b2f..ee24c419 100644
--- a/crates/atuin/src/command/client/info.rs
+++ b/crates/turtle/src/command/client/info.rs
@@ -1,9 +1,9 @@
-use atuin_client::settings::Settings;
+use crate::atuin_client::settings::Settings;
 
 use crate::{SHA, VERSION};
 
 pub fn run(settings: &Settings) {
-    let config = atuin_common::utils::config_dir();
+    let config = crate::atuin_common::utils::config_dir();
     let mut config_file = config.clone();
     config_file.push("config.toml");
     let mut sever_config = config;
diff --git a/crates/atuin/src/command/client/init.rs b/crates/turtle/src/command/client/init.rs
index 39cd1247..bf9747bb 100644
--- a/crates/atuin/src/command/client/init.rs
+++ b/crates/turtle/src/command/client/init.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::{Settings, Tmux};
+use crate::atuin_client::settings::{Settings, Tmux};
 use clap::{Parser, ValueEnum};
 
 mod bash;
diff --git a/crates/atuin/src/command/client/init/bash.rs b/crates/turtle/src/command/client/init/bash.rs
index 2280dc3d..fd17e37e 100644
--- a/crates/atuin/src/command/client/init/bash.rs
+++ b/crates/turtle/src/command/client/init/bash.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Tmux;
+use crate::atuin_client::settings::Tmux;
 
 fn print_tmux_config(tmux: &Tmux) {
     if tmux.enabled {
diff --git a/crates/atuin/src/command/client/init/fish.rs b/crates/turtle/src/command/client/init/fish.rs
index 07c6a5ba..8a046bfa 100644
--- a/crates/atuin/src/command/client/init/fish.rs
+++ b/crates/turtle/src/command/client/init/fish.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Tmux;
+use crate::atuin_client::settings::Tmux;
 
 fn print_tmux_config(tmux: &Tmux) {
     if tmux.enabled {
diff --git a/crates/atuin/src/command/client/init/powershell.rs b/crates/turtle/src/command/client/init/powershell.rs
index f92f1cbe..10c0c461 100644
--- a/crates/atuin/src/command/client/init/powershell.rs
+++ b/crates/turtle/src/command/client/init/powershell.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Tmux;
+use crate::atuin_client::settings::Tmux;
 
 pub fn init_static(disable_up_arrow: bool, disable_ctrl_r: bool, _tmux: &Tmux) {
     let base = include_str!("../../../shell/atuin.ps1");
diff --git a/crates/atuin/src/command/client/init/xonsh.rs b/crates/turtle/src/command/client/init/xonsh.rs
index 9fb5730d..a17d85d8 100644
--- a/crates/atuin/src/command/client/init/xonsh.rs
+++ b/crates/turtle/src/command/client/init/xonsh.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Tmux;
+use crate::atuin_client::settings::Tmux;
 
 pub fn init_static(disable_up_arrow: bool, disable_ctrl_r: bool, _tmux: &Tmux) {
     let base = include_str!("../../../shell/atuin.xsh");
diff --git a/crates/atuin/src/command/client/init/zsh.rs b/crates/turtle/src/command/client/init/zsh.rs
index 3f325167..38c3086b 100644
--- a/crates/atuin/src/command/client/init/zsh.rs
+++ b/crates/turtle/src/command/client/init/zsh.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Tmux;
+use crate::atuin_client::settings::Tmux;
 
 fn print_tmux_config(tmux: &Tmux) {
     if tmux.enabled {
diff --git a/crates/atuin/src/command/client/search.rs b/crates/turtle/src/command/client/search.rs
index a9dc9a68..4a2114d5 100644
--- a/crates/atuin/src/command/client/search.rs
+++ b/crates/turtle/src/command/client/search.rs
@@ -1,11 +1,11 @@
 use std::fs::File;
 use std::io::{IsTerminal as _, Write, stderr, stdout};
 
-use atuin_common::utils::{self, Escapable as _};
+use crate::atuin_common::utils::{self, Escapable as _};
 use clap::Parser;
 use eyre::Result;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     database::{OptFilters, current_context},
     encryption,
diff --git a/crates/atuin/src/command/client/search/cursor.rs b/crates/turtle/src/command/client/search/cursor.rs
index c1cdfee4..84f94082 100644
--- a/crates/atuin/src/command/client/search/cursor.rs
+++ b/crates/turtle/src/command/client/search/cursor.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::WordJumpMode;
+use crate::atuin_client::settings::WordJumpMode;
 
 pub struct Cursor {
     source: String,
diff --git a/crates/atuin/src/command/client/search/duration.rs b/crates/turtle/src/command/client/search/duration.rs
index 54856c87..54856c87 100644
--- a/crates/atuin/src/command/client/search/duration.rs
+++ b/crates/turtle/src/command/client/search/duration.rs
diff --git a/crates/atuin/src/command/client/search/engines.rs b/crates/turtle/src/command/client/search/engines.rs
index 886f0171..0f92b4c7 100644
--- a/crates/atuin/src/command/client/search/engines.rs
+++ b/crates/turtle/src/command/client/search/engines.rs
@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use atuin_client::{
+use crate::atuin_client::{
     database::{Context, Database, OptFilters},
     history::{AUTHOR_FILTER_ALL_USER, History, HistoryId},
     settings::{FilterMode, SearchMode, Settings},
diff --git a/crates/atuin/src/command/client/search/engines/daemon.rs b/crates/turtle/src/command/client/search/engines/daemon.rs
index 8b15c180..b1299c02 100644
--- a/crates/atuin/src/command/client/search/engines/daemon.rs
+++ b/crates/turtle/src/command/client/search/engines/daemon.rs
@@ -1,10 +1,10 @@
-use async_trait::async_trait;
-use atuin_client::{
+use crate::atuin_client::{
     database::{Database, OptFilters},
     history::{AUTHOR_FILTER_ALL_USER, History},
     settings::{SearchMode, Settings},
 };
-use atuin_daemon::client::{DaemonClientErrorKind, SearchClient, classify_error};
+use crate::atuin_daemon::client::{DaemonClientErrorKind, SearchClient, classify_error};
+use async_trait::async_trait;
 use atuin_nucleo_matcher::{
     Config, Matcher, Utf32Str,
     pattern::{CaseMatching, Normalization, Pattern},
@@ -22,8 +22,6 @@ pub struct Search {
     settings: Settings,
     #[cfg(unix)]
     socket_path: String,
-    #[cfg(not(unix))]
-    tcp_port: u64,
 }
 
 impl Search {
@@ -34,8 +32,6 @@ impl Search {
             settings: settings.clone(),
             #[cfg(unix)]
             socket_path: settings.daemon.socket_path.clone(),
-            #[cfg(not(unix))]
-            tcp_port: settings.daemon.tcp_port,
         }
     }
 
@@ -51,9 +47,6 @@ impl Search {
         #[cfg(unix)]
         let client = SearchClient::new(self.socket_path.clone()).await?;
 
-        #[cfg(not(unix))]
-        let client = SearchClient::new(self.tcp_port).await?;
-
         self.client = Some(client);
         Ok(())
     }
diff --git a/crates/atuin/src/command/client/search/engines/db.rs b/crates/turtle/src/command/client/search/engines/db.rs
index b15aabd8..2765faf5 100644
--- a/crates/atuin/src/command/client/search/engines/db.rs
+++ b/crates/turtle/src/command/client/search/engines/db.rs
@@ -1,6 +1,6 @@
 use super::{SearchEngine, SearchState};
 use async_trait::async_trait;
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     database::OptFilters,
     database::{QueryToken, QueryTokenizer},
diff --git a/crates/atuin/src/command/client/search/engines/skim.rs b/crates/turtle/src/command/client/search/engines/skim.rs
index fe05fd09..96a6574d 100644
--- a/crates/atuin/src/command/client/search/engines/skim.rs
+++ b/crates/turtle/src/command/client/search/engines/skim.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use async_trait::async_trait;
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     history::{History, is_known_agent},
     settings::FilterMode,
diff --git a/crates/atuin/src/command/client/search/history_list.rs b/crates/turtle/src/command/client/search/history_list.rs
index 7af324b4..4c83d7eb 100644
--- a/crates/atuin/src/command/client/search/history_list.rs
+++ b/crates/turtle/src/command/client/search/history_list.rs
@@ -2,12 +2,12 @@ use std::time::Duration;
 
 use super::duration::format_duration;
 use super::engines::SearchEngine;
-use atuin_client::{
+use crate::atuin_client::{
     history::History,
     settings::{UiColumn, UiColumnType},
     theme::{Meaning, Theme},
 };
-use atuin_common::utils::Escapable as _;
+use crate::atuin_common::utils::Escapable as _;
 use itertools::Itertools;
 use ratatui::{
     backend::FromCrossterm,
diff --git a/crates/atuin/src/command/client/search/inspector.rs b/crates/turtle/src/command/client/search/inspector.rs
index e2cdabe5..1ebc4383 100644
--- a/crates/atuin/src/command/client/search/inspector.rs
+++ b/crates/turtle/src/command/client/search/inspector.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 use time::macros::format_description;
 
-use atuin_client::{
+use crate::atuin_client::{
     history::{History, HistoryStats},
     settings::{Settings, Timezone},
 };
@@ -338,7 +338,7 @@ pub fn draw_full(
 #[cfg(test)]
 mod tests {
     use super::draw_ultracompact;
-    use atuin_client::{
+    use crate::atuin_client::{
         history::{History, HistoryId, HistoryStats},
         theme::ThemeManager,
     };
diff --git a/crates/atuin/src/command/client/search/interactive.rs b/crates/turtle/src/command/client/search/interactive.rs
index 4efba803..a3d2cb79 100644
--- a/crates/atuin/src/command/client/search/interactive.rs
+++ b/crates/turtle/src/command/client/search/interactive.rs
@@ -6,7 +6,7 @@ use std::{
 #[cfg(unix)]
 use std::io::Read as _;
 
-use atuin_common::{shell::Shell, utils::Escapable as _};
+use crate::atuin_common::{shell::Shell, utils::Escapable as _};
 use eyre::Result;
 use time::OffsetDateTime;
 use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
@@ -16,7 +16,7 @@ use super::{
     engines::{SearchEngine, SearchState},
     history_list::{HistoryList, ListState},
 };
-use atuin_client::{
+use crate::atuin_client::{
     database::{Context, Database, current_context},
     history::{History, HistoryId, HistoryStats, store::HistoryStore},
     settings::{
@@ -50,9 +50,6 @@ use ratatui::crossterm::event::{
     KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
 };
 
-#[cfg(windows)]
-use windows_sys::Win32::System::Console::{GetConsoleOutputCP, SetConsoleOutputCP};
-
 const TAB_TITLES: [&str; 2] = ["Search", "Inspect"];
 
 pub enum InputAction {
@@ -97,9 +94,9 @@ impl InspectingState {
 
 pub fn to_compactness(f: &Frame, settings: &Settings) -> Compactness {
     if match settings.style {
-        atuin_client::settings::Style::Auto => f.area().height < 14,
-        atuin_client::settings::Style::Compact => true,
-        atuin_client::settings::Style::Full => false,
+        crate::atuin_client::settings::Style::Auto => f.area().height < 14,
+        crate::atuin_client::settings::Style::Compact => true,
+        crate::atuin_client::settings::Style::Full => false,
     } {
         if settings.auto_hide_height != 0 && f.area().height <= settings.auto_hide_height {
             Compactness::Ultracompact
@@ -166,7 +163,7 @@ impl State {
         self.results_len = results.len();
 
         if smart_sort {
-            Ok(atuin_history::sort::sort(
+            Ok(crate::atuin_history::sort::sort(
                 self.search.input.as_str(),
                 results,
             ))
@@ -1275,14 +1272,9 @@ enum TerminalWriter {
     Stdout(std::io::Stdout),
     #[cfg(unix)]
     Tty(std::fs::File),
-    #[cfg(windows)]
-    ConOut(std::io::LineWriter<std::fs::File>, u32),
 }
 
 impl TerminalWriter {
-    #[cfg(windows)]
-    const CP_UTF8: u32 = 65001;
-
     fn new() -> std::io::Result<Self> {
         let stdout = stdout();
         if stdout.is_terminal() {
@@ -1301,35 +1293,6 @@ impl TerminalWriter {
                     .open("/dev/tty")?,
             ))
         }
-
-        // On Windows, use CONOUT$ which is the equivalent of /dev/tty, but this
-        // requires setting the current console output code page to UTF-8 for the
-        // TUI to render properly. We'll set it back to its previous value upon exit.
-        #[cfg(windows)]
-        {
-            let file = std::fs::File::options()
-                .read(true)
-                .write(true)
-                .open("CONOUT$")?;
-
-            let initial_console_output_cp = unsafe { GetConsoleOutputCP() };
-            if initial_console_output_cp != Self::CP_UTF8 {
-                unsafe {
-                    SetConsoleOutputCP(Self::CP_UTF8);
-                }
-            }
-
-            Ok(TerminalWriter::ConOut(
-                std::io::LineWriter::new(file),
-                initial_console_output_cp,
-            ))
-        }
-
-        #[cfg(not(any(unix, windows)))]
-        Err(std::io::Error::new(
-            std::io::ErrorKind::Unsupported,
-            "Interactive mode requires a terminal",
-        ))
     }
 }
 
@@ -1339,8 +1302,6 @@ impl Write for TerminalWriter {
             TerminalWriter::Stdout(stdout) => stdout.write(buf),
             #[cfg(unix)]
             TerminalWriter::Tty(file) => file.write(buf),
-            #[cfg(windows)]
-            TerminalWriter::ConOut(writer, _) => writer.write(buf),
         }
     }
 
@@ -1349,21 +1310,6 @@ impl Write for TerminalWriter {
             TerminalWriter::Stdout(stdout) => stdout.flush(),
             #[cfg(unix)]
             TerminalWriter::Tty(file) => file.flush(),
-            #[cfg(windows)]
-            TerminalWriter::ConOut(writer, _) => writer.flush(),
-        }
-    }
-}
-
-impl Drop for TerminalWriter {
-    fn drop(&mut self) {
-        #[cfg(windows)]
-        if let TerminalWriter::ConOut(_, initial_console_output_cp) = self
-            && *initial_console_output_cp != Self::CP_UTF8
-        {
-            unsafe {
-                SetConsoleOutputCP(*initial_console_output_cp);
-            }
         }
     }
 }
@@ -1668,10 +1614,6 @@ pub async fn history(
         }
     };
 
-    #[cfg(not(unix))]
-    let (saved_screen, popup_rect, _popup_scroll_offset): (Option<()>, Rect, u16) =
-        (None, Rect::default(), 0);
-
     let popup_mode = saved_screen.is_some();
 
     let stdout = Stdout::new(inline_height > 0, settings.no_mouse)?;
@@ -2053,9 +1995,9 @@ fn set_clipboard(_s: String) {}
 
 #[cfg(test)]
 mod tests {
-    use atuin_client::database::Context;
-    use atuin_client::history::History;
-    use atuin_client::settings::{
+    use crate::atuin_client::database::Context;
+    use crate::atuin_client::history::History;
+    use crate::atuin_client::settings::{
         FilterMode, KeymapMode, Preview, PreviewStrategy, SearchMode, Settings,
     };
     use time::OffsetDateTime;
@@ -2264,7 +2206,7 @@ mod tests {
 
     #[test]
     fn test_accept_keybindings() {
-        use atuin_client::settings::Keys;
+        use crate::atuin_client::settings::Keys;
         use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
         let mut settings = Settings::utc();
@@ -2870,8 +2812,8 @@ mod tests {
 
     #[test]
     fn execute_exit_returns_based_on_exit_mode() {
+        use crate::atuin_client::settings::ExitMode;
         use crate::command::client::search::keybindings::Action;
-        use atuin_client::settings::ExitMode;
 
         let mut state = make_executor_state(100, 0);
         let mut settings = Settings::utc();
@@ -3043,7 +2985,7 @@ mod tests {
 
     #[test]
     fn keymap_config_return_query() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
         use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
         use std::collections::HashMap;
 
diff --git a/crates/atuin/src/command/client/search/keybindings/actions.rs b/crates/turtle/src/command/client/search/keybindings/actions.rs
index ff2ef7de..ff2ef7de 100644
--- a/crates/atuin/src/command/client/search/keybindings/actions.rs
+++ b/crates/turtle/src/command/client/search/keybindings/actions.rs
diff --git a/crates/atuin/src/command/client/search/keybindings/conditions.rs b/crates/turtle/src/command/client/search/keybindings/conditions.rs
index 055ae905..055ae905 100644
--- a/crates/atuin/src/command/client/search/keybindings/conditions.rs
+++ b/crates/turtle/src/command/client/search/keybindings/conditions.rs
diff --git a/crates/atuin/src/command/client/search/keybindings/defaults.rs b/crates/turtle/src/command/client/search/keybindings/defaults.rs
index a76cd4a9..c8401e37 100644
--- a/crates/atuin/src/command/client/search/keybindings/defaults.rs
+++ b/crates/turtle/src/command/client/search/keybindings/defaults.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use atuin_client::settings::{KeyBindingConfig, Settings};
+use crate::atuin_client::settings::{KeyBindingConfig, Settings};
 use tracing::warn;
 
 use super::actions::Action;
@@ -354,7 +354,7 @@ pub fn default_vim_insert_keymap(settings: &Settings) -> Keymap {
 /// bindings. We respect the user's `keymap_mode` to provide vim-style j/k
 /// navigation for vim users.
 pub fn default_inspector_keymap(settings: &Settings) -> Keymap {
-    use atuin_client::settings::KeymapMode;
+    use crate::atuin_client::settings::KeymapMode;
 
     let mut km = Keymap::new();
 
@@ -495,7 +495,7 @@ impl KeymapSet {
     /// - If `[keymap]` is empty/absent, `[keys]` customizes the defaults
     ///   (current behavior for backward compatibility).
     pub fn from_settings(settings: &Settings) -> Self {
-        use atuin_client::settings::Keys;
+        use crate::atuin_client::settings::Keys;
 
         if settings.keymap.is_empty() {
             // No [keymap] section → use [keys] to customize defaults
@@ -975,7 +975,7 @@ mod tests {
 
     #[test]
     fn parse_simple_binding_config() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
         let cfg = KeyBindingConfig::Simple("accept".to_string());
         let binding = super::parse_binding_config(&cfg).unwrap();
         assert_eq!(binding.rules.len(), 1);
@@ -985,7 +985,7 @@ mod tests {
 
     #[test]
     fn parse_conditional_binding_config() {
-        use atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
+        use crate::atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
         let cfg = KeyBindingConfig::Rules(vec![
             KeyRuleConfig {
                 when: Some("cursor-at-start".to_string()),
@@ -1006,14 +1006,14 @@ mod tests {
 
     #[test]
     fn parse_binding_config_invalid_action() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
         let cfg = KeyBindingConfig::Simple("not-a-real-action".to_string());
         assert!(super::parse_binding_config(&cfg).is_err());
     }
 
     #[test]
     fn parse_binding_config_invalid_condition() {
-        use atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
+        use crate::atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
         let cfg = KeyBindingConfig::Rules(vec![KeyRuleConfig {
             when: Some("not-a-real-condition".to_string()),
             action: "exit".to_string(),
@@ -1023,7 +1023,7 @@ mod tests {
 
     #[test]
     fn config_override_replaces_key() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
         use std::collections::HashMap;
 
         let mut settings = default_settings();
@@ -1048,7 +1048,7 @@ mod tests {
 
     #[test]
     fn config_override_preserves_unoverridden_keys() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
         use std::collections::HashMap;
 
         let mut settings = default_settings();
@@ -1072,7 +1072,7 @@ mod tests {
 
     #[test]
     fn config_conditional_override() {
-        use atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
+        use crate::atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
         use std::collections::HashMap;
 
         let mut settings = default_settings();
@@ -1131,7 +1131,7 @@ mod tests {
 
     #[test]
     fn keymap_overrides_ignore_keys_section() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
 
         // Set up: [keys] disables scroll_exits, but [keymap] is present
         let mut settings = default_settings();
@@ -1172,7 +1172,7 @@ mod tests {
 
     #[test]
     fn keymap_present_resets_to_standard_keys_defaults() {
-        use atuin_client::settings::KeyBindingConfig;
+        use crate::atuin_client::settings::KeyBindingConfig;
 
         let mut settings = default_settings();
         // Disable all [keys] behaviors
@@ -1214,7 +1214,7 @@ mod tests {
 
     #[test]
     fn keys_has_non_default_values_detection() {
-        use atuin_client::settings::Keys;
+        use crate::atuin_client::settings::Keys;
 
         let standard = Keys::standard_defaults();
         assert!(!standard.has_non_default_values());
@@ -1230,7 +1230,7 @@ mod tests {
 
     #[test]
     fn original_input_empty_condition_in_config() {
-        use atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
+        use crate::atuin_client::settings::{KeyBindingConfig, KeyRuleConfig};
         use std::collections::HashMap;
 
         let mut settings = default_settings();
diff --git a/crates/atuin/src/command/client/search/keybindings/key.rs b/crates/turtle/src/command/client/search/keybindings/key.rs
index c2eb31c6..c2eb31c6 100644
--- a/crates/atuin/src/command/client/search/keybindings/key.rs
+++ b/crates/turtle/src/command/client/search/keybindings/key.rs
diff --git a/crates/atuin/src/command/client/search/keybindings/keymap.rs b/crates/turtle/src/command/client/search/keybindings/keymap.rs
index 0d362863..0d362863 100644
--- a/crates/atuin/src/command/client/search/keybindings/keymap.rs
+++ b/crates/turtle/src/command/client/search/keybindings/keymap.rs
diff --git a/crates/atuin/src/command/client/search/keybindings/mod.rs b/crates/turtle/src/command/client/search/keybindings/mod.rs
index 3b6eb2b2..3b6eb2b2 100644
--- a/crates/atuin/src/command/client/search/keybindings/mod.rs
+++ b/crates/turtle/src/command/client/search/keybindings/mod.rs
diff --git a/crates/turtle/src/command/client/server.rs b/crates/turtle/src/command/client/server.rs
new file mode 100644
index 00000000..7de27551
--- /dev/null
+++ b/crates/turtle/src/command/client/server.rs
@@ -0,0 +1,61 @@
+use std::net::SocketAddr;
+
+use crate::atuin_server::{Settings, launch, launch_metrics_server};
+use crate::atuin_server_database::DbType;
+use crate::atuin_server_postgres::Postgres;
+use crate::atuin_server_sqlite::Sqlite;
+
+use clap::Subcommand;
+use eyre::{Context, Result, eyre};
+
+#[derive(Subcommand, Clone, Debug)]
+#[command(infer_subcommands = true)]
+pub enum Cmd {
+    /// Start the server
+    Start {
+        /// The host address to bind
+        #[clap(long)]
+        host: Option<String>,
+
+        /// The port to bind
+        #[clap(long, short)]
+        port: Option<u16>,
+    },
+
+    /// Print server example configuration
+    DefaultConfig,
+}
+
+impl Cmd {
+    #[expect(clippy::too_many_lines)]
+    pub async fn run(self) -> Result<()> {
+        match self {
+            Cmd::Start { host, port } => {
+                let settings = Settings::new().wrap_err("could not load server settings")?;
+                let host = host.as_ref().unwrap_or(&settings.host).clone();
+                let port = port.unwrap_or(settings.port);
+                let addr = SocketAddr::new(host.parse()?, port);
+
+                if settings.metrics.enable {
+                    tokio::spawn(launch_metrics_server(
+                        settings.metrics.host.clone(),
+                        settings.metrics.port,
+                    ));
+                }
+
+                match settings.db_settings.db_type() {
+                    DbType::Postgres => launch::<Postgres>(settings, addr).await,
+                    DbType::Sqlite => launch::<Sqlite>(settings, addr).await,
+                    DbType::Unknown => {
+                        Err(eyre!("db_uri must start with postgres:// or sqlite://"))
+                    }
+                }
+            }
+            Cmd::DefaultConfig => {
+                // TODO(@bpeetz): Add this back <2026-06-11>
+                println!("TODO");
+                Ok(())
+            }
+        }
+    }
+}
diff --git a/crates/atuin/src/command/client/setup.rs b/crates/turtle/src/command/client/setup.rs
index 8de73d62..b32ceb97 100644
--- a/crates/atuin/src/command/client/setup.rs
+++ b/crates/turtle/src/command/client/setup.rs
@@ -1,4 +1,4 @@
-use atuin_client::settings::Settings;
+use crate::atuin_client::settings::Settings;
 
 use colored::Colorize;
 use eyre::Result;
diff --git a/crates/atuin/src/command/client/stats.rs b/crates/turtle/src/command/client/stats.rs
index a7fc00ac..fc10e949 100644
--- a/crates/atuin/src/command/client/stats.rs
+++ b/crates/turtle/src/command/client/stats.rs
@@ -3,13 +3,13 @@ use eyre::Result;
 use interim::parse_date_string;
 use time::{Duration, OffsetDateTime, Time};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::{Database, current_context},
     settings::Settings,
     theme::Theme,
 };
 
-use atuin_history::stats::{compute, pretty_print};
+use crate::atuin_history::stats::{compute, pretty_print};
 
 fn parse_ngram_size(s: &str) -> Result<usize, String> {
     let value = s
diff --git a/crates/atuin/src/command/client/store.rs b/crates/turtle/src/command/client/store.rs
index 513c404a..dfa3b66c 100644
--- a/crates/atuin/src/command/client/store.rs
+++ b/crates/turtle/src/command/client/store.rs
@@ -1,7 +1,7 @@
 use clap::Subcommand;
 use eyre::Result;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     record::{sqlite_store::SqliteStore, store::Store},
     settings::Settings,
diff --git a/crates/atuin/src/command/client/store/pull.rs b/crates/turtle/src/command/client/store/pull.rs
index 25b925c7..c9c9c379 100644
--- a/crates/atuin/src/command/client/store/pull.rs
+++ b/crates/turtle/src/command/client/store/pull.rs
@@ -1,7 +1,7 @@
 use clap::Args;
 use eyre::Result;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     encryption::load_key,
     record::store::Store,
diff --git a/crates/atuin/src/command/client/store/purge.rs b/crates/turtle/src/command/client/store/purge.rs
index ad2369ce..f7996c4b 100644
--- a/crates/atuin/src/command/client/store/purge.rs
+++ b/crates/turtle/src/command/client/store/purge.rs
@@ -1,7 +1,7 @@
 use clap::Args;
 use eyre::Result;
 
-use atuin_client::{
+use crate::atuin_client::{
     encryption::load_key,
     record::{sqlite_store::SqliteStore, store::Store},
     settings::Settings,
diff --git a/crates/atuin/src/command/client/store/push.rs b/crates/turtle/src/command/client/store/push.rs
index d8569e1e..724dfbef 100644
--- a/crates/atuin/src/command/client/store/push.rs
+++ b/crates/turtle/src/command/client/store/push.rs
@@ -1,9 +1,9 @@
-use atuin_common::record::HostId;
+use crate::atuin_common::record::HostId;
 use clap::Args;
 use eyre::Result;
 use uuid::Uuid;
 
-use atuin_client::{
+use crate::atuin_client::{
     api_client::Client,
     encryption::load_key,
     record::sync::Operation,
diff --git a/crates/atuin/src/command/client/store/rebuild.rs b/crates/turtle/src/command/client/store/rebuild.rs
index b9f2837b..80e201c2 100644
--- a/crates/atuin/src/command/client/store/rebuild.rs
+++ b/crates/turtle/src/command/client/store/rebuild.rs
@@ -4,7 +4,7 @@ use eyre::{Result, bail};
 #[cfg(feature = "daemon")]
 use crate::command::client::daemon as daemon_cmd;
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database, encryption, history::store::HistoryStore,
     record::sqlite_store::SqliteStore, settings::Settings,
 };
@@ -51,7 +51,7 @@ impl Rebuild {
         history_store.build(database).await?;
 
         #[cfg(feature = "daemon")]
-        daemon_cmd::emit_event(settings, atuin_daemon::DaemonEvent::HistoryRebuilt).await;
+        daemon_cmd::emit_event(settings, crate::atuin_daemon::DaemonEvent::HistoryRebuilt).await;
 
         Ok(())
     }
diff --git a/crates/atuin/src/command/client/store/rekey.rs b/crates/turtle/src/command/client/store/rekey.rs
index c92d2555..e63be447 100644
--- a/crates/atuin/src/command/client/store/rekey.rs
+++ b/crates/turtle/src/command/client/store/rekey.rs
@@ -2,7 +2,7 @@ use clap::Args;
 use eyre::Result;
 use tokio::{fs::File, io::AsyncWriteExt};
 
-use atuin_client::{
+use crate::atuin_client::{
     encryption::{decode_key, generate_encoded_key, load_key},
     record::sqlite_store::SqliteStore,
     record::store::Store,
diff --git a/crates/atuin/src/command/client/store/verify.rs b/crates/turtle/src/command/client/store/verify.rs
index 84bec96a..5aa1dc70 100644
--- a/crates/atuin/src/command/client/store/verify.rs
+++ b/crates/turtle/src/command/client/store/verify.rs
@@ -1,7 +1,7 @@
 use clap::Args;
 use eyre::Result;
 
-use atuin_client::{
+use crate::atuin_client::{
     encryption::load_key,
     record::{sqlite_store::SqliteStore, store::Store},
     settings::Settings,
diff --git a/crates/atuin/src/command/client/sync.rs b/crates/turtle/src/command/client/sync.rs
index 5b8c2cb7..a4839b5f 100644
--- a/crates/atuin/src/command/client/sync.rs
+++ b/crates/turtle/src/command/client/sync.rs
@@ -1,7 +1,7 @@
 use clap::Subcommand;
 use eyre::{Result, WrapErr};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database,
     encryption,
     history::store::HistoryStore,
@@ -53,7 +53,7 @@ impl Cmd {
             Self::Register(r) => r.run(&settings).await,
             Self::Status => status::run(&settings).await,
             Self::Key {} => {
-                use atuin_client::encryption::{encode_key, load_key};
+                use crate::atuin_client::encryption::{encode_key, load_key};
                 let key = load_key(&settings).wrap_err("could not load encryption key")?;
 
                 let encode = encode_key(&key).wrap_err("could not encode encryption key")?;
diff --git a/crates/atuin/src/command/client/sync/status.rs b/crates/turtle/src/command/client/sync/status.rs
index c992eb3e..00088b59 100644
--- a/crates/atuin/src/command/client/sync/status.rs
+++ b/crates/turtle/src/command/client/sync/status.rs
@@ -1,5 +1,5 @@
 use crate::{SHA, VERSION};
-use atuin_client::{api_client, settings::Settings};
+use crate::atuin_client::{api_client, settings::Settings};
 use colored::Colorize;
 use eyre::{Result, bail};
 
diff --git a/crates/atuin/src/command/client/wrapped.rs b/crates/turtle/src/command/client/wrapped.rs
index 0e0c9f14..694157c2 100644
--- a/crates/atuin/src/command/client/wrapped.rs
+++ b/crates/turtle/src/command/client/wrapped.rs
@@ -3,9 +3,9 @@ use eyre::Result;
 use std::collections::{HashMap, HashSet};
 use time::{Date, Duration, Month, OffsetDateTime, Time};
 
-use atuin_client::{database::Database, settings::Settings, theme::Theme};
+use crate::atuin_client::{database::Database, settings::Settings, theme::Theme};
 
-use atuin_history::stats::{Stats, compute};
+use crate::atuin_history::stats::{Stats, compute};
 
 #[derive(Debug)]
 struct WrappedStats {
@@ -20,7 +20,11 @@ struct WrappedStats {
 
 impl WrappedStats {
     #[expect(clippy::too_many_lines, clippy::cast_precision_loss)]
-    fn new(settings: &Settings, stats: &Stats, history: &[atuin_client::history::History]) -> Self {
+    fn new(
+        settings: &Settings,
+        stats: &Stats,
+        history: &[crate::atuin_client::history::History],
+    ) -> Self {
         let nav_commands = stats
             .top
             .iter()
@@ -313,7 +317,7 @@ pub async fn run(
     );
 
     println!("Your Top Commands:");
-    atuin_history::stats::pretty_print(stats.clone(), 1, theme);
+    crate::atuin_history::stats::pretty_print(stats.clone(), 1, theme);
     println!();
 
     print_fun_facts(&wrapped_stats, &stats, year);
diff --git a/crates/atuin/src/command/contributors.rs b/crates/turtle/src/command/contributors.rs
index 452fd335..452fd335 100644
--- a/crates/atuin/src/command/contributors.rs
+++ b/crates/turtle/src/command/contributors.rs
diff --git a/crates/atuin/src/command/external.rs b/crates/turtle/src/command/external.rs
index 5d875e9d..e1f0cddd 100644
--- a/crates/atuin/src/command/external.rs
+++ b/crates/turtle/src/command/external.rs
@@ -3,7 +3,7 @@ use std::process::Command;
 use std::{io, process};
 
 #[cfg(feature = "client")]
-use atuin_client::plugin::{OfficialPluginRegistry, PluginContext};
+use crate::atuin_client::plugin::{OfficialPluginRegistry, PluginContext};
 use clap::CommandFactory;
 use clap::builder::{StyledStr, Styles};
 use eyre::Result;
diff --git a/crates/atuin/src/command/gen_completions.rs b/crates/turtle/src/command/gen_completions.rs
index 10d4f689..10d4f689 100644
--- a/crates/atuin/src/command/gen_completions.rs
+++ b/crates/turtle/src/command/gen_completions.rs
diff --git a/crates/atuin/src/command/mod.rs b/crates/turtle/src/command/mod.rs
index 8aac4062..e58bfe72 100644
--- a/crates/atuin/src/command/mod.rs
+++ b/crates/turtle/src/command/mod.rs
@@ -24,7 +24,7 @@ pub enum AtuinCmd {
     /// PTY proxy for atuin
     #[cfg(feature = "pty-proxy")]
     #[command(alias = "hex")]
-    PtyProxy(atuin_pty_proxy::PtyProxy),
+    PtyProxy(crate::atuin_pty_proxy::PtyProxy),
 
     /// Generate a UUID
     Uuid,
@@ -63,7 +63,7 @@ impl AtuinCmd {
                 Ok(())
             }
             Self::Uuid => {
-                println!("{}", atuin_common::utils::uuid_v7().as_simple());
+                println!("{}", crate::atuin_common::utils::uuid_v7().as_simple());
                 Ok(())
             }
             Self::GenCompletions(gen_completions) => gen_completions.run(),
@@ -73,7 +73,7 @@ impl AtuinCmd {
 }
 
 #[cfg(all(feature = "pty-proxy", unix))]
-fn run_pty_proxy(proxy: atuin_pty_proxy::PtyProxy) {
+fn run_pty_proxy(proxy: crate::atuin_pty_proxy::PtyProxy) {
     #[cfg(feature = "daemon")]
     proxy.run(semantic_command_capture_sink());
 
@@ -81,14 +81,8 @@ fn run_pty_proxy(proxy: atuin_pty_proxy::PtyProxy) {
     proxy.run(None);
 }
 
-#[cfg(all(feature = "pty-proxy", not(unix)))]
-fn run_pty_proxy(_proxy: atuin_pty_proxy::PtyProxy) {
-    eprintln!("atuin pty-proxy currently supports unix platforms");
-    std::process::exit(1);
-}
-
 #[cfg(all(feature = "daemon", feature = "pty-proxy", unix))]
-fn semantic_command_capture_sink() -> Option<atuin_pty_proxy::CommandCaptureSink> {
+fn semantic_command_capture_sink() -> Option<crate::atuin_pty_proxy::CommandCaptureSink> {
     use std::sync::mpsc;
     use std::time::Duration;
 
@@ -96,8 +90,8 @@ fn semantic_command_capture_sink() -> Option<atuin_pty_proxy::CommandCaptureSink
         return None;
     }
 
-    let settings = atuin_client::settings::Settings::new().ok()?;
-    let (tx, rx) = mpsc::sync_channel::<atuin_pty_proxy::CommandCapture>(128);
+    let settings = crate::atuin_client::settings::Settings::new().ok()?;
+    let (tx, rx) = mpsc::sync_channel::<crate::atuin_pty_proxy::CommandCapture>(128);
 
     std::thread::spawn(move || {
         let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
@@ -139,12 +133,12 @@ fn is_truthy_env(name: &str) -> bool {
 
 #[cfg(all(feature = "daemon", feature = "pty-proxy", unix))]
 async fn send_semantic_command_captures(
-    settings: &atuin_client::settings::Settings,
-    batch: Vec<atuin_pty_proxy::CommandCapture>,
+    settings: &crate::atuin_client::settings::Settings,
+    batch: Vec<crate::atuin_pty_proxy::CommandCapture>,
 ) {
     let captures = batch
         .into_iter()
-        .map(|capture| atuin_daemon::semantic::CommandCapture {
+        .map(|capture| crate::atuin_daemon::semantic::CommandCapture {
             prompt: capture.prompt,
             command: capture.command,
             output: capture.output,
@@ -156,7 +150,7 @@ async fn send_semantic_command_captures(
         })
         .collect();
 
-    if let Ok(mut client) = atuin_daemon::SemanticClient::from_settings(settings).await {
+    if let Ok(mut client) = crate::atuin_daemon::SemanticClient::from_settings(settings).await {
         let _ = client.record_commands(captures).await;
     }
 }
diff --git a/crates/atuin/src/main.rs b/crates/turtle/src/main.rs
index 255db36a..e5b80ee8 100644
--- a/crates/atuin/src/main.rs
+++ b/crates/turtle/src/main.rs
@@ -1,5 +1,7 @@
 #![warn(clippy::pedantic, clippy::nursery)]
 #![allow(clippy::use_self, clippy::missing_const_for_fn)] // not 100% reliable
+// #![deny(unsafe_code)]
+#![forbid(unsafe_code)]
 
 use clap::Parser;
 use clap::builder::Styles;
@@ -10,6 +12,16 @@ use command::AtuinCmd;
 
 mod command;
 
+mod atuin_client;
+mod atuin_common;
+mod atuin_daemon;
+mod atuin_history;
+mod atuin_pty_proxy;
+mod atuin_server;
+mod atuin_server_database;
+mod atuin_server_postgres;
+mod atuin_server_sqlite;
+
 #[cfg(feature = "sync")]
 mod print_error;
 #[cfg(feature = "sync")]
diff --git a/crates/atuin/src/print_error.rs b/crates/turtle/src/print_error.rs
index a6da283d..4d4724bc 100644
--- a/crates/atuin/src/print_error.rs
+++ b/crates/turtle/src/print_error.rs
@@ -1,6 +1,6 @@
 use std::io::IsTerminal;
 
-use atuin_client::record::sync::SyncError;
+use crate::atuin_client::record::sync::SyncError;
 use colored::Colorize;
 use crossterm::terminal;
 
diff --git a/crates/atuin/src/shell/.gitattributes b/crates/turtle/src/shell/.gitattributes
index fae8897c..fae8897c 100644
--- a/crates/atuin/src/shell/.gitattributes
+++ b/crates/turtle/src/shell/.gitattributes
diff --git a/crates/atuin/src/shell/atuin.bash b/crates/turtle/src/shell/atuin.bash
index 8b540bd7..8b540bd7 100644
--- a/crates/atuin/src/shell/atuin.bash
+++ b/crates/turtle/src/shell/atuin.bash
diff --git a/crates/atuin/src/shell/atuin.fish b/crates/turtle/src/shell/atuin.fish
index 15b33451..15b33451 100644
--- a/crates/atuin/src/shell/atuin.fish
+++ b/crates/turtle/src/shell/atuin.fish
diff --git a/crates/atuin/src/shell/atuin.nu b/crates/turtle/src/shell/atuin.nu
index d37457e4..d37457e4 100644
--- a/crates/atuin/src/shell/atuin.nu
+++ b/crates/turtle/src/shell/atuin.nu
diff --git a/crates/atuin/src/shell/atuin.ps1 b/crates/turtle/src/shell/atuin.ps1
index 431ee2c3..431ee2c3 100644
--- a/crates/atuin/src/shell/atuin.ps1
+++ b/crates/turtle/src/shell/atuin.ps1
diff --git a/crates/atuin/src/shell/atuin.xsh b/crates/turtle/src/shell/atuin.xsh
index a0283402..a0283402 100644
--- a/crates/atuin/src/shell/atuin.xsh
+++ b/crates/turtle/src/shell/atuin.xsh
diff --git a/crates/atuin/src/shell/atuin.zsh b/crates/turtle/src/shell/atuin.zsh
index 7a7375aa..7a7375aa 100644
--- a/crates/atuin/src/shell/atuin.zsh
+++ b/crates/turtle/src/shell/atuin.zsh
diff --git a/crates/atuin/src/sync.rs b/crates/turtle/src/sync.rs
index 02e4db69..56aef615 100644
--- a/crates/atuin/src/sync.rs
+++ b/crates/turtle/src/sync.rs
@@ -1,10 +1,10 @@
 use eyre::{Context, Result};
 
-use atuin_client::{
+use crate::atuin_client::{
     database::Database, history::store::HistoryStore, record::sqlite_store::SqliteStore,
     settings::Settings,
 };
-use atuin_common::record::RecordId;
+use crate::atuin_common::record::RecordId;
 
 // This is the only crate that ties together all other crates.
 // Therefore, it's the only crate where functions tying together all stores can live
@@ -18,7 +18,7 @@ pub async fn build(
     db: &dyn Database,
     downloaded: Option<&[RecordId]>,
 ) -> Result<()> {
-    let encryption_key: [u8; 32] = atuin_client::encryption::load_key(settings)
+    let encryption_key: [u8; 32] = crate::atuin_client::encryption::load_key(settings)
         .context("could not load encryption key")?
         .into();
author	Benedikt Peetz <benedikt.peetz@b-peetz.de>	2026-06-11 00:54:30 +0200
committer	Benedikt Peetz <benedikt.peetz@b-peetz.de>	2026-06-11 00:54:30 +0200
commit	5c39e7cf284a1f6e9a1657f2deb44e359fc47eb8 (patch)
tree	c64baa8d5866c8e339eaf660dd3f94f30a3f7d8a /crates/turtle/src
parent	chore: Somewhat simplify sync code (diff)
download	atuin-5c39e7cf284a1f6e9a1657f2deb44e359fc47eb8.zip