8 files changed, 354 insertions, 77 deletions

diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs
index 7753ba1..4a7c1ec 100644
--- a/src/bin/git_remote_nostr/list.rs
+++ b/src/bin/git_remote_nostr/list.rs
@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use client::get_state_from_cache;
 use git::RepoActions;
 use ngit::{
-    client,
+    client::{self, is_verbose},
     fetch::fetch_from_git_server,
     git::{self},
     git_events::{KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_to_cover_letter, tag_value},
@@ -27,7 +27,9 @@ pub async fn run_list(
 
     let term = console::Term::stderr();
 
-    term.write_line("git servers: listing refs...")?;
+    if is_verbose() {
+        term.write_line("git servers: listing refs...")?;
+    }
     let remote_states = list_from_remotes(
         &term,
         git_repo,
diff --git a/src/bin/git_remote_nostr/main.rs b/src/bin/git_remote_nostr/main.rs
index b26981d..3663d5b 100644
--- a/src/bin/git_remote_nostr/main.rs
+++ b/src/bin/git_remote_nostr/main.rs
@@ -12,7 +12,7 @@ use std::{
 };
 
 use anyhow::{Context, Result, bail};
-use client::{Connect, consolidate_fetch_reports, get_repo_ref_from_cache};
+use client::{Connect, consolidate_fetch_reports, get_repo_ref_from_cache, is_verbose};
 use git::{RepoActions, nostr_url::NostrUrlDecoded};
 use ngit::{
     client::{self, Params},
@@ -156,7 +156,10 @@ async fn fetching_with_report_for_helper(
     trusted_maintainer_coordinate: &Nip19Coordinate,
 ) -> Result<()> {
     let term = console::Term::stderr();
-    term.write_line("nostr: fetching...")?;
+    let verbose = is_verbose();
+    if verbose {
+        term.write_line("nostr: fetching...")?;
+    }
     let (relay_reports, progress_reporter) = client
         .fetch_all(
             Some(git_repo_path),
@@ -166,10 +169,12 @@ async fn fetching_with_report_for_helper(
         .await?;
     let report = consolidate_fetch_reports(relay_reports);
     if report.to_string().is_empty() {
-        term.write_line("nostr: no updates")?;
+        if verbose {
+            term.write_line("nostr: no updates")?;
+        }
     } else {
         term.write_line(&format!("nostr updates: {report}"))?;
     }
-    progress_reporter.clear()?;
+    let _ = progress_reporter.clear();
     Ok(())
 }
diff --git a/src/bin/ngit/main.rs b/src/bin/ngit/main.rs
index 65f6bca..77ef955 100644
--- a/src/bin/ngit/main.rs
+++ b/src/bin/ngit/main.rs
@@ -15,10 +15,6 @@ use ngit::{
 
 mod sub_commands;
 
-fn is_verbose() -> bool {
-    std::env::var("NGIT_VERBOSE").is_ok() || std::env::var("NGIT_TEST").is_ok()
-}
-
 #[tokio::main]
 async fn main() {
     let cli = Cli::parse();
@@ -29,7 +25,7 @@ async fn main() {
         std::env::set_var("NGIT_INTERACTIVE_MODE", "1");
     }
 
-    if cli.verbose || std::env::var("NGIT_TEST").is_ok() {
+    if cli.verbose || std::env::var("NGITTEST").is_ok() {
         std::env::set_var("NGIT_VERBOSE", "1");
     }
 
diff --git a/src/bin/ngit/sub_commands/apply.rs b/src/bin/ngit/sub_commands/apply.rs
index 4ed6caa..2d5d8d5 100644
--- a/src/bin/ngit/sub_commands/apply.rs
+++ b/src/bin/ngit/sub_commands/apply.rs
@@ -1,9 +1,11 @@
 use std::{
     io::Write,
     process::{Command, Stdio},
+    time::Duration,
 };
 
 use anyhow::{Context, Result, bail};
+use indicatif::{ProgressBar, ProgressStyle};
 use ngit::{
     client::get_all_proposal_patch_pr_pr_update_events_from_cache,
     git_events::get_pr_tip_event_or_most_recent_patch_with_ancestors,
@@ -18,16 +20,55 @@ use crate::{
 };
 
 fn run_git_fetch(remote_name: &str) -> Result<()> {
-    println!("fetching from {remote_name}...");
-    let exit_status = Command::new("git")
+    let verbose = ngit::client::is_verbose();
+    if verbose {
+        println!("fetching from {remote_name}...");
+    }
+
+    let spinner = if verbose {
+        None
+    } else {
+        let pb = ProgressBar::new_spinner()
+            .with_style(
+                ProgressStyle::with_template("{spinner} {msg}")
+                    .unwrap()
+                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+            )
+            .with_message(format!("Fetching from {remote_name}..."));
+        pb.enable_steady_tick(Duration::from_millis(100));
+        Some(pb)
+    };
+
+    let output = Command::new("git")
         .args(["fetch", remote_name])
-        .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit())
-        .status()
+        .stdout(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .stderr(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .output()
         .context("failed to run git fetch")?;
 
-    if !exit_status.success() {
-        bail!("git fetch {remote_name} exited with error: {exit_status}");
+    if let Some(spinner) = spinner {
+        spinner.finish_and_clear();
+    }
+
+    if !output.status.success() {
+        if !verbose {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if !stderr.is_empty() {
+                eprintln!("{stderr}");
+            }
+        }
+        bail!(
+            "git fetch {remote_name} exited with error: {}",
+            output.status
+        );
     }
     Ok(())
 }
diff --git a/src/bin/ngit/sub_commands/checkout.rs b/src/bin/ngit/sub_commands/checkout.rs
index 6ded778..2fc9a09 100644
--- a/src/bin/ngit/sub_commands/checkout.rs
+++ b/src/bin/ngit/sub_commands/checkout.rs
@@ -1,9 +1,11 @@
 use std::{
     collections::HashSet,
     process::{Command, Stdio},
+    time::Duration,
 };
 
 use anyhow::{Context, Result, bail};
+use indicatif::{ProgressBar, ProgressStyle};
 use ngit::{
     client::{
         Params, get_all_proposal_patch_pr_pr_update_events_from_cache,
@@ -97,16 +99,55 @@ pub async fn launch(id: &str) -> Result<()> {
 }
 
 fn run_git_fetch(remote_name: &str) -> Result<()> {
-    println!("fetching from {remote_name}...");
-    let exit_status = Command::new("git")
+    let verbose = ngit::client::is_verbose();
+    if verbose {
+        println!("fetching from {remote_name}...");
+    }
+
+    let spinner = if verbose {
+        None
+    } else {
+        let pb = ProgressBar::new_spinner()
+            .with_style(
+                ProgressStyle::with_template("{spinner} {msg}")
+                    .unwrap()
+                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+            )
+            .with_message(format!("Fetching from {remote_name}..."));
+        pb.enable_steady_tick(Duration::from_millis(100));
+        Some(pb)
+    };
+
+    let output = Command::new("git")
         .args(["fetch", remote_name])
-        .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit())
-        .status()
+        .stdout(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .stderr(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .output()
         .context("failed to run git fetch")?;
 
-    if !exit_status.success() {
-        bail!("git fetch {remote_name} exited with error: {exit_status}");
+    if let Some(spinner) = spinner {
+        spinner.finish_and_clear();
+    }
+
+    if !output.status.success() {
+        if !verbose {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if !stderr.is_empty() {
+                eprintln!("{stderr}");
+            }
+        }
+        bail!(
+            "git fetch {remote_name} exited with error: {}",
+            output.status
+        );
     }
     Ok(())
 }
diff --git a/src/bin/ngit/sub_commands/list.rs b/src/bin/ngit/sub_commands/list.rs
index 68a10cc..ff43bd9 100644
--- a/src/bin/ngit/sub_commands/list.rs
+++ b/src/bin/ngit/sub_commands/list.rs
@@ -3,9 +3,11 @@ use std::{
     io::Write,
     ops::Add,
     process::{Command, Stdio},
+    time::Duration,
 };
 
 use anyhow::{Context, Result, bail};
+use indicatif::{ProgressBar, ProgressStyle};
 use ngit::{
     client::{
         Params, get_all_proposal_patch_pr_pr_update_events_from_cache,
@@ -39,16 +41,55 @@ use crate::{
 };
 
 fn run_git_fetch(remote_name: &str) -> Result<()> {
-    println!("fetching from {remote_name}...");
-    let exit_status = Command::new("git")
+    let verbose = ngit::client::is_verbose();
+    if verbose {
+        println!("fetching from {remote_name}...");
+    }
+
+    let spinner = if verbose {
+        None
+    } else {
+        let pb = ProgressBar::new_spinner()
+            .with_style(
+                ProgressStyle::with_template("{spinner} {msg}")
+                    .unwrap()
+                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+            )
+            .with_message(format!("Fetching from {remote_name}..."));
+        pb.enable_steady_tick(Duration::from_millis(100));
+        Some(pb)
+    };
+
+    let output = Command::new("git")
         .args(["fetch", remote_name])
-        .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit())
-        .status()
+        .stdout(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .stderr(if verbose {
+            Stdio::inherit()
+        } else {
+            Stdio::piped()
+        })
+        .output()
         .context("failed to run git fetch")?;
 
-    if !exit_status.success() {
-        bail!("git fetch {remote_name} exited with error: {exit_status}");
+    if let Some(spinner) = spinner {
+        spinner.finish_and_clear();
+    }
+
+    if !output.status.success() {
+        if !verbose {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            if !stderr.is_empty() {
+                eprintln!("{stderr}");
+            }
+        }
+        bail!(
+            "git fetch {remote_name} exited with error: {}",
+            output.status
+        );
     }
     Ok(())
 }
@@ -297,10 +338,7 @@ fn show_proposal_details(
     }
 
     println!();
-    println!(
-        "To checkout: ngit checkout {}",
-        proposal.id
-    );
+    println!("To checkout: ngit checkout {}", proposal.id);
     println!("To apply:    ngit apply {}", proposal.id);
 
     Ok(())
diff --git a/src/lib/client.rs b/src/lib/client.rs
index 89fcaf7..583f01c 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -16,10 +16,10 @@ use std::{
     fs::create_dir_all,
     path::Path,
     sync::{
-        Arc, RwLock,
+        Arc, Mutex, RwLock,
         atomic::{AtomicU64, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use anyhow::{Context, Result, anyhow, bail};
@@ -65,6 +65,65 @@ use crate::{
     repo_state::RepoState,
 };
 
+pub fn is_verbose() -> bool {
+    std::env::var("NGIT_VERBOSE").is_ok()
+}
+
+const SPINNER_EXPAND_DELAY_SECS: u64 = 5;
+
+struct SpinnerState {
+    spinner: ProgressBar,
+    start_time: Instant,
+    expanded_multi: Option<MultiProgress>,
+}
+
+impl SpinnerState {
+    fn new() -> Self {
+        let multi_progress = MultiProgress::new();
+        let spinner = multi_progress.add(
+            ProgressBar::new_spinner()
+                .with_style(
+                    ProgressStyle::with_template("{spinner} {msg}")
+                        .unwrap()
+                        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+                )
+                .with_message("Checking relays and git servers..."),
+        );
+        spinner.enable_steady_tick(Duration::from_millis(100));
+        Self {
+            spinner,
+            start_time: Instant::now(),
+            expanded_multi: None,
+        }
+    }
+
+    fn should_expand(&self) -> bool {
+        self.expanded_multi.is_none()
+            && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS
+    }
+
+    fn expand(&mut self) -> &MultiProgress {
+        if self.expanded_multi.is_none() {
+            self.spinner.finish_and_clear();
+            self.expanded_multi = Some(MultiProgress::new());
+        }
+        self.expanded_multi.as_ref().unwrap()
+    }
+
+    fn finish(&self, has_errors: bool) {
+        if has_errors {
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        } else {
+            self.spinner.finish_and_clear();
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        }
+    }
+}
+
 #[allow(clippy::struct_field_names)]
 pub struct Client {
     client: nostr_sdk::Client,
@@ -370,14 +429,15 @@ impl Connect for Client {
         )
         .await?;
 
+        let verbose = is_verbose();
+        let spinner_state = if !verbose {
+            Some(Arc::new(Mutex::new(SpinnerState::new())))
+        } else {
+            None
+        };
         let progress_reporter = MultiProgress::new();
 
-        // Track successful relays for adaptive timeout (switch to SHORT when
-        // SUCCESS_THRESHOLD succeed)
         let success_count = Arc::new(AtomicU64::new(0));
-
-        // Track current timeout value for progress bar display (starts at LONG,
-        // switches to SHORT)
         let current_timeout = Arc::new(AtomicU64::new(long_timeout()));
 
         let mut processed_relays = HashSet::new();
@@ -388,7 +448,6 @@ impl Connect for Client {
             let relays = request
                 .repo_relays
                 .union(&request.user_relays_for_profiles)
-                // don't look for events on blaster
                 .filter(|&r| !r.as_str().contains("nostr.mutinywallet.com"))
                 .cloned()
                 .collect::<HashSet<RelayUrl>>()
@@ -412,12 +471,12 @@ impl Connect for Client {
             let success_count_for_loop = success_count.clone();
             let current_timeout_for_loop = current_timeout.clone();
             let total_relays = relays.len() as u64;
+            let spinner_state_clone = spinner_state.clone();
 
             let futures: Vec<_> = relays
                 .iter()
                 .map(|r| {
                     if profile_relays_only.contains(r) {
-                        // if relay isn't a repo relay, just filter for user profile
                         FetchRequest {
                             selected_relay: Some(r.to_owned()),
                             repo_coordinates_without_relays: vec![],
@@ -447,6 +506,8 @@ impl Connect for Client {
                     let current_timeout_clone = current_timeout_for_loop.clone();
                     let progress_reporter_clone = progress_reporter.clone();
                     let total_relays_clone = total_relays;
+                    let spinner_state_for_task = spinner_state_clone.clone();
+                    let verbose_for_task = verbose;
                     async move {
                         let relay_column_width = request.relay_column_width;
 
@@ -455,7 +516,7 @@ impl Connect for Client {
                             .clone()
                             .context("fetch_all_from_relay called without a relay")?;
 
-                        let pb = if std::env::var("NGITTEST").is_err() {
+                        let pb = if verbose_for_task {
                             let pb = progress_reporter_clone.add(
                                 ProgressBar::new(1)
                                     .with_prefix(
@@ -469,6 +530,26 @@ impl Connect for Client {
                             );
                             pb.enable_steady_tick(Duration::from_millis(300));
                             Some(pb)
+                        } else if let Some(ref state) = spinner_state_for_task {
+                            let mut state = state.lock().unwrap();
+                            if state.should_expand() {
+                                let multi = state.expand().clone();
+                                let pb = multi.add(
+                                    ProgressBar::new(1)
+                                        .with_prefix(
+                                            format!(
+                                                "{: <relay_column_width$} connecting",
+                                                &relay_url
+                                            )
+                                            .to_string(),
+                                        )
+                                        .with_style(pb_style(current_timeout_clone.clone())?),
+                                );
+                                pb.enable_steady_tick(Duration::from_millis(300));
+                                Some(pb)
+                            } else {
+                                None
+                            }
                         } else {
                             None
                         };
@@ -508,36 +589,27 @@ impl Connect for Client {
                             bail!("{reason}");
                         }
 
-                        // Adaptive timeout using tokio::select!
-                        // Start the fetch operation once and race it against an adaptive timeout
                         let pb_clone = pb.clone();
                         let fetch_future = self.fetch_all_from_relay(git_repo_path, request, &pb_clone);
                         tokio::pin!(fetch_future);
 
-                        // Create an adaptive timeout that switches from long to short
-                        // when SUCCESS_THRESHOLD of relays succeed
                         let timeout_future = async {
-                            // Poll for timeout or SUCCESS_THRESHOLD success threshold
                             let check_interval = Duration::from_millis(100);
                             let long_timeout_end = tokio::time::Instant::now() + Duration::from_secs(long_timeout());
 
                             loop {
-                                // Check if SUCCESS_THRESHOLD of relays have succeeded
                                 let current_success_count = success_count_clone.load(Ordering::Relaxed);
                                 let threshold = (total_relays_clone as f64 * SUCCESS_THRESHOLD).ceil() as u64;
 
                                 if current_success_count >= threshold {
-                                    // SUCCESS_THRESHOLD reached, switch to short timeout
                                     tokio::time::sleep(Duration::from_secs(short_timeout())).await;
                                     return "short";
                                 }
 
-                                // Check if long timeout has expired
                                 if tokio::time::Instant::now() >= long_timeout_end {
                                     return "long";
                                 }
 
-                                // Sleep briefly before checking again
                                 tokio::time::sleep(check_interval).await;
                             }
                         };
@@ -546,11 +618,9 @@ impl Connect for Client {
                         let result = tokio::select! {
                             result = &mut fetch_future => {
                                 if result.is_ok() {
-                                    // Increment success count
                                     let new_count = success_count_clone.fetch_add(1, Ordering::Relaxed) + 1;
                                     let threshold = (total_relays_clone as f64 * SUCCESS_THRESHOLD).ceil() as u64;
 
-                                    // If we've reached SUCCESS_THRESHOLD, update timeout display
                                     if new_count >= threshold {
                                         current_timeout_clone.store(short_timeout(), Ordering::Relaxed);
                                     }
@@ -565,7 +635,6 @@ impl Connect for Client {
 
                         match result {
                             Err(error) => {
-                                // Check error for timeout/connection issues and add to skip list
                                 if error.to_string().contains("connection timeout") || error.to_string().contains("timeout after") {
                                     self.skip_relay_for_session(relay_url.clone(), error.to_string());
                                 }
@@ -619,6 +688,12 @@ impl Connect for Client {
                 set
             };
         }
+
+        if let Some(ref state) = spinner_state {
+            let has_errors = relay_reports.iter().any(Result::is_err);
+            state.lock().unwrap().finish(has_errors);
+        }
+
         Ok((relay_reports, progress_reporter))
     }
 
@@ -2084,8 +2159,11 @@ pub async fn fetching_with_report(
     #[cfg(not(test))] client: &Client,
     trusted_maintainer_coordinate: &Nip19Coordinate,
 ) -> Result<FetchReport> {
-    let term = console::Term::stderr();
-    term.write_line("fetching updates...")?;
+    let verbose = is_verbose();
+    if verbose {
+        let term = console::Term::stderr();
+        term.write_line("fetching updates...")?;
+    }
     let (relay_reports, progress_reporter) = client
         .fetch_all(
             Some(git_repo_path),
diff --git a/src/lib/list.rs b/src/lib/list.rs
index ce8737c..3b37b37 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -3,10 +3,10 @@ use std::{
     path::PathBuf,
     str::FromStr,
     sync::{
-        Arc,
+        Arc, Mutex,
         atomic::{AtomicU64, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use anyhow::{Result, anyhow};
@@ -16,6 +16,7 @@ use indicatif::{MultiProgress, ProgressBar, ProgressState, ProgressStyle};
 use nostr::hashes::sha1::Hash as Sha1Hash;
 
 use crate::{
+    client::is_verbose,
     git::{
         Repo, RepoActions,
         nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
@@ -28,6 +29,61 @@ use crate::{
     },
 };
 
+const SPINNER_EXPAND_DELAY_SECS: u64 = 5;
+
+struct GitSpinnerState {
+    spinner: ProgressBar,
+    start_time: Instant,
+    expanded_multi: Option<MultiProgress>,
+}
+
+impl GitSpinnerState {
+    fn new() -> Self {
+        let multi_progress = MultiProgress::new();
+        let spinner = multi_progress.add(
+            ProgressBar::new_spinner()
+                .with_style(
+                    ProgressStyle::with_template("{spinner} {msg}")
+                        .unwrap()
+                        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+                )
+                .with_message("Checking git servers..."),
+        );
+        spinner.enable_steady_tick(Duration::from_millis(100));
+        Self {
+            spinner,
+            start_time: Instant::now(),
+            expanded_multi: None,
+        }
+    }
+
+    fn should_expand(&self) -> bool {
+        self.expanded_multi.is_none()
+            && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS
+    }
+
+    fn expand(&mut self) -> &MultiProgress {
+        if self.expanded_multi.is_none() {
+            self.spinner.finish_and_clear();
+            self.expanded_multi = Some(MultiProgress::new());
+        }
+        self.expanded_multi.as_ref().unwrap()
+    }
+
+    fn finish(&self, has_errors: bool) {
+        if has_errors {
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        } else {
+            self.spinner.finish_and_clear();
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        }
+    }
+}
+
 /// Sync issues identified for a single remote
 #[derive(Default, Debug, Clone)]
 pub struct RemoteIssues {
@@ -111,18 +167,18 @@ pub async fn list_from_remotes(
         return HashMap::new();
     }
 
-    let progress_reporter = if std::env::var("NGITTEST").is_err() {
-        MultiProgress::new()
+    let verbose = is_verbose();
+    let spinner_state = if !verbose {
+        Some(Arc::new(Mutex::new(GitSpinnerState::new())))
     } else {
-        MultiProgress::with_draw_target(indicatif::ProgressDrawTarget::hidden())
+        None
     };
+    let progress_reporter = MultiProgress::new();
 
-    // Track successful servers for adaptive timeout
     let success_count = Arc::new(AtomicU64::new(0));
     let current_timeout = Arc::new(AtomicU64::new(git_server_long_timeout()));
     let total_servers = git_servers.len() as u64;
 
-    // Calculate column width for alignment
     let server_column_width = git_servers
         .iter()
         .map(|s| get_short_git_server_name(s).chars().count())
@@ -139,11 +195,13 @@ pub async fn list_from_remotes(
             let current_timeout_clone = current_timeout.clone();
             let progress_reporter_clone = progress_reporter.clone();
             let decoded_nostr_url = decoded_nostr_url.clone();
+            let spinner_state_clone = spinner_state.clone();
+            let verbose_for_task = verbose;
 
             async move {
                 let server_name = get_short_git_server_name(&url);
 
-                let pb = if std::env::var("NGITTEST").is_err() {
+                let pb = if verbose_for_task {
                     match git_server_pb_style(current_timeout_clone.clone()) {
                         Ok(style) => {
                             let pb = progress_reporter_clone.add(
@@ -164,6 +222,28 @@ pub async fn list_from_remotes(
                         }
                         Err(_) => None,
                     }
+                } else if let Some(ref spinner_state_arc) = spinner_state_clone {
+                    let mut state = spinner_state_arc.lock().unwrap();
+                    if state.should_expand() {
+                        let multi = state.expand().clone();
+                        let pb = multi.add(
+                            ProgressBar::new(1)
+                                .with_prefix(
+                                    console::style(format!(
+                                        "{: <server_column_width$} connecting",
+                                        &server_name
+                                    ))
+                                    .for_stderr()
+                                    .yellow()
+                                    .to_string(),
+                                )
+                                .with_style(git_server_pb_style(current_timeout_clone.clone()).unwrap()),
+                        );
+                        pb.enable_steady_tick(Duration::from_millis(300));
+                        Some(pb)
+                    } else {
+                        None
+                    }
                 } else {
                     None
                 };
@@ -191,7 +271,6 @@ pub async fn list_from_remotes(
                     }
                 }
 
-                // Create the list operation future - spawn_blocking to avoid blocking async runtime
                 let git_repo_path = git_repo.get_path().ok().map(|p| p.to_path_buf());
                 let url_clone = url.clone();
                 let decoded_nostr_url_clone = decoded_nostr_url.clone();
@@ -199,7 +278,6 @@ pub async fn list_from_remotes(
 
                 let list_future = async move {
                     match tokio::task::spawn_blocking(move || {
-                        // Re-open repo in blocking thread (git2::Repository is not Send)
                         let git_repo = match git_repo_path {
                             Some(path) => Repo::from_path(&path).ok(),
                             None => None,
@@ -274,11 +352,9 @@ pub async fn list_from_remotes(
                         Err((url, error))
                     }
                     Ok(state) => {
-                        // Determine sync status message and styling using existing functions
                         let status_msg = if state.is_empty() {
                             "empty repository".to_string()
                         } else if let Some(nostr_state) = nostr_state {
-                            // Use existing generate_remote_sync_warnings to get detailed status
                             let mut temp_states = HashMap::new();
                             temp_states.insert(url.clone(), (state.clone(), is_grasp_server));
                             let remote_issues = identify_remote_sync_issues(git_repo, nostr_state, &temp_states);
@@ -287,7 +363,6 @@ pub async fn list_from_remotes(
                             if warnings.is_empty() {
                                 "in sync".to_string()
                             } else {
-                                // Extract the message after "WARNING: <server> "
                                 let warning = &warnings[0];
                                 let server_name = get_short_git_server_name(&url);
                                 let prefix = format!("WARNING: {} ", server_name);
@@ -296,7 +371,6 @@ pub async fn list_from_remotes(
                                     .to_string()
                             }
                         } else {
-                            // No nostr state to compare against
                             "success".to_string()
                         };
 
@@ -333,20 +407,22 @@ pub async fn list_from_remotes(
         .await;
 
     let mut remote_states = HashMap::new();
-    let mut all_succeeded = true;
+    let mut has_errors = false;
     for result in results {
         match result {
             Ok((url, state, is_grasp_server)) => {
                 remote_states.insert(url, (state, is_grasp_server));
             }
             Err((url, error)) => {
-                all_succeeded = false;
+                has_errors = true;
                 let _ = term.write_line(&format!("failed to list from {}: {}", url, error));
             }
         }
     }
 
-    if all_succeeded {
+    if let Some(ref spinner_state_arc) = spinner_state {
+        spinner_state_arc.lock().unwrap().finish(has_errors);
+    } else if !has_errors {
         let _ = progress_reporter.clear();
     }