sync PR refs (refs/nostr/<event-id>) to all owner repos when push received

When a push to refs/nostr/<event-id> is received (PR data), the git data
is now synced to all other owner repositories that share maintainers with
the source owner. This mirrors the behavior added for state event data.

Changes:
- Add sync_pr_refs_to_owner_repos() function in git/sync.rs
- Add PrSyncResult struct to track sync statistics
- Add copy_single_commit_between_repos() helper function
- Call PR sync in handle_receive_pack after successful push
- Add unit test for PrSyncResult default values

2 files changed, 271 insertions, 2 deletions

diff --git a/src/git/handlers.rs b/src/git/handlers.rs
index e86d2a3..23a15ba 100644
--- a/src/git/handlers.rs
+++ b/src/git/handlers.rs
@@ -15,8 +15,8 @@ use super::protocol::{GitService, PktLine};
 use super::subprocess::GitSubprocess;
 use super::try_set_head_if_available;
 
-use crate::git::authorization::{authorize_push, fetch_repository_data};
-use crate::git::sync::sync_to_owner_repos;
+use crate::git::authorization::{authorize_push, fetch_repository_data, parse_pushed_refs};
+use crate::git::sync::{sync_pr_refs_to_owner_repos, sync_to_owner_repos};
 use crate::nostr::builder::SharedDatabase;
 use crate::nostr::events::{KIND_PR, KIND_PR_UPDATE, KIND_REPOSITORY_STATE};
 use crate::purgatory::Purgatory;
@@ -383,6 +383,54 @@ pub async fn handle_receive_pack(
         }
     }
 
+    // Sync PR data (refs/nostr/<event-id>) to other owner repositories
+    // Parse pushed refs to find refs/nostr/* refs
+    let pushed_refs = parse_pushed_refs(&request_body);
+    let pr_refs: Vec<(String, String)> = pushed_refs
+        .iter()
+        .filter_map(|(_, new_oid, ref_name)| {
+            ref_name.strip_prefix("refs/nostr/").map(|event_id| {
+                (event_id.to_string(), new_oid.clone())
+            })
+        })
+        .collect();
+
+    if !pr_refs.is_empty() {
+        match fetch_repository_data(&database, identifier).await {
+            Ok(db_repo_data) => {
+                let git_data_path_buf = std::path::PathBuf::from(git_data_path);
+                let pr_sync_result = sync_pr_refs_to_owner_repos(
+                    &repo_path,
+                    &pr_refs,
+                    &db_repo_data,
+                    &git_data_path_buf,
+                    owner_pubkey,
+                );
+
+                if pr_sync_result.repos_synced > 0 {
+                    info!(
+                        "Synced {} PR refs to {} other owner repositories for {}",
+                        pr_sync_result.refs_created,
+                        pr_sync_result.repos_synced,
+                        identifier
+                    );
+                }
+
+                if !pr_sync_result.errors.is_empty() {
+                    for (repo, error) in &pr_sync_result.errors {
+                        warn!("Error syncing PR ref to {}: {}", repo, error);
+                    }
+                }
+            }
+            Err(e) => {
+                warn!(
+                    "Failed to fetch repository data for PR sync after push to {}: {}",
+                    identifier, e
+                );
+            }
+        }
+    }
+
     Ok(Response::builder()
         .status(StatusCode::OK)
         .header(
diff --git a/src/git/sync.rs b/src/git/sync.rs
index c99eb43..998f490 100644
--- a/src/git/sync.rs
+++ b/src/git/sync.rs
@@ -7,6 +7,8 @@
 //!    copied to other owner repos that authorize the same state
 //! 2. Purgatory sync fetches git data from remote - needs to distribute to all
 //!    authorized owner repos
+//! 3. A push to refs/nostr/<event-id> (PR data) is received - needs to be synced
+//!    to all other owner repos that share maintainers
 //!
 //! ## Architecture
 //!
@@ -54,6 +56,217 @@ pub struct AlignmentResult {
     pub head_set: bool,
 }
 
+/// Result of syncing PR refs to owner repositories
+#[derive(Debug, Default)]
+pub struct PrSyncResult {
+    /// Number of repositories synced
+    pub repos_synced: usize,
+    /// Number of refs created across all repos
+    pub refs_created: usize,
+    /// Errors encountered (repo path -> error message)
+    pub errors: Vec<(String, String)>,
+}
+
+/// Sync PR data (refs/nostr/<event-id>) from a source repository to all other
+/// owner repositories that share maintainers.
+///
+/// This function:
+/// 1. Collects all authorized maintainers per owner from announcements
+/// 2. For each owner that shares at least one maintainer with the source owner:
+///    - Copies missing OIDs for the PR commits
+///    - Creates the refs/nostr/<event-id> ref pointing to the same commit
+///
+/// # Arguments
+/// * `source_repo_path` - Path to the repository that has the PR git data
+/// * `pr_refs` - List of (event_id, commit_hash) tuples for PR refs that were pushed
+/// * `db_repo_data` - Repository data from database (announcements + states)
+/// * `git_data_path` - Base path for git repositories
+/// * `source_owner_pubkey` - The owner pubkey of the source repository
+///
+/// # Returns
+/// A `PrSyncResult` with statistics about what was synced
+pub fn sync_pr_refs_to_owner_repos(
+    source_repo_path: &Path,
+    pr_refs: &[(String, String)], // (event_id, commit_hash)
+    db_repo_data: &RepositoryData,
+    git_data_path: &Path,
+    source_owner_pubkey: &str,
+) -> PrSyncResult {
+    let mut result = PrSyncResult::default();
+
+    if pr_refs.is_empty() {
+        return result;
+    }
+
+    // Collect authorized maintainers per owner
+    let by_owner = collect_authorized_maintainers(&db_repo_data.announcements);
+
+    // Get the maintainer set for the source owner
+    let source_maintainers = match by_owner.get(source_owner_pubkey) {
+        Some(maintainers) => maintainers,
+        None => {
+            debug!(
+                "No maintainer set found for source owner {}",
+                source_owner_pubkey
+            );
+            return result;
+        }
+    };
+
+    debug!(
+        source_owner = %source_owner_pubkey,
+        pr_refs_count = pr_refs.len(),
+        owners = by_owner.len(),
+        "Syncing PR refs to owner repositories"
+    );
+
+    for (owner, maintainers) in &by_owner {
+        // Skip the source owner - we already have the data there
+        if owner == source_owner_pubkey {
+            continue;
+        }
+
+        // Check if this owner shares any maintainers with the source owner
+        // (i.e., there's overlap in their maintainer sets)
+        let has_shared_maintainer = maintainers.iter().any(|m| source_maintainers.contains(m));
+
+        if !has_shared_maintainer {
+            debug!(
+                owner = %owner,
+                "Skipping owner - no shared maintainers with source"
+            );
+            continue;
+        }
+
+        // Find the announcement for this owner
+        let announcement = db_repo_data
+            .announcements
+            .iter()
+            .find(|a| a.event.pubkey.to_hex() == *owner);
+
+        let Some(announcement) = announcement else {
+            continue;
+        };
+
+        let target_repo_path = git_data_path.join(announcement.repo_path());
+
+        if !target_repo_path.exists() {
+            debug!(
+                owner = %owner,
+                repo_path = %target_repo_path.display(),
+                "Skipping owner - repository doesn't exist"
+            );
+            continue;
+        }
+
+        // Sync each PR ref
+        let mut refs_created_for_owner = 0;
+        for (event_id, commit_hash) in pr_refs {
+            // Copy the commit if missing
+            if !oid_exists(&target_repo_path, commit_hash) {
+                if let Err(e) =
+                    copy_single_commit_between_repos(source_repo_path, &target_repo_path, commit_hash)
+                {
+                    warn!(
+                        event_id = %event_id,
+                        source = %source_repo_path.display(),
+                        target = %target_repo_path.display(),
+                        error = %e,
+                        "Failed to copy PR commit between repos"
+                    );
+                    result
+                        .errors
+                        .push((target_repo_path.display().to_string(), e));
+                    continue;
+                }
+            }
+
+            // Create the refs/nostr/<event-id> ref
+            let ref_name = format!("refs/nostr/{}", event_id);
+            match git::update_ref(&target_repo_path, &ref_name, commit_hash) {
+                Ok(()) => {
+                    info!(
+                        event_id = %event_id,
+                        commit = %commit_hash,
+                        target = %target_repo_path.display(),
+                        "Created PR ref in target repository"
+                    );
+                    refs_created_for_owner += 1;
+                }
+                Err(e) => {
+                    warn!(
+                        event_id = %event_id,
+                        target = %target_repo_path.display(),
+                        error = %e,
+                        "Failed to create PR ref in target repository"
+                    );
+                    result.errors.push((target_repo_path.display().to_string(), e));
+                }
+            }
+        }
+
+        if refs_created_for_owner > 0 {
+            result.repos_synced += 1;
+            result.refs_created += refs_created_for_owner;
+
+            info!(
+                owner = %owner,
+                repo_path = %target_repo_path.display(),
+                refs_created = refs_created_for_owner,
+                "Synced PR refs to owner repository"
+            );
+        }
+    }
+
+    info!(
+        repos_synced = result.repos_synced,
+        refs_created = result.refs_created,
+        errors = result.errors.len(),
+        "Completed PR ref sync to owner repositories"
+    );
+
+    result
+}
+
+/// Copy a single commit from source repository to target repository
+fn copy_single_commit_between_repos(
+    source_repo: &Path,
+    target_repo: &Path,
+    commit_hash: &str,
+) -> Result<(), String> {
+    debug!(
+        "Copying commit {} from {} to {}",
+        commit_hash,
+        source_repo.display(),
+        target_repo.display()
+    );
+
+    let output = Command::new("git")
+        .args([
+            "fetch",
+            source_repo.to_str().ok_or("Invalid source path")?,
+            commit_hash,
+        ])
+        .current_dir(target_repo)
+        .output()
+        .map_err(|e| format!("Failed to execute git fetch: {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!(
+            "git fetch failed for commit {}: {}",
+            commit_hash, stderr
+        ));
+    }
+
+    debug!(
+        "Copied commit {} to {}",
+        commit_hash,
+        target_repo.display()
+    );
+    Ok(())
+}
+
 /// Sync git data from a source repository to all other owner repositories
 /// that authorize the given state event.
 ///
@@ -450,4 +663,12 @@ mod tests {
         assert_eq!(result.refs_deleted, 0);
         assert!(!result.head_set);
     }
+
+    #[test]
+    fn test_pr_sync_result_default() {
+        let result = PrSyncResult::default();
+        assert_eq!(result.repos_synced, 0);
+        assert_eq!(result.refs_created, 0);
+        assert!(result.errors.is_empty());
+    }
 }