Revert "feat: upgrade repo to Full sync and trigger PR event subscription after announcement promotion"

This reverts commit d76003b629a4a03dba23a8a1c41da6e4ac4c30cf.

2 files changed, 0 insertions, 155 deletions

diff --git a/src/nostr/builder.rs b/src/nostr/builder.rs
index 4c66f6d..aff12a6 100644
--- a/src/nostr/builder.rs
+++ b/src/nostr/builder.rs
@@ -98,24 +98,6 @@ impl Nip34WritePolicy {
         self.ctx.set_local_relay(relay);
     }
 
-    /// Set the repo sync index for relay discovery from user-submitted purgatory announcements.
-    ///
-    /// When a user submits an announcement that goes to purgatory (no git data yet),
-    /// the relay needs to discover and connect to relays listed in the announcement's
-    /// `relays` and `clone` tags. This index is updated when the announcement is accepted
-    /// into purgatory, triggering the sync system to connect and sync state events.
-    pub fn set_repo_sync_index(&self, index: crate::sync::RepoSyncIndex) {
-        self.ctx.set_repo_sync_index(index);
-    }
-
-    /// Set the sync action sender for sending AddFilters actions to SyncManager.
-    ///
-    /// This allows the write policy to notify the SyncManager when user-submitted
-    /// purgatory announcements need relay discovery (triggering new connections).
-    pub fn set_sync_action_tx(&self, tx: tokio::sync::mpsc::Sender<crate::sync::AddFilters>) {
-        self.ctx.set_sync_action_tx(tx);
-    }
-
     /// Handle repository announcement event
     async fn handle_announcement(&self, event: &Event) -> WritePolicyResult {
         let event_id_str = event.id.to_bech32().unwrap_or_else(|_| event.id.to_hex());
@@ -164,106 +146,6 @@ impl Nip34WritePolicy {
                             "Accepted announcement to purgatory: {} (waiting for git data)",
                             event_id_str
                         );
-
-                        // Register in repo_sync_index with StateOnly level so the sync
-                        // system discovers and connects to relays listed in this announcement.
-                        // This is needed for user-submitted announcements (not via sync path)
-                        // to trigger relay discovery and state event sync.
-                        if let Some(repo_sync_index) = self.ctx.get_repo_sync_index() {
-                            if let Some(identifier) = event.tags.iter().find_map(|tag| {
-                                let tag_vec = tag.as_slice();
-                                if tag_vec.len() >= 2 && tag_vec[0] == "d" {
-                                    Some(tag_vec[1].to_string())
-                                } else {
-                                    None
-                                }
-                            }) {
-                                let repo_id =
-                                    format!("30617:{}:{}", event.pubkey, identifier);
-
-                                // Get relay URLs stored in purgatory for this announcement
-                                let relays = self
-                                    .ctx
-                                    .purgatory
-                                    .find_announcement(&event.pubkey, &identifier)
-                                    .map(|entry| entry.relays)
-                                    .unwrap_or_default();
-
-                                if !relays.is_empty() {
-                                    use crate::sync::{
-                                        AddFilters, PendingItems, RepoSyncNeeds, SyncLevel,
-                                    };
-
-                                    // Update repo_sync_index with StateOnly for this repo
-                                    let new_repos = {
-                                        let mut index = repo_sync_index.write().await;
-                                        let entry =
-                                            index.entry(repo_id.clone()).or_insert_with(|| {
-                                                RepoSyncNeeds {
-                                                    relays: std::collections::HashSet::new(),
-                                                    root_events: std::collections::HashSet::new(),
-                                                    sync_level: SyncLevel::StateOnly,
-                                                }
-                                            });
-                                        entry.relays.extend(relays.iter().cloned());
-                                        // Don't upgrade if already Full
-                                        tracing::info!(
-                                            repo_id = %repo_id,
-                                            relay_count = entry.relays.len(),
-                                            "Registered user-submitted purgatory announcement in \
-                                             RepoSyncIndex with StateOnly level for relay discovery"
-                                        );
-                                        // Return cloned relays for AddFilters
-                                        relays.clone()
-                                    };
-
-                                    // Send AddFilters to SyncManager so it connects to these relays
-                                    if let Some(tx) = self.ctx.get_sync_action_tx() {
-                                        // Build state-only filters for this repo
-                                        let state_only_repos: std::collections::HashSet<String> =
-                                            std::iter::once(repo_id.clone()).collect();
-                                        let filters =
-                                            crate::sync::filters::build_sync_level_aware_filters(
-                                                &std::collections::HashSet::new(),
-                                                &state_only_repos,
-                                                &std::collections::HashSet::new(),
-                                                None,
-                                            );
-
-                                        for relay_url in new_repos {
-                                            // Skip our own domain
-                                            if relay_url.contains(&self.ctx.domain) {
-                                                continue;
-                                            }
-                                            let action = AddFilters {
-                                                relay_url: relay_url.clone(),
-                                                items: PendingItems {
-                                                    repos: state_only_repos.clone(),
-                                                    root_events: std::collections::HashSet::new(),
-                                                },
-                                                filters: filters.clone(),
-                                            };
-                                            if let Err(e) = tx.send(action).await {
-                                                tracing::warn!(
-                                                    relay = %relay_url,
-                                                    error = %e,
-                                                    "Failed to send AddFilters action for \
-                                                     user-submitted purgatory announcement"
-                                                );
-                                            } else {
-                                                tracing::info!(
-                                                    relay = %relay_url,
-                                                    repo_id = %repo_id,
-                                                    "Sent AddFilters to SyncManager for \
-                                                     user-submitted purgatory announcement relay"
-                                                );
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
                         WritePolicyResult::Reject {
                             status: true, // Client sees OK
                             message: "purgatory: won't be served until git data arrives".into(),
diff --git a/src/nostr/policy/mod.rs b/src/nostr/policy/mod.rs
index 78a09fc..1566b6c 100644
--- a/src/nostr/policy/mod.rs
+++ b/src/nostr/policy/mod.rs
@@ -20,7 +20,6 @@ pub use crate::git::sync::AlignmentResult;
 
 use super::SharedDatabase;
 use crate::purgatory::Purgatory;
-use crate::sync::{AddFilters, RepoSyncIndex};
 use nostr_relay_builder::LocalRelay;
 use std::sync::Arc;
 
@@ -35,16 +34,6 @@ pub struct PolicyContext {
     pub local_relay: Arc<std::sync::RwLock<Option<LocalRelay>>>,
     /// Configuration reference for policy settings (includes blacklists)
     pub config: crate::config::Config,
-    /// Optional repo sync index for triggering relay discovery when announcements
-    /// go to purgatory via user submission (not via the sync path).
-    /// Wrapped in Arc<RwLock> for interior mutability (PolicyContext is Clone).
-    pub repo_sync_index: Arc<std::sync::RwLock<Option<RepoSyncIndex>>>,
-    /// Optional sender for AddFilters actions to SyncManager.
-    /// Used to trigger relay discovery when user-submitted purgatory announcements
-    /// are registered with StateOnly sync level.
-    /// Wrapped in Arc<RwLock> for interior mutability (PolicyContext is Clone).
-    pub sync_action_tx:
-        Arc<std::sync::RwLock<Option<tokio::sync::mpsc::Sender<AddFilters>>>>,
 }
 
 impl PolicyContext {
@@ -62,8 +51,6 @@ impl PolicyContext {
             purgatory,
             local_relay: Arc::new(std::sync::RwLock::new(None)),
             config,
-            repo_sync_index: Arc::new(std::sync::RwLock::new(None)),
-            sync_action_tx: Arc::new(std::sync::RwLock::new(None)),
         }
     }
 
@@ -81,28 +68,4 @@ impl PolicyContext {
         let guard = self.local_relay.read().unwrap();
         guard.clone()
     }
-
-    /// Set the repo sync index for relay discovery from user-submitted purgatory announcements.
-    pub fn set_repo_sync_index(&self, index: RepoSyncIndex) {
-        let mut guard = self.repo_sync_index.write().unwrap();
-        *guard = Some(index);
-    }
-
-    /// Get a clone of the repo sync index if it's been set.
-    pub fn get_repo_sync_index(&self) -> Option<RepoSyncIndex> {
-        let guard = self.repo_sync_index.read().unwrap();
-        guard.clone()
-    }
-
-    /// Set the sync action sender for sending AddFilters actions to SyncManager.
-    pub fn set_sync_action_tx(&self, tx: tokio::sync::mpsc::Sender<AddFilters>) {
-        let mut guard = self.sync_action_tx.write().unwrap();
-        *guard = Some(tx);
-    }
-
-    /// Get a clone of the sync action sender if it's been set.
-    pub fn get_sync_action_tx(&self) -> Option<tokio::sync::mpsc::Sender<AddFilters>> {
-        let guard = self.sync_action_tx.read().unwrap();
-        guard.clone()
-    }
 }