From 6e680c56496fb038ea40900c6b1126e4ef051efe Mon Sep 17 00:00:00 2001
From: DanConwayDev <DanConwayDev@protonmail.com>
Date: Wed, 14 Jan 2026 15:11:16 +0000
Subject: [PATCH] Integrate event restoration and cleanup into recovery flow

---
 src/nostr/builder.rs | 73 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 72 insertions(+), 1 deletion(-)

diff --git a/src/nostr/builder.rs b/src/nostr/builder.rs
index ecbba3b..d1c8842 100644
--- a/src/nostr/builder.rs
+++ b/src/nostr/builder.rs
@@ -152,7 +152,78 @@ impl Nip34WritePolicy {
                                                 announcement.owner_npub(),
                                                 announcement.identifier
                                             );
-                                            // Note: Event restoration will be handled in Phase 4B
+
+                                            // Restore events from holding database
+                                            let event_ids: Vec<_> =
+                                                recovery_info.events.iter().map(|e| e.id).collect();
+
+                                            match holding_db
+                                                .restore_events_to_main(
+                                                    &self.ctx.database,
+                                                    &event_ids,
+                                                )
+                                                .await
+                                            {
+                                                Ok(result) => {
+                                                    tracing::info!(
+                                                        "Restored {} events from holding database for {}/{}",
+                                                        result.restored_count,
+                                                        announcement.owner_npub(),
+                                                        announcement.identifier
+                                                    );
+
+                                                    if result.failed_count > 0 {
+                                                        tracing::warn!(
+                                                            "Failed to restore {} events for {}/{}",
+                                                            result.failed_count,
+                                                            announcement.owner_npub(),
+                                                            announcement.identifier
+                                                        );
+                                                    }
+
+                                                    // Cleanup archive files after successful recovery
+                                                    match crate::git::archive::cleanup_after_recovery(
+                                                        &recovery_info.archive_path,
+                                                        &announcement.owner_npub(),
+                                                        &announcement.identifier,
+                                                    ) {
+                                                        Ok(stats) => {
+                                                            tracing::info!(
+                                                                "Cleaned up archive for {}/{}: {} bytes reclaimed",
+                                                                announcement.owner_npub(),
+                                                                announcement.identifier,
+                                                                stats.bytes_reclaimed
+                                                            );
+                                                        }
+                                                        Err(e) => {
+                                                            tracing::warn!(
+                                                                "Failed to cleanup archive for {}/{}: {}",
+                                                                announcement.owner_npub(),
+                                                                announcement.identifier,
+                                                                e
+                                                            );
+                                                        }
+                                                    }
+
+                                                    // Delete events from holding database
+                                                    let deleted_count =
+                                                        holding_db.delete_events(&event_ids).await;
+                                                    tracing::info!(
+                                                        "Deleted {} events from holding database for {}/{}",
+                                                        deleted_count,
+                                                        announcement.owner_npub(),
+                                                        announcement.identifier
+                                                    );
+                                                }
+                                                Err(e) => {
+                                                    tracing::warn!(
+                                                        "Failed to restore events for {}/{}: {}",
+                                                        announcement.owner_npub(),
+                                                        announcement.identifier,
+                                                        e
+                                                    );
+                                                }
+                                            }
                                         }
                                         Err(e) => {
                                             tracing::warn!(