chore: Move everything into one big crate

That helps remove duplicated code and rustc/cargo will now also show
dead code correctly.

16 files changed, 62 insertions, 221 deletions

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(())
-}