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());
+    }
 }