feat(send): `in-reply-to` tags npubs and events

in addition to being used to create a new proposal revision,
in-reply-to can now be used to reference other events and npubs.

for example an issues or kind 1 threads where the proposal is relevant

the proposal will only be marked as a revision if the first parameter is
a reference to an existing proposal root

5 files changed, 401 insertions, 36 deletions

diff --git a/src/git.rs b/src/git.rs
index 77c1dcb..e797cb8 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -1526,6 +1526,7 @@ mod tests {
                 None,
                 None,
                 &None,
+                &[],
             )
         }
         fn test_patch_applies_to_repository(patch_event: nostr::Event) -> Result<()> {
@@ -1687,6 +1688,7 @@ mod tests {
                 &TEST_KEY_1_KEYS,
                 &RepoRef::try_from(generate_repo_ref_event()).unwrap(),
                 &None,
+                &[],
             )?;
 
             events.reverse();
diff --git a/src/sub_commands/push.rs b/src/sub_commands/push.rs
index bb50ee2..fefe102 100644
--- a/src/sub_commands/push.rs
+++ b/src/sub_commands/push.rs
@@ -108,7 +108,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             cli_args,
             &sub_commands::send::SubCommandArgs {
                 since_or_range: String::new(),
-                in_reply_to: Some(proposal_root_event.id.to_string()),
+                in_reply_to: vec![proposal_root_event.id.to_string()],
                 title: None,
                 description: None,
                 no_cover_letter: args.no_cover_letter,
@@ -166,6 +166,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 None,
                 None,
                 &None,
+                &[],
             )
             .context("cannot make patch event from commit")?,
         );
diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index 78d00b2..4639b01 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -31,10 +31,10 @@ pub struct SubCommandArgs {
     #[arg(default_value = "")]
     /// commits to send as proposal; like in `git format-patch` eg. HEAD~2
     pub(crate) since_or_range: String,
-    #[clap(long)]
-    /// nevent or event id of an existing proposal for which this is a new
-    /// version
-    pub(crate) in_reply_to: Option<String>,
+    #[clap(long, value_parser, num_args = 0.., value_delimiter = ' ')]
+    /// references to an existing proposal for which this is a new
+    /// version and/or events / npubs to tag as mentions
+    pub(crate) in_reply_to: Vec<String>,
     /// don't prompt for a cover letter
     #[arg(long, action)]
     pub(crate) no_cover_letter: bool,
@@ -50,14 +50,29 @@ pub struct SubCommandArgs {
 pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     let git_repo = Repo::discover().context("cannot find a git repository")?;
 
-    if let Some(id) = &args.in_reply_to {
-        println!("creating proposal revision for: {id}");
-    }
-
     let (main_branch_name, main_tip) = git_repo
         .get_main_or_master_branch()
         .context("the default branches (main or master) do not exist")?;
 
+    #[cfg(not(test))]
+    let mut client = Client::default();
+    #[cfg(test)]
+    let mut client = <MockConnect as std::default::Default>::default();
+
+    let (root_proposal_id, mention_tags) = get_root_proposal_id_and_mentions_from_in_reply_to(
+        &client,
+        // TODO: user repo relays when when event cache is in place
+        client.get_fallback_relays(),
+        &args.in_reply_to,
+    )
+    .await?;
+
+    if let Some(root_ref) = args.in_reply_to.first() {
+        if root_proposal_id.is_some() {
+            println!("creating proposal revision for: {root_ref}");
+        }
+    }
+
     let mut commits: Vec<Sha1Hash> = {
         if args.since_or_range.is_empty() {
             let branch_name = git_repo.get_checked_out_branch_name()?;
@@ -163,12 +178,6 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     } else {
         None
     };
-
-    #[cfg(not(test))]
-    let mut client = Client::default();
-    #[cfg(test)]
-    let mut client = <MockConnect as std::default::Default>::default();
-
     let (keys, user_ref) = login::launch(&cli_args.nsec, &cli_args.password, Some(&client)).await?;
 
     client.set_keys(&keys).await;
@@ -194,7 +203,8 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         &commits,
         &keys,
         &repo_ref,
-        &args.in_reply_to,
+        &root_proposal_id,
+        &mention_tags,
     )?;
 
     println!(
@@ -227,7 +237,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     )
     .await?;
 
-    if args.in_reply_to.is_none() {
+    if root_proposal_id.is_none() {
         if let Some(event) = events.first() {
             // TODO: add gitworkshop.dev to njump and remove direct gitworkshop link
             println!(
@@ -538,15 +548,77 @@ mod tests_unique_and_duplicate {
     }
 }
 
+async fn get_root_proposal_id_and_mentions_from_in_reply_to(
+    #[cfg(test)] client: &crate::client::MockConnect,
+    #[cfg(not(test))] client: &Client,
+    repo_relays: &[String],
+    in_reply_to: &[String],
+) -> Result<(Option<String>, Vec<nostr::Tag>)> {
+    let root_proposal_id = if let Some(first) = in_reply_to.first() {
+        match event_tag_from_nip19_or_hex(first, "in-reply-to", nostr::Marker::Root, true, false)? {
+            Tag::Event {
+                event_id,
+                relay_url: _,
+                marker: _,
+            } => {
+                let events = client
+                    .get_events(
+                        repo_relays.to_vec(),
+                        vec![nostr::Filter::new().id(event_id)],
+                    )
+                    .await
+                    .context("whilst getting events specified in --in-reply-to")?;
+                if let Some(first) = events.iter().find(|e| e.id.eq(&event_id)) {
+                    if event_is_patch_set_root(first) {
+                        Some(event_id.to_string())
+                    } else {
+                        None
+                    }
+                } else {
+                    bail!(
+                        "cannot find first event specified in --in-reply-to \"{}\"",
+                        first,
+                    )
+                }
+            }
+            _ => None,
+        }
+    } else {
+        return Ok((None, vec![]));
+    };
+
+    let mut mention_tags = vec![];
+    for (i, reply_to) in in_reply_to.iter().enumerate() {
+        if i.ne(&0) || root_proposal_id.is_none() {
+            mention_tags.push(
+                event_tag_from_nip19_or_hex(
+                    reply_to,
+                    "in-reply-to",
+                    nostr::Marker::Mention,
+                    true,
+                    false,
+                )
+                .context(format!(
+                    "{reply_to} in 'in-reply-to' not a valid nostr reference"
+                ))?,
+            );
+        }
+    }
+
+    Ok((root_proposal_id, mention_tags))
+}
+
 pub static PATCH_KIND: u64 = 1617;
 
+#[allow(clippy::too_many_lines)]
 pub fn generate_cover_letter_and_patch_events(
     cover_letter_title_description: Option<(String, String)>,
     git_repo: &Repo,
     commits: &[Sha1Hash],
     keys: &nostr::Keys,
     repo_ref: &RepoRef,
-    in_reply_to: &Option<String>,
+    root_proposal_id: &Option<String>,
+    mentions: &[nostr::Tag],
 ) -> Result<Vec<nostr::Event>> {
     let root_commit = git_repo
         .get_root_commit()
@@ -578,18 +650,19 @@ pub fn generate_cover_letter_and_patch_events(
                 Tag::Reference(format!("{root_commit}")),
                 Tag::Hashtag("cover-letter".to_string()),
             ],
-            if let Some(event_ref) = in_reply_to.clone() {
+            if let Some(event_ref) = root_proposal_id.clone() {
                 vec![
                     Tag::Hashtag("root".to_string()),
                     Tag::Hashtag("revision-root".to_string()),
                     // TODO check if id is for a root proposal (perhaps its for an issue?)
-                    e_tag_from_nip19(&event_ref,"proposal",nostr::Marker::Reply)?,
+                    event_tag_from_nip19_or_hex(&event_ref,"proposal",nostr::Marker::Reply, false, false)?,
                 ]
             } else {
                 vec![
                     Tag::Hashtag("root".to_string()),
                 ]
             },
+            mentions.to_vec(),
             // this is not strictly needed but makes for prettier branch names
             // eventually a prefix will be needed of the event id to stop 2 proposals with the same name colliding
             // a change like this, or the removal of this tag will require the actual branch name to be tracked
@@ -651,7 +724,8 @@ pub fn generate_cover_letter_and_patch_events(
                 } else {
                     None
                 },
-                in_reply_to,
+                root_proposal_id,
+                if events.is_empty() { mentions } else { &[] },
             )
             .context("failed to generate patch event")?,
         );
@@ -659,19 +733,20 @@ pub fn generate_cover_letter_and_patch_events(
     Ok(events)
 }
 
-fn e_tag_from_nip19(
+fn event_tag_from_nip19_or_hex(
     reference: &str,
     reference_name: &str,
     marker: nostr::Marker,
+    allow_npub_reference: bool,
+    prompt_for_correction: bool,
 ) -> Result<nostr::Tag> {
     let mut bech32 = reference.to_string();
     loop {
         if bech32.is_empty() {
             bech32 = Interactor::default().input(
-                PromptInputParms::default().with_prompt(&format!("{reference_name} nevent")),
+                PromptInputParms::default().with_prompt(&format!("{reference_name} reference")),
             )?;
         }
-
         if let Ok(nip19) = Nip19::from_bech32(bech32.clone()) {
             match nip19 {
                 Nip19::Event(n) => {
@@ -688,6 +763,22 @@ fn e_tag_from_nip19(
                         marker: Some(marker),
                     });
                 }
+                Nip19::Coordinate(coordinate) => {
+                    break Ok(nostr::Tag::A {
+                        coordinate,
+                        relay_url: None,
+                    });
+                }
+                Nip19::Profile(profile) => {
+                    if allow_npub_reference {
+                        break Ok(nostr::Tag::public_key(profile.public_key));
+                    }
+                }
+                Nip19::Pubkey(public_key) => {
+                    if allow_npub_reference {
+                        break Ok(nostr::Tag::public_key(public_key));
+                    }
+                }
                 _ => {}
             }
         }
@@ -698,7 +789,11 @@ fn e_tag_from_nip19(
                 marker: Some(marker),
             });
         }
-        println!("not a valid {reference_name} event reference");
+        if prompt_for_correction {
+            println!("not a valid {reference_name} event reference");
+        } else {
+            bail!(format!("not a valid {reference_name} event reference"));
+        }
 
         bech32 = String::new();
     }
@@ -810,7 +905,8 @@ pub fn generate_patch_event(
     parent_patch_event_id: Option<nostr::EventId>,
     series_count: Option<(u64, u64)>,
     branch_name: Option<String>,
-    in_reply_to: &Option<String>,
+    root_proposal_id: &Option<String>,
+    mentions: &[nostr::Tag],
 ) -> Result<nostr::Event> {
     let commit_parent = git_repo
         .get_commit_parent(commit)
@@ -849,19 +945,19 @@ pub fn generate_patch_event(
                     relay_url: relay_hint.clone(),
                     marker: Some(Marker::Root),
                 }]
-            } else if let Some(event_ref) = in_reply_to.clone() {
+            } else if let Some(event_ref) = root_proposal_id.clone() {
                 vec![
                     Tag::Hashtag("root".to_string()),
                     Tag::Hashtag("revision-root".to_string()),
                     // TODO check if id is for a root proposal (perhaps its for an issue?)
-                    e_tag_from_nip19(&event_ref,"proposal",nostr::Marker::Reply)?,
+                    event_tag_from_nip19_or_hex(&event_ref,"proposal",nostr::Marker::Reply, false, false)?,
                 ]
             } else {
                 vec![
                     Tag::Hashtag("root".to_string()),
                 ]
             },
-
+            mentions.to_vec(),
             if let Some(id) = parent_patch_event_id {
                 vec![Tag::Event {
                     event_id: id,
diff --git a/test_utils/src/lib.rs b/test_utils/src/lib.rs
index ad187be..a693607 100644
--- a/test_utils/src/lib.rs
+++ b/test_utils/src/lib.rs
@@ -4,6 +4,7 @@ use anyhow::{bail, ensure, Context, Result};
 use dialoguer::theme::{ColorfulTheme, Theme};
 use directories::ProjectDirs;
 use nostr::{self, Kind, Tag};
+use nostr_sdk::serde_json;
 use once_cell::sync::Lazy;
 use rexpect::session::{Options, PtySession};
 use strip_ansi_escapes::strip_str;
@@ -178,6 +179,11 @@ pub fn generate_repo_ref_event() -> nostr::Event {
     .unwrap()
 }
 
+/// enough to fool event_is_patch_set_root
+pub fn get_pretend_proposal_root_event() -> nostr::Event {
+    serde_json::from_str(r#"{"id":"8cb75aa4cda10a3a0f3242dc49d36159d30b3185bf63414cf6ce17f5c14a73b1","pubkey":"f53e4bcd7a9cdef049cf6467d638a1321958acd3b71eb09823fd6fadb023d768","created_at":1714984571,"kind":1617,"tags":[["t","root"]],"content":"","sig":"6c197314b8c4c61da696dff888198333004d1ecc5d7bae2c554857f2f2b0d3ecc09369a5d8ba089c1bf89e3c6f5be40ade873fd698438ef8b303ffc6df35eb3f"}"#).unwrap()
+}
+
 /// wrapper for a cli testing tool - currently wraps rexpect and dialoguer
 ///
 /// 1. allow more accurate articulation of expected behaviour
diff --git a/tests/send.rs b/tests/send.rs
index a38546a..8474c19 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -1284,9 +1284,14 @@ mod when_range_ommited_prompts_for_selection_defaulting_ahead_of_main {
     }
 }
 
-mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specified {
+mod root_proposal_specified_using_in_reply_to_with_range_of_head_2_and_cover_letter_details_specified {
+
+    use nostr::ToBech32;
+
     use super::*;
+
     fn cli_tester_create_proposal(git_repo: &GitTestRepo) -> CliTester {
+        let proposal_root_bech32 = get_pretend_proposal_root_event().id.to_bech32().unwrap();
         let args = vec![
             "--nsec",
             TEST_KEY_1_NSEC,
@@ -1296,7 +1301,8 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
             "send",
             "HEAD~2",
             "--in-reply-to",
-            "nevent1qqsypm62fzw7qynvlc4gjl3tr0jw4vmh659nvr2cc5qyhdg92a5yy0qzypumuen7l8wthtz45p3ftn58pvrs9xlumvkuu2xet8egzkcklqtesxygzam",
+            &proposal_root_bech32,
+            // "nevent1qqsged665nx6zz36puey9hzf6ds4n5ctxxzm7c6pfnmvu9l4c9988vgzyr6nuj7d02wdauzfeajx043c5yepjk9v6wm3avycy07kltdsy0tksh0zxyx",
             "--title",
             "exampletitle",
             "--description",
@@ -1305,7 +1311,12 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
         CliTester::new_from_dir(&git_repo.dir, args)
     }
     fn expect_msgs_first(p: &mut CliTester, include_cover_letter: bool) -> Result<()> {
-        p.expect("creating proposal revision for: nevent1qqsypm62fzw7qynvlc4gjl3tr0jw4vmh659nvr2cc5qyhdg92a5yy0qzypumuen7l8wthtz45p3ftn58pvrs9xlumvkuu2xet8egzkcklqtesxygzam\r\n")?;
+        let proposal_root_bech32 = get_pretend_proposal_root_event().id.to_bech32().unwrap();
+        p.expect(format!(
+            "creating proposal revision for: {}\r\n",
+            proposal_root_bech32,
+        ))?;
+        // p.expect("creating proposal revision for: nevent1qqsged665nx6zz36puey9hzf6ds4n5ctxxzm7c6pfnmvu9l4c9988vgzyr6nuj7d02wdauzfeajx043c5yepjk9v6wm3avycy07kltdsy0tksh0zxyx\r\n")?;
         p.expect("creating proposal from 2 commits:\r\n")?;
         p.expect("fe973a8 add t4.md\r\n")?;
         p.expect("232efb3 add t3.md\r\n")?;
@@ -1343,6 +1354,7 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
                         &vec![
                             generate_test_key_1_metadata_event("fred"),
                             generate_test_key_1_relay_list_event(),
+                            get_pretend_proposal_root_event(),
                         ],
                     )?;
                     Ok(())
@@ -1357,7 +1369,7 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
                     relay.respond_events(
                         client_id,
                         &subscription_id,
-                        &vec![generate_repo_ref_event()],
+                        &vec![generate_repo_ref_event(), get_pretend_proposal_root_event()],
                     )?;
                     Ok(())
                 }),
@@ -1405,6 +1417,7 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
                             &vec![
                                 generate_test_key_1_metadata_event("fred"),
                                 generate_test_key_1_relay_list_event(),
+                                get_pretend_proposal_root_event(),
                             ],
                         )?;
                         Ok(())
@@ -1419,7 +1432,7 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
                         relay.respond_events(
                             client_id,
                             &subscription_id,
-                            &vec![generate_repo_ref_event()],
+                            &vec![generate_repo_ref_event(), get_pretend_proposal_root_event()],
                         )?;
                         Ok(())
                     }),
@@ -1430,7 +1443,6 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
             // // check relay had the right number of events
             let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
                 let mut p = cli_tester_create_proposal(&git_repo);
-
                 expect_msgs_first(&mut p, true)?;
                 relay::expect_send_with_progress(
                     &mut p,
@@ -1516,7 +1528,7 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
                         .unwrap()
                         .as_vec()[1],
                     // id of state nevent
-                    "40ef4a489de0126cfe2a897e2b1be4eab377d50b360d58c5004bb5055768423c",
+                    "8cb75aa4cda10a3a0f3242dc49d36159d30b3185bf63414cf6ce17f5c14a73b1",
                 );
             }
             Ok(())
@@ -1552,3 +1564,251 @@ mod in_reply_to_specified_with_range_of_head_2_and_cover_letter_details_specifie
         Ok(())
     }
 }
+
+mod in_reply_to_mentions_issue {
+    use nostr::ToBech32;
+
+    use super::*;
+    pub fn get_pretend_issue_event() -> nostr::Event {
+        serde_json::from_str(r#"{"created_at":1709286372,"content":"please provide feedback\nthis is an example ngit issue to demonstrate gitworkshop.dev.\n\nplease provide feedback with in reply to this issue or by creating a new issue.","tags":[["r","26689f97810fc656c7134c76e2a37d33b2e40ce7"],["a","30617:a008def15796fba9a0d6fab04e8fd57089285d9fd505da5a83fe8aad57a3564d:ngit","wss://relay.damus.io","root"],["p","a008def15796fba9a0d6fab04e8fd57089285d9fd505da5a83fe8aad57a3564d"]],"kind":1621,"pubkey":"a008def15796fba9a0d6fab04e8fd57089285d9fd505da5a83fe8aad57a3564d","id":"e944765d625ae7323d080da0df069c726a0e5490a17b452f854d85e18f781588","sig":"a1af9e89a35f1f7ef93e3de33986bd86cb7c4d7d9abb233c0c6405f32b5788171e47f84551afe8515b3107d12f03472721ea784b8791ff3f25e66a3169a54c20"}"#).unwrap()
+    }
+
+    fn cli_tester_create_proposal(git_repo: &GitTestRepo) -> CliTester {
+        let proposal_root_bech32 = get_pretend_issue_event().id.to_bech32().unwrap();
+        let args = vec![
+            "--nsec",
+            TEST_KEY_1_NSEC,
+            "--password",
+            TEST_PASSWORD,
+            "--disable-cli-spinners",
+            "send",
+            "HEAD~2",
+            "--in-reply-to",
+            &proposal_root_bech32,
+            // "note1a9z8vhtzttnny0ggpksd7p5uwf4qu4ys59a52tu9fkz7rrmczkyqc46ngg",
+            "--title",
+            "exampletitle",
+            "--description",
+            "exampledescription",
+        ];
+        CliTester::new_from_dir(&git_repo.dir, args)
+    }
+
+    async fn prep_run_create_proposal() -> Result<(
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+    )> {
+        let git_repo = prep_git_repo()?;
+        // fallback (51,52) user write (53, 55) repo (55, 56)
+        let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+            Relay::new(
+                8051,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![
+                            generate_test_key_1_metadata_event("fred"),
+                            generate_test_key_1_relay_list_event(),
+                            get_pretend_issue_event(),
+                        ],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8052, None, None),
+            Relay::new(8053, None, None),
+            Relay::new(
+                8055,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![generate_repo_ref_event(), get_pretend_issue_event()],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8056, None, None),
+        );
+
+        // // check relay had the right number of events
+        let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+            let mut p = cli_tester_create_proposal(&git_repo);
+            p.expect_end_eventually()?;
+            for p in [51, 52, 53, 55, 56] {
+                relay::shutdown_relay(8000 + p)?;
+            }
+            Ok(())
+        });
+
+        // launch relay
+        let _ = join!(
+            r51.listen_until_close(),
+            r52.listen_until_close(),
+            r53.listen_until_close(),
+            r55.listen_until_close(),
+            r56.listen_until_close(),
+        );
+        cli_tester_handle.join().unwrap()?;
+        Ok((r51, r52, r53, r55, r56))
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn issue_event_mentioned_in_tagged_cover_letter() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+        for relay in [&r53, &r55, &r56] {
+            let cover_letter_event: &nostr::Event =
+                relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
+            assert!(cover_letter_event.iter_tags().any(|t| {
+                t.as_vec()[0].eq("e")
+                    && t.as_vec()[1].eq(&get_pretend_issue_event().id.to_hex())
+                    && t.as_vec()[3].eq(&"mention")
+            }));
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn isnt_tagged_as_revision() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+        for relay in [&r53, &r55, &r56] {
+            let cover_letter_event: &nostr::Event =
+                relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
+            assert!(
+                !cover_letter_event
+                    .iter_tags()
+                    .any(|t| { t.as_vec()[0].eq("t") && t.as_vec()[1].eq(&"revision-root") })
+            );
+        }
+        Ok(())
+    }
+}
+mod in_reply_to_mentions_npub_and_nprofile_which_get_mentioned_in_proposal_root {
+    use nostr::JsonUtil;
+
+    use super::*;
+
+    fn cli_tester_create_proposal(git_repo: &GitTestRepo) -> CliTester {
+        let args = vec![
+            "--nsec",
+            TEST_KEY_1_NSEC,
+            "--password",
+            TEST_PASSWORD,
+            "--disable-cli-spinners",
+            "send",
+            "HEAD~2",
+            "--in-reply-to",
+            // nsec1q3c5xnsm5m4wgsrhwnz04p0d5mevkryyggqgdpa9jwulpq9gldhswgtxvq
+            "npub1knxeegzqg0xqflsryvg7l7x7nmpe7kd7pl7zazug0a7t99tdsphszuyapx",
+            // nsec1nx5ulvcndhcuu8k6q8fenw50l6y75sec7pj8vr0r68l6a44w3lqspvj02k
+            "nprofile1qqsvru3yqrec6dxjn06f8cjh79jcu9wyaxu4y6v47yzpsx7vjm4xcuc33z2n3",
+            "--title",
+            "exampletitle",
+            "--description",
+            "exampledescription",
+        ];
+        CliTester::new_from_dir(&git_repo.dir, args)
+    }
+
+    async fn prep_run_create_proposal() -> Result<(
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+    )> {
+        let git_repo = prep_git_repo()?;
+        // fallback (51,52) user write (53, 55) repo (55, 56)
+        let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+            Relay::new(
+                8051,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![
+                            generate_test_key_1_metadata_event("fred"),
+                            generate_test_key_1_relay_list_event(),
+                        ],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8052, None, None),
+            Relay::new(8053, None, None),
+            Relay::new(
+                8055,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![generate_repo_ref_event()],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8056, None, None),
+        );
+
+        // // check relay had the right number of events
+        let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+            let mut p = cli_tester_create_proposal(&git_repo);
+            p.expect_end_eventually()?;
+            for p in [51, 52, 53, 55, 56] {
+                relay::shutdown_relay(8000 + p)?;
+            }
+            Ok(())
+        });
+
+        // launch relay
+        let _ = join!(
+            r51.listen_until_close(),
+            r52.listen_until_close(),
+            r53.listen_until_close(),
+            r55.listen_until_close(),
+            r56.listen_until_close(),
+        );
+        cli_tester_handle.join().unwrap()?;
+        Ok((r51, r52, r53, r55, r56))
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn npub_and_nprofile_mentioned_in_tagged_cover_letter() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+        for relay in [&r53, &r55, &r56] {
+            let cover_letter_event: &nostr::Event =
+                relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
+            println!("{:?}", &cover_letter_event.as_json());
+            assert!(cover_letter_event.iter_tags().any(|t| {
+                t.as_vec()[0].eq("p")
+                    && t.as_vec()[1].eq(&nostr::Keys::parse(
+                        "nsec1q3c5xnsm5m4wgsrhwnz04p0d5mevkryyggqgdpa9jwulpq9gldhswgtxvq",
+                    )
+                    .unwrap()
+                    .public_key()
+                    .to_hex())
+            }));
+            assert!(cover_letter_event.iter_tags().any(|t| {
+                t.as_vec()[0].eq("p")
+                    && t.as_vec()[1].eq(&nostr::Keys::parse(
+                        "nsec1nx5ulvcndhcuu8k6q8fenw50l6y75sec7pj8vr0r68l6a44w3lqspvj02k",
+                    )
+                    .unwrap()
+                    .public_key()
+                    .to_hex())
+            }));
+        }
+        Ok(())
+    }
+}