Merge branch 'add-PR-feature-to-remote'

6 files changed, 592 insertions, 188 deletions

diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index b191850..f3d4362 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -1,6 +1,6 @@
 use core::str;
 use std::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     io::Stdin,
     sync::{Arc, Mutex},
     time::Instant,
@@ -16,7 +16,7 @@ use ngit::{
         nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
         utils::check_ssh_keys,
     },
-    git_events::tag_value,
+    git_events::{KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, tag_value},
     login::get_curent_user,
     repo_ref::{RepoRef, is_grasp_server},
 };
@@ -37,38 +37,78 @@ pub async fn run_fetch(
 ) -> Result<()> {
     let mut fetch_batch = get_oids_from_fetch_batch(stdin, oid, refstr)?;
 
-    let oids_from_git_servers = fetch_batch
+    let oids_from_state = fetch_batch
         .iter()
         .filter(|(refstr, _)| !refstr.contains("refs/heads/pr/"))
         .map(|(_, oid)| oid.clone())
         .collect::<Vec<String>>();
 
+    let pr_oid_clone_url_map = identify_clone_urls_for_oids_from_pr_pr_update_events(
+        fetch_batch.values().collect::<Vec<&String>>(),
+        git_repo,
+        repo_ref,
+    )
+    .await?;
+
+    let oids_to_fetch_from_git_servers = [
+        oids_from_state.clone(),
+        pr_oid_clone_url_map
+            .keys()
+            .cloned()
+            .collect::<Vec<String>>(),
+    ]
+    .concat();
+
+    let git_servers = {
+        let mut seen: HashSet<String> = HashSet::new();
+        let mut out: Vec<String> = vec![];
+        for server in &repo_ref.git_server {
+            if seen.insert(server.clone()) {
+                out.push(server.clone());
+            }
+        }
+        for url in pr_oid_clone_url_map.values().flatten() {
+            if seen.insert(url.clone()) {
+                out.push(url.clone());
+            }
+        }
+        out
+    };
+
     let mut errors = vec![];
     let term = console::Term::stderr();
 
-    for git_server_url in &repo_ref.git_server {
+    for git_server_url in &git_servers {
+        let oids_to_fetch_from_server = oids_to_fetch_from_git_servers
+            .clone()
+            .into_iter()
+            .filter(|oid| !git_repo.does_commit_exist(oid).unwrap_or(false))
+            .collect::<Vec<String>>();
+
+        if oids_to_fetch_from_server.is_empty() {
+            continue;
+        }
+
         let term = console::Term::stderr();
         if let Err(error) = fetch_from_git_server(
             git_repo,
-            &oids_from_git_servers,
+            &oids_from_state,
             git_server_url,
             &repo_ref.to_nostr_git_url(&None),
             &term,
             is_grasp_server(git_server_url, &repo_ref.grasp_servers()),
         ) {
             errors.push(error);
-        } else {
-            break;
         }
     }
 
-    if oids_from_git_servers
+    if oids_from_state
         .iter()
         .any(|oid| !git_repo.does_commit_exist(oid).unwrap())
         && !errors.is_empty()
     {
         bail!(
-            "fetch: failed to fetch objects in nostr state event from:\r\n{}",
+            "fetch: failed to fetch objects from:\r\n{}",
             errors
                 .iter()
                 .map(|e| format!(" - {e}"))
@@ -79,12 +119,43 @@ pub async fn run_fetch(
 
     fetch_batch.retain(|refstr, _| refstr.contains("refs/heads/pr/"));
 
-    fetch_open_or_draft_proposals(git_repo, &term, repo_ref, &fetch_batch).await?;
+    fetch_open_or_draft_proposals_from_patches(git_repo, &term, repo_ref, &fetch_batch).await?;
+    // TODO fetch_open_or_draft_proposals just needs to do it for patches
     term.flush()?;
     println!();
     Ok(())
 }
 
+async fn identify_clone_urls_for_oids_from_pr_pr_update_events(
+    oids: Vec<&String>,
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+) -> Result<HashMap<String, Vec<String>>> {
+    let mut map: HashMap<String, Vec<String>> = HashMap::new();
+
+    let open_and_draft_proposals = get_open_or_draft_proposals(git_repo, repo_ref).await?;
+
+    for (_, (_, events)) in open_and_draft_proposals {
+        for event in events {
+            if [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&event.kind) {
+                if let Ok(c) = tag_value(&event, "c") {
+                    if oids.contains(&&c) {
+                        for tag in event.tags.as_slice() {
+                            if tag.kind().eq(&nostr::event::TagKind::Clone) {
+                                for clone_url in tag.as_slice().iter().skip(1) {
+                                    map.entry(c.clone()).or_default().push(clone_url.clone());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(map)
+}
+
 pub fn make_commits_for_proposal(
     git_repo: &Repo,
     repo_ref: &RepoRef,
@@ -128,7 +199,7 @@ pub fn make_commits_for_proposal(
     Ok(tip_commit_id)
 }
 
-async fn fetch_open_or_draft_proposals(
+async fn fetch_open_or_draft_proposals_from_patches(
     git_repo: &Repo,
     term: &console::Term,
     repo_ref: &RepoRef,
@@ -140,12 +211,19 @@ async fn fetch_open_or_draft_proposals(
         let current_user = get_curent_user(git_repo)?;
 
         for refstr in proposal_refs.keys() {
-            if let Some((_, (_, patches))) = find_proposal_and_patches_by_branch_name(
+            if let Some((_, (_, events_to_apply))) = find_proposal_and_patches_by_branch_name(
                 refstr,
                 &open_and_draft_proposals,
                 current_user.as_ref(),
             ) {
-                if let Err(error) = make_commits_for_proposal(git_repo, repo_ref, patches) {
+                if events_to_apply
+                    .iter()
+                    .any(|e| e.kind.eq(&KIND_PULL_REQUEST) || e.kind.eq(&KIND_PULL_REQUEST_UPDATE))
+                {
+                    // do nothing - we fetch these oids as part of run_fetch
+                } else if let Err(error) =
+                    make_commits_for_proposal(git_repo, repo_ref, events_to_apply)
+                {
                     term.write_line(
                         format!("WARNING: failed to create branch for {refstr}, error: {error}",)
                             .as_str(),
@@ -429,6 +507,7 @@ fn fetch_from_git_server_url(
         remote_callbacks.credentials(auth.credentials(&git_config));
     }
     fetch_options.remote_callbacks(remote_callbacks);
+
     git_server_remote.download(oids, Some(&mut fetch_options))?;
 
     git_server_remote.disconnect()?;
diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs
index b9fb0c0..7bdf170 100644
--- a/src/bin/git_remote_nostr/list.rs
+++ b/src/bin/git_remote_nostr/list.rs
@@ -11,7 +11,7 @@ use ngit::{
         self,
         nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
     },
-    git_events::event_to_cover_letter,
+    git_events::{KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_to_cover_letter, tag_value},
     login::get_curent_user,
     repo_ref::{self, is_grasp_server},
 };
@@ -122,6 +122,16 @@ async fn get_open_and_draft_proposals_state(
 
     // without trusting commit_id we must apply each patch which requires the oid of
     // the parent so we much do a fetch
+
+    // As we are fetching from git servers we mighgt as well get oids from pull
+    // request too
+    // TODO get Pull Request and Pull Request Update Events add these to
+    // refs/nostr/<event-id>
+    // TODO prepare PRs and PRS oids to try and fetch from repo servers that are or
+    // clone urls in PR/update event we are using anyway. TODO after we tried
+    // and failed to get them from these server we should fallback to fetch them
+    // from listed clone urls in PR/update but not during list, only during fetch
+
     for (git_server_url, (oids_from_git_servers, is_grasp_server)) in remote_states {
         if fetch_from_git_server(
             git_repo,
@@ -144,7 +154,7 @@ async fn get_open_and_draft_proposals_state(
     let mut state = HashMap::new();
     let open_and_draft_proposals = get_open_or_draft_proposals(git_repo, repo_ref).await?;
     let current_user = get_curent_user(git_repo)?;
-    for (_, (proposal, patches)) in open_and_draft_proposals {
+    for (_, (proposal, events_to_apply)) in open_and_draft_proposals {
         if let Ok(cl) = event_to_cover_letter(&proposal) {
             if let Ok(mut branch_name) = cl.get_branch_name_with_pr_prefix_and_shorthand_id() {
                 branch_name = if let Some(public_key) = current_user {
@@ -156,15 +166,43 @@ async fn get_open_and_draft_proposals_state(
                 } else {
                     branch_name
                 };
-                match make_commits_for_proposal(git_repo, repo_ref, &patches) {
-                    Ok(tip) => {
-                        state.insert(format!("refs/heads/{branch_name}"), tip);
+                // if events_to_apply contains a PR or PR Update event it should be the only
+                // event in the Vec
+                if let Some(pr_or_pr_update) = events_to_apply
+                    .iter()
+                    .find(|e| e.kind.eq(&KIND_PULL_REQUEST) || e.kind.eq(&KIND_PULL_REQUEST_UPDATE))
+                {
+                    match tag_value(pr_or_pr_update, "c") {
+                        Ok(tip) => {
+                            state.insert(format!("refs/heads/{branch_name}"), tip);
+                        }
+                        Err(_) => {
+                            let _ = term.write_line(
+                                format!(
+                                    "WARNING: failed to fetch branch {branch_name} error: {} event poorly formatted",
+                                    if pr_or_pr_update.kind.eq(&KIND_PULL_REQUEST) {
+                                        "PR"
+                                    } else {
+                                        "PR update"
+                                    }
+                                )
+                                .as_str(),
+                            );
+                        }
                     }
-                    Err(error) => {
-                        let _ = term.write_line(
-                            format!("WARNING: failed to fetch branch {branch_name} error: {error}")
+                } else {
+                    match make_commits_for_proposal(git_repo, repo_ref, &events_to_apply) {
+                        Ok(tip) => {
+                            state.insert(format!("refs/heads/{branch_name}"), tip);
+                        }
+                        Err(error) => {
+                            let _ = term.write_line(
+                                format!(
+                                    "WARNING: failed to fetch branch {branch_name} error: {error}"
+                                )
                                 .as_str(),
-                        );
+                            );
+                        }
                     }
                 }
             }
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index 9ff8af0..909a0ab 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -12,23 +12,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, get_commit_id_from_patch,
+    generate_cover_letter_and_patch_events, generate_patch_event,
+    generate_unsigned_pr_or_update_event, get_commit_id_from_patch,
 };
 use git2::{Oid, Repository};
 use ngit::{
     cli_interactor::count_lines_per_msg_vec,
-    client::{self, get_event_from_cache_by_id},
+    client::{self, get_event_from_cache_by_id, sign_draft_event},
     git::{
         self,
         nostr_url::{CloneUrl, NostrUrlDecoded},
         oid_to_shorthand_string,
     },
-    git_events::{self, event_to_cover_letter, get_event_root},
+    git_events::{self, KIND_PULL_REQUEST, event_to_cover_letter, get_event_root},
     login::{self, user::UserRef},
-    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server},
+    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server, normalize_grasp_server_url},
     repo_state,
 };
-use nostr::nips::nip10::Marker;
+use nostr::{event::UnsignedEvent, nips::nip10::Marker};
 use nostr_sdk::{
     Event, EventBuilder, EventId, Kind, NostrSigner, PublicKey, RelayUrl, Tag, TagStandard,
     hashes::sha1::Hash as Sha1Hash,
@@ -65,7 +66,7 @@ pub async fn run_push(
         .cloned()
         .collect::<Vec<String>>();
 
-    let mut git_server_refspecs = refspecs
+    let mut git_state_refspecs = refspecs
         .iter()
         .filter(|r| !r.contains("refs/heads/pr/"))
         .cloned()
@@ -105,12 +106,12 @@ pub async fn run_push(
     let (rejected_refspecs, remote_refspecs) = create_rejected_refspecs_and_remotes_refspecs(
         &term,
         git_repo,
-        &git_server_refspecs,
+        &git_state_refspecs,
         &existing_state,
         &list_outputs,
     )?;
 
-    git_server_refspecs.retain(|refspec| {
+    git_state_refspecs.retain(|refspec| {
         if let Some(rejected) = rejected_refspecs.get(&refspec.to_string()) {
             let (_, to) = refspec_to_from_to(refspec).unwrap();
             println!("error {to} {} out of sync with nostr", rejected.join(" "));
@@ -121,11 +122,11 @@ pub async fn run_push(
     });
 
     // all refspecs aren't rejected
-    if !(git_server_refspecs.is_empty() && proposal_refspecs.is_empty()) {
-        let (rejected_proposal_refspecs, rejected) = create_and_publish_events(
+    if !(git_state_refspecs.is_empty() && proposal_refspecs.is_empty()) {
+        let (rejected_proposal_refspecs, rejected) = create_and_publish_events_and_proposals(
             git_repo,
             repo_ref,
-            &git_server_refspecs,
+            &git_state_refspecs,
             &proposal_refspecs,
             client,
             existing_state,
@@ -134,7 +135,7 @@ pub async fn run_push(
         .await?;
 
         if !rejected {
-            for refspec in git_server_refspecs.iter().chain(proposal_refspecs.iter()) {
+            for refspec in git_state_refspecs.iter().chain(proposal_refspecs.iter()) {
                 if rejected_proposal_refspecs.contains(refspec) {
                     continue;
                 }
@@ -153,7 +154,7 @@ pub async fn run_push(
             for (git_server_url, remote_refspecs) in remote_refspecs {
                 let remote_refspecs = remote_refspecs
                     .iter()
-                    .filter(|refspec| git_server_refspecs.contains(refspec))
+                    .filter(|refspec| git_state_refspecs.contains(refspec))
                     .cloned()
                     .collect::<Vec<String>>();
                 if !refspecs.is_empty() {
@@ -174,7 +175,7 @@ pub async fn run_push(
     Ok(())
 }
 
-async fn create_and_publish_events(
+async fn create_and_publish_events_and_proposals(
     git_repo: &Repo,
     repo_ref: &RepoRef,
     git_server_refspecs: &Vec<String>,
@@ -320,18 +321,23 @@ async fn process_proposal_refspecs(
             {
                 if refspec.starts_with('+') {
                     // force push
-                    let (_, main_tip) = git_repo.get_main_or_master_branch()?;
+                    let (main_branch_name, main_tip) = git_repo.get_main_or_master_branch()?;
                     let (mut ahead, _) =
                         git_repo.get_commits_ahead_behind(&main_tip, &tip_of_pushed_branch)?;
                     ahead.reverse();
-                    for patch in generate_cover_letter_and_patch_events(
-                        None,
+                    if ahead.is_empty() {
+                        bail!(
+                            "cannot push '{from}' as proposal as branch isn't ahead of '{main_branch_name}'"
+                        );
+                    }
+                    for patch in generate_patches_or_pr_event_or_pr_updates(
                         git_repo,
+                        repo_ref,
                         &ahead,
+                        user_ref,
+                        Some(proposal),
                         signer,
-                        repo_ref,
-                        &Some(proposal.id.to_string()),
-                        &[],
+                        term,
                     )
                     .await?
                     {
@@ -355,27 +361,50 @@ async fn process_proposal_refspecs(
                         };
                         let mut parent_patch = tip_patch.clone();
                         ahead.reverse();
-                        for (i, commit) in ahead.iter().enumerate() {
-                            let new_patch = generate_patch_event(
+                        if ahead.is_empty() {
+                            bail!(
+                                "cannot push '{from}' as proposal as branch isn't ahead of proposal on nostr"
+                            );
+                        }
+                        if proposal.kind.eq(&KIND_PULL_REQUEST)
+                            || are_commits_too_big_for_patches(git_repo, &ahead)
+                        {
+                            for event in generate_patches_or_pr_event_or_pr_updates(
                                 git_repo,
-                                &git_repo.get_root_commit()?,
-                                commit,
-                                Some(thread_id),
-                                signer,
                                 repo_ref,
-                                Some(parent_patch.id),
-                                Some((
-                                    (patches.len() + i + 1).try_into().unwrap(),
-                                    (patches.len() + ahead.len()).try_into().unwrap(),
-                                )),
-                                None,
-                                &None,
-                                &[],
+                                &ahead,
+                                user_ref,
+                                Some(proposal),
+                                signer,
+                                term,
                             )
-                            .await
-                            .context("failed to make patch event from commit")?;
-                            events.push(new_patch.clone());
-                            parent_patch = new_patch;
+                            .await?
+                            {
+                                events.push(event);
+                            }
+                        } else {
+                            for (i, commit) in ahead.iter().enumerate() {
+                                let new_patch = generate_patch_event(
+                                    git_repo,
+                                    &git_repo.get_root_commit()?,
+                                    commit,
+                                    Some(thread_id),
+                                    signer,
+                                    repo_ref,
+                                    Some(parent_patch.id),
+                                    Some((
+                                        (patches.len() + i + 1).try_into().unwrap(),
+                                        (patches.len() + ahead.len()).try_into().unwrap(),
+                                    )),
+                                    None,
+                                    &None,
+                                    &[],
+                                )
+                                .await
+                                .context("failed to make patch event from commit")?;
+                                events.push(new_patch.clone());
+                                parent_patch = new_patch;
+                            }
                         }
                     } else {
                         // we shouldn't get here
@@ -400,22 +429,21 @@ async fn process_proposal_refspecs(
             }
         } else {
             // TODO new proposal / couldn't find exisiting proposal
-            let (_, main_tip) = git_repo.get_main_or_master_branch()?;
+            let (main_branch_name, main_tip) = git_repo.get_main_or_master_branch()?;
             let (mut ahead, _) =
                 git_repo.get_commits_ahead_behind(&main_tip, &tip_of_pushed_branch)?;
             ahead.reverse();
-            for patch in generate_cover_letter_and_patch_events(
-                None,
-                git_repo,
-                &ahead,
-                signer,
-                repo_ref,
-                &None,
-                &[],
+            if ahead.is_empty() {
+                bail!(
+                    "cannot push '{from}' as proposal as branch isn't ahead of '{main_branch_name}'"
+                );
+            }
+            for event in generate_patches_or_pr_event_or_pr_updates(
+                git_repo, repo_ref, &ahead, user_ref, None, signer, term,
             )
             .await?
             {
-                events.push(patch);
+                events.push(event);
             }
         }
     }
@@ -423,6 +451,145 @@ 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,
+    repo_ref: &RepoRef,
+    ahead: &[Sha1Hash],
+    user_ref: &UserRef,
+    root_proposal: Option<&Event>,
+    signer: &Arc<dyn NostrSigner>,
+    term: &Term,
+) -> Result<Vec<Event>> {
+    let mut events: Vec<Event> = vec![];
+    let use_pr = root_proposal.is_some_and(|proposal| proposal.kind.eq(&KIND_PULL_REQUEST))
+        || 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
+            .git_server
+            .iter()
+            .filter(|s| is_grasp_server(s, &repo_grasps));
+
+        let mut unsigned_pr_event: Option<UnsignedEvent> = None;
+        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."
+            );
+
+            // 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
+        }
+        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?;
+            events.push(pr_event);
+            if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+                events.push(
+                    create_close_status_for_original_patch(
+                        signer,
+                        repo_ref,
+                        root_proposal.unwrap(),
+                    )
+                    .await?,
+                );
+            }
+        } 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"
+            );
+            // TODO suggest `ngit send` where user could specify their own clone
+            // url to push to once that feature is added
+        }
+    } else {
+        for patch in generate_cover_letter_and_patch_events(
+            None,
+            git_repo,
+            ahead,
+            signer,
+            repo_ref,
+            &root_proposal.map(|proposal| proposal.id.to_string()),
+            &[],
+        )
+        .await?
+        {
+            events.push(patch);
+        }
+    }
+
+    Ok(events)
+}
+
 fn push_to_remote(
     git_repo: &Repo,
     git_server_url: &str,
@@ -1079,7 +1246,7 @@ type MergedProposalsInfo =
 async fn get_merged_proposals_info(
     git_repo: &Repo,
     ahead: &Vec<Sha1Hash>,
-    available_patches: &[Event],
+    available_patches_pr_pr_update: &[Event],
 ) -> Result<MergedProposalsInfo> {
     let mut proposals: MergedProposalsInfo = HashMap::new();
 
@@ -1089,19 +1256,19 @@ async fn get_merged_proposals_info(
         // are in ahead
         if commit.parent_count() > 1 {
             for parent in commit.parents() {
-                for patch_event in available_patches
+                for event in available_patches_pr_pr_update
                     .iter()
                     .filter(|e| {
                         e.tags.iter().any(|t| {
                             t.as_slice().len() > 1
-                                && t.as_slice()[0].eq("commit")
+                                && (t.as_slice()[0].eq("commit") || t.as_slice()[0].eq("c"))
                                 && t.as_slice()[1].eq(&parent.id().to_string())
                         })
                     })
                     .collect::<Vec<&Event>>()
                 {
                     if let Ok((proposal_id, revision_id)) =
-                        get_proposal_and_revision_root_from_patch(git_repo, patch_event).await
+                        get_proposal_and_revision_root_from_patch(git_repo, event).await
                     {
                         let (entry_revision_id, merged_patches) =
                             proposals.entry(proposal_id).or_default();
@@ -1114,12 +1281,12 @@ async fn get_merged_proposals_info(
         } else {
             // three way merge or fast forward merge commits
             // note: ahead included commits of three-way merged branches
-            let mut matching_patches = available_patches
+            let mut matching_patches = available_patches_pr_pr_update
                 .iter()
                 .filter(|e| {
                     e.tags.iter().any(|t| {
                         t.as_slice().len() > 1
-                            && t.as_slice()[0].eq("commit")
+                            && (t.as_slice()[0].eq("commit") || t.as_slice()[0].eq("c"))
                             && t.as_slice()[1].eq(&commit_hash.to_string())
                     })
                 })
@@ -1144,7 +1311,7 @@ async fn get_merged_proposals_info(
             // applied commits - this is done after so that merged revisions take priority
             if matching_patches.is_empty() {
                 let author = git_repo.get_commit_author(commit_hash)?;
-                matching_patches = available_patches
+                matching_patches = available_patches_pr_pr_update
                     .iter()
                     .filter(|e| {
                         if let Ok(patch_author) = get_patch_author(e) {
@@ -1391,6 +1558,62 @@ 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/git_remote_nostr/utils.rs b/src/bin/git_remote_nostr/utils.rs
index dc75872..2cb85bf 100644
--- a/src/bin/git_remote_nostr/utils.rs
+++ b/src/bin/git_remote_nostr/utils.rs
@@ -10,7 +10,7 @@ use anyhow::{Context, Result, bail};
 use git2::Repository;
 use ngit::{
     client::{
-        get_all_proposal_patch_events_from_cache, get_events_from_local_cache,
+        get_all_proposal_patch_pr_pr_update_events_from_cache, get_events_from_local_cache,
         get_proposals_and_revisions_from_cache,
     },
     git::{
@@ -18,7 +18,7 @@ use ngit::{
         nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
     },
     git_events::{
-        event_is_revision_root, get_most_recent_patch_with_ancestors,
+        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,
@@ -103,7 +103,10 @@ pub async fn get_open_or_draft_proposals(
         get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates())
             .await?
             .iter()
-            .filter(|e| !event_is_revision_root(e))
+            .filter(|e|
+                // If we wanted to treat to list Pull Requests that revise a Patch we would do this:
+                // e.kind.eq(&KIND_PULL_REQUEST) ||
+                !event_is_revision_root(e))
             .cloned()
             .collect();
 
@@ -123,32 +126,23 @@ pub async fn get_open_or_draft_proposals(
     };
     let mut open_or_draft_proposals = HashMap::new();
 
-    for proposal in proposals {
-        let status = if let Some(e) = statuses
-            .iter()
-            .filter(|e| {
-                status_kinds().contains(&e.kind)
-                    && e.tags.iter().any(|t| {
-                        t.as_slice().len() > 1 && t.as_slice()[1].eq(&proposal.id.to_string())
-                    })
-            })
-            .collect::<Vec<&nostr::Event>>()
-            .first()
-        {
-            e.kind
-        } else {
-            Kind::GitStatusOpen
-        };
+    for proposal in &proposals {
+        let status = get_status(proposal, repo_ref, &statuses, &proposals);
         if [Kind::GitStatusOpen, Kind::GitStatusDraft].contains(&status) {
-            if let Ok(commits_events) =
-                get_all_proposal_patch_events_from_cache(git_repo_path, repo_ref, &proposal.id)
-                    .await
+            if let Ok(commits_events) = get_all_proposal_patch_pr_pr_update_events_from_cache(
+                git_repo_path,
+                repo_ref,
+                &proposal.id,
+            )
+            .await
             {
                 if let Ok(most_recent_proposal_patch_chain) =
-                    get_most_recent_patch_with_ancestors(commits_events.clone())
+                    get_pr_tip_event_or_most_recent_patch_with_ancestors(commits_events.clone())
                 {
-                    open_or_draft_proposals
-                        .insert(proposal.id, (proposal, most_recent_proposal_patch_chain));
+                    open_or_draft_proposals.insert(
+                        proposal.id,
+                        (proposal.clone(), most_recent_proposal_patch_chain),
+                    );
                 }
             }
         }
@@ -165,18 +159,25 @@ pub async fn get_all_proposals(
         get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates())
             .await?
             .iter()
-            .filter(|e| !event_is_revision_root(e))
+            .filter(|e|
+                // If we wanted to treat to list Pull Requests that revise a Patch we would do this:
+                // e.kind.eq(&KIND_PULL_REQUEST) ||
+                !event_is_revision_root(e))
             .cloned()
             .collect();
 
     let mut all_proposals = HashMap::new();
 
     for proposal in proposals {
-        if let Ok(commits_events) =
-            get_all_proposal_patch_events_from_cache(git_repo_path, repo_ref, &proposal.id).await
+        if let Ok(commits_events) = get_all_proposal_patch_pr_pr_update_events_from_cache(
+            git_repo_path,
+            repo_ref,
+            &proposal.id,
+        )
+        .await
         {
             if let Ok(most_recent_proposal_patch_chain) =
-                get_most_recent_patch_with_ancestors(commits_events.clone())
+                get_pr_tip_event_or_most_recent_patch_with_ancestors(commits_events.clone())
             {
                 all_proposals.insert(proposal.id, (proposal, most_recent_proposal_patch_chain));
             }
diff --git a/src/bin/ngit/sub_commands/init.rs b/src/bin/ngit/sub_commands/init.rs
index 1242e45..eaaf83d 100644
--- a/src/bin/ngit/sub_commands/init.rs
+++ b/src/bin/ngit/sub_commands/init.rs
@@ -229,7 +229,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 .map(std::string::ToString::to_string)
                 .collect::<Vec<String>>()
         } else {
-            client.get_fallback_relays().clone()
+            client.get_relay_default_set().clone()
         }
     } else {
         args.relays.clone()
@@ -252,14 +252,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         args.blossoms.clone()
     };
 
-    let fallback_grasp_servers =
-        if let Ok(Some(s)) = git_repo.get_git_config_item("nostr.grasp-default-set", None) {
-            s.split(';')
-                .filter_map(|url| normalize_grasp_server_url(url).ok()) // Attempt to parse and filter out errors
-                .collect()
-        } else {
-            vec!["relay.ngit.dev".to_string(), "gitnostr.com".to_string()]
-        };
+    let fallback_grasp_servers = client.get_grasp_default_set();
 
     let selected_grasp_servers = if has_server_and_relay_flags {
         // ignore so a script running `ngit init` can contiue without prompts
@@ -269,14 +262,13 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             repo_ref.as_ref(),
             &args.relays,
             &args.clone_url,
-            &args.blossoms,
             &identifier,
         );
         let mut selections: Vec<bool> = vec![true; options.len()]; // Initialize selections based on existing options
         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)) {
+            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
             }
@@ -464,7 +456,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             let mut selections: Vec<bool> = vec![true; options.len()];
 
             // add fallback relays as options
-            for relay in client.get_fallback_relays().clone() {
+            for relay in client.get_relay_default_set().clone() {
                 if !options.iter().any(|r| r.contains(&relay))
                     && !formatted_selected_grasp_servers
                         .iter()
diff --git a/src/bin/ngit/sub_commands/list.rs b/src/bin/ngit/sub_commands/list.rs
index 0330be1..0083c91 100644
--- a/src/bin/ngit/sub_commands/list.rs
+++ b/src/bin/ngit/sub_commands/list.rs
@@ -3,10 +3,12 @@ use std::{io::Write, ops::Add};
 use anyhow::{Context, Result, bail};
 use ngit::{
     client::{
-        Params, get_all_proposal_patch_events_from_cache, get_proposals_and_revisions_from_cache,
+        Params, get_all_proposal_patch_pr_pr_update_events_from_cache,
+        get_proposals_and_revisions_from_cache,
     },
     git_events::{
-        get_commit_id_from_patch, get_most_recent_patch_with_ancestors, status_kinds, tag_value,
+        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, get_commit_id_from_patch,
+        get_pr_tip_event_or_most_recent_patch_with_ancestors, get_status, status_kinds, tag_value,
     },
 };
 use nostr_sdk::Kind;
@@ -70,26 +72,15 @@ pub async fn launch() -> Result<()> {
 
     let proposals: Vec<nostr::Event> = proposals_and_revisions
         .iter()
-        .filter(|e| !event_is_revision_root(e))
+        .filter(|e|
+            // If we wanted to treat to list Pull Requests that revise a Patch we would do this:
+            // e.kind.eq(&KIND_PULL_REQUEST) ||
+            !event_is_revision_root(e))
         .cloned()
         .collect();
 
     for proposal in &proposals {
-        let status = if let Some(e) = statuses
-            .iter()
-            .filter(|e| {
-                status_kinds().contains(&e.kind)
-                    && e.tags.iter().any(|t| {
-                        t.as_slice().len() > 1 && t.as_slice()[1].eq(&proposal.id.to_string())
-                    })
-            })
-            .collect::<Vec<&nostr::Event>>()
-            .first()
-        {
-            e.kind
-        } else {
-            Kind::GitStatusOpen
-        };
+        let status = get_status(proposal, &repo_ref, &statuses, &proposals);
         if status.eq(&Kind::GitStatusOpen) {
             open_proposals.push(proposal);
         } else if status.eq(&Kind::GitStatusClosed) {
@@ -184,21 +175,22 @@ pub async fn launch() -> Result<()> {
         let cover_letter = event_to_cover_letter(proposals_for_status[selected_index])
             .context("failed to extract proposal details from proposal root event")?;
 
-        let commits_events: Vec<nostr::Event> = get_all_proposal_patch_events_from_cache(
-            git_repo_path,
-            &repo_ref,
-            &proposals_for_status[selected_index].id,
-        )
-        .await?;
+        let commits_events: Vec<nostr::Event> =
+            get_all_proposal_patch_pr_pr_update_events_from_cache(
+                git_repo_path,
+                &repo_ref,
+                &proposals_for_status[selected_index].id,
+            )
+            .await?;
 
-        let Ok(most_recent_proposal_patch_chain) =
-            get_most_recent_patch_with_ancestors(commits_events.clone())
+        let Ok(most_recent_proposal_patch_chain_or_pr_or_pr_update) =
+            get_pr_tip_event_or_most_recent_patch_with_ancestors(commits_events.clone())
         else {
             if Interactor::default().confirm(
                 PromptConfirmParms::default()
                     .with_default(true)
                     .with_prompt(
-                        "failed to find any patches on this proposal. choose another proposal?",
+                        "failed to find any PR or patch events on this proposal. choose another proposal?",
                     ),
             )? {
                 continue;
@@ -208,15 +200,60 @@ pub async fn launch() -> Result<()> {
         // for commit in &most_recent_proposal_patch_chain {
         //     println!("recent_event: {:?}", commit.as_json());
         // }
+        if most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .iter()
+            .any(|e| [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&e.kind))
+        {
+            match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_prompt(
+                        "this is new PR event kind which isn't supported in `ngit list` yet",
+                    )
+                    .with_default(0)
+                    .with_choices(
+                        if [Kind::GitStatusOpen, Kind::GitStatusDraft].contains(&selected_status)
+                            && git_repo
+                                .get_first_nostr_remote_when_in_ngit_binary()
+                                .await
+                                .is_ok_and(|r| r.is_some())
+                        {
+                            vec![
+                                format!(
+                                    "I'll manually checkout the proposal at remote branch '{}'",
+                                    cover_letter
+                                        .get_branch_name_with_pr_prefix_and_shorthand_id()
+                                        .unwrap()
+                                ),
+                                // TODO fetch oids and follow similar logic for dealing with
+                                // conflcts as with patches below
+                                "back to proposals".to_string(),
+                            ]
+                        } else {
+                            vec!["back to proposals".to_string()]
+                        },
+                    ),
+            )? {
+                0 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
 
-        let binding_patch_text_ref = format!("{} commits", most_recent_proposal_patch_chain.len());
-        let patch_text_ref = if most_recent_proposal_patch_chain.len().gt(&1) {
+        let binding_patch_text_ref = format!(
+            "{} commits",
+            most_recent_proposal_patch_chain_or_pr_or_pr_update.len()
+        );
+        let patch_text_ref = if most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .len()
+            .gt(&1)
+        {
             binding_patch_text_ref.as_str()
         } else {
             "1 commit"
         };
 
-        let no_support_for_patches_as_branch = most_recent_proposal_patch_chain
+        let no_support_for_patches_as_branch = most_recent_proposal_patch_chain_or_pr_or_pr_update
             .iter()
             .any(|event| !patch_supports_commit_ids(event));
 
@@ -226,16 +263,18 @@ pub async fn launch() -> Result<()> {
                 PromptChoiceParms::default()
                     .with_default(0)
                     .with_choices(vec![
-                        "learn why 'patch only' proposals can't be checked out".to_string(),
+                        "learn why this proposals can't be checked out".to_string(),
                         format!("apply to current branch with `git am`"),
                         format!("download to ./patches"),
                         "back".to_string(),
                     ]),
             )? {
                 0 => {
-                    println!("Some proposals are posted as 'patch only'\n");
                     println!(
-                        "they are not anchored against a particular state of the code base like a standard proposal or a GitHub Pull Request can be\n"
+                        "Some proposals are posted as patch without listing a parent commit\n"
+                    );
+                    println!(
+                        "they are not anchored against a particular state of the code base like a standard patch or a pull request can be\n"
                     );
                     println!(
                         "they are designed to reviewed by studying the diff (in a tool like gitworkshop.dev) and if acceptable by a maintainer, applied to the latest version of master with any conflicts resolved as the do so\n"
@@ -244,7 +283,7 @@ pub async fn launch() -> Result<()> {
                         "this has proven to be a smoother workflow for large scale projects with a high frequency of changes, even when patches are exchanged via email\n"
                     );
                     println!(
-                        "by default ngit posts proposals that support both the branch and patch model so either workflow can be used"
+                        "by default ngit posts proposals with a parent commit so either workflow can be used"
                     );
                     Interactor::default().choice(
                         PromptChoiceParms::default()
@@ -253,8 +292,13 @@ pub async fn launch() -> Result<()> {
                     )?;
                     continue;
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -277,9 +321,11 @@ pub async fn launch() -> Result<()> {
             .eq(&cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?);
 
         let proposal_base_commit = str_to_sha1(&tag_value(
-            most_recent_proposal_patch_chain.last().context(
-                "there should be at least one patch as we have already checked for this",
-            )?,
+            most_recent_proposal_patch_chain_or_pr_or_pr_update
+                .last()
+                .context(
+                    "there should be at least one patch as we have already checked for this",
+                )?,
             "parent-commit",
         )?)
         .context("failed to get valid parent commit id from patch")?;
@@ -300,8 +346,8 @@ pub async fn launch() -> Result<()> {
                 ],
             ))? {
                 0 | 3 => continue,
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain_or_pr_or_pr_update, &git_repo),
                 _ => {
                     bail!("unexpected choice")
                 }
@@ -309,9 +355,13 @@ pub async fn launch() -> Result<()> {
         }
 
         let proposal_tip = str_to_sha1(
-            &get_commit_id_from_patch(most_recent_proposal_patch_chain.first().context(
-                "there should be at least one patch as we have already checked for this",
-            )?)
+            &get_commit_id_from_patch(
+                most_recent_proposal_patch_chain_or_pr_or_pr_update
+                    .first()
+                    .context(
+                        "there should be at least one patch as we have already checked for this",
+                    )?,
+            )
             .context("failed to get valid commit_id from patch")?,
         )
         .context("failed to get valid commit_id from patch")?;
@@ -325,7 +375,7 @@ pub async fn launch() -> Result<()> {
                 .choice(PromptChoiceParms::default().with_default(0).with_choices(vec![
                 format!(
                     "create and checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
-                    most_recent_proposal_patch_chain.len(),
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                     proposal_behind_main.len(),
                 ),
                 format!("apply to current branch with `git am`"),
@@ -337,7 +387,7 @@ pub async fn launch() -> Result<()> {
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
 
@@ -347,8 +397,8 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain_or_pr_or_pr_update, &git_repo),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -382,7 +432,7 @@ pub async fn launch() -> Result<()> {
                     .with_choices(vec![
                         format!(
                             "checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
-                            most_recent_proposal_patch_chain.len(),
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                             proposal_behind_main.len(),
                         ),
                         format!("apply to current branch with `git am`"),
@@ -401,8 +451,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -414,11 +469,14 @@ pub async fn launch() -> Result<()> {
             git_repo.get_commits_ahead_behind(&master_tip, &local_branch_tip)?;
 
         // new appendments to proposal
-        if let Some(index) = most_recent_proposal_patch_chain.iter().position(|patch| {
-            get_commit_id_from_patch(patch)
-                .unwrap_or_default()
-                .eq(&local_branch_tip.to_string())
-        }) {
+        if let Some(index) = most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .iter()
+            .position(|patch| {
+                get_commit_id_from_patch(patch)
+                    .unwrap_or_default()
+                    .eq(&local_branch_tip.to_string())
+            })
+        {
             return match Interactor::default().choice(
                 PromptChoiceParms::default()
                     .with_default(0)
@@ -437,7 +495,7 @@ pub async fn launch() -> Result<()> {
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
                     println!(
@@ -448,8 +506,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -467,7 +530,7 @@ pub async fn launch() -> Result<()> {
         }) {
             println!(
                 "updated proposal available ({} ahead {} behind '{main_branch_name}'). existing version is {} ahead {} behind '{main_branch_name}'",
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
@@ -492,11 +555,11 @@ pub async fn launch() -> Result<()> {
                     git_repo.checkout(
                         &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
                     )?;
-                    let chain_length = most_recent_proposal_patch_chain.len();
+                    let chain_length = most_recent_proposal_patch_chain_or_pr_or_pr_update.len();
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
                     println!(
@@ -520,8 +583,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                2 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                3 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                2 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                3 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 4 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -581,7 +649,7 @@ pub async fn launch() -> Result<()> {
         if git_repo.does_commit_exist(&proposal_tip.to_string())? {
             println!(
                 "you have previously applied the latest version of the proposal ({} ahead {} behind '{main_branch_name}') but your local proposal branch has amended or rebased it ({} ahead {} behind '{main_branch_name}')",
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
@@ -594,7 +662,7 @@ pub async fn launch() -> Result<()> {
                 "your local proposal branch ({} ahead {} behind '{main_branch_name}') has conflicting changes with the latest published proposal ({} ahead {} behind '{main_branch_name}')",
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
             );
 
@@ -639,11 +707,11 @@ pub async fn launch() -> Result<()> {
                     &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
                     &proposal_base_commit.to_string(),
                 )?;
-                let chain_length = most_recent_proposal_patch_chain.len();
+                let chain_length = most_recent_proposal_patch_chain_or_pr_or_pr_update.len();
                 let _ = git_repo
                     .apply_patch_chain(
                         &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                        most_recent_proposal_patch_chain,
+                        most_recent_proposal_patch_chain_or_pr_or_pr_update,
                     )
                     .context("failed to apply patch chain")?;
 
@@ -658,8 +726,11 @@ pub async fn launch() -> Result<()> {
                 );
                 Ok(())
             }
-            2 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-            3 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+            2 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+            3 => save_patches_to_dir(
+                most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                &git_repo,
+            ),
             4 => continue,
             _ => {
                 bail!("unexpected choice")