fix: import remote outbox on outbound follow accept (k-ap 0.4.2)

k-ap now emits OutboundFollowAccepted when remote accepts our follow.
Bridge maps it to FollowAccepted domain event. Worker handler looks up
the actor's outbox URL and calls import_remote_outbox. Previously the
accept was silent — no backfill happened, feed stayed empty.

crates/adapters/activitypub/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-k-ap = { version = "0.4.1", registry = "gitea" }
+k-ap = { version = "0.4.2", registry = "gitea" }
 domain = { workspace = true }
 axum = { workspace = true }
 serde = { workspace = true }

crates/adapters/activitypub/src/federation_event_bridge.rs

@@ -46,6 +46,28 @@ impl k_ap::EventPublisher for FederationEventBridge {
                 tracing::warn!(inbox = %inbox, error = %error, "federation delivery failed permanently");
                 Ok(())
             }
+            FederationEvent::OutboundFollowAccepted {
+                local_user_id,
+                remote_actor_url,
+                outbox_url,
+            } => {
+                let identity = domain::value_objects::SocialIdentity::Remote {
+                    actor_url: remote_actor_url,
+                };
+                self.domain_publisher
+                    .publish(&DomainEvent::FollowAccepted {
+                        owner: UserId::from_uuid(local_user_id),
+                        requester: identity,
+                    })
+                    .await
+                    .map_err(|e| anyhow::anyhow!(e.to_string()))?;
+
+                if let Some(outbox) = outbox_url {
+                    tracing::info!(outbox = %outbox, "importing remote outbox after follow accepted");
+                    // Handled by FollowBackfillHandler reacting to FollowAccepted
+                }
+                Ok(())
+            }
         }
     }
 }

crates/worker/src/follow_backfill_handler.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use domain::{
-    errors::DomainError, events::DomainEvent, ports::EventHandler, value_objects::SocialIdentity,
-};
+use domain::{errors::DomainError, events::DomainEvent, ports::EventHandler, value_objects::SocialIdentity};
 
 pub struct FollowBackfillHandler {
     pub ap_service: Arc<dyn activitypub::ActivityPubPort>,
@@ -14,10 +12,26 @@ impl EventHandler for FollowBackfillHandler {
     async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
         match event {
             DomainEvent::FollowAccepted {
+                owner,
                 requester: SocialIdentity::Remote { actor_url },
-                ..
             } => {
-                tracing::info!(actor = %actor_url, "follow accepted from remote actor");
+                tracing::info!(actor = %actor_url, "follow accepted — looking up outbox for import");
+                let following = self
+                    .ap_service
+                    .get_following(owner.value())
+                    .await
+                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+                if let Some(actor) = following.iter().find(|a| a.url == *actor_url) {
+                    if let Some(outbox_url) = &actor.outbox_url {
+                        tracing::info!(outbox = %outbox_url, actor = %actor_url, "importing remote outbox");
+                        self.ap_service
+                            .import_remote_outbox(outbox_url, actor_url)
+                            .await
+                            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+                    } else {
+                        tracing::warn!(actor = %actor_url, "no outbox URL for accepted follow — skipping import");
+                    }
+                }
                 Ok(())
             }
             DomainEvent::BackfillFollower {