14 files changed, 1120 insertions, 445 deletions
diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index 221d964..2cc87da 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -18,7 +18,7 @@ use ngit::{
    },
    git_events::{KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, tag_value},
    login::get_curent_user,
-    repo_ref::{RepoRef, is_grasp_server},
+    repo_ref::{RepoRef, is_grasp_server_in_list},
    utils::{
        Direction, find_proposal_and_patches_by_branch_name, get_oids_from_fetch_batch,
        get_open_or_draft_proposals, get_read_protocols_to_try, join_with_and,
@@ -96,7 +96,7 @@ pub async fn run_fetch(
            git_server_url,
            &repo_ref.to_nostr_git_url(&None),
            &term,
-            is_grasp_server(git_server_url, &repo_ref.grasp_servers()),
+            is_grasp_server_in_list(git_server_url, &repo_ref.grasp_servers()),
        ) {
            errors.push(error);
        }
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index d0cf923..1738790 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -10,25 +10,24 @@ use client::{get_events_from_local_cache, get_state_from_cache, send_events, sig
 use console::Term;
 use git::{RepoActions, sha1_to_oid};
 use git_events::{
-    generate_cover_letter_and_patch_events, generate_patch_event,
+    generate_cover_letter_and_patch_events, generate_patch_event, get_commit_id_from_patch,
-    generate_unsigned_pr_or_update_event, get_commit_id_from_patch,
 };
 use git2::{Oid, Repository};
 use ngit::{
-    client::{self, get_event_from_cache_by_id, sign_draft_event},
+    client::{self, get_event_from_cache_by_id},
    git::{self, nostr_url::NostrUrlDecoded},
    git_events::{self, KIND_PULL_REQUEST, event_to_cover_letter, get_event_root},
    list::list_from_remotes,
    login::{self, user::UserRef},
-    push::{push_to_remote, push_to_remote_url},
+    push::{push_refs_and_generate_pr_or_pr_update_event, push_to_remote},
-    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server, normalize_grasp_server_url},
+    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server_in_list},
    repo_state,
    utils::{
        find_proposal_and_patches_by_branch_name, get_all_proposals, get_remote_name_by_url,
        get_short_git_server_name, read_line,
    },
 };
-use nostr::{event::UnsignedEvent, nips::nip10::Marker};
+use nostr::nips::nip10::Marker;
 use nostr_sdk::{
    Event, EventBuilder, EventId, Kind, NostrSigner, PublicKey, RelayUrl, Tag, TagStandard,
    hashes::sha1::Hash as Sha1Hash,
@@ -154,7 +153,7 @@ pub async fn run_push(
                        &repo_ref.to_nostr_git_url(&None),
                        &remote_refspecs,
                        &term,
-                        is_grasp_server(&git_server_url, &repo_ref.grasp_servers()),
+                        is_grasp_server_in_list(&git_server_url, &repo_ref.grasp_servers()),
                    );
                }
            }
@@ -357,7 +356,7 @@ async fn process_proposal_refspecs(
                            );
                        }
                        if proposal.kind.eq(&KIND_PULL_REQUEST)
-                            || are_commits_too_big_for_patches(git_repo, &ahead)
+                            || git_repo.are_commits_too_big_for_patches(&ahead)
                        {
                            for event in generate_patches_or_pr_event_or_pr_updates(
                                git_repo,
@@ -441,19 +440,6 @@ async fn process_proposal_refspecs(
    Ok((events, rejected_proposal_refspecs))
 }
-fn are_commits_too_big_for_patches(git_repo: &Repo, commits: &[Sha1Hash]) -> bool {
-    commits.iter().any(|commit| {
-        if let Ok(patch) = git_repo.make_patch_from_commit(commit, &None) {
-            patch.len()
-                > ((65 // max recomended patch event size specified in nip34 in kb
-            // allownace for nostr event wrapper (id, pubkey, tags, sig)
-            - 1) * 1024)
-        } else {
-            true
-        }
-    })
-}
 #[allow(clippy::too_many_lines)]
 async fn generate_patches_or_pr_event_or_pr_updates(
    git_repo: &Repo,
@@ -464,96 +450,50 @@ async fn generate_patches_or_pr_event_or_pr_updates(
    signer: &Arc<dyn NostrSigner>,
    term: &Term,
 ) -> Result<Vec<Event>> {
-    let mut events: Vec<Event> = vec![];
+    let parent_is_pr = root_proposal.is_some_and(|proposal| proposal.kind.eq(&KIND_PULL_REQUEST));
-    let use_pr = root_proposal.is_some_and(|proposal| proposal.kind.eq(&KIND_PULL_REQUEST))
+    let use_pr = parent_is_pr || git_repo.are_commits_too_big_for_patches(ahead);
-        || are_commits_too_big_for_patches(git_repo, ahead);
    if use_pr {
        let repo_grasps = repo_ref.grasp_servers();
-        let repo_grasp_clone_urls = repo_ref
+        let repo_grasp_clone_urls: Vec<String> = repo_ref
            .git_server
            .iter()
-            .filter(|s| is_grasp_server(s, &repo_grasps));
+            .filter(|s| is_grasp_server_in_list(s, &repo_grasps))
+            .cloned()
-        let mut unsigned_pr_event: Option<UnsignedEvent> = None;
+            .collect();
-        let mut failed_clone_urls = vec![];
-        for clone_url in repo_grasp_clone_urls {
-            let mut draft_pr_event = if let Some(ref unsigned_pr_event) = unsigned_pr_event {
-                unsigned_pr_event.clone()
-            } else {
-                generate_unsigned_pr_or_update_event(
-                    git_repo,
-                    repo_ref,
-                    &user_ref.public_key,
-                    root_proposal,
-                    ahead.first().context("no commits to push")?,
-                    &[clone_url],
-                    &[],
-                )?
-            };
-            let refspec = format!(
-                "{}:refs/nostr/{}",
-                ahead.first().unwrap(),
-                draft_pr_event.id()
-            );
-            if let Err(error) = push_to_remote_url(git_repo, clone_url, &[refspec], term) {
-                failed_clone_urls.push(clone_url);
-                term.write_line(
-                    format!(
-                        "push: error sending commit data to {}: {error}",
-                        normalize_grasp_server_url(clone_url)?
-                    )
-                    .as_str(),
-                )?;
-            } else {
-                term.write_line(
-                    format!(
-                        "push: commit data sent to {}",
-                        normalize_grasp_server_url(clone_url)?
-                    )
-                    .as_str(),
-                )?;
-                unsigned_pr_event = Some(draft_pr_event);
-            }
-        }
-        if unsigned_pr_event.is_none() {
-            bail!(
-                "a commit in your proposal is too big for a nostr patch. The repository doesnt list a grasp server which would otherwise be used to submit your proposal as nostr Pull Request. Soon ngit will support pushing your changes to a different git / grasp git server."
-            );
+        if repo_grasp_clone_urls.is_empty() {
            // TODO get grasp_default_set servers that aren't in repo_grasps
            // cycle through until one succeeds TODO create
            // personal-fork announcement with grasp servers and
            // push, after a few seconds push ref/nostr/eventid. if
            // one success break out of for loop and continue
+            bail!(
+                "The repository doesnt list a grasp server which would otherwise be used to submit your proposal as nostr Pull Request. Soon ngit will support pushing your changes to a different git / grasp git server."
+            );
        }
-        if let Some(unsigned_pr_event) = unsigned_pr_event {
-            let pr_event = sign_draft_event(
+        if let (Some(events), _) = push_refs_and_generate_pr_or_pr_update_event(
-                unsigned_pr_event,
+            git_repo,
-                signer,
+            repo_ref,
-                if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+            ahead.first().context("no commits to push")?,
-                    "Pull Request Replacing Original Patch"
+            user_ref,
-                } else if root_proposal.is_some() {
+            root_proposal,
-                    "Pull Request Update"
+            &None,
-                } else {
+            &repo_grasp_clone_urls,
-                    "Pull Request"
+            None,
-                }
+            signer,
-                .to_string(),
+            term,
-            )
+        )
-            .await?;
+        .await.context(
-            events.push(pr_event);
+            if parent_is_pr {
-            if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+                "couldn't generate PR update event"
-                events.push(
+            } else {
-                    create_close_status_for_original_patch(
+                "a commit in your proposal is too big for a nostr patch so we tried to create it as a nostr PR instead. Unfortunately this failed."
-                        signer,
-                        repo_ref,
-                        root_proposal.unwrap(),
-                    )
-                    .await?,
-                );
            }
+        )? {
+            Ok(events)
        } else {
            bail!(
                "a commit in your proposal is too big for a nostr patch. tried to use submit as a nostr Pull Request but could not find a grasp server that would accept your changes"
@@ -562,7 +502,7 @@ async fn generate_patches_or_pr_event_or_pr_updates(
            // url to push to once that feature is added
        }
    } else {
-        for patch in generate_cover_letter_and_patch_events(
+        generate_cover_letter_and_patch_events(
            None,
            git_repo,
            ahead,
@@ -571,13 +511,8 @@ async fn generate_patches_or_pr_event_or_pr_updates(
            &root_proposal.map(|proposal| proposal.id.to_string()),
            &[],
        )
-        .await?
+        .await
-        {
-            events.push(patch);
-        }
    }
-    Ok(events)
 }
 type HashMapUrlRefspecs = HashMap<String, Vec<String>>;
@@ -1272,62 +1207,6 @@ async fn create_merge_status(
    .await
 }
-async fn create_close_status_for_original_patch(
-    signer: &Arc<dyn NostrSigner>,
-    repo_ref: &RepoRef,
-    proposal: &Event,
-) -> Result<Event> {
-    let mut public_keys = repo_ref
-        .maintainers
-        .iter()
-        .copied()
-        .collect::<HashSet<PublicKey>>();
-    public_keys.insert(proposal.pubkey);
-    sign_event(
-        EventBuilder::new(nostr::event::Kind::GitStatusClosed, String::new()).tags(
-            [
-                vec![
-                    Tag::custom(
-                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
-                        vec![
-                            "Git patch closed as forthcoming update is too large. Replacing with Pull Request"
-                                .to_string(),
-                        ],
-                    ),
-                    Tag::from_standardized(nostr::TagStandard::Event {
-                        event_id: proposal.id,
-                        relay_url: repo_ref.relays.first().cloned(),
-                        marker: Some(Marker::Root),
-                        public_key: None,
-                        uppercase: false,
-                    }),
-                ],
-                public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(),
-                repo_ref
-                    .coordinates()
-                    .iter()
-                    .map(|c| {
-                        Tag::from_standardized(TagStandard::Coordinate {
-                            coordinate: c.coordinate.clone(),
-                            relay_url: c.relays.first().cloned(),
-                            uppercase: false,
-                        })
-                    })
-                    .collect::<Vec<Tag>>(),
-                vec![
-                    Tag::from_standardized(nostr::TagStandard::Reference(
-                        repo_ref.root_commit.to_string(),
-                    )),
-                ],
-            ]
-            .concat(),
-        ),
-        signer,
-        "close status for original patch".to_string(),
-    )
-    .await
-}
 async fn get_proposal_and_revision_root_from_patch(
    git_repo: &Repo,
    patch: &Event,
diff --git a/src/bin/ngit/sub_commands/init.rs b/src/bin/ngit/sub_commands/init.rs
index eaaf83d..98daee4 100644
--- a/src/bin/ngit/sub_commands/init.rs
+++ b/src/bin/ngit/sub_commands/init.rs
@@ -9,15 +9,17 @@ use std::{
 use anyhow::{Context, Result, bail};
 use console::{Style, Term};
-use dialoguer::theme::{ColorfulTheme, Theme};
 use ngit::{
    UrlWithoutSlash,
-    cli_interactor::{PromptChoiceParms, PromptConfirmParms, PromptMultiChoiceParms},
+    cli_interactor::{
+        PromptChoiceParms, PromptConfirmParms, multi_select_with_custom_value,
+        show_multi_input_prompt_success,
+    },
    client::{Params, send_events},
    git::nostr_url::{CloneUrl, NostrUrlDecoded},
    repo_ref::{
-        detect_existing_grasp_servers, extract_npub, extract_pks, normalize_grasp_server_url,
+        detect_existing_grasp_servers, extract_npub, extract_pks,
-        save_repo_config_to_yaml,
+        format_grasp_server_url_as_relay_url, normalize_grasp_server_url, save_repo_config_to_yaml,
    },
 };
 use nostr::{
@@ -266,11 +268,23 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
        );
        let mut selections: Vec<bool> = vec![true; options.len()]; // Initialize selections based on existing options
        let empty = options.is_empty();
+        for user_grasp_option in user_ref.grasp_list.urls {
+            // Check if any option contains the user_grasp_option as a substring
+            if !options
+                .iter()
+                .any(|option| option.contains(user_grasp_option.as_str()))
+            {
+                options.push(user_grasp_option.to_string()); // Add if not found
+                selections.push(empty); // mark as selected if no existing grasp otherwise not
+            }
+        }
+        let empty = options.is_empty();
        for fallback in fallback_grasp_servers {
            // Check if any option contains the fallback as a substring
            if !options.iter().any(|option| option.contains(fallback)) {
                options.push(fallback.clone()); // Add fallback if not found
-                selections.push(empty); // mark as selected if no existing ngit relay otherwise not
+                selections.push(empty); // mark as selected if no existing selections otherwise not
            }
        }
        let selected = multi_select_with_custom_value(
@@ -727,6 +741,11 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
        web,
        relays: relays.clone(),
        blossoms,
+        hashtags: if let Some(repo_ref) = repo_ref {
+            repo_ref.hashtags
+        } else {
+            vec![]
+        },
        trusted_maintainer: user_ref.public_key,
        maintainers_without_annoucnement: None,
        maintainers: maintainers.clone(),
@@ -848,93 +867,6 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
    Ok(())
 }
-fn multi_select_with_custom_value<F>(
-    prompt: &str,
-    custom_choice_prompt: &str,
-    mut choices: Vec<String>,
-    mut defaults: Vec<bool>,
-    validate_choice: F,
-) -> Result<Vec<String>>
-where
-    F: Fn(&str) -> Result<String>,
-{
-    let mut selected_choices = vec![];
-    // Loop to allow users to add more choices
-    loop {
-        // Add 'add another' option at the end of the choices
-        let mut current_choices = choices.clone();
-        current_choices.push(if current_choices.is_empty() {
-            "add".to_string()
-        } else {
-            "add another".to_string()
-        });
-        // Create default selections based on the provided defaults
-        let mut current_defaults = defaults.clone();
-        current_defaults.push(current_choices.len() == 1); // 'add another' should not be selected by default
-        // Prompt for selections
-        let selected_indices: Vec<usize> = Interactor::default().multi_choice(
-            PromptMultiChoiceParms::default()
-                .with_prompt(prompt)
-                .dont_report()
-                .with_choices(current_choices.clone())
-                .with_defaults(current_defaults),
-        )?;
-        // Collect selected choices
-        selected_choices.clear(); // Clear previous selections to update
-        for &index in &selected_indices {
-            if index < choices.len() {
-                // Exclude 'add another' option
-                selected_choices.push(choices[index].clone());
-            }
-        }
-        // Check if 'add another' was selected
-        if selected_indices.contains(&(choices.len())) {
-            // Last index is 'add another'
-            let mut new_choice: String;
-            loop {
-                new_choice = Interactor::default().input(
-                    PromptInputParms::default()
-                        .with_prompt(custom_choice_prompt)
-                        .dont_report()
-                        .optional(),
-                )?;
-                if new_choice.is_empty() {
-                    break;
-                }
-                // Validate the new choice
-                match validate_choice(&new_choice) {
-                    Ok(valid_choice) => {
-                        new_choice = valid_choice; // Use the fixed version of the input
-                        break; // Valid choice, exit the loop
-                    }
-                    Err(err) => {
-                        // Inform the user about the validation error
-                        println!("Error: {err}");
-                    }
-                }
-            }
-            // Add the new choice to the choices vector
-            if !new_choice.is_empty() {
-                choices.push(new_choice.clone()); // Add new choice to the end of the list
-                selected_choices.push(new_choice); // Automatically select the new choice
-                defaults.push(true); // Set the new choice as selected by default
-            }
-        } else {
-            // Exit the loop if 'add another' was not selected
-            break;
-        }
-    }
-    Ok(selected_choices)
-}
 fn format_grasp_server_url_as_clone_url(
    url: &str,
    public_key: &PublicKey,
@@ -953,14 +885,6 @@ fn format_grasp_server_url_as_clone_url(
    ))
 }
-fn format_grasp_server_url_as_relay_url(url: &str) -> Result<String> {
-    let grasp_server_url = normalize_grasp_server_url(url)?;
-    if grasp_server_url.contains("http://") {
-        return Ok(grasp_server_url.replace("http://", "ws://"));
-    }
-    Ok(format!("wss://{grasp_server_url}"))
-}
 fn format_grasp_server_url_as_blossom_url(url: &str) -> Result<String> {
    let grasp_server_url = normalize_grasp_server_url(url)?;
    if grasp_server_url.contains("http://") {
@@ -982,19 +906,6 @@ fn parse_relay_url(s: &str) -> Result<RelayUrl> {
    .context(format!("failed to parse relay url: {s}"))
 }
-pub fn show_multi_input_prompt_success(label: &str, values: &[String]) {
-    let values_str: Vec<&str> = values.iter().map(std::string::String::as_str).collect();
-    eprintln!("{}", {
-        let mut s = String::new();
-        let _ = ColorfulTheme::default().format_multi_select_prompt_selection(
-            &mut s,
-            label,
-            &values_str,
-        );
-        s
-    });
-}
 fn push_main_or_master_branch(git_repo: &Repo) -> Result<()> {
    let main_branch_name = {
        let local_branches = git_repo
diff --git a/src/bin/ngit/sub_commands/send.rs b/src/bin/ngit/sub_commands/send.rs
index 8b49e37..3ae941f 100644
--- a/src/bin/ngit/sub_commands/send.rs
+++ b/src/bin/ngit/sub_commands/send.rs
@@ -1,12 +1,32 @@
-use std::path::Path;
+use std::{path::Path, str::FromStr, thread, time::Duration};
 use anyhow::{Context, Result, bail};
 use console::Style;
 use ngit::{
+    cli_interactor::{
+        PromptChoiceParms, multi_select_with_custom_value, show_multi_input_prompt_success,
+    },
    client::{Params, send_events},
-    git_events::{EventRefType, generate_cover_letter_and_patch_events},
+    git::nostr_url::CloneUrl,
+    git_events::{
+        EventRefType, KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE,
+        generate_cover_letter_and_patch_events,
+    },
+    push::push_refs_and_generate_pr_or_pr_update_event,
+    repo_ref::{
+        format_grasp_server_url_as_clone_url, format_grasp_server_url_as_relay_url,
+        is_grasp_server_in_list, normalize_grasp_server_url,
+    },
+    utils::proposal_tip_is_pr_or_pr_update,
+};
+use nostr::{
+    ToBech32,
+    event::{Event, Kind},
+    nips::{
+        nip01::Coordinate,
+        nip19::{Nip19Coordinate, Nip19Event},
+    },
 };
-use nostr::{ToBech32, nips::nip19::Nip19Event};
 use nostr_sdk::hashes::sha1::Hash as Sha1Hash;
 use crate::{
@@ -60,12 +80,14 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
        fetching_with_report(git_repo_path, &client, &repo_coordinates).await?;
    }
-    let (root_proposal_id, mention_tags) =
+    let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?;
-        get_root_proposal_id_and_mentions_from_in_reply_to(git_repo.get_path()?, &args.in_reply_to)
+    let (root_proposal, mention_tags) =
+        get_root_proposal_and_mentions_from_in_reply_to(git_repo.get_path()?, &args.in_reply_to)
            .await?;
    if let Some(root_ref) = args.in_reply_to.first() {
-        if root_proposal_id.is_some() {
+        if root_proposal.is_some() {
            println!("creating proposal revision for: {root_ref}");
        }
    }
@@ -104,41 +126,38 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
    let (first_commit_ahead, behind) =
        git_repo.get_commits_ahead_behind(&main_tip, commits.last().context("no commits")?)?;
-    // check proposal ahead of origin/main
+    check_commits_are_suitable_for_proposal(
-    if first_commit_ahead.len().gt(&1) && !Interactor::default().confirm(
+        &first_commit_ahead,
-            PromptConfirmParms::default()
+        &commits,
-                .with_prompt(
+        &behind,
-                    format!("proposal builds on a commit {} ahead of '{main_branch_name}' - do you want to continue?", first_commit_ahead.len() - 1)
+        main_branch_name,
-                )
+        &main_tip,
-                .with_default(false)
+    )?;
-        ).context("failed to get confirmation response from interactor confirm")? {
-        bail!("aborting because selected commits were ahead of origin/master");
+    let as_pr = {
-    }
+        if let Some(root_proposal) = &root_proposal {
+            proposal_tip_is_pr_or_pr_update(git_repo_path, &repo_ref, &root_proposal.id).await?
-    // check if a selected commit is already in origin
+        } else {
-    if commits.iter().any(|c| c.eq(&main_tip)) {
+            false
-        if !Interactor::default().confirm(
-            PromptConfirmParms::default()
-                .with_prompt(
-                    format!("proposal contains commit(s) already in  '{main_branch_name}'. proceed anyway?")
-                )
-                .with_default(false)
-        ).context("failed to get confirmation response from interactor confirm")? {
-            bail!("aborting as proposal contains commit(s) already in '{main_branch_name}'");
        }
-    }
+    } || git_repo.are_commits_too_big_for_patches(&commits);
-    // check proposal isn't behind origin/main
-    else if !behind.is_empty() && !Interactor::default().confirm(
-            PromptConfirmParms::default()
-                .with_prompt(
-                    format!("proposal is {} behind '{main_branch_name}'. consider rebasing before submission. proceed anyway?", behind.len())
-                )
-                .with_default(false)
-        ).context("failed to get confirmation response from interactor confirm")? {
-        bail!("aborting so commits can be rebased");
-    }
-    let title = if args.no_cover_letter {
+    let title = if as_pr {
+        match &args.title {
+            Some(t) => Some(t.clone()),
+            None => {
+                if root_proposal.is_none() {
+                    Some(
+                        Interactor::default()
+                            .input(PromptInputParms::default().with_prompt("title"))?
+                            .clone(),
+                    )
+                } else {
+                    None
+                }
+            }
+        }
+    } else if args.no_cover_letter {
        None
    } else {
        match &args.title {
@@ -168,7 +187,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
                t.clone()
            } else {
                Interactor::default()
-                    .input(PromptInputParms::default().with_prompt("cover letter description"))?
+                    .input(PromptInputParms::default().with_prompt("description"))?
                    .clone()
            },
        ))
@@ -176,7 +195,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
        None
    };
-    let (signer, user_ref, _) = login::login_or_signup(
+    let (signer, mut user_ref, _) = login::login_or_signup(
        &Some(&git_repo),
        &extract_signer_cli_arguments(cli_args).unwrap_or(None),
        &cli_args.password,
@@ -187,42 +206,316 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
    client.set_signer(signer.clone()).await;
-    let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?;
    // oldest first
    commits.reverse();
-    let events = generate_cover_letter_and_patch_events(
+    let events = if as_pr {
-        cover_letter_title_description.clone(),
+        let mut to_try = vec![];
-        &git_repo,
+        let mut tried = vec![];
-        &commits,
+        let repo_grasps = repo_ref.grasp_servers();
-        &signer,
+        // if the user already has a fork, or is a maintainer, use those git servers
-        &repo_ref,
+        let mut user_repo_ref = get_repo_ref_from_cache(
-        &root_proposal_id,
+            Some(git_repo_path),
-        &mention_tags,
+            &Nip19Coordinate {
-    )
+                coordinate: Coordinate {
-    .await?;
+                    kind: nostr::event::Kind::GitRepoAnnouncement,
+                    public_key: user_ref.public_key,
-    println!(
+                    identifier: repo_ref.identifier.clone(),
-        "posting {} patch{} {} a covering letter...",
+                },
-        if cover_letter_title_description.is_none() {
+                relays: vec![],
-            events.len()
+            },
-        } else {
+        )
-            events.len() - 1
+        .await
-        },
+        .ok();
-        if cover_letter_title_description.is_none() && events.len().eq(&1)
+        if let Some(user_repo_ref) = &user_repo_ref {
-            || cover_letter_title_description.is_some() && events.len().eq(&2)
+            for url in &user_repo_ref.git_server {
-        {
+                if CloneUrl::from_str(url).is_ok() {
-            ""
+                    to_try.push(url.clone());
-        } else {
+                }
-            "es"
+            }
-        },
+        }
-        if cover_letter_title_description.is_none() {
+        if !to_try.is_empty() || !repo_grasps.is_empty() {
-            "without"
+            println!(
+                "pushing proposal refs to {}",
+                if repo_ref.maintainers.contains(&user_ref.public_key) {
+                    "repository git servers"
+                } else if to_try.is_empty() {
+                    "repository grasp servers"
+                } else if repo_grasps.is_empty() {
+                    "the git servers listed in your fork"
+                } else {
+                    "the git servers listed in your fork and repository grasp servers"
+                }
+            );
        } else {
-            "with"
+            println!(
+                "The repository doesn't list a grasp server which would otherwise be used to submit your proposal as nostr Pull Request."
+            );
+        }
+        // also use repo grasp servers
+        for url in &repo_ref.git_server {
+            if is_grasp_server_in_list(url, &repo_grasps) && !to_try.contains(url) {
+                to_try.push(url.clone());
+            }
        }
-    );
+        let mut git_ref = None;
+        let events = loop {
+            let (events, _server_responses) = push_refs_and_generate_pr_or_pr_update_event(
+                &git_repo,
+                &repo_ref,
+                commits.last().context("no commits")?,
+                &user_ref,
+                root_proposal.as_ref(),
+                &cover_letter_title_description,
+                &to_try,
+                git_ref.clone(),
+                &signer,
+                &console::Term::stdout(),
+            )
+            .await?;
+            for url in to_try {
+                tried.push(url);
+            }
+            to_try = vec![];
+            if let Some(events) = events {
+                break events;
+            }
+            // fallback to creating user personal-fork on their grasp servers
+            let untried_user_grasp_servers: Vec<String> = user_ref
+                .grasp_list
+                .urls
+                .iter()
+                .map(std::string::ToString::to_string)
+                .filter(|g| {
+                    // is a grasp server not in list of tried
+                    !is_grasp_server_in_list(g, &tried)
+                })
+                .collect();
+            if untried_user_grasp_servers.is_empty()
+                && Interactor::default().choice(
+                    PromptChoiceParms::default()
+                        .with_prompt("choose alternative git server")
+                        .dont_report()
+                        .with_choices(vec![
+                            "choose grasp server(s)".to_string(),
+                            "enter a git repo url with write permission".to_string(),
+                        ])
+                        .with_default(0),
+                )? == 1
+            {
+                loop {
+                    let clone_url = Interactor::default()
+                        .input(
+                            PromptInputParms::default()
+                                .with_prompt("git repo url with write permission"),
+                        )?
+                        .clone();
+                    if CloneUrl::from_str(&clone_url).is_ok() {
+                        to_try.push(clone_url);
+                        let mut git_ref_or_branch_name = Interactor::default()
+                            .input(
+                                PromptInputParms::default()
+                                    .with_prompt("ref / branch name")
+                                    .with_default(
+                                        git_ref.unwrap_or("refs/nostr/<event-id>".to_string()),
+                                    ),
+                            )?
+                            .clone();
+                        if !git_ref_or_branch_name.starts_with("refs/") {
+                            git_ref_or_branch_name = format!("refs/heads/{git_ref_or_branch_name}");
+                        }
+                        git_ref = Some(git_ref_or_branch_name);
+                        break;
+                    }
+                    println!("invalid clone url");
+                }
+                continue;
+            }
+            let mut new_grasp_server_events: Vec<Event> = vec![];
+            let grasp_servers = if untried_user_grasp_servers.is_empty() {
+                let default_choices: Vec<String> = client
+                    .get_grasp_default_set()
+                    .iter()
+                    .filter(|g| !is_grasp_server_in_list(g, &tried))
+                    .cloned()
+                    .collect();
+                let selections = vec![true; default_choices.len()]; // all selected by default
+                let grasp_servers = multi_select_with_custom_value(
+                    "alternative grasp server(s)",
+                    "grasp server",
+                    default_choices,
+                    selections,
+                    normalize_grasp_server_url,
+                )?;
+                show_multi_input_prompt_success("alternative grasp server(s)", &grasp_servers);
+                if grasp_servers.is_empty() {
+                    // ask again
+                    continue;
+                }
+                let normalised_grasp_servers: Vec<String> = grasp_servers
+                    .iter()
+                    .filter_map(|g| normalize_grasp_server_url(g).ok())
+                    .collect();
+                // if any grasp servers not listed in user grasp list prompt to update
+                let grasp_servers_not_in_user_prefs: Vec<String> = normalised_grasp_servers
+                    .iter()
+                    .filter(|g| {
+                        !user_ref.grasp_list.urls.contains(
+                            // unwrap is safe as we constructed g
+                            &nostr::Url::parse(&format_grasp_server_url_as_relay_url(g).unwrap())
+                                .unwrap(),
+                        )
+                    })
+                    .cloned()
+                    .collect();
+                if !grasp_servers_not_in_user_prefs.is_empty()
+                    && Interactor::default().confirm(
+                        PromptConfirmParms::default()
+                            .with_prompt(
+                                "add these to your list of prefered grasp servers?".to_string(),
+                            )
+                            .with_default(true),
+                    )?
+                {
+                    for g in &normalised_grasp_servers {
+                        let as_url = nostr::Url::parse(&format_grasp_server_url_as_relay_url(g)?)?;
+                        if !user_ref.grasp_list.urls.contains(&as_url) {
+                            user_ref.grasp_list.urls.push(as_url);
+                        }
+                    }
+                    new_grasp_server_events.push(user_ref.grasp_list.to_event(&signer).await?);
+                }
+                normalised_grasp_servers
+            } else {
+                untried_user_grasp_servers
+            };
+            println!(
+                "{} personal-fork so we can push commits to your prefered grasp servers",
+                if user_repo_ref.is_some() {
+                    "Updating"
+                } else {
+                    "Creating a"
+                },
+            );
+            let grasp_servers_as_personal_clone_url: Vec<String> = grasp_servers
+                .iter()
+                .filter_map(|g| {
+                    format_grasp_server_url_as_clone_url(
+                        g,
+                        &user_ref.public_key,
+                        &repo_ref.identifier,
+                    )
+                    .ok()
+                })
+                .collect();
+            // create personal-fork / update existing user repo and add these grasp servers
+            let updated_user_repo_ref = {
+                if let Some(mut user_repo_ref) = user_repo_ref {
+                    for g in &grasp_servers_as_personal_clone_url {
+                        user_repo_ref.add_grasp_server(g)?;
+                    }
+                    user_repo_ref
+                } else {
+                    // clone repo_ref and reset as personal-fork
+                    let mut user_repo_ref = repo_ref.clone();
+                    user_repo_ref.trusted_maintainer = user_ref.public_key;
+                    user_repo_ref.maintainers = vec![user_ref.public_key];
+                    user_repo_ref.git_server = vec![];
+                    user_repo_ref.relays = vec![];
+                    if !user_repo_ref
+                        .hashtags
+                        .contains(&"personal-fork".to_string())
+                    {
+                        user_repo_ref.hashtags.push("personal-fork".to_string());
+                    }
+                    user_repo_ref
+                }
+            };
+            // pubish event to my-relays and my-fork-relays
+            new_grasp_server_events.push(updated_user_repo_ref.to_event(&signer).await?);
+            send_events(
+                &client,
+                Some(git_repo_path),
+                new_grasp_server_events,
+                user_ref.relays.write(),
+                updated_user_repo_ref.relays.clone(),
+                !cli_args.disable_cli_spinners,
+                false,
+            )
+            .await?;
+            user_repo_ref = Some(updated_user_repo_ref);
+            // wait a few seconds
+            let countdown_start = 5;
+            let term = console::Term::stdout();
+            for i in (1..=countdown_start).rev() {
+                term.write_line(
+                    format!(
+                        "waiting {i}s grasp servers to create your repo before we push your data"
+                    )
+                    .as_str(),
+                )?;
+                thread::sleep(Duration::new(1, 0)); // Sleep for 1 second
+                term.clear_last_lines(1)?;
+            }
+            term.flush().unwrap(); // Ensure the output is flushed to the terminal
+            // add grasp servers to to_try
+            for url in grasp_servers_as_personal_clone_url {
+                to_try.push(url);
+            }
+            // the loop with continue with the grasp servers
+        };
+        println!(
+            "posting {}",
+            if events.iter().any(|e| e.kind.eq(&Kind::GitStatusClosed)) {
+                "proposal revision as new PR event, and a close status for the old patch"
+            } else if events.iter().any(|e| e.kind.eq(&KIND_PULL_REQUEST_UPDATE)) {
+                "proposal revision as PR update event"
+            } else {
+                "proposal as PR event"
+            }
+        );
+        events
+    } else {
+        let events = generate_cover_letter_and_patch_events(
+            cover_letter_title_description.clone(),
+            &git_repo,
+            &commits,
+            &signer,
+            &repo_ref,
+            &root_proposal.as_ref().map(|e| e.id.to_string()),
+            &mention_tags,
+        )
+        .await?;
+        println!(
+            "posting {} patch{} {} a covering letter...",
+            if cover_letter_title_description.is_none() {
+                events.len()
+            } else {
+                events.len() - 1
+            },
+            if cover_letter_title_description.is_none() && events.len().eq(&1)
+                || cover_letter_title_description.is_some() && events.len().eq(&2)
+            {
+                ""
+            } else {
+                "es"
+            },
+            if cover_letter_title_description.is_none() {
+                "without"
+            } else {
+                "with"
+            }
+        );
+        events
+    };
    send_events(
        &client,
@@ -235,7 +528,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
    )
    .await?;
-    if root_proposal_id.is_none() {
+    if root_proposal.is_none() {
        if let Some(event) = events.first() {
            let event_bech32 = if let Some(relay) = repo_ref.relays.first() {
                Nip19Event {
@@ -251,8 +544,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
            println!(
                "{}",
                dim.apply_to(format!(
-                    "view in gitworkshop.dev: https://gitworkshop.dev/repo/{}/proposal/{}",
+                    "view in gitworkshop.dev: https://gitworkshop.dev/{}",
-                    repo_ref.coordinate_with_hint().to_bech32()?,
                    &event_bech32,
                ))
            );
@@ -269,6 +561,49 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
    Ok(())
 }
+fn check_commits_are_suitable_for_proposal(
+    first_commit_ahead: &[Sha1Hash],
+    commits: &[Sha1Hash],
+    behind: &[Sha1Hash],
+    main_branch_name: &str,
+    main_tip: &Sha1Hash,
+) -> Result<()> {
+    // check proposal ahead of origin/main
+    if first_commit_ahead.len().gt(&1) && !Interactor::default().confirm(
+            PromptConfirmParms::default()
+                .with_prompt(
+                    format!("proposal builds on a commit {} ahead of '{main_branch_name}' - do you want to continue?", first_commit_ahead.len() - 1)
+                )
+                .with_default(false)
+        ).context("failed to get confirmation response from interactor confirm")? {
+        bail!("aborting because selected commits were ahead of origin/master");
+    }
+    // check if a selected commit is already in origin
+    if commits.iter().any(|c| c.eq(main_tip)) {
+        if !Interactor::default().confirm(
+            PromptConfirmParms::default()
+                .with_prompt(
+                    format!("proposal contains commit(s) already in  '{main_branch_name}'. proceed anyway?")
+                )
+                .with_default(false)
+        ).context("failed to get confirmation response from interactor confirm")? {
+            bail!("aborting as proposal contains commit(s) already in '{main_branch_name}'");
+        }
+    }
+    // check proposal isn't behind origin/main
+    else if !behind.is_empty() && !Interactor::default().confirm(
+            PromptConfirmParms::default()
+                .with_prompt(
+                    format!("proposal is {} behind '{main_branch_name}'. consider rebasing before submission. proceed anyway?", behind.len())
+                )
+                .with_default(false)
+        ).context("failed to get confirmation response from interactor confirm")? {
+        bail!("aborting so commits can be rebased");
+    }
+    Ok(())
+}
 fn choose_commits(git_repo: &Repo, proposed_commits: Vec<Sha1Hash>) -> Result<Vec<Sha1Hash>> {
    let mut proposed_commits = if proposed_commits.len().gt(&10) {
        vec![]
@@ -360,11 +695,11 @@ fn summarise_commit_for_selection(git_repo: &Repo, commit: &Sha1Hash) -> Result<
    ))
 }
-async fn get_root_proposal_id_and_mentions_from_in_reply_to(
+async fn get_root_proposal_and_mentions_from_in_reply_to(
    git_repo_path: &Path,
    in_reply_to: &[String],
-) -> Result<(Option<String>, Vec<nostr::Tag>)> {
+) -> Result<(Option<Event>, Vec<nostr::Tag>)> {
-    let root_proposal_id = if let Some(first) = in_reply_to.first() {
+    let root_proposal = if let Some(first) = in_reply_to.first() {
        match event_tag_from_nip19_or_hex(first, "in-reply-to", EventRefType::Root, true, false)?
            .as_standardized()
        {
@@ -382,8 +717,8 @@ async fn get_root_proposal_id_and_mentions_from_in_reply_to(
                .await?;
                if let Some(first) = events.iter().find(|e| e.id.eq(event_id)) {
-                    if event_is_patch_set_root(first) {
+                    if event_is_patch_set_root(first) || first.kind.eq(&KIND_PULL_REQUEST) {
-                        Some(event_id.to_string())
+                        Some(first.clone())
                    } else {
                        None
                    }
@@ -399,7 +734,7 @@ async fn get_root_proposal_id_and_mentions_from_in_reply_to(
    let mut mention_tags = vec![];
    for (i, reply_to) in in_reply_to.iter().enumerate() {
-        if i.ne(&0) || root_proposal_id.is_none() {
+        if i.ne(&0) || root_proposal.is_none() {
            mention_tags.push(
                event_tag_from_nip19_or_hex(
                    reply_to,
@@ -415,7 +750,7 @@ async fn get_root_proposal_id_and_mentions_from_in_reply_to(
        }
    }
-    Ok((root_proposal_id, mention_tags))
+    Ok((root_proposal, mention_tags))
 }
 // TODO
diff --git a/src/bin/ngit/sub_commands/sync.rs b/src/bin/ngit/sub_commands/sync.rs
index c1a3484..00dfe75 100644
--- a/src/bin/ngit/sub_commands/sync.rs
+++ b/src/bin/ngit/sub_commands/sync.rs
@@ -127,33 +127,47 @@ pub async fn launch(args: &SubCommandArgs) -> Result<()> {
                term.write_line(&format!("{remote_name} already in sync"))?;
            }
            // report already in sync
-        } else if let Err(error) = push_to_remote(
-            &git_repo,
-            url,
-            &decoded_nostr_url,
-            &refspecs,
-            &term,
-            *is_grasp_server,
-        ) {
-            term.write_line(&format!(
-                "error pushing updates to {remote_name}: error: {error}"
-            ))?;
-        } else if *is_grasp_server || args.force {
-            term.write_line(&format!("{remote_name} sync completed"))?;
-            // TODO we only know if there was an error but not if it
-            // rejected any updates
        } else {
-            // we should report on refs not force pushed
+            match push_to_remote(
-            term.write_line(&format!("{remote_name} sync completed"))?;
+                &git_repo,
-        }
+                url,
-        for name in &not_deleted {
+                &decoded_nostr_url,
-            term.write_line(&format!("  - {name} not deleted"))?;
+                &refspecs,
-        }
+                &term,
-        for name in &not_updated {
+                *is_grasp_server,
-            term.write_line(&format!("  - {name} not updated due to conflicts"))?;
+            ) {
-        }
+                Err(error) => {
-        if !not_updated.is_empty() || !not_deleted.is_empty() {
+                    term.write_line(&format!(
-            term.write_line("run `ngit sync --force` to delete refs or overwrite conflicts and potentially lose work")?;
+                        "error pushing updates to {remote_name}: error: {error}"
+                    ))?;
+                }
+                Ok(updated_refs) => {
+                    if updated_refs.values().all(std::option::Option::is_none) {
+                        if *is_grasp_server || args.force {
+                            term.write_line(&format!("{remote_name} sync completed"))?;
+                            // TODO we only know if there was an error but not
+                            // if it rejected any
+                            // updates
+                        } else {
+                            // we should report on refs not force pushed
+                            term.write_line(&format!("{remote_name} sync completed"))?;
+                        }
+                    } else {
+                        term.write_line(&format!(
+                            "{remote_name} sync completed but not all changes were accepted"
+                        ))?;
+                    }
+                    for name in &not_deleted {
+                        term.write_line(&format!("  - {name} not deleted"))?;
+                    }
+                    for name in &not_updated {
+                        term.write_line(&format!("  - {name} not updated due to conflicts"))?;
+                    }
+                    if !not_updated.is_empty() || !not_deleted.is_empty() {
+                        term.write_line("run `ngit sync --force` to delete refs or overwrite conflicts and potentially lose work")?;
+                    }
+                }
+            }
        }
    }
diff --git a/src/lib/cli_interactor.rs b/src/lib/cli_interactor.rs
index 8fca81d..e944bf9 100644
--- a/src/lib/cli_interactor.rs
+++ b/src/lib/cli_interactor.rs
@@ -1,5 +1,8 @@
 use anyhow::{Context, Result};
-use dialoguer::{Confirm, Input, Password, theme::ColorfulTheme};
+use dialoguer::{
+    Confirm, Input, Password,
+    theme::{ColorfulTheme, Theme},
+};
 use indicatif::TermLike;
 #[cfg(test)]
 use mockall::*;
@@ -236,6 +239,106 @@ impl PromptMultiChoiceParms {
    }
 }
+pub fn multi_select_with_custom_value<F>(
+    prompt: &str,
+    custom_choice_prompt: &str,
+    mut choices: Vec<String>,
+    mut defaults: Vec<bool>,
+    validate_choice: F,
+) -> Result<Vec<String>>
+where
+    F: Fn(&str) -> Result<String>,
+{
+    let mut selected_choices = vec![];
+    // Loop to allow users to add more choices
+    loop {
+        // Add 'add another' option at the end of the choices
+        let mut current_choices = choices.clone();
+        current_choices.push(if current_choices.is_empty() {
+            "add".to_string()
+        } else {
+            "add another".to_string()
+        });
+        // Create default selections based on the provided defaults
+        let mut current_defaults = defaults.clone();
+        current_defaults.push(current_choices.len() == 1); // 'add another' should not be selected by default
+        // Prompt for selections
+        let selected_indices: Vec<usize> = Interactor::default().multi_choice(
+            PromptMultiChoiceParms::default()
+                .with_prompt(prompt)
+                .dont_report()
+                .with_choices(current_choices.clone())
+                .with_defaults(current_defaults),
+        )?;
+        // Collect selected choices
+        selected_choices.clear(); // Clear previous selections to update
+        for &index in &selected_indices {
+            if index < choices.len() {
+                // Exclude 'add another' option
+                selected_choices.push(choices[index].clone());
+            }
+        }
+        // Check if 'add another' was selected
+        if selected_indices.contains(&(choices.len())) {
+            // Last index is 'add another'
+            let mut new_choice: String;
+            loop {
+                new_choice = Interactor::default().input(
+                    PromptInputParms::default()
+                        .with_prompt(custom_choice_prompt)
+                        .dont_report()
+                        .optional(),
+                )?;
+                if new_choice.is_empty() {
+                    break;
+                }
+                // Validate the new choice
+                match validate_choice(&new_choice) {
+                    Ok(valid_choice) => {
+                        new_choice = valid_choice; // Use the fixed version of the input
+                        break; // Valid choice, exit the loop
+                    }
+                    Err(err) => {
+                        // Inform the user about the validation error
+                        println!("Error: {err}");
+                    }
+                }
+            }
+            // Add the new choice to the choices vector
+            if !new_choice.is_empty() {
+                choices.push(new_choice.clone()); // Add new choice to the end of the list
+                selected_choices.push(new_choice); // Automatically select the new choice
+                defaults.push(true); // Set the new choice as selected by default
+            }
+        } else {
+            // Exit the loop if 'add another' was not selected
+            break;
+        }
+    }
+    Ok(selected_choices)
+}
+pub fn show_multi_input_prompt_success(label: &str, values: &[String]) {
+    let values_str: Vec<&str> = values.iter().map(std::string::String::as_str).collect();
+    eprintln!("{}", {
+        let mut s = String::new();
+        let _ = ColorfulTheme::default().format_multi_select_prompt_selection(
+            &mut s,
+            label,
+            &values_str,
+        );
+        s
+    });
+}
 #[derive(Debug, Default)]
 pub struct Printer {
    printed_lines: Vec<String>,
diff --git a/src/lib/client.rs b/src/lib/client.rs
index 3fcfba4..0984b19 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -53,7 +53,7 @@ use crate::{
    get_dirs,
    git::{Repo, RepoActions, get_git_config_item},
    git_events::{
-        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_is_cover_letter,
+        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, KIND_USER_GRASP_LIST, event_is_cover_letter,
        event_is_patch_set_root, event_is_revision_root, event_is_valid_pr_or_pr_update,
        status_kinds,
    },
@@ -241,7 +241,7 @@ impl Connect for Client {
        if let Some(git_repo_path) = git_repo_path {
            save_event_in_local_cache(git_repo_path, &event).await?;
        }
-        if event.kind.eq(&Kind::GitRepoAnnouncement) {
+        if [Kind::GitRepoAnnouncement, KIND_USER_GRASP_LIST].contains(&event.kind) {
            save_event_in_global_cache(git_repo_path, &event).await?;
        }
        Ok(event.id)
@@ -1308,17 +1308,21 @@ async fn create_relays_request(
                user_profiles.insert(current_user);
            }
        }
-        let mut map: HashMap<PublicKey, (Timestamp, Timestamp)> = HashMap::new();
+        let mut map: HashMap<PublicKey, (Timestamp, Timestamp, Timestamp)> = HashMap::new();
        for public_key in &user_profiles {
            if let Ok(user_ref) = get_user_ref_from_cache(git_repo_path, public_key).await {
                map.insert(
                    public_key.to_owned(),
-                    (user_ref.metadata.created_at, user_ref.relays.created_at),
+                    (
+                        user_ref.metadata.created_at,
+                        user_ref.relays.created_at,
+                        user_ref.grasp_list.created_at,
+                    ),
                );
            } else {
                map.insert(
                    public_key.to_owned(),
-                    (Timestamp::from(0), Timestamp::from(0)),
+                    (Timestamp::from(0), Timestamp::from(0), Timestamp::from(0)),
                );
            }
        }
@@ -1545,16 +1549,22 @@ async fn process_fetched_events(
                {
                    fresh_profiles.insert(event.pubkey);
                }
-            } else if [Kind::RelayList, Kind::Metadata].contains(&event.kind) {
+            } else if [Kind::RelayList, Kind::Metadata, KIND_USER_GRASP_LIST].contains(&event.kind)
+            {
                if request.missing_contributor_profiles.contains(&event.pubkey) {
                    report.contributor_profiles.insert(event.pubkey);
-                } else if let Some((_, (metadata_timestamp, relay_list_timestamp))) = request
+                } else if let Some((
+                    _,
+                    (metadata_timestamp, relay_list_timestamp, grasp_list_timestamp),
+                )) = request
                    .profiles_to_fetch_from_user_relays
                    .get_key_value(&event.pubkey)
                {
                    if (Kind::Metadata.eq(&event.kind) && event.created_at.gt(metadata_timestamp))
                        || (Kind::RelayList.eq(&event.kind)
                            && event.created_at.gt(relay_list_timestamp))
+                        || (KIND_USER_GRASP_LIST.eq(&event.kind)
+                            && event.created_at.gt(grasp_list_timestamp))
                    {
                        report.profile_updates.insert(event.pubkey);
                    }
@@ -1716,35 +1726,21 @@ pub fn get_filter_repo_events(repo_coordinates: &HashSet<Nip19Coordinate>) -> no
                .map(|c| c.identifier.clone())
                .collect::<Vec<String>>(),
        )
-        .authors(
-            repo_coordinates
-                .iter()
-                .map(|c| c.public_key)
-                .collect::<Vec<PublicKey>>(),
-        )
 }
 pub static STATE_KIND: nostr::Kind = Kind::Custom(30618);
 pub fn get_filter_state_events(repo_coordinates: &HashSet<Nip19Coordinate>) -> nostr::Filter {
-    nostr::Filter::default()
+    nostr::Filter::default().kind(STATE_KIND).identifiers(
-        .kind(STATE_KIND)
+        repo_coordinates
-        .identifiers(
+            .iter()
-            repo_coordinates
+            .map(|c| c.identifier.clone())
-                .iter()
+            .collect::<Vec<String>>(),
-                .map(|c| c.identifier.clone())
+    )
-                .collect::<Vec<String>>(),
-        )
-        .authors(
-            repo_coordinates
-                .iter()
-                .map(|c| c.public_key)
-                .collect::<Vec<PublicKey>>(),
-        )
 }
 pub fn get_filter_contributor_profiles(contributors: HashSet<PublicKey>) -> nostr::Filter {
    nostr::Filter::default()
-        .kinds(vec![Kind::Metadata, Kind::RelayList])
+        .kinds(vec![Kind::Metadata, Kind::RelayList, KIND_USER_GRASP_LIST])
        .authors(contributors)
 }
@@ -1848,7 +1844,7 @@ pub struct FetchRequest {
    contributors: HashSet<PublicKey>,
    missing_contributor_profiles: HashSet<PublicKey>,
    existing_events: HashSet<EventId>,
-    profiles_to_fetch_from_user_relays: HashMap<PublicKey, (Timestamp, Timestamp)>,
+    profiles_to_fetch_from_user_relays: HashMap<PublicKey, (Timestamp, Timestamp, Timestamp)>,
    user_relays_for_profiles: HashSet<RelayUrl>,
 }
diff --git a/src/lib/git/mod.rs b/src/lib/git/mod.rs
index b275b49..3d5297f 100644
--- a/src/lib/git/mod.rs
+++ b/src/lib/git/mod.rs
@@ -75,6 +75,7 @@ pub trait RepoActions {
        commit: &Sha1Hash,
        series_count: &Option<(u64, u64)>,
    ) -> Result<String>;
+    fn are_commits_too_big_for_patches(&self, commits: &[Sha1Hash]) -> bool;
    fn extract_commit_pgp_signature(&self, commit: &Sha1Hash) -> Result<String>;
    fn checkout(&self, ref_name: &str) -> Result<Sha1Hash>;
    fn create_branch_at_commit(&self, branch_name: &str, commit: &str) -> Result<()>;
@@ -380,6 +381,19 @@ impl RepoActions for Repo {
            .to_owned())
    }
+    fn are_commits_too_big_for_patches(&self, commits: &[Sha1Hash]) -> bool {
+        commits.iter().any(|commit| {
+            if let Ok(patch) = self.make_patch_from_commit(commit, &None) {
+                patch.len()
+                    > ((65 // max recomended patch event size specified in nip34 in kb
+                // allownace for nostr event wrapper (id, pubkey, tags, sig)
+                - 1) * 1024)
+            } else {
+                true
+            }
+        })
+    }
    fn extract_commit_pgp_signature(&self, commit: &Sha1Hash) -> Result<String> {
        let oid = Oid::from_bytes(commit.as_byte_array()).context(format!(
            "failed to convert commit_id format for {}",
diff --git a/src/lib/git_events.rs b/src/lib/git_events.rs
index 8ba5419..5ea630a 100644
--- a/src/lib/git_events.rs
+++ b/src/lib/git_events.rs
@@ -63,6 +63,7 @@ pub fn status_kinds() -> Vec<Kind> {
 pub const KIND_PULL_REQUEST: Kind = Kind::Custom(1618);
 pub const KIND_PULL_REQUEST_UPDATE: Kind = Kind::Custom(1619);
+pub const KIND_USER_GRASP_LIST: Kind = Kind::Custom(10317);
 pub fn event_is_patch_set_root(event: &Event) -> bool {
    event.kind.eq(&Kind::GitPatch)
@@ -376,11 +377,13 @@ pub fn event_tag_from_nip19_or_hex(
    }
 }
+#[allow(clippy::too_many_arguments)]
 pub fn generate_unsigned_pr_or_update_event(
    git_repo: &Repo,
    repo_ref: &RepoRef,
    signing_public_key: &PublicKey,
    root_proposal: Option<&Event>,
+    title_description_overide: &Option<(String, String)>,
    commit: &Sha1Hash,
    clone_url_hint: &[&str],
    mentions: &[nostr::Tag],
@@ -395,13 +398,17 @@ pub fn generate_unsigned_pr_or_update_event(
        None
    };
-    let title = if let Some(cl) = &root_patch_cover_letter {
+    let title = if let Some((title, _)) = &title_description_overide {
+        title.clone()
+    } else if let Some(cl) = &root_patch_cover_letter {
        cl.title.clone()
    } else {
        git_repo.get_commit_message_summary(commit)?
    };
-    let description = if let Some(cl) = &root_patch_cover_letter {
+    let description = if let Some((_, description)) = &title_description_overide {
+        description.clone()
+    } else if let Some(cl) = &root_patch_cover_letter {
        cl.description.clone()
    } else {
        let mut description = git_repo.get_commit_message(commit)?.trim().to_string();
diff --git a/src/lib/list.rs b/src/lib/list.rs
index b940546..b867858 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -9,7 +9,7 @@ use crate::{
        Repo, RepoActions,
        nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
    },
-    repo_ref::is_grasp_server,
+    repo_ref::is_grasp_server_in_list,
    utils::{Direction, get_read_protocols_to_try, join_with_and, set_protocol_preference},
 };
@@ -23,7 +23,7 @@ pub fn list_from_remotes(
    let mut remote_states = HashMap::new();
    let mut errors = HashMap::new();
    for url in git_servers {
-        let is_grasp_server = is_grasp_server(url, grasp_servers);
+        let is_grasp_server = is_grasp_server_in_list(url, grasp_servers);
        match list_from_remote(term, git_repo, url, decoded_nostr_url, is_grasp_server) {
            Err(error) => {
                errors.insert(url, error);
diff --git a/src/lib/login/user.rs b/src/lib/login/user.rs
index 071cb25..0b702ef 100644
--- a/src/lib/login/user.rs
+++ b/src/lib/login/user.rs
@@ -1,7 +1,7 @@
-use std::{collections::HashSet, path::Path};
+use std::{collections::HashSet, path::Path, sync::Arc};
 use anyhow::{Context, Result, bail};
-use nostr::PublicKey;
+use nostr::{PublicKey, Url, event::Tag, signer::NostrSigner};
 use nostr_sdk::{Alphabet, JsonUtil, Kind, SingleLetterTag, Timestamp, ToBech32};
 use serde::{self, Deserialize, Serialize};
@@ -9,13 +9,17 @@ use serde::{self, Deserialize, Serialize};
 use crate::client::Client;
 #[cfg(test)]
 use crate::client::MockConnect;
-use crate::client::{Connect, get_event_from_global_cache};
+use crate::{
+    client::{Connect, get_event_from_global_cache, sign_event},
+    git_events::KIND_USER_GRASP_LIST,
+};
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRef {
    pub public_key: PublicKey,
    pub metadata: UserMetadata,
    pub relays: UserRelays,
+    pub grasp_list: UserGraspList,
 }
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -49,6 +53,35 @@ impl UserRelays {
 }
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct UserGraspList {
+    pub urls: Vec<Url>,
+    pub created_at: Timestamp,
+}
+impl UserGraspList {
+    pub async fn to_event(&mut self, signer: &Arc<dyn NostrSigner>) -> Result<nostr::Event> {
+        let event = sign_event(
+            nostr_sdk::EventBuilder::new(KIND_USER_GRASP_LIST, "").tags(
+                self.urls
+                    .iter()
+                    .map(|url| {
+                        Tag::custom(
+                            nostr::TagKind::Custom(std::borrow::Cow::Borrowed("g")),
+                            vec![url.to_string()],
+                        )
+                    })
+                    .collect::<Vec<_>>(),
+            ),
+            signer,
+            "user grasp list".to_string(),
+        )
+        .await?;
+        self.created_at = event.created_at;
+        Ok(event)
+    }
+}
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRelayRef {
    pub url: String,
    pub read: bool,
@@ -84,6 +117,7 @@ pub async fn get_user_details(
            public_key: public_key.to_owned(),
            metadata: extract_user_metadata(public_key, &[])?,
            relays: extract_user_relays(public_key, &[]),
+            grasp_list: extract_user_grasp_list(public_key, &[]),
        };
        if cache_only {
            Ok(empty)
@@ -117,6 +151,9 @@ pub async fn get_user_ref_from_cache(
        nostr::Filter::default()
            .author(*public_key)
            .kind(Kind::RelayList),
+        nostr::Filter::default()
+            .author(*public_key)
+            .kind(KIND_USER_GRASP_LIST),
    ];
    let events = get_event_from_global_cache(git_repo_path, filters.clone()).await?;
@@ -128,6 +165,7 @@ pub async fn get_user_ref_from_cache(
        public_key: public_key.to_owned(),
        metadata: extract_user_metadata(public_key, &events)?,
        relays: extract_user_relays(public_key, &events),
+        grasp_list: extract_user_grasp_list(public_key, &events),
    })
 }
@@ -215,3 +253,36 @@ pub fn extract_user_relays(public_key: &nostr::PublicKey, events: &[nostr::Event
        },
    }
 }
+pub fn extract_user_grasp_list(
+    public_key: &nostr::PublicKey,
+    events: &[nostr::Event],
+) -> UserGraspList {
+    let event = events
+        .iter()
+        .filter(|e| e.kind.eq(&KIND_USER_GRASP_LIST) && e.pubkey.eq(public_key))
+        .max_by_key(|e| e.created_at);
+    UserGraspList {
+        urls: if let Some(event) = event {
+            event
+                .tags
+                .iter()
+                .filter_map(|t| {
+                    if t.as_slice().len() > 1 && t.as_slice()[0] == "g" {
+                        Url::parse(&t.as_slice()[1]).ok()
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        } else {
+            vec![]
+        },
+        created_at: if let Some(event) = event {
+            event.created_at
+        } else {
+            Timestamp::from(0)
+        },
+    }
+}
diff --git a/src/lib/push.rs b/src/lib/push.rs
index 0d0ec93..8cb0212 100644
--- a/src/lib/push.rs
+++ b/src/lib/push.rs
@@ -1,25 +1,38 @@
 use std::{
+    collections::{HashMap, HashSet},
    sync::{Arc, Mutex},
    time::Instant,
 };
-use anyhow::{Result, anyhow};
+use anyhow::{Context, Result, anyhow};
 use auth_git2::GitAuthenticator;
 use console::Term;
+use nostr::{
+    event::{Event, EventBuilder, Kind, Tag, TagStandard, UnsignedEvent},
+    hashes::sha1::Hash as Sha1Hash,
+    key::PublicKey,
+    nips::nip10::Marker,
+    signer::NostrSigner,
+};
 use crate::{
    cli_interactor::count_lines_per_msg_vec,
+    client::{sign_draft_event, sign_event},
    git::{
-        Repo,
+        Repo, RepoActions,
        nostr_url::{CloneUrl, NostrUrlDecoded},
        oid_to_shorthand_string,
    },
+    git_events::generate_unsigned_pr_or_update_event,
+    login::user::UserRef,
+    repo_ref::{RepoRef, is_grasp_server_clone_url, normalize_grasp_server_url},
    utils::{
        Direction, get_short_git_server_name, get_write_protocols_to_try, join_with_and,
        set_protocol_preference,
    },
 };
+// returns a HashMap of refs responded to and any related cancellation reasons
 pub fn push_to_remote(
    git_repo: &Repo,
    git_server_url: &str,
@@ -27,35 +40,65 @@ pub fn push_to_remote(
    remote_refspecs: &[String],
    term: &Term,
    is_grasp_server: bool,
-) -> Result<()> {
+) -> Result<HashMap<String, Option<String>>> {
    let server_url = git_server_url.parse::<CloneUrl>()?;
    let protocols_to_attempt =
        get_write_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_grasp_server);
    let mut failed_protocols = vec![];
    let mut success = false;
+    let mut ref_updates = HashMap::new();
    for protocol in &protocols_to_attempt {
        term.write_line(format!("push: {} over {protocol}...", server_url.short_name(),).as_str())?;
        let formatted_url = server_url.format_as(protocol, &decoded_nostr_url.user)?;
-        if let Err(error) = push_to_remote_url(git_repo, &formatted_url, remote_refspecs, term) {
+        match push_to_remote_url(git_repo, &formatted_url, remote_refspecs, term) {
-            term.write_line(
+            Err(error) => {
-                format!("push: {formatted_url} failed over {protocol}: {error}").as_str(),
+                term.write_line(
-            )?;
+                    format!("push: {formatted_url} failed over {protocol}: {error}").as_str(),
-            failed_protocols.push(protocol);
+                )?;
-        } else {
+                failed_protocols.push(protocol);
-            success = true;
+            }
-            if !failed_protocols.is_empty() {
+            Ok(ref_updates_on_protocol) => {
-                term.write_line(format!("push: succeeded over {protocol}").as_str())?;
+                success = true;
-                let _ = set_protocol_preference(git_repo, protocol, &server_url, &Direction::Push);
+                if ref_updates_on_protocol
+                    .values()
+                    .all(|error| error.is_none())
+                {
+                    if !failed_protocols.is_empty() {
+                        term.write_line(format!("push: succeeded over {protocol}").as_str())?;
+                        let _ = set_protocol_preference(
+                            git_repo,
+                            protocol,
+                            &server_url,
+                            &Direction::Push,
+                        );
+                    }
+                    break;
+                } else {
+                    term.write_line(
+                        format!(
+                            "push: {formatted_url} with {protocol} complete but {}ref{} not accepted:", 
+                            if remote_refspecs.len() != failed_protocols.len() { "some " } else {""},
+                            if remote_refspecs.len() == 1 { "s"} else {""},
+                        ).as_str(),
+                    )?;
+                    for (git_ref, error) in &ref_updates_on_protocol {
+                        if let Some(error) = error {
+                            term.write_line(format!("push:    - {git_ref}: {error}").as_str())?;
+                        }
+                    }
+                    // TODO do we want to report on the refs that weren't responded to?
+                    ref_updates = ref_updates_on_protocol;
+                }
+                break;
            }
-            break;
        }
    }
    if success {
-        Ok(())
+        Ok(ref_updates)
    } else {
        let error = anyhow!(
            "{} failed over {}{}",
@@ -72,12 +115,13 @@ pub fn push_to_remote(
    }
 }
+// returns HashMaps of refspecs responded to and any failure message
 pub fn push_to_remote_url(
    git_repo: &Repo,
    git_server_url: &str,
    remote_refspecs: &[String],
    term: &Term,
-) -> Result<()> {
+) -> Result<HashMap<String, Option<String>>> {
    let git_config = git_repo.git_repo.config()?;
    let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
    let auth = GitAuthenticator::default();
@@ -91,6 +135,9 @@ pub fn push_to_remote_url(
        let push_reporter = Arc::clone(&push_reporter);
        move |name, error| {
            let mut reporter = push_reporter.lock().unwrap();
+            reporter
+                .ref_updates
+                .insert(name.to_string(), error.map(|s| s.to_string()));
            if let Some(error) = error {
                let existing_lines = reporter.count_all_existing_lines();
                reporter.update_reference_errors.push(format!(
@@ -115,7 +162,11 @@ pub fn push_to_remote_url(
                    .unwrap_or("")
                    .replace("refs/heads/", "")
                    .replace("refs/tags/", "tags/");
-                let msg = if update.dst().is_zero() {
+                let msg = if let Some(Some(_)) =
+                    reporter.ref_updates.get(update.dst_refname().unwrap_or(""))
+                {
+                    format!("push: - [failed]          {dst_refname}")
+                } else if update.dst().is_zero() {
                    format!("push: - [delete]          {dst_refname}")
                } else if update.src().is_zero() {
                    if update.dst_refname().unwrap_or("").contains("refs/tags") {
@@ -174,7 +225,8 @@ pub fn push_to_remote_url(
    push_options.remote_callbacks(remote_callbacks);
    git_server_remote.push(remote_refspecs, Some(&mut push_options))?;
    let _ = git_server_remote.disconnect();
-    Ok(())
+    let reporter = push_reporter.lock().unwrap();
+    Ok(reporter.ref_updates.clone())
 }
 #[allow(clippy::cast_precision_loss)]
@@ -223,6 +275,7 @@ pub struct PushReporter<'a> {
    negotiation: Vec<String>,
    transfer_progress_msgs: Vec<String>,
    update_reference_errors: Vec<String>,
+    ref_updates: HashMap<String, Option<String>>,
    term: &'a console::Term,
    start_time: Option<Instant>,
    end_time: Option<Instant>,
@@ -234,6 +287,7 @@ impl<'a> PushReporter<'a> {
            negotiation: vec![],
            transfer_progress_msgs: vec![],
            update_reference_errors: vec![],
+            ref_updates: HashMap::new(),
            term,
            start_time: None,
            end_time: None,
@@ -308,3 +362,183 @@ impl<'a> PushReporter<'a> {
        }
    }
 }
+#[allow(clippy::too_many_arguments)]
+pub async fn push_refs_and_generate_pr_or_pr_update_event(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    tip: &Sha1Hash,
+    user_ref: &UserRef,
+    root_proposal: Option<&Event>,
+    title_description_overide: &Option<(String, String)>,
+    servers: &[String],
+    git_ref: Option<String>,
+    signer: &Arc<dyn NostrSigner>,
+    term: &Term,
+) -> Result<(Option<Vec<Event>>, Vec<(String, Result<()>)>)> {
+    let mut responses: Vec<(String, Result<()>)> = vec![];
+    let mut unsigned_pr_event: Option<UnsignedEvent> = None;
+    for clone_url in servers {
+        let mut draft_pr_event = if let Some(ref unsigned_pr_event) = unsigned_pr_event {
+            unsigned_pr_event.clone()
+        } else {
+            generate_unsigned_pr_or_update_event(
+                git_repo,
+                repo_ref,
+                &user_ref.public_key,
+                root_proposal,
+                title_description_overide,
+                tip,
+                &[clone_url],
+                &[],
+            )?
+        };
+        let git_ref_used = git_ref
+            .clone()
+            .unwrap_or("refs/nostr/<event-id>".to_string())
+            .replace("<event-id>", &draft_pr_event.id().to_string());
+        let refspec = format!("{tip}:{git_ref_used}");
+        let res = if is_grasp_server_clone_url(clone_url) {
+            push_to_remote_url(git_repo, clone_url, &[refspec], term)
+        } else {
+            // anticipated only when pushing to user's own repo or a personal-fork with
+            // non-grasp git servers. this is used to extract prefered protocols / ssh
+            // details from nostr url
+            let decoded_nostr_url = {
+                if let Ok(Some((_, decoded_nostr_url))) = git_repo
+                .get_first_nostr_remote_when_in_ngit_binary()
+                .await.context("failed to list git remotes")
+                .context("no `nostr://` remote detected. `ngit sync` must be run from a repo with a nostr remote") {
+                    decoded_nostr_url
+                } else {
+                    repo_ref.to_nostr_git_url(&Some(git_repo))
+                }
+            };
+            push_to_remote(
+                git_repo,
+                clone_url,
+                &decoded_nostr_url,
+                &[refspec],
+                term,
+                false,
+            )
+        };
+        match res {
+            Err(error) => {
+                let normalized_url = normalize_grasp_server_url(clone_url)?;
+                term.write_line(&format!(
+                    "push: error sending commit data to {normalized_url}: {error}"
+                ))?;
+                responses.push((clone_url.clone(), Err(anyhow!(error))));
+            }
+            Ok(ref_updates) => {
+                let normalized_url = normalize_grasp_server_url(clone_url)?;
+                if let Some((_, Some(error))) = ref_updates.iter().next() {
+                    term.write_line(&format!(
+                        "push: error sending commit data to {normalized_url}: {error}"
+                    ))?;
+                    responses.push((clone_url.clone(), Err(anyhow!(error.clone()))));
+                } else {
+                    responses.push((clone_url.clone(), Ok(())));
+                    term.write_line(&format!("push: commit data sent to {normalized_url}"))?;
+                    unsigned_pr_event = Some(draft_pr_event);
+                }
+            }
+        }
+    }
+    if let Some(unsigned_pr_event) = unsigned_pr_event {
+        let pr_event = sign_draft_event(
+            unsigned_pr_event,
+            signer,
+            if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+                "Pull Request Replacing Original Patch"
+            } else if root_proposal.is_some() {
+                "Pull Request Update"
+            } else {
+                "Pull Request"
+            }
+            .to_string(),
+        )
+        .await?;
+        if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+            Ok((
+                Some(vec![
+                    pr_event,
+                    create_close_status_for_original_patch(
+                        signer,
+                        repo_ref,
+                        root_proposal.unwrap(),
+                    )
+                    .await?,
+                ]),
+                responses,
+            ))
+        } else {
+            Ok((Some(vec![pr_event]), responses))
+        }
+    } else {
+        Ok((None, responses))
+    }
+}
+async fn create_close_status_for_original_patch(
+    signer: &Arc<dyn NostrSigner>,
+    repo_ref: &RepoRef,
+    proposal: &Event,
+) -> Result<Event> {
+    let mut public_keys = repo_ref
+        .maintainers
+        .iter()
+        .copied()
+        .collect::<HashSet<PublicKey>>();
+    public_keys.insert(proposal.pubkey);
+    sign_event(
+        EventBuilder::new(nostr::event::Kind::GitStatusClosed, String::new()).tags(
+            [
+                vec![
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+                        vec![
+                            "Git patch closed as forthcoming update is too large. Replacing with Pull Request"
+                                .to_string(),
+                        ],
+                    ),
+                    Tag::from_standardized(nostr::TagStandard::Event {
+                        event_id: proposal.id,
+                        relay_url: repo_ref.relays.first().cloned(),
+                        marker: Some(Marker::Root),
+                        public_key: None,
+                        uppercase: false,
+                    }),
+                ],
+                public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(),
+                repo_ref
+                    .coordinates()
+                    .iter()
+                    .map(|c| {
+                        Tag::from_standardized(TagStandard::Coordinate {
+                            coordinate: c.coordinate.clone(),
+                            relay_url: c.relays.first().cloned(),
+                            uppercase: false,
+                        })
+                    })
+                    .collect::<Vec<Tag>>(),
+                vec![
+                    Tag::from_standardized(nostr::TagStandard::Reference(
+                        repo_ref.root_commit.to_string(),
+                    )),
+                ],
+            ]
+            .concat(),
+        ),
+        signer,
+        "close status for original patch".to_string(),
+    )
+    .await
+}
diff --git a/src/lib/repo_ref.rs b/src/lib/repo_ref.rs
index bca4a3b..b2bd381 100644
--- a/src/lib/repo_ref.rs
+++ b/src/lib/repo_ref.rs
@@ -40,6 +40,7 @@ pub struct RepoRef {
    pub web: Vec<String>,
    pub relays: Vec<RelayUrl>,
    pub blossoms: Vec<Url>,
+    pub hashtags: Vec<String>,
    pub maintainers: Vec<PublicKey>,
    pub trusted_maintainer: PublicKey,
    // set to None if not known
@@ -71,6 +72,7 @@ impl TryFrom<(nostr::Event, Option<PublicKey>)> for RepoRef {
            web: Vec::new(),
            relays: Vec::new(),
            blossoms: Vec::new(),
+            hashtags: Vec::new(),
            maintainers: Vec::new(),
            trusted_maintainer: trusted_maintainer.unwrap_or(event.pubkey),
            maintainers_without_annoucnement: None,
@@ -118,6 +120,7 @@ impl TryFrom<(nostr::Event, Option<PublicKey>)> for RepoRef {
                        }
                    }
                }
+                [t, hashtag, ..] if t == "t" => r.hashtags.push(hashtag.clone()),
                [t, blossoms @ ..] if t == "blossoms" => {
                    for b in blossoms {
                        if let Ok(b) = Url::parse(b) {
@@ -217,6 +220,15 @@ impl RepoRef {
                            vec![format!("git repository: {}", self.name.clone())],
                        ),
                    ],
+                    self.hashtags
+                        .iter()
+                        .map(|h| {
+                            Tag::custom(
+                                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("t")),
+                                vec![h.clone()],
+                            )
+                        })
+                        .collect(),
                    if self.blossoms.is_empty() {
                        vec![]
                    } else {
@@ -311,6 +323,29 @@ impl RepoRef {
    pub fn grasp_servers(&self) -> Vec<String> {
        detect_existing_grasp_servers(Some(self), &[], &[], &self.identifier)
    }
+    // returns false if already present so didn't need adding
+    pub fn add_grasp_server(&mut self, clone_url: &str) -> Result<bool> {
+        if !is_grasp_server_clone_url(clone_url) {
+            bail!("invalid grasp server clone url. does not end with .git");
+        }
+        let relay_url = RelayUrl::parse(
+            &format_grasp_server_url_as_relay_url(clone_url)
+                .context("invalid grasp server clone url")?,
+        )
+        .context("invalid grasp server clone url")?;
+        if !self.relays.contains(&relay_url) {
+            self.relays.push(relay_url);
+        }
+        if !self.git_server.contains(&clone_url.to_string()) {
+            self.git_server.push(clone_url.to_string());
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
 }
 pub async fn get_repo_coordinates_when_remote_unknown(
@@ -448,7 +483,7 @@ async fn get_repo_coordinate_from_user_prompt(
    println!(
        "{}",
        dim.apply_to(
-            "hint: https://gitworkshop.dev/repos lists repositories and their nostr address"
+            "hint: https://gitworkshop.dev/search lists repositories and their nostr address"
        ),
    );
    let git_repo_path = git_repo.get_path()?;
@@ -699,13 +734,54 @@ pub fn extract_npub(s: &str) -> Result<&str> {
    }
 }
-pub fn is_grasp_server(url: &str, grasp_servers: &[String]) -> bool {
+pub fn is_grasp_server_in_list(url: &str, grasp_servers: &[String]) -> bool {
    if !grasp_servers.is_empty() {
-        if let Ok(n) = normalize_grasp_server_url(url) {
+        if let Ok(url) = normalize_grasp_server_url(url) {
-            return grasp_servers.contains(&n);
+            grasp_servers.iter().any(|s| {
+                if let Ok(s) = normalize_grasp_server_url(s) {
+                    s == url
+                } else {
+                    false
+                }
+            })
+        } else {
+            false
        }
+    } else {
+        false
+    }
+}
+pub fn is_grasp_server_clone_url(url: &str) -> bool {
+    extract_npub(url).is_ok()
+        && (url.ends_with(".git") || url.ends_with(".git/"))
+        && url.starts_with("http")
+}
+pub fn format_grasp_server_url_as_relay_url(url: &str) -> Result<String> {
+    let grasp_server_url = normalize_grasp_server_url(url)?;
+    if grasp_server_url.contains("http://") {
+        return Ok(grasp_server_url.replace("http://", "ws://"));
    }
-    false
+    Ok(format!("wss://{grasp_server_url}"))
+}
+pub fn format_grasp_server_url_as_clone_url(
+    grasp_server: &str,
+    public_key: &PublicKey,
+    identifier: &str,
+) -> Result<String> {
+    let grasp_server_url = normalize_grasp_server_url(grasp_server)?;
+    let prefix = if grasp_server_url.contains("http://") {
+        ""
+    } else {
+        "https://"
+    };
+    Ok(format!(
+        "{prefix}{grasp_server_url}/{}/{identifier}.git",
+        public_key.to_bech32()?
+    ))
 }
 #[cfg(test)]
@@ -730,6 +806,7 @@ mod tests {
                RelayUrl::parse("ws://relay2.io").unwrap(),
            ],
            blossoms: vec![],
+            hashtags: vec![],
            trusted_maintainer: TEST_KEY_1_KEYS.public_key(),
            maintainers_without_annoucnement: None,
            maintainers: vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],
diff --git a/src/lib/utils.rs b/src/lib/utils.rs
index 431757f..431a14f 100644
--- a/src/lib/utils.rs
+++ b/src/lib/utils.rs
@@ -3,11 +3,13 @@ use std::{
    collections::HashMap,
    fmt,
    io::{self, Stdin},
+    path::Path,
    str::FromStr,
 };
 use anyhow::{Context, Result, bail};
 use git2::Repository;
+use nostr::nips::nip19::ToBech32;
 use nostr_sdk::{Event, EventId, Kind, PublicKey, Url};
 use crate::{
@@ -20,7 +22,8 @@ use crate::{
        nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
    },
    git_events::{
-        event_is_revision_root, get_pr_tip_event_or_most_recent_patch_with_ancestors, get_status,
+        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_is_revision_root,
+        get_pr_tip_event_or_most_recent_patch_with_ancestors, get_status,
        is_event_proposal_root_for_branch, status_kinds,
    },
    repo_ref::RepoRef,
@@ -187,6 +190,37 @@ pub async fn get_all_proposals(
    Ok(all_proposals)
 }
+pub async fn proposal_tip_is_pr_or_pr_update(
+    git_repo_path: &Path,
+    repo_ref: &RepoRef,
+    proposal_id: &EventId,
+) -> Result<bool> {
+    let commits_events =
+        get_all_proposal_patch_pr_pr_update_events_from_cache(git_repo_path, repo_ref, proposal_id)
+            .await
+            .context(format!(
+                "cannot get existing proposal events for {}",
+                proposal_id.to_bech32()?
+            ))?;
+    let most_recent_proposal_patch_chain = get_pr_tip_event_or_most_recent_patch_with_ancestors(
+        commits_events.clone(),
+    )
+    .context(format!(
+        "cannot find tip from proposal events for {}",
+        proposal_id.to_bech32()?,
+    ))?;
+    Ok([KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(
+        &most_recent_proposal_patch_chain
+            .first()
+            .context(format!(
+                "cannot find any proposal events for {}",
+                proposal_id.to_bech32()?
+            ))?
+            .kind,
+    ))
+}
 pub fn find_proposal_and_patches_by_branch_name<'a>(
    refstr: &'a str,
    proposals: &'a HashMap<EventId, (Event, Vec<Event>)>,