extract grasp/maintainership helpers to lib and auto-accept on push

move apply_grasp_infrastructure, latest_event_repo_ref to lib/repo_ref.rs
and wait_for_grasp_servers + grasp_servers_from_user_or_fallback to a
new lib/accept_maintainership.rs so both binaries can share them.

add accept_maintainership_with_defaults which publishes the co-maintainer's
own Kind:30617 announcement with defaults (user grasp servers, shared
metadata from existing events) then waits for grasp server provisioning
and updates nostr.repo config and origin remote.

replace the push error block with a call to accept_maintainership_with_defaults
so pushing now silently accepts co-maintainership instead of failing.

7 files changed, 613 insertions, 422 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75fe9a8..6d93f43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Auto-accept co-maintainership on push**: when pushing to a repo where you are listed as a maintainer but have not yet published an announcement, ngit now automatically publishes your announcement (using your grasp servers or the trusted maintainer's as fallback) and provisions your grasp server instead of failing
 - `ngit account login --signer-relay` - specify custom relays for nostrconnect (auto-prefixes with `wss://` if no scheme)
 - `ngit checkout <id>` - checkout a proposal branch by event-id or nevent
 - `ngit apply <id>` - apply proposal patches to current branch
diff --git a/src/bin/git_remote_nostr/main.rs b/src/bin/git_remote_nostr/main.rs
index f670b7b..e0821e9 100644
--- a/src/bin/git_remote_nostr/main.rs
+++ b/src/bin/git_remote_nostr/main.rs
@@ -203,7 +203,7 @@ async fn main() -> Result<()> {
                     &repo_ref,
                     &stdin,
                     refspec,
-                    &client,
+                    &mut client,
                     list_outputs.clone(),
                     title_description,
                 )
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index e1c94f8..b64cdd9 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -14,6 +14,7 @@ use git_events::{
 };
 use git2::{Oid, Repository};
 use ngit::{
+    accept_maintainership::accept_maintainership_with_defaults,
     client::{self, get_event_from_cache_by_id},
     git::{self, nostr_url::NostrUrlDecoded},
     git_events::{
@@ -50,7 +51,7 @@ pub async fn run_push(
     repo_ref: &RepoRef,
     stdin: &Stdin,
     initial_refspec: &str,
-    client: &Client,
+    client: &mut Client,
     list_outputs: Option<HashMap<String, (HashMap<String, String>, bool)>>,
     title_description: Option<(String, String)>,
 ) -> Result<()> {
@@ -127,7 +128,7 @@ pub async fn run_push(
             repo_ref,
             &git_state_refspecs,
             &proposal_refspecs,
-            client,
+            client, // &mut Client
             existing_state,
             &term,
             title_description.as_ref(),
@@ -182,7 +183,7 @@ async fn create_and_publish_events_and_proposals(
     repo_ref: &RepoRef,
     git_server_refspecs: &Vec<String>,
     proposal_refspecs: &Vec<String>,
-    client: &Client,
+    client: &mut Client,
     existing_state: HashMap<String, String>,
     term: &Term,
     title_description: Option<&(String, String)>,
@@ -216,16 +217,14 @@ async fn create_and_publish_events_and_proposals(
         .clone()
         .is_some_and(|ms| ms.contains(&user_ref.public_key))
     {
-        for refspec in git_server_refspecs {
-            let (_, to) = refspec_to_from_to(refspec).unwrap();
-            eprintln!(
-                "error {to} you have been offered co-maintainership of '{}'. to accept, run `ngit init` which will publish your own repository announcement. use `ngit init -d` to accept with defaults and no interactive prompts.",
-                repo_ref.name,
-            );
-        }
-        if proposal_refspecs.is_empty() {
-            return Ok((vec![], true));
-        }
+        // Auto-accept co-maintainership: publish the user's own announcement
+        // with defaults before proceeding with the push. The announcement is
+        // required (not just for consent, but to prevent scammers from
+        // attributing a person's state events to a fake project with the same
+        // identifier). See docs/design/co-maintainer-announcement-rationale.md.
+        accept_maintainership_with_defaults(git_repo, repo_ref, &user_ref, client, &signer)
+            .await
+            .context("failed to auto-accept co-maintainership")?;
     }
 
     let mut events = vec![];
diff --git a/src/bin/ngit/sub_commands/init.rs b/src/bin/ngit/sub_commands/init.rs
index 39c8e8e..d24a41e 100644
--- a/src/bin/ngit/sub_commands/init.rs
+++ b/src/bin/ngit/sub_commands/init.rs
@@ -3,19 +3,14 @@ use std::{
     env,
     process::{Command, Stdio},
     str::FromStr,
-    sync::{
-        Arc, Mutex,
-        atomic::{AtomicBool, AtomicU64, Ordering},
-    },
-    time::Duration,
+    sync::Arc,
 };
 
 use anyhow::{Context, Result, bail};
 use console::{Style, Term};
-use futures::future::join_all;
 use git2::Oid;
-use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle};
 use ngit::{
+    accept_maintainership::{grasp_servers_from_user_or_fallback, wait_for_grasp_servers},
     cli_interactor::{
         PromptChoiceParms, PromptConfirmParms, cli_error, multi_select_with_custom_value,
         show_multi_input_prompt_success,
@@ -25,8 +20,8 @@ use ngit::{
     git::nostr_url::{CloneUrl, NostrUrlDecoded},
     list::list_from_remote,
     repo_ref::{
-        detect_existing_grasp_servers, extract_npub, extract_pks,
-        format_grasp_server_url_as_relay_url, is_grasp_server_clone_url,
+        apply_grasp_infrastructure, detect_existing_grasp_servers, extract_npub, extract_pks,
+        format_grasp_server_url_as_relay_url, is_grasp_server_clone_url, latest_event_repo_ref,
         normalize_grasp_server_url, save_repo_config_to_yaml,
     },
     repo_state::RepoState,
@@ -129,16 +124,6 @@ fn my_event_repo_ref(repo_ref: &RepoRef, my_pubkey: &PublicKey) -> Option<RepoRe
         .and_then(|e| RepoRef::try_from((e.clone(), None)).ok())
 }
 
-/// Find the latest event (by `created_at`) across all maintainer events and
-/// parse it into a `RepoRef` for shared metadata (name, description, web).
-fn latest_event_repo_ref(repo_ref: &RepoRef) -> Option<RepoRef> {
-    repo_ref
-        .events
-        .values()
-        .max_by_key(|e| e.created_at)
-        .and_then(|e| RepoRef::try_from((e.clone(), None)).ok())
-}
-
 /// Check if a grasp-format clone URL belongs to the given public key.
 fn is_my_grasp_clone_url(url: &str, my_pubkey: &PublicKey) -> bool {
     if !is_grasp_server_clone_url(url) {
@@ -261,60 +246,6 @@ fn resolve_hashtags(args_hashtag: &[String], state: &InitState) -> Result<Vec<St
     Ok(vec![])
 }
 
-/// Derive clone-urls and relays from selected grasp servers.
-///
-/// For each grasp server, adds/replaces the corresponding clone URL in
-/// `git_servers` and adds a relay URL to `relays`. Grasp-derived infrastructure
-/// is always added — the other lists (`git_servers`, `relays`)
-/// contain *additional* infrastructure beyond what grasp servers provide.
-fn apply_grasp_infrastructure(
-    grasp_servers: &[String],
-    git_servers: &mut Vec<String>,
-    relays: &mut Vec<String>,
-    public_key: &PublicKey,
-    identifier: &str,
-) -> Result<()> {
-    for (grasp_relay_insert_idx, grasp_server) in grasp_servers.iter().enumerate() {
-        // Always add grasp-derived clone URL
-        let clone_url = format_grasp_server_url_as_clone_url(grasp_server, public_key, identifier)?;
-
-        let grasp_server_clone_root = if clone_url.contains("https://") {
-            format!("https://{grasp_server}")
-        } else {
-            grasp_server.to_string()
-        };
-
-        let matching_positions: Vec<usize> = git_servers
-            .iter()
-            .enumerate()
-            .filter_map(|(idx, url)| {
-                if url.contains(&grasp_server_clone_root) {
-                    Some(idx)
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        if matching_positions.is_empty() {
-            git_servers.push(clone_url);
-        } else {
-            git_servers[matching_positions[0]] = clone_url;
-            for &position in matching_positions.iter().skip(1).rev() {
-                git_servers.remove(position);
-            }
-        }
-
-        // Prepend grasp-derived relay in order (for relay hint) so that the
-        // first grasp server in the list ends up at relays[0].
-        let relay_url = format_grasp_server_url_as_relay_url(grasp_server)?;
-        if !relays.contains(&relay_url) {
-            relays.insert(grasp_relay_insert_idx, relay_url);
-        }
-    }
-    Ok(())
-}
-
 /// Resolve which grasp servers to use. Handles flag overrides, detection from
 /// existing URLs, user grasp list / system fallbacks, and interactive
 /// prompting.
@@ -392,26 +323,6 @@ fn resolve_grasp_servers(
     Ok(selected)
 }
 
-fn grasp_servers_from_user_or_fallback(
-    user_ref: &ngit::login::user::UserRef,
-    client: &Client,
-) -> Vec<String> {
-    if user_ref.grasp_list.urls.is_empty() {
-        client
-            .get_grasp_default_set()
-            .iter()
-            .map(std::string::ToString::to_string)
-            .collect()
-    } else {
-        user_ref
-            .grasp_list
-            .urls
-            .iter()
-            .map(std::string::ToString::to_string)
-            .collect()
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Validation
 // ---------------------------------------------------------------------------
@@ -1626,24 +1537,6 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     .await
 }
 
-fn format_grasp_server_url_as_clone_url(
-    url: &str,
-    public_key: &PublicKey,
-    identifier: &str,
-) -> Result<String> {
-    let grasp_server_url = normalize_grasp_server_url(url)?;
-    if grasp_server_url.contains("http://") {
-        return Ok(format!(
-            "{grasp_server_url}/{}/{identifier}.git",
-            public_key.to_bech32()?
-        ));
-    }
-    Ok(format!(
-        "https://{grasp_server_url}/{}/{identifier}.git",
-        public_key.to_bech32()?
-    ))
-}
-
 fn parse_relay_url(s: &str) -> Result<RelayUrl> {
     // Attempt to parse the original string
     match RelayUrl::parse(s) {
@@ -1733,300 +1626,3 @@ fn run_ngit_sync() -> Result<()> {
         bail!("ngit sync process exited with an error: {exit_status}");
     }
 }
-
-fn check_git_server_ready(git_repo_path: &std::path::Path, git_server_url: &str) -> bool {
-    let Ok(git_repo) = git2::Repository::open(git_repo_path) else {
-        return false;
-    };
-    let Ok(mut remote) = git_repo.remote_anonymous(git_server_url) else {
-        return false;
-    };
-    match remote.connect(git2::Direction::Fetch) {
-        Ok(()) => {
-            let _ = remote.disconnect();
-            true
-        }
-        Err(_) => false,
-    }
-}
-
-/// Holds the final style+message for a bar that completed before the detail
-/// view was revealed.
-struct DeferredServerFinish {
-    bar: ProgressBar,
-    style: ProgressStyle,
-    message: String,
-}
-
-struct ServerRevealState {
-    revealed: AtomicBool,
-    deferred: Mutex<Vec<DeferredServerFinish>>,
-}
-
-struct PollContext {
-    timeout_secs: u64,
-    total: u64,
-    ready_count: Arc<AtomicU64>,
-    spinner_pb: ProgressBar,
-    reveal_state: Arc<ServerRevealState>,
-}
-
-fn create_server_bars(clone_urls: &[String], detail_multi: &MultiProgress) -> Vec<ProgressBar> {
-    let waiting_style = ProgressStyle::with_template("  {spinner} {msg}")
-        .unwrap()
-        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈");
-    clone_urls
-        .iter()
-        .map(|url| {
-            let name = url
-                .trim_start_matches("https://")
-                .trim_start_matches("http://")
-                .to_string();
-            detail_multi.add(
-                ProgressBar::new_spinner()
-                    .with_style(waiting_style.clone())
-                    .with_message(
-                        console::style(format!("{name} - waiting"))
-                            .for_stderr()
-                            .dim()
-                            .to_string(),
-                    ),
-            )
-        })
-        .collect()
-}
-
-fn spawn_expand_timer(
-    expand_delay_ms: u64,
-    spinner_pb: ProgressBar,
-    detail_multi: MultiProgress,
-    heading_bar: ProgressBar,
-    reveal_state: Arc<ServerRevealState>,
-    server_bars: Vec<ProgressBar>,
-) -> tokio::task::JoinHandle<()> {
-    tokio::spawn(async move {
-        tokio::time::sleep(Duration::from_millis(expand_delay_ms)).await;
-        spinner_pb.finish_and_clear();
-        detail_multi.set_draw_target(ProgressDrawTarget::stderr());
-        heading_bar.finish_with_message("waiting for servers to create bare git repo...");
-        let mut deferred = reveal_state.deferred.lock().unwrap();
-        reveal_state.revealed.store(true, Ordering::Release);
-        for df in deferred.drain(..) {
-            df.bar.set_style(df.style);
-            df.bar.finish_with_message(df.message);
-        }
-        for bar in &server_bars {
-            if !bar.is_finished() {
-                bar.enable_steady_tick(Duration::from_millis(100));
-            }
-        }
-    })
-}
-
-fn finalize_spinner(all_ready: bool, spinner_pb: &ProgressBar, final_ready: u64, total: u64) {
-    if all_ready {
-        spinner_pb.finish_and_clear();
-    } else {
-        spinner_pb.set_style(ProgressStyle::with_template("{msg}").unwrap());
-        spinner_pb.finish_with_message(format!(
-            "timed out waiting for servers to create bare git repo ({final_ready}/{total} - complete), proceeding anyway"
-        ));
-    }
-}
-
-fn finish_server_bar(
-    bar: &ProgressBar,
-    style: ProgressStyle,
-    message: String,
-    reveal_state: &Arc<ServerRevealState>,
-) {
-    let mut deferred = reveal_state.deferred.lock().unwrap();
-    if reveal_state.revealed.load(Ordering::Acquire) {
-        drop(deferred);
-        bar.set_style(style);
-        bar.finish_with_message(message);
-    } else {
-        // Style is set now so the timer can drain it correctly; finish is
-        // deferred until the detail view becomes visible.
-        bar.set_style(style.clone());
-        deferred.push(DeferredServerFinish {
-            bar: bar.clone(),
-            style,
-            message,
-        });
-    }
-}
-
-async fn poll_single_server(
-    url: String,
-    git_repo_path: std::path::PathBuf,
-    bar: ProgressBar,
-    ctx: Arc<PollContext>,
-) -> bool {
-    let poll_interval = Duration::from_millis(500);
-    let deadline = tokio::time::Instant::now() + Duration::from_secs(ctx.timeout_secs);
-    let mut ready = false;
-    loop {
-        let is_ready = tokio::task::spawn_blocking({
-            let url = url.clone();
-            let path = git_repo_path.clone();
-            move || check_git_server_ready(&path, &url)
-        })
-        .await
-        .unwrap_or(false);
-
-        if is_ready {
-            ready = true;
-            break;
-        }
-
-        if tokio::time::Instant::now() >= deadline {
-            break;
-        }
-
-        tokio::time::sleep(poll_interval).await;
-    }
-
-    let count = if ready {
-        ctx.ready_count.fetch_add(1, Ordering::Relaxed) + 1
-    } else {
-        ctx.ready_count.load(Ordering::Relaxed)
-    };
-
-    ctx.spinner_pb.set_message(format!(
-        "waiting for servers to create bare git repo... ({count}/{total} - complete)",
-        total = ctx.total
-    ));
-
-    let name = url
-        .trim_start_matches("https://")
-        .trim_start_matches("http://")
-        .to_string();
-    if ready {
-        let style = ProgressStyle::with_template(&format!(
-            "  {} {{msg}}",
-            console::style("✔").for_stderr().green()
-        ))
-        .unwrap();
-        let msg = console::style(format!("{name} - ready"))
-            .for_stderr()
-            .green()
-            .to_string();
-        finish_server_bar(&bar, style, msg, &ctx.reveal_state);
-    } else {
-        let style = ProgressStyle::with_template(&format!(
-            "  {} {{msg}}",
-            console::style("✘").for_stderr().red()
-        ))
-        .unwrap();
-        let msg = console::style(format!("{name} - timeout"))
-            .for_stderr()
-            .red()
-            .to_string();
-        finish_server_bar(&bar, style, msg, &ctx.reveal_state);
-    }
-
-    ready
-}
-
-/// Poll grasp servers in parallel until all are ready or timeout is reached.
-///
-/// Shows a concise spinner with `x/y - complete` progress. After 5s without
-/// all servers responding, expands to show per-server status bars (including
-/// any that already finished). Times out after 15s (2s in tests) and proceeds
-/// anyway rather than failing.
-async fn wait_for_grasp_servers(
-    git_repo: &Repo,
-    grasp_servers: &[String],
-    public_key: &PublicKey,
-    identifier: &str,
-) -> Result<()> {
-    let clone_urls: Vec<String> = grasp_servers
-        .iter()
-        .filter_map(|gs| format_grasp_server_url_as_clone_url(gs, public_key, identifier).ok())
-        .collect();
-
-    if clone_urls.is_empty() {
-        return Ok(());
-    }
-
-    let is_test = std::env::var("NGITTEST").is_ok();
-    let timeout_secs: u64 = if is_test { 2 } else { 15 };
-    let expand_delay_ms: u64 = if is_test { 500 } else { 5000 };
-    let total = clone_urls.len() as u64;
-
-    // Spinner shown immediately with x/y count
-    let spinner_multi = MultiProgress::new();
-    let spinner_pb = spinner_multi.add(
-        ProgressBar::new_spinner()
-            .with_style(
-                ProgressStyle::with_template("{spinner} {msg}")
-                    .unwrap()
-                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
-            )
-            .with_message(format!(
-                "waiting for servers to create bare git repo... (0/{total} - complete)"
-            )),
-    );
-    spinner_pb.enable_steady_tick(Duration::from_millis(100));
-
-    // Detail MultiProgress starts hidden; revealed after expand_delay_ms.
-    // A heading bar is pre-added at position 0 so it holds its slot before
-    // any per-server bars are added.
-    let detail_multi = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
-    let heading_bar = detail_multi
-        .add(ProgressBar::new(0).with_style(ProgressStyle::with_template("{msg}").unwrap()));
-
-    let ready_count = Arc::new(AtomicU64::new(0));
-    let reveal_state = Arc::new(ServerRevealState {
-        revealed: AtomicBool::new(false),
-        deferred: Mutex::new(Vec::new()),
-    });
-
-    let server_bars = create_server_bars(&clone_urls, &detail_multi);
-
-    let timer_handle = spawn_expand_timer(
-        expand_delay_ms,
-        spinner_pb.clone(),
-        detail_multi.clone(),
-        heading_bar,
-        reveal_state.clone(),
-        server_bars.clone(),
-    );
-
-    // Poll each server in parallel
-    let git_repo_path = git_repo.get_path()?.to_path_buf();
-    let poll_ctx = Arc::new(PollContext {
-        timeout_secs,
-        total,
-        ready_count: ready_count.clone(),
-        spinner_pb: spinner_pb.clone(),
-        reveal_state: reveal_state.clone(),
-    });
-    let futures: Vec<_> = clone_urls
-        .iter()
-        .enumerate()
-        .map(|(i, url)| {
-            poll_single_server(
-                url.clone(),
-                git_repo_path.clone(),
-                server_bars[i].clone(),
-                poll_ctx.clone(),
-            )
-        })
-        .collect();
-
-    let results = join_all(futures).await;
-    let final_ready = ready_count.load(Ordering::Relaxed);
-
-    timer_handle.abort();
-
-    if reveal_state.revealed.load(Ordering::Acquire) {
-        let _ = detail_multi.clear();
-    }
-
-    let all_ready = results.iter().all(|&r| r);
-    finalize_spinner(all_ready, &spinner_pb, final_ready, total);
-
-    Ok(())
-}
diff --git a/src/lib/accept_maintainership.rs b/src/lib/accept_maintainership.rs
new file mode 100644
index 0000000..173d1a5
--- /dev/null
+++ b/src/lib/accept_maintainership.rs
@@ -0,0 +1,529 @@
+//! Auto-accept co-maintainership on push.
+//!
+//! When a user has been offered co-maintainership (they appear in another
+//! maintainer's `maintainers` tag but have never published their own
+//! Kind:30617 announcement), pushing would normally fail. This module
+//! provides `accept_maintainership_with_defaults`, called by the push path
+//! to silently publish the co-maintainer's announcement with sensible
+//! defaults before continuing the push.
+//!
+//! See `docs/design/co-maintainer-announcement-rationale.md` for why the
+//! announcement is required (scam-protection) even though the fetch/read side
+//! already trusts state events from all listed maintainers.
+use std::{
+    collections::HashMap,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicU64, Ordering},
+    },
+    time::Duration,
+};
+
+use anyhow::{Context, Result};
+use futures::future::join_all;
+use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle};
+use nostr::{
+    PublicKey, ToBech32,
+    nips::{nip01::Coordinate, nip19::Nip19Coordinate},
+};
+use nostr_sdk::{Kind, NostrSigner, RelayUrl};
+
+#[cfg(not(test))]
+use crate::client::Client;
+#[cfg(test)]
+use crate::client::MockConnect;
+use crate::{
+    client::{Connect, send_events},
+    git::{Repo, RepoActions},
+    login::user::UserRef,
+    repo_ref::{
+        RepoRef, apply_grasp_infrastructure, format_grasp_server_url_as_clone_url,
+        latest_event_repo_ref,
+    },
+};
+
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+
+/// Publish the co-maintainer's own Kind:30617 announcement with defaults and
+/// update the local git config / origin remote to point to it.
+///
+/// This is called automatically from the push path when the pushing user is
+/// listed as a maintainer but has not yet published their own announcement.
+/// No interactive prompts are shown — all values come from the existing
+/// announcement and the user's saved grasp server / relay preferences.
+pub async fn accept_maintainership_with_defaults(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    user_ref: &UserRef,
+    #[cfg(test)] client: &mut MockConnect,
+    #[cfg(not(test))] client: &mut Client,
+    signer: &Arc<dyn NostrSigner>,
+) -> Result<()> {
+    let my_pubkey = &user_ref.public_key;
+    let identifier = &repo_ref.identifier;
+
+    // --- Step 1: resolve infrastructure ---
+
+    let selected_grasp_servers = grasp_servers_from_user_or_fallback(user_ref, client);
+
+    let mut git_servers: Vec<String> = vec![];
+    let mut relay_strings: Vec<String> = client
+        .get_relay_default_set()
+        .iter()
+        .map(std::string::ToString::to_string)
+        .collect();
+
+    apply_grasp_infrastructure(
+        &selected_grasp_servers,
+        &mut git_servers,
+        &mut relay_strings,
+        my_pubkey,
+        identifier,
+    )?;
+
+    let relays: Vec<RelayUrl> = relay_strings
+        .iter()
+        .filter_map(|r| RelayUrl::parse(r).ok())
+        .collect();
+
+    // --- Step 2: resolve shared metadata from latest existing event ---
+
+    let latest = latest_event_repo_ref(repo_ref);
+    let name = latest
+        .as_ref()
+        .map(|lr| lr.name.clone())
+        .unwrap_or_else(|| identifier.clone());
+    let description = latest
+        .as_ref()
+        .map(|lr| lr.description.clone())
+        .unwrap_or_default();
+    let web = latest.as_ref().map(|lr| lr.web.clone()).unwrap_or_default();
+    let hashtags = latest
+        .as_ref()
+        .map(|lr| lr.hashtags.clone())
+        .unwrap_or_default();
+    let blossoms = latest
+        .as_ref()
+        .map(|lr| lr.blossoms.clone())
+        .unwrap_or_default();
+    let root_commit = latest
+        .as_ref()
+        .map(|lr| lr.root_commit.clone())
+        .filter(|c| !c.is_empty())
+        .unwrap_or_else(|| repo_ref.root_commit.clone());
+
+    // --- Step 3: maintainers = [me, trusted_maintainer] ---
+
+    let mut maintainers = vec![*my_pubkey];
+    if repo_ref.trusted_maintainer != *my_pubkey {
+        maintainers.push(repo_ref.trusted_maintainer);
+    }
+
+    // --- Step 4: build RepoRef ---
+
+    let my_repo_ref = RepoRef {
+        identifier: identifier.clone(),
+        name: name.clone(),
+        description,
+        root_commit,
+        git_server: git_servers,
+        web,
+        relays: relays.clone(),
+        blossoms,
+        hashtags,
+        trusted_maintainer: *my_pubkey,
+        maintainers_without_annoucnement: None,
+        maintainers,
+        events: HashMap::new(),
+        nostr_git_url: None,
+    };
+
+    // --- Step 5: sign and publish the announcement ---
+
+    eprintln!(
+        "info: accepting co-maintainership of '{}' with defaults",
+        name
+    );
+    eprintln!("info: publishing your repository announcement to nostr...");
+
+    let repo_event = my_repo_ref.to_event(signer).await?;
+
+    client.set_signer(signer.clone()).await;
+
+    send_events(
+        client,
+        Some(git_repo.get_path()?),
+        vec![repo_event],
+        user_ref.relays.write(),
+        relays.clone(),
+        false, // no spinner — we are mid-push
+        true,  // silent
+    )
+    .await
+    .context("failed to publish co-maintainer announcement")?;
+
+    // --- Step 6: wait for grasp server provisioning ---
+
+    if !selected_grasp_servers.is_empty() {
+        wait_for_grasp_servers(git_repo, &selected_grasp_servers, my_pubkey, identifier).await?;
+    }
+
+    // --- Step 7: update nostr.repo git config ---
+
+    git_repo
+        .save_git_config_item(
+            "nostr.repo",
+            &Nip19Coordinate {
+                coordinate: Coordinate {
+                    kind: Kind::GitRepoAnnouncement,
+                    public_key: *my_pubkey,
+                    identifier: identifier.clone(),
+                },
+                relays: vec![],
+            }
+            .to_bech32()?,
+            false,
+        )
+        .context("failed to update nostr.repo git config")?;
+
+    // --- Step 8: update origin remote ---
+
+    let nostr_url = my_repo_ref.to_nostr_git_url(&Some(git_repo)).to_string();
+    if git_repo.git_repo.find_remote("origin").is_ok() {
+        git_repo
+            .git_repo
+            .remote_set_url("origin", &nostr_url)
+            .context("failed to update origin remote")?;
+    } else {
+        git_repo
+            .git_repo
+            .remote("origin", &nostr_url)
+            .context("failed to set origin remote")?;
+    }
+
+    eprintln!("info: co-maintainership accepted. run `ngit init` to customise your announcement.");
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Grasp server helpers
+// ---------------------------------------------------------------------------
+
+/// Return the user's saved grasp servers, falling back to client defaults.
+pub fn grasp_servers_from_user_or_fallback(
+    user_ref: &UserRef,
+    #[cfg(test)] client: &MockConnect,
+    #[cfg(not(test))] client: &Client,
+) -> Vec<String> {
+    if user_ref.grasp_list.urls.is_empty() {
+        client
+            .get_grasp_default_set()
+            .iter()
+            .map(std::string::ToString::to_string)
+            .collect()
+    } else {
+        user_ref
+            .grasp_list
+            .urls
+            .iter()
+            .map(std::string::ToString::to_string)
+            .collect()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Grasp server provisioning poll
+// ---------------------------------------------------------------------------
+
+/// Holds the final style + message for a bar that completed before the detail
+/// view was revealed.
+struct DeferredServerFinish {
+    bar: ProgressBar,
+    style: ProgressStyle,
+    message: String,
+}
+
+struct ServerRevealState {
+    revealed: AtomicBool,
+    deferred: Mutex<Vec<DeferredServerFinish>>,
+}
+
+struct PollContext {
+    timeout_secs: u64,
+    total: u64,
+    ready_count: Arc<AtomicU64>,
+    spinner_pb: ProgressBar,
+    reveal_state: Arc<ServerRevealState>,
+}
+
+fn check_git_server_ready(git_repo_path: &std::path::Path, git_server_url: &str) -> bool {
+    let Ok(git_repo) = git2::Repository::open(git_repo_path) else {
+        return false;
+    };
+    let Ok(mut remote) = git_repo.remote_anonymous(git_server_url) else {
+        return false;
+    };
+    match remote.connect(git2::Direction::Fetch) {
+        Ok(()) => {
+            let _ = remote.disconnect();
+            true
+        }
+        Err(_) => false,
+    }
+}
+
+fn create_server_bars(clone_urls: &[String], detail_multi: &MultiProgress) -> Vec<ProgressBar> {
+    let waiting_style = ProgressStyle::with_template("  {spinner} {msg}")
+        .unwrap()
+        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈");
+    clone_urls
+        .iter()
+        .map(|url| {
+            let name = url
+                .trim_start_matches("https://")
+                .trim_start_matches("http://")
+                .to_string();
+            detail_multi.add(
+                ProgressBar::new_spinner()
+                    .with_style(waiting_style.clone())
+                    .with_message(
+                        console::style(format!("{name} - waiting"))
+                            .for_stderr()
+                            .dim()
+                            .to_string(),
+                    ),
+            )
+        })
+        .collect()
+}
+
+fn spawn_expand_timer(
+    expand_delay_ms: u64,
+    spinner_pb: ProgressBar,
+    detail_multi: MultiProgress,
+    heading_bar: ProgressBar,
+    reveal_state: Arc<ServerRevealState>,
+    server_bars: Vec<ProgressBar>,
+) -> tokio::task::JoinHandle<()> {
+    tokio::spawn(async move {
+        tokio::time::sleep(Duration::from_millis(expand_delay_ms)).await;
+        spinner_pb.finish_and_clear();
+        detail_multi.set_draw_target(ProgressDrawTarget::stderr());
+        heading_bar.finish_with_message("waiting for servers to create bare git repo...");
+        let mut deferred = reveal_state.deferred.lock().unwrap();
+        reveal_state.revealed.store(true, Ordering::Release);
+        for df in deferred.drain(..) {
+            df.bar.set_style(df.style);
+            df.bar.finish_with_message(df.message);
+        }
+        for bar in &server_bars {
+            if !bar.is_finished() {
+                bar.enable_steady_tick(Duration::from_millis(100));
+            }
+        }
+    })
+}
+
+fn finalize_spinner(all_ready: bool, spinner_pb: &ProgressBar, final_ready: u64, total: u64) {
+    if all_ready {
+        spinner_pb.finish_and_clear();
+    } else {
+        spinner_pb.set_style(ProgressStyle::with_template("{msg}").unwrap());
+        spinner_pb.finish_with_message(format!(
+            "timed out waiting for servers to create bare git repo ({final_ready}/{total} - complete), proceeding anyway"
+        ));
+    }
+}
+
+fn finish_server_bar(
+    bar: &ProgressBar,
+    style: ProgressStyle,
+    message: String,
+    reveal_state: &Arc<ServerRevealState>,
+) {
+    let mut deferred = reveal_state.deferred.lock().unwrap();
+    if reveal_state.revealed.load(Ordering::Acquire) {
+        drop(deferred);
+        bar.set_style(style);
+        bar.finish_with_message(message);
+    } else {
+        bar.set_style(style.clone());
+        deferred.push(DeferredServerFinish {
+            bar: bar.clone(),
+            style,
+            message,
+        });
+    }
+}
+
+async fn poll_single_server(
+    url: String,
+    git_repo_path: std::path::PathBuf,
+    bar: ProgressBar,
+    ctx: Arc<PollContext>,
+) -> bool {
+    let poll_interval = Duration::from_millis(500);
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(ctx.timeout_secs);
+    let mut ready = false;
+    loop {
+        let is_ready = tokio::task::spawn_blocking({
+            let url = url.clone();
+            let path = git_repo_path.clone();
+            move || check_git_server_ready(&path, &url)
+        })
+        .await
+        .unwrap_or(false);
+
+        if is_ready {
+            ready = true;
+            break;
+        }
+
+        if tokio::time::Instant::now() >= deadline {
+            break;
+        }
+
+        tokio::time::sleep(poll_interval).await;
+    }
+
+    let count = if ready {
+        ctx.ready_count.fetch_add(1, Ordering::Relaxed) + 1
+    } else {
+        ctx.ready_count.load(Ordering::Relaxed)
+    };
+
+    ctx.spinner_pb.set_message(format!(
+        "waiting for servers to create bare git repo... ({count}/{total} - complete)",
+        total = ctx.total
+    ));
+
+    let name = url
+        .trim_start_matches("https://")
+        .trim_start_matches("http://")
+        .to_string();
+    if ready {
+        let style = ProgressStyle::with_template(&format!(
+            "  {} {{msg}}",
+            console::style("✔").for_stderr().green()
+        ))
+        .unwrap();
+        let msg = console::style(format!("{name} - ready"))
+            .for_stderr()
+            .green()
+            .to_string();
+        finish_server_bar(&bar, style, msg, &ctx.reveal_state);
+    } else {
+        let style = ProgressStyle::with_template(&format!(
+            "  {} {{msg}}",
+            console::style("✘").for_stderr().red()
+        ))
+        .unwrap();
+        let msg = console::style(format!("{name} - timeout"))
+            .for_stderr()
+            .red()
+            .to_string();
+        finish_server_bar(&bar, style, msg, &ctx.reveal_state);
+    }
+
+    ready
+}
+
+/// Poll grasp servers in parallel until all are ready or timeout is reached.
+///
+/// Shows a concise spinner with `x/y - complete` progress. After 5 s without
+/// all servers responding, expands to show per-server status bars (including
+/// any that already finished). Times out after 15 s (2 s in tests) and
+/// proceeds rather than failing.
+pub async fn wait_for_grasp_servers(
+    git_repo: &Repo,
+    grasp_servers: &[String],
+    public_key: &PublicKey,
+    identifier: &str,
+) -> Result<()> {
+    let clone_urls: Vec<String> = grasp_servers
+        .iter()
+        .filter_map(|gs| format_grasp_server_url_as_clone_url(gs, public_key, identifier).ok())
+        .collect();
+
+    if clone_urls.is_empty() {
+        return Ok(());
+    }
+
+    let is_test = std::env::var("NGITTEST").is_ok();
+    let timeout_secs: u64 = if is_test { 2 } else { 15 };
+    let expand_delay_ms: u64 = if is_test { 500 } else { 5000 };
+    let total = clone_urls.len() as u64;
+
+    let spinner_multi = MultiProgress::new();
+    let spinner_pb = spinner_multi.add(
+        ProgressBar::new_spinner()
+            .with_style(
+                ProgressStyle::with_template("{spinner} {msg}")
+                    .unwrap()
+                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+            )
+            .with_message(format!(
+                "waiting for servers to create bare git repo... (0/{total} - complete)"
+            )),
+    );
+    spinner_pb.enable_steady_tick(Duration::from_millis(100));
+
+    let detail_multi = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
+    let heading_bar = detail_multi
+        .add(ProgressBar::new(0).with_style(ProgressStyle::with_template("{msg}").unwrap()));
+
+    let ready_count = Arc::new(AtomicU64::new(0));
+    let reveal_state = Arc::new(ServerRevealState {
+        revealed: AtomicBool::new(false),
+        deferred: Mutex::new(Vec::new()),
+    });
+
+    let server_bars = create_server_bars(&clone_urls, &detail_multi);
+
+    let timer_handle = spawn_expand_timer(
+        expand_delay_ms,
+        spinner_pb.clone(),
+        detail_multi.clone(),
+        heading_bar,
+        reveal_state.clone(),
+        server_bars.clone(),
+    );
+
+    let git_repo_path = git_repo.get_path()?.to_path_buf();
+    let poll_ctx = Arc::new(PollContext {
+        timeout_secs,
+        total,
+        ready_count: ready_count.clone(),
+        spinner_pb: spinner_pb.clone(),
+        reveal_state: reveal_state.clone(),
+    });
+    let futures: Vec<_> = clone_urls
+        .iter()
+        .enumerate()
+        .map(|(i, url)| {
+            poll_single_server(
+                url.clone(),
+                git_repo_path.clone(),
+                server_bars[i].clone(),
+                poll_ctx.clone(),
+            )
+        })
+        .collect();
+
+    let results = join_all(futures).await;
+    let final_ready = ready_count.load(Ordering::Relaxed);
+
+    timer_handle.abort();
+
+    if reveal_state.revealed.load(Ordering::Acquire) {
+        let _ = detail_multi.clear();
+    }
+
+    let all_ready = results.iter().all(|&r| r);
+    finalize_spinner(all_ready, &spinner_pb, final_ready, total);
+
+    Ok(())
+}
diff --git a/src/lib/mod.rs b/src/lib/mod.rs
index b388b23..1229e8c 100644
--- a/src/lib/mod.rs
+++ b/src/lib/mod.rs
@@ -1,3 +1,4 @@
+pub mod accept_maintainership;
 pub mod cli_interactor;
 pub mod client;
 pub mod fetch;
diff --git a/src/lib/repo_ref.rs b/src/lib/repo_ref.rs
index 9573238..c0f9136 100644
--- a/src/lib/repo_ref.rs
+++ b/src/lib/repo_ref.rs
@@ -814,6 +814,71 @@ pub fn format_grasp_server_url_as_clone_url(
     ))
 }
 
+/// Find the latest announcement event (by `created_at`) across all maintainer
+/// events and parse it into a `RepoRef` for shared metadata (name, description,
+/// web, etc.).
+pub fn latest_event_repo_ref(repo_ref: &RepoRef) -> Option<RepoRef> {
+    repo_ref
+        .events
+        .values()
+        .max_by_key(|e| e.created_at)
+        .and_then(|e| RepoRef::try_from((e.clone(), None)).ok())
+}
+
+/// Derive clone-URLs and relay URLs from selected grasp servers.
+///
+/// For each grasp server, adds or replaces the corresponding clone URL in
+/// `git_servers` and prepends a relay URL in `relays`. Grasp-derived
+/// infrastructure always takes priority — the other lists contain *additional*
+/// infrastructure beyond what grasp servers provide.
+pub fn apply_grasp_infrastructure(
+    grasp_servers: &[String],
+    git_servers: &mut Vec<String>,
+    relays: &mut Vec<String>,
+    public_key: &PublicKey,
+    identifier: &str,
+) -> Result<()> {
+    for (grasp_relay_insert_idx, grasp_server) in grasp_servers.iter().enumerate() {
+        // Always add grasp-derived clone URL
+        let clone_url = format_grasp_server_url_as_clone_url(grasp_server, public_key, identifier)?;
+
+        let grasp_server_clone_root = if clone_url.contains("https://") {
+            format!("https://{grasp_server}")
+        } else {
+            grasp_server.to_string()
+        };
+
+        let matching_positions: Vec<usize> = git_servers
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, url)| {
+                if url.contains(&grasp_server_clone_root) {
+                    Some(idx)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        if matching_positions.is_empty() {
+            git_servers.push(clone_url);
+        } else {
+            git_servers[matching_positions[0]] = clone_url;
+            for &position in matching_positions.iter().skip(1).rev() {
+                git_servers.remove(position);
+            }
+        }
+
+        // Prepend grasp-derived relay in order (for relay hint) so that the
+        // first grasp server in the list ends up at relays[0].
+        let relay_url = format_grasp_server_url_as_relay_url(grasp_server)?;
+        if !relays.contains(&relay_url) {
+            relays.insert(grasp_relay_insert_idx, relay_url);
+        }
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use test_utils::*;