diff --git a/crates/radicle-node/src/runtime/handle.rs b/crates/radicle-node/src/runtime/handle.rs
index d3acc256..14b3eaf9 100644
--- a/crates/radicle-node/src/runtime/handle.rs
+++ b/crates/radicle-node/src/runtime/handle.rs
@@ -356,10 +356,35 @@ impl radicle::node::Handle for Handle {
     fn debug(&self) -> Result<serde_json::Value, Self::Error> {
         let (sender, receiver) = chan::bounded(1);
         let query: Arc<QueryState> = Arc::new(move |state| {
+            let fetcher_state = state.fetching();
             let debug = serde_json::json!({
                 "outboxSize": state.outbox().len(),
-                "fetching": state.fetching(),
-                "rateLimiter": state.limiter(),
+                "fetching": fetcher_state.active_fetches()
+                    .iter()
+                    .map(|(rid, active)| {
+                        json!({
+                            "rid": rid,
+                            "from": active.from(),
+                            "refsAt": active.refs(),
+                        })
+                    }).collect::<Vec<_>>(),
+                "queue": fetcher_state.queued_fetches().iter().map(|(node, queue)| {
+                    json!({
+                        "nid": node,
+                        "queue": queue.iter().map(|fetch| {
+                            json!({
+                                "rid": fetch.rid,
+                                "refsAt": fetch.refs,
+                            })
+                        }).collect::<Vec<_>>()
+                    })
+                }).collect::<Vec<_>>(),
+                "rateLimiter": state.limiter().buckets.iter().map(|(host, bucket)| {
+                    json!({
+                        "host": host.to_string(),
+                        "bucket": bucket
+                    })
+                }).collect::<Vec<_>>(),
                 "events": json!({
                     "subscribers": state.emitter().subscriptions(),
                     "pending": state.emitter().pending(),
diff --git a/crates/radicle-protocol/src/fetcher/state.rs b/crates/radicle-protocol/src/fetcher/state.rs
index 62b87b77..cde707a6 100644
--- a/crates/radicle-protocol/src/fetcher/state.rs
+++ b/crates/radicle-protocol/src/fetcher/state.rs
@@ -10,7 +10,6 @@ pub mod event;
 
 pub use command::Command;
 pub use event::Event;
-use serde::Serialize;
 
 use std::collections::{BTreeMap, VecDeque};
 use std::num::NonZeroUsize;
@@ -43,7 +42,7 @@ pub const MAX_CONCURRENCY: NonZeroUsize = NonZeroUsize::MIN;
 /// of fetches can happen with it concurrently. This does not guarantee that the
 /// node will actually allow this node to fetch from it – since it will maintain
 /// its own capacity for connections and load.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct FetcherState {
     /// The active fetches that are occurring, ensuring only one fetch per repository.
     active: BTreeMap<RepoId, ActiveFetch>,
@@ -236,7 +235,7 @@ impl FetcherState {
 }
 
 /// Configuration for the [`FetcherState`].
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Config {
     /// Maximum number of concurrent fetches per peer connection.
     maximum_concurrency: NonZeroUsize,
@@ -272,7 +271,7 @@ impl Default for Config {
 }
 
 /// An active fetch represents a repository being fetched by a particular node.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ActiveFetch {
     pub from: NodeId,
     pub refs: RefsToFetch,
@@ -291,7 +290,7 @@ impl ActiveFetch {
 }
 
 /// A fetch that is waiting to be processed, in the fetch queue.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct QueuedFetch {
     /// The repository that will be fetched.
     pub rid: RepoId,
@@ -305,15 +304,14 @@ pub struct QueuedFetch {
 ///
 /// It ensures that the queue contains unique items for fetching, and does not
 /// exceed the provided maximum capacity.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Queue {
     queue: VecDeque<QueuedFetch>,
     max_queue_size: MaxQueueSize,
 }
 
 /// The maximum number of fetches that can be queued for a single node.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
-#[serde(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct MaxQueueSize(usize);
 
 impl MaxQueueSize {
diff --git a/crates/radicle-protocol/src/service/limiter.rs b/crates/radicle-protocol/src/service/limiter.rs
index a7021e0a..bd8afa56 100644
--- a/crates/radicle-protocol/src/service/limiter.rs
+++ b/crates/radicle-protocol/src/service/limiter.rs
@@ -2,7 +2,6 @@ use std::collections::{HashMap, HashSet};
 
 use localtime::LocalTime;
 use radicle::node::{address, config, HostName, NodeId};
-use serde::Serialize;
 
 /// Peer rate limiter.
 ///
@@ -10,7 +9,7 @@ use serde::Serialize;
 /// and every request from that address consumes one token. Tokens refill at a predefined
 /// rate. This mechanism allows for consistent request rates with potential bursts up to the
 /// bucket's capacity.
-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, Default)]
 pub struct RateLimiter {
     pub buckets: HashMap<HostName, TokenBucket>,
     pub bypass: HashSet<NodeId>,