fix: portal wrapup share card to escape transform stacking context

- filter wrapup top directors/actors with count < 2
- add watch_medium to wrapup report + adapters
- profile trends: genre breakdown, rating histogram, watch medium dist
- fix unused StarDisplay import in movie detail

.github/workflows/ci.yml

@@ -57,8 +57,8 @@ jobs:
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_TOKEN || github.token }}
 
       - name: Docker metadata
         id: meta

.gitignore

@@ -14,6 +14,7 @@
 .worktrees/
 .superpowers/
 docs/
+!docs/adr/
 
 imgs/
 .sqlx/

CONTEXT.md

@@ -4,10 +4,62 @@ A personal movie diary that tracks what you watch, when, and what you thought ab
 
 ## Language
 
+**Movie**:
+A film in the catalog, identified by title and release year. Optionally linked to an external metadata provider (e.g. TMDb) for enrichment. One Movie record is shared across all users — "Blade Runner (1982)" exists once regardless of how many people review it.
+_Avoid_: Film entry, title record
+
+**Person**:
+Someone involved in making a movie — actor, director, crew member. Sourced from an external metadata provider and enriched with biographical data. Linked to Movies through cast/crew credits. Not a User — Person is movie-industry people only.
+_Avoid_: Celebrity, artist, talent
+
 **Review**:
 A single record of watching a movie — captures the rating, optional comment, when it was watched, and how it was watched.
 _Avoid_: Diary entry, watch, log entry
 
+**Rating**:
+A 1–5 whole-star score given to a movie in a Review. No half-stars, no zero.
+_Avoid_: Score, grade, stars (as a noun for the value itself)
+
 **WatchMedium**:
 The channel through which a movie was watched: Cinema, Streaming, TV, PhysicalMedia, Download, MediaServer, or Other.
 _Avoid_: Source, format, venue, platform
+
+**Watchlist**:
+A user's collection of movies they intend to watch. Each item is a simple bookmark — no priority or ordering. A movie leaves the watchlist implicitly when reviewed, or explicitly when removed.
+_Avoid_: Queue, backlog, to-watch list
+
+**Goal**:
+A yearly target a user sets — e.g. "watch 50 movies in 2025." Progress is tracked automatically as reviews are logged. Currently only supports movie-count goals, but the model is designed for other goal types in the future.
+_Avoid_: Challenge, resolution, target
+
+**WrapUp**:
+A generated summary report of viewing activity over a date range — statistics, trends, highlights, top directors/actors/genres. Can be personal (one user) or global (all users). Generated asynchronously. Shown to users as "Year in Review."
+_Avoid_: Stats page, recap, summary
+
+**User**:
+A registered account with a username, email, and profile (display name, bio, avatar, banner). Can be Standard or Admin.
+_Avoid_: Account, member, profile (as a synonym for the whole User)
+
+**SocialIdentity**:
+The uniform identifier for anyone involved in a social interaction — either a local User or a remote federated actor. Social commands and queries operate on SocialIdentity so the domain never branches on local vs remote.
+_Avoid_: Actor, participant, social user
+
+**Follow**:
+A social relationship where one user subscribes to another's activity. Always requires acceptance by the target user. Works identically for local and federated (ActivityPub) users. Once accepted, the followed user's reviews appear in the follower's Feed.
+_Avoid_: Subscribe, connect, friend
+
+**Feed**:
+A chronological timeline of reviews from users you follow — both local and federated. The main social surface of the app.
+_Avoid_: Timeline, activity stream, home
+
+**WatchEvent**:
+An automatically detected viewing reported by an external source — currently Jellyfin and Plex via webhook, but conceptually any system that can report "this person watched this movie" (e.g. a cinema ticket service). Arrives in a pending state; the user confirms it (creating a Review) or dismisses it.
+_Avoid_: Playback event, webhook event, auto-import
+
+**Import**:
+Bulk ingestion of reviews from an external file — Letterboxd CSV, IMDb CSV, or a generic JSON format. The user uploads a file, column mappings are applied, and reviews are created in batch.
+_Avoid_: Upload, migration, sync
+
+**ImportProfile**:
+A saved set of column-to-field mappings for an Import. Reusable across imports and shareable between users.
+_Avoid_: Template, mapping preset, import config

Cargo.lock

@@ -2892,9 +2892,9 @@ dependencies = [
 
 [[package]]
 name = "k-ap"
-version = "0.4.1"
+version = "0.5.0"
 source = "sparse+https://git.gabrielkaszewski.dev/api/packages/GKaszewski/cargo/"
-checksum = "03e39c04075b39960c329feba896a16aba37f0863669c28e7106b7cc45a9988d"
+checksum = "ab6066cccc6ae8aaa2f6262ac7d471e58930a04be3266a2e367d6bdd8aaaba29"
 dependencies = [
  "activitypub_federation",
  "anyhow",
@@ -2903,9 +2903,11 @@ dependencies = [
  "chrono",
  "enum_delegate",
  "futures",
+ "paste",
  "reqwest 0.13.3",
  "serde",
  "serde_json",
+ "thiserror 2.0.18",
  "tokio",
  "tracing",
  "url",

Cargo.toml

@@ -98,7 +98,6 @@ infra-wiring = { path = "crates/infra-wiring" }
 
 [profile.dev]
 debug = 1                    # line tables only — still debuggable, much faster linking
-split-debuginfo = "unpacked" # macOS: skip dsymutil on every link
 
 [profile.dev.package."*"]
 opt-level = 2                # compile deps faster at runtime; paid once, cached after

README.md

@@ -47,7 +47,7 @@ Open `http://localhost:3000`. The HTTP server and background worker start togeth
 
 ## Features
 
-- Log movies with a TMDB/OMDb ID or manual title/year/director, with a 0–5 rating and optional watch medium (cinema, streaming, TV, physical media, download, media server)
+- Log movies with a TMDB/OMDb ID or manual title/year/director, with a 1–5 rating and optional watch medium (cinema, streaming, TV, physical media, download, media server)
 - Edit reviews after the fact — update rating, comment, date, or watch medium via partial PATCH; each watch is still a separate record (re-watches tracked)
 - Background poster fetching and storage (local filesystem or S3-compatible)
 - Movie enrichment via TMDb — full cast, crew, genres, keywords, runtime, budget/revenue, ratings; fetched automatically on movie discovery and refreshed every 30 days; exposed via `GET /api/v1/movies/{id}/profile`
@@ -60,8 +60,9 @@ Open `http://localhost:3000`. The HTTP server and background worker start togeth
 - Watchlist — add movies to watch later, per-user; federated watchlist entries visible for remote actors
 - User profiles — display name, bio, avatar, banner, custom profile fields; editable via HTML settings page or REST API; account deletion broadcasts AP `Delete` actor activity; `alsoKnownAs` change triggers AP `Move` for account migration
 - Jellyfin/Plex auto-import — media server sends a webhook on playback stop, movies land in a watch queue; review and confirm with a rating to create diary entries; per-user webhook tokens with SHA-256 auth; setup UI at `/settings/integrations`
-- Annual Wrap-Up — Spotify Wrapped for movies: per-user and instance-wide year-in-review with stats (top directors, actors, genres, rating distribution, watch time, rewatches, budget analysis), shareable HTML page at `/wrapups/{user_id}/{year}`; admin-triggered or auto-generated in January
+- Annual Wrap-Up — Spotify Wrapped for movies: per-user and instance-wide year-in-review with stats (top directors, actors, genres, rating distribution, watch time, watch medium breakdown, rewatches, budget analysis); directors/actors filtered by minimum watch count for statistical relevance; shareable HTML page at `/wrapups/{user_id}/{year}`; admin-triggered or auto-generated in January
 - Goals — set a "watch N movies in YEAR" target with a progress bar; progress computed from existing reviews (backwards compatible); per-user federation toggle in settings; displayed on profile (SPA: interactive with create/edit/delete, classic HTML: read-only glassmorphic card)
+- Profile trends — top directors, genre breakdown, rating distribution histogram, watch medium breakdown, monthly activity chart; all computed from the user's review history
 - CSV and JSON diary export
 - File importer: upload CSV, TSV, JSON, or XLSX from any source (Letterboxd, IMDb, etc.), map columns to domain fields via a step-by-step wizard or REST API, save mapping profiles for repeat imports
 - REST API v1 (`/api/v1/`) with full feature parity with the HTML interface
@@ -90,17 +91,18 @@ Hexagonal (Ports & Adapters) with Domain-Driven Design:
 ```
 api-types           — shared REST API request/response DTOs (Serialize/Deserialize + utoipa schemas) + HtmlPageContext; used by presentation, tui, and template adapters
 infra-wiring        — shared infrastructure types (DbPool, EventBusBackend, AppConfig) used by both presentation and worker binaries
-domain              — pure types and CQRS port traits (MovieCommand/MovieQuery, WatchEventCommand/WatchEventQuery, PersonCommand/PersonQuery, SearchCommand/SearchPort, ImageFetcher, RssFeedRenderer), no external deps except serde
-application         — use cases (commands + queries), business logic orchestration; handlers delegate here for all domain logic
+domain              — pure types and CQRS port traits (MovieCommand/MovieQuery, WatchEventCommand/WatchEventQuery, GoalCommand/GoalQuery, DiaryQuery, PersonCommand/PersonQuery, SearchCommand/SearchPort, SocialCommand/SocialQuery, ImageFetcher, RssFeedRenderer), no external deps except serde
+application         — use cases (commands + queries), business logic orchestration; handlers delegate here for all domain logic; modules: auth, diary, goals, import, integrations, movies, person, search, social, users, watchlist, wrapup
 presentation        — Axum HTTP router, OpenAPI spec assembly, Swagger UI + Scalar serving, composition root for the HTTP process
 worker              — standalone worker binary (event consumer, poster sync, federation)
 adapters/
+  adapter-common       — shared row-to-domain conversions, sqlx error mapping, date/uuid parsing utils
   auth                 — JWT issuance and validation (Argon2 passwords)
   sqlite               — SQLite repository + connection factory
   postgres             — PostgreSQL repository + connection factory
   metadata             — TMDB / OMDb HTTP client
   poster-fetcher       — downloads poster images
-  image-storage        — stores images (posters + user avatars) on local filesystem or S3-compatible storage
+  object-storage       — stores images (posters + user avatars) on local filesystem or S3-compatible storage
   poster-sync          — event handler: triggers poster fetch+store on MovieDiscovered
   image-converter      — optional background worker: converts stored images to AVIF or WebP; backfills existing images via a 24h periodic job
   tmdb-enrichment      — TMDb HTTP client implementing MovieEnrichmentClient and PersonEnrichmentClient; event handlers (MovieEnrichmentHandler, PersonEnrichmentHandler) live in the application layer
@@ -113,6 +115,7 @@ adapters/
   event-payload        — shared event serialization DTOs (used by all event bus adapters)
   sqlite-event-queue   — durable polling event queue backed by SQLite
   postgres-event-queue — durable polling event queue backed by PostgreSQL
+  event-publisher      — in-memory event channel (used in tests)
   nats                 — NATS Core / JetStream event publisher and consumer
   event-publisher      — in-memory event channel (used in tests)
   activitypub          — ActivityPub federation adapter (follow, inbox/outbox, actor); delegates to k-ap for protocol internals

architecture.mmd

@@ -24,6 +24,7 @@ graph TB
             UC_INTEGRATIONS["integrations<br/>webhooks, watch_queue,<br/>confirm, dismiss"]
             UC_SEARCH["search<br/>execute"]
             UC_PERSON["person<br/>get, get_credits"]
+            UC_SOCIAL["social<br/>follow, unfollow,<br/>accept, reject, block"]
         end
         subgraph EventHandlers["Event Handlers"]
             EH_MOVIE["MovieEnrichmentHandler<br/><i>on MovieEnrichmentRequested</i>"]
@@ -59,10 +60,10 @@ graph TB
             M_SEARCH["SearchQuery,<br/>SearchResults"]
         end
         subgraph Ports["Port Traits (Interfaces)"]
-            P_REPOS["MovieCommand / MovieQuery<br/>ReviewRepository<br/>DiaryRepository / StatsRepository<br/>UserRepository<br/>WatchlistRepository<br/>WatchEventCommand / WatchEventQuery<br/>WebhookTokenRepository<br/>ImportSessionRepository<br/>MovieProfileRepository<br/>WrapUpRepository<br/>GoalRepository<br/>UserSettingsRepository<br/>MovieDeduplicator"]
-            P_SERVICES["AuthService<br/>MetadataClient<br/>PosterFetcherClient<br/>ImageFetcher<br/>ObjectStorage<br/>EventPublisher<br/>EventConsumer<br/>PasswordHasher<br/>DiaryExporter<br/>DocumentParser<br/>RssFeedRenderer"]
-            P_SEARCH["SearchPort<br/>SearchCommand<br/>PersonQuery<br/>PersonCommand"]
-            P_FEDERATION["SocialQueryPort<br/>LocalApContentQuery<br/>RemoteWatchlistRepository<br/>RemoteGoalRepository"]
+            P_REPOS["MovieCommand / MovieQuery<br/>ReviewRepository<br/>DiaryQuery / StatsRepository<br/>UserRepository / UserProfileFieldsRepository<br/>WatchlistRepository<br/>WatchEventCommand / WatchEventQuery<br/>WebhookTokenRepository<br/>ImportSessionRepository / ImportProfileRepository<br/>MovieProfileRepository<br/>WrapUpRepository / WrapUpStatsQuery<br/>GoalCommand / GoalQuery<br/>UserSettingsRepository / RefreshSessionRepository<br/>MovieDeduplicator"]
+            P_SERVICES["AuthService<br/>MetadataClient / MovieEnrichmentClient<br/>PersonEnrichmentClient<br/>PosterFetcherClient<br/>ImageFetcher / ObjectStorage<br/>EventPublisher / EventConsumer<br/>PasswordHasher<br/>DiaryExporter / DocumentParser<br/>RssFeedRenderer / MediaServerParser"]
+            P_SEARCH["SearchPort / SearchCommand<br/>PersonQuery / PersonCommand<br/>FederatedProfileQuery"]
+            P_FEDERATION["SocialCommand / SocialQuery<br/>FederationAdminQuery<br/>LocalApContentQuery<br/>RemoteWatchlistRepository<br/>RemoteGoalRepository"]
         end
         subgraph DomainServices["Services (pure, no I/O)"]
             DS_WRAPUP["WrapUpAnalyzer<br/><i>build_report, compute_*</i>"]
@@ -82,6 +83,7 @@ graph TB
 
     subgraph Adapters["Adapters (implement Port Traits)"]
         direction TB
+        A_COMMON["adapter-common<br/><i>Shared row conversions,<br/>error mapping, date utils</i>"]
         subgraph Storage["Storage"]
             A_SQLITE["sqlite<br/><i>SQLite repos</i>"]
             A_PG["postgres<br/><i>PostgreSQL repos</i>"]
@@ -91,7 +93,9 @@ graph TB
         end
         subgraph Messaging["Messaging"]
             A_NATS["nats<br/><i>JetStream / Core</i>"]
+            A_SQLITE_QUEUE["sqlite-event-queue<br/><i>Polling, dead-letter</i>"]
             A_PG_QUEUE["postgres-event-queue<br/><i>Polling, dead-letter</i>"]
+            A_EVT_PUB["event-publisher<br/><i>In-memory (tests)</i>"]
             A_PAYLOAD["event-payload<br/><i>Serde (de)serialization</i>"]
         end
         subgraph External["External Services"]

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.5.0", registry = "gitea" }
 domain = { workspace = true }
 axum = { workspace = true }
 serde = { workspace = true }

crates/adapters/activitypub/src/composite_handler.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use chrono::{DateTime, Utc};
-use k_ap::{ApContentReader, ApObjectHandler};
+use k_ap::{ApContentReader, ApObjectHandler, LocalObject};
 use url::Url;
 
 use crate::{
@@ -21,10 +20,9 @@ impl ApContentReader for CompositeObjectHandler {
     async fn get_local_objects_page(
         &self,
         user_id: uuid::Uuid,
-        before: Option<DateTime<Utc>>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
         limit: usize,
-    ) -> anyhow::Result<Vec<(Url, serde_json::Value, DateTime<Utc>)>> {
-        // Fetch from all three sources (watchlist/goals return all, reviews use DB pagination)
+    ) -> anyhow::Result<Vec<LocalObject>> {
         let fetch_limit = limit * 3;
         let reviews = self
             .review
@@ -39,16 +37,15 @@ impl ApContentReader for CompositeObjectHandler {
             .get_local_objects_page(user_id, None, usize::MAX)
             .await?;
 
-        let mut all: Vec<(Url, serde_json::Value, DateTime<Utc>)> = Vec::new();
+        let mut all: Vec<LocalObject> = Vec::new();
         all.extend(reviews);
         all.extend(watchlist);
         all.extend(goals);
 
-        // Apply before filter and sort descending by timestamp
         if let Some(before_ts) = before {
-            all.retain(|(_, _, ts)| *ts < before_ts);
+            all.retain(|obj| obj.published_at < before_ts);
         }
-        all.sort_by_key(|b| std::cmp::Reverse(b.2));
+        all.sort_by_key(|obj| std::cmp::Reverse(obj.published_at));
         all.truncate(limit);
         Ok(all)
     }

crates/adapters/activitypub/src/event_handler.rs

@@ -217,7 +217,7 @@ impl ActivityPubEventHandler {
         let json = serde_json::to_value(obj)?;
 
         self.ap_service
-            .broadcast_create_note(user_id.value(), json, ApVisibility::Public, vec![])
+            .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
             .await?;
 
         let year = review.watched_at().year() as u16;
@@ -283,7 +283,7 @@ impl ActivityPubEventHandler {
         let json = serde_json::to_value(obj)?;
 
         self.ap_service
-            .broadcast_update_note(user_id.value(), json, ApVisibility::Public, vec![])
+            .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
             .await?;
 
         Ok(())
@@ -349,7 +349,7 @@ impl ActivityPubEventHandler {
         let json = serde_json::to_value(obj)?;
 
         self.ap_service
-            .broadcast_create_note(user_id.value(), json, ApVisibility::Public, vec![])
+            .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
             .await?;
         Ok(())
     }
@@ -416,7 +416,7 @@ impl ActivityPubEventHandler {
             let json = serde_json::to_value(obj)?;
 
             self.ap_service
-                .broadcast_update_note(user_id.value(), json, ApVisibility::Public, vec![])
+                .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
                 .await?;
         }
 
@@ -462,7 +462,7 @@ impl ActivityPubEventHandler {
         );
         let json = serde_json::to_value(obj)?;
         self.ap_service
-            .broadcast_update_note(user_id.value(), json, ApVisibility::Public, vec![])
+            .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
             .await?;
         Ok(())
     }
@@ -494,11 +494,11 @@ impl ActivityPubEventHandler {
         let json = serde_json::to_value(obj)?;
         if is_create {
             self.ap_service
-                .broadcast_create_note(user_id.value(), json, ApVisibility::Public, vec![])
+                .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
                 .await?;
         } else {
             self.ap_service
-                .broadcast_update_note(user_id.value(), json, ApVisibility::Public, vec![])
+                .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
                 .await?;
         }
         Ok(())

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/adapters/activitypub/src/goal_handler.rs

@@ -7,7 +7,7 @@ use domain::{
     ports::{GoalQuery, RemoteGoalRepository},
     value_objects::UserId,
 };
-use k_ap::{ApContentReader, ApObjectHandler};
+use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
 use url::Url;
 
 use crate::objects::{GoalObject, goal_to_ap_object};
@@ -26,7 +26,7 @@ impl ApContentReader for GoalObjectHandler {
         user_id: uuid::Uuid,
         _before: Option<DateTime<chrono::Utc>>,
         _limit: usize,
-    ) -> anyhow::Result<Vec<(Url, serde_json::Value, DateTime<chrono::Utc>)>> {
+    ) -> anyhow::Result<Vec<LocalObject>> {
         let uid = UserId::from_uuid(user_id);
         let goals = self
             .goal_repo
@@ -35,6 +35,7 @@ impl ApContentReader for GoalObjectHandler {
             .map_err(|e| anyhow::anyhow!(e.to_string()))?;
 
         let actor = actor_url(&self.base_url, user_id);
+        let follower_cc = format!("{}/followers", actor);
         let mut results = Vec::new();
         for goal in goals {
             let ap_id = goal_url(&self.base_url, user_id, goal.year());
@@ -47,7 +48,15 @@ impl ApContentReader for GoalObjectHandler {
                 0,
                 &self.base_url,
             );
-            results.push((ap_id, serde_json::to_value(obj)?, published));
+            results.push(LocalObject {
+                ap_id,
+                object: serde_json::to_value(obj)?,
+                published_at: published,
+                to: vec![AS_PUBLIC.to_string()],
+                cc: vec![follower_cc.clone()],
+                bto: vec![],
+                bcc: vec![],
+            });
         }
         Ok(results)
     }

crates/adapters/activitypub/src/lib.rs

@@ -6,6 +6,7 @@ pub mod objects;
 pub mod port;
 pub mod remote_review_repository;
 pub mod review_handler;
+pub mod social_adapter;
 pub(crate) mod urls;
 pub mod user_adapter;
 pub mod watchlist_handler;
@@ -17,24 +18,27 @@ pub const INSTANCE_ACTOR_ID: uuid::Uuid =
 pub use k_ap::{
     ActivityPubService, ActivityRepository, ActorRepository, ApContentReader, ApFederationConfig,
     ApObjectHandler, ApUser, ApUserRepository, BlocklistRepository, FederationData,
-    FollowRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
+    FollowRepository, Follower, FollowerStatus, FollowingStatus, LocalObject, RemoteActor,
 };
 
 pub use event_handler::ActivityPubEventHandler;
 pub use port::{ActivityPubPort, NoopActivityPubService};
 pub use remote_review_repository::{RemoteReviewRepository, RemoteReviewUpdate};
 pub use review_handler::ReviewObjectHandler;
+pub use social_adapter::CompositeSocialAdapter;
 pub use user_adapter::DomainUserRepoAdapter;
 
-pub type FederationRepos = (
-    std::sync::Arc<dyn ActivityRepository>,
-    std::sync::Arc<dyn FollowRepository>,
-    std::sync::Arc<dyn ActorRepository>,
-    std::sync::Arc<dyn BlocklistRepository>,
-    std::sync::Arc<dyn domain::ports::SocialQueryPort>,
-    std::sync::Arc<dyn RemoteReviewRepository>,
-    std::sync::Arc<dyn domain::ports::RemoteWatchlistRepository>,
-);
+pub struct FederationRepos {
+    pub activity: std::sync::Arc<dyn ActivityRepository>,
+    pub follow: std::sync::Arc<dyn FollowRepository>,
+    pub actor: std::sync::Arc<dyn ActorRepository>,
+    pub blocklist: std::sync::Arc<dyn BlocklistRepository>,
+    pub admin_query: std::sync::Arc<dyn domain::ports::FederationAdminQuery>,
+    pub review_store: std::sync::Arc<dyn RemoteReviewRepository>,
+    pub remote_watchlist: std::sync::Arc<dyn domain::ports::RemoteWatchlistRepository>,
+    pub follow_command: std::sync::Arc<dyn domain::ports::FollowCommand>,
+    pub follow_query: std::sync::Arc<dyn domain::ports::FollowQuery>,
+}
 
 pub struct ActivityPubWire {
     pub service: std::sync::Arc<dyn ActivityPubPort>,
@@ -58,6 +62,8 @@ pub struct ActivityPubDeps {
     pub stats_repo: std::sync::Arc<dyn domain::ports::StatsRepository>,
     pub user_repo: std::sync::Arc<dyn domain::ports::UserRepository>,
     pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
+    pub follow_command: std::sync::Arc<dyn domain::ports::FollowCommand>,
+    pub follow_query: std::sync::Arc<dyn domain::ports::FollowQuery>,
     pub base_url: String,
     pub allow_registration: bool,
     pub event_publisher: std::sync::Arc<dyn domain::ports::EventPublisher>,
@@ -80,6 +86,8 @@ pub async fn wire(deps: ActivityPubDeps) -> anyhow::Result<ActivityPubWire> {
         stats_repo,
         user_repo,
         federation_settings,
+        follow_command: _,
+        follow_query: _,
         base_url,
         allow_registration,
         event_publisher,
@@ -139,6 +147,10 @@ pub async fn wire(deps: ActivityPubDeps) -> anyhow::Result<ActivityPubWire> {
             .event_publisher(fed_event_bridge)
             .allow_registration(allow_registration)
             .software_name("movies-diary")
+            .nodeinfo_metadata(serde_json::json!({
+                "nodeName": "movies-diary",
+                "nodeDescription": "A federated movie diary"
+            }))
             .debug(federation_debug)
             .build()
             .await?,

crates/adapters/activitypub/src/objects.rs

@@ -1,11 +1,17 @@
 use chrono::{DateTime, Utc};
 use k_ap::AS_PUBLIC;
-use k_ap::NoteType;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
 use domain::models::Review;
 
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+pub(crate) enum ActivityStreamsType {
+    #[default]
+    Note,
+    Article,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApAttachment {
@@ -34,7 +40,7 @@ pub(crate) fn normalize_hashtag(title: &str) -> String {
 #[serde(rename_all = "camelCase")]
 pub struct ReviewObject {
     #[serde(rename = "type")]
-    pub(crate) kind: NoteType,
+    pub(crate) kind: ActivityStreamsType,
     pub(crate) id: Url,
     pub(crate) attributed_to: Url,
     pub(crate) content: String,
@@ -104,12 +110,12 @@ pub fn review_to_ap_object(review: &Review, input: ReviewApInput) -> ReviewObjec
     let tag = vec![
         ApHashtag {
             kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/moviesdiary", &base_url)).expect("valid base_url"),
+            href: Url::parse(&format!("{}/tags/moviesdiary", base_url)).expect("valid base_url"),
             name: "#MoviesDiary".to_string(),
         },
         ApHashtag {
             kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/{}", &base_url, normalized.to_lowercase()))
+            href: Url::parse(&format!("{}/tags/{}", base_url, normalized.to_lowercase()))
                 .expect("valid base_url"),
             name: format!("#{}", normalized),
         },
@@ -125,7 +131,7 @@ pub fn review_to_ap_object(review: &Review, input: ReviewApInput) -> ReviewObjec
     };
 
     ReviewObject {
-        kind: NoteType::default(),
+        kind: ActivityStreamsType::default(),
         id: ap_id,
         attributed_to: actor_url.clone(),
         content,
@@ -150,7 +156,7 @@ pub fn review_to_ap_object(review: &Review, input: ReviewApInput) -> ReviewObjec
 #[serde(rename_all = "camelCase")]
 pub struct WatchlistObject {
     #[serde(rename = "type")]
-    pub(crate) kind: NoteType,
+    pub(crate) kind: ActivityStreamsType,
     pub(crate) id: Url,
     pub(crate) attributed_to: Url,
     pub(crate) content: String,
@@ -218,7 +224,7 @@ pub fn watchlist_to_ap_object(input: WatchlistApInput) -> WatchlistObject {
     ];
 
     WatchlistObject {
-        kind: NoteType::default(),
+        kind: ActivityStreamsType::default(),
         id: ap_id,
         attributed_to: actor_url.clone(),
         content,
@@ -240,7 +246,7 @@ pub fn watchlist_to_ap_object(input: WatchlistApInput) -> WatchlistObject {
 #[serde(rename_all = "camelCase")]
 pub struct GoalObject {
     #[serde(rename = "type")]
-    pub(crate) kind: NoteType,
+    pub(crate) kind: ActivityStreamsType,
     pub(crate) id: Url,
     pub(crate) attributed_to: Url,
     pub(crate) content: String,
@@ -277,7 +283,7 @@ pub fn goal_to_ap_object(
     }];
 
     GoalObject {
-        kind: NoteType::default(),
+        kind: ActivityStreamsType::default(),
         id: ap_id,
         attributed_to: actor_url.clone(),
         content,

crates/adapters/activitypub/src/port.rs

@@ -6,9 +6,6 @@ use k_ap::{ActivityPubService, BlockedDomain, RemoteActor};
 #[async_trait]
 pub trait ActivityPubPort: Send + Sync {
     async fn actor_json(&self, user_id: &str) -> anyhow::Result<String>;
-    async fn count_following(&self, local_user_id: Uuid) -> anyhow::Result<usize>;
-    async fn count_accepted_followers(&self, local_user_id: Uuid) -> anyhow::Result<usize>;
-    async fn get_pending_followers(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>>;
     async fn follow(&self, local_user_id: Uuid, handle: &str) -> anyhow::Result<()>;
     async fn unfollow(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
     async fn accept_follower(
@@ -22,8 +19,6 @@ pub trait ActivityPubPort: Send + Sync {
         remote_actor_url: &str,
     ) -> anyhow::Result<()>;
     async fn get_following(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>>;
-    async fn get_accepted_followers(&self, local_user_id: Uuid)
-    -> anyhow::Result<Vec<RemoteActor>>;
     async fn remove_follower(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
     async fn block_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
     async fn unblock_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
@@ -54,15 +49,6 @@ impl ActivityPubPort for ActivityPubService {
     async fn actor_json(&self, user_id: &str) -> anyhow::Result<String> {
         self.actor_json(user_id).await
     }
-    async fn count_following(&self, local_user_id: Uuid) -> anyhow::Result<usize> {
-        self.count_following(local_user_id).await
-    }
-    async fn count_accepted_followers(&self, local_user_id: Uuid) -> anyhow::Result<usize> {
-        self.count_accepted_followers(local_user_id).await
-    }
-    async fn get_pending_followers(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        self.get_pending_followers(local_user_id).await
-    }
     async fn follow(&self, local_user_id: Uuid, handle: &str) -> anyhow::Result<()> {
         self.follow(local_user_id, handle).await
     }
@@ -86,12 +72,6 @@ impl ActivityPubPort for ActivityPubService {
     async fn get_following(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
         self.get_following(local_user_id).await
     }
-    async fn get_accepted_followers(
-        &self,
-        local_user_id: Uuid,
-    ) -> anyhow::Result<Vec<RemoteActor>> {
-        self.get_accepted_followers(local_user_id).await
-    }
     async fn remove_follower(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()> {
         self.remove_follower(local_user_id, actor_url).await
     }
@@ -147,15 +127,6 @@ impl ActivityPubPort for NoopActivityPubService {
     async fn actor_json(&self, _: &str) -> anyhow::Result<String> {
         Ok(String::new())
     }
-    async fn count_following(&self, _: Uuid) -> anyhow::Result<usize> {
-        Ok(0)
-    }
-    async fn count_accepted_followers(&self, _: Uuid) -> anyhow::Result<usize> {
-        Ok(0)
-    }
-    async fn get_pending_followers(&self, _: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        Ok(vec![])
-    }
     async fn follow(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
         Ok(())
     }
@@ -171,9 +142,6 @@ impl ActivityPubPort for NoopActivityPubService {
     async fn get_following(&self, _: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
         Ok(vec![])
     }
-    async fn get_accepted_followers(&self, _: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        Ok(vec![])
-    }
     async fn remove_follower(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
         Ok(())
     }

crates/adapters/activitypub/src/review_handler.rs

@@ -7,7 +7,7 @@ use domain::{
     ports::{DiaryQuery, EventPublisher, LocalApContentQuery, MovieQuery},
     value_objects::{Comment, ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
 };
-use k_ap::{ApContentReader, ApObjectHandler};
+use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
 use url::Url;
 
 use crate::objects::{ReviewApInput, ReviewObject, review_to_ap_object};
@@ -30,7 +30,7 @@ impl ApContentReader for ReviewObjectHandler {
         user_id: uuid::Uuid,
         before: Option<chrono::DateTime<chrono::Utc>>,
         limit: usize,
-    ) -> anyhow::Result<Vec<(url::Url, serde_json::Value, chrono::DateTime<chrono::Utc>)>> {
+    ) -> anyhow::Result<Vec<LocalObject>> {
         let domain_user_id = UserId::from_uuid(user_id);
         let before_naive = before.map(|dt| dt.naive_utc());
         let entries = self
@@ -65,7 +65,16 @@ impl ApContentReader for ReviewObjectHandler {
                     base_url: self.base_url.clone(),
                 },
             );
-            results.push((ap_id, serde_json::to_value(obj)?, published));
+            let follower_cc = format!("{}/followers", actor);
+            results.push(LocalObject {
+                ap_id,
+                object: serde_json::to_value(obj)?,
+                published_at: published,
+                to: vec![AS_PUBLIC.to_string()],
+                cc: vec![follower_cc],
+                bto: vec![],
+                bcc: vec![],
+            });
         }
         Ok(results)
     }

crates/adapters/activitypub/src/social_adapter.rs

@@ -0,0 +1,298 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    ports::{FollowCommand, FollowQuery, SocialCommand, SocialQuery, UserRepository},
+    value_objects::{FollowStatus, FollowTarget, SocialActor, SocialIdentity, UserId, Username},
+};
+
+use super::ActivityPubPort;
+
+pub struct CompositeSocialAdapter {
+    ap_service: Arc<dyn ActivityPubPort>,
+    user_repo: Arc<dyn UserRepository>,
+    follow_command: Arc<dyn FollowCommand>,
+    follow_query: Arc<dyn FollowQuery>,
+    base_url: String,
+}
+
+impl CompositeSocialAdapter {
+    pub fn new(
+        ap_service: Arc<dyn ActivityPubPort>,
+        user_repo: Arc<dyn UserRepository>,
+        follow_command: Arc<dyn FollowCommand>,
+        follow_query: Arc<dyn FollowQuery>,
+        base_url: String,
+    ) -> Self {
+        Self {
+            ap_service,
+            user_repo,
+            follow_command,
+            follow_query,
+            base_url,
+        }
+    }
+
+    fn local_actor_url(&self, user_id: &UserId) -> String {
+        format!("{}/users/{}", self.base_url, user_id.value())
+    }
+
+    fn actor_url_from_identity(&self, identity: &SocialIdentity) -> String {
+        match identity {
+            SocialIdentity::Local(uid) => self.local_actor_url(uid),
+            SocialIdentity::Remote { actor_url } => actor_url.clone(),
+        }
+    }
+
+    async fn resolve_target_identity(
+        &self,
+        target: &FollowTarget,
+    ) -> Result<SocialIdentity, DomainError> {
+        match target {
+            FollowTarget::Identity(id) => Ok(id.clone()),
+            FollowTarget::Handle(handle) => {
+                let host = handle.rsplit_once('@').map(|(_, h)| h).unwrap_or("");
+                let local_host = SocialIdentity::host_from_base_url(&self.base_url);
+                if host == local_host {
+                    let username_str = handle
+                        .trim_start_matches('@')
+                        .split('@')
+                        .next()
+                        .unwrap_or("");
+                    if let Ok(username) = Username::new(username_str.to_string())
+                        && let Some(user) = self.user_repo.find_by_username(&username).await?
+                    {
+                        return Ok(SocialIdentity::Local(user.id().clone()));
+                    }
+                }
+                Ok(SocialIdentity::Remote {
+                    actor_url: handle.clone(),
+                })
+            }
+        }
+    }
+}
+
+fn ap_err(e: anyhow::Error) -> DomainError {
+    DomainError::InfrastructureError(e.to_string())
+}
+
+#[async_trait]
+impl SocialCommand for CompositeSocialAdapter {
+    async fn follow(&self, follower: &UserId, target: &FollowTarget) -> Result<(), DomainError> {
+        let identity = self.resolve_target_identity(target).await?;
+
+        if let SocialIdentity::Local(ref target_id) = identity {
+            if follower == target_id {
+                return Err(DomainError::ValidationError(
+                    "Cannot follow yourself".into(),
+                ));
+            }
+            let follower_url = self.local_actor_url(follower);
+            let target_url = self.local_actor_url(target_id);
+            self.follow_command
+                .add_follower(target_id.value(), &follower_url, FollowStatus::Pending)
+                .await?;
+            self.follow_command
+                .add_follow(follower.value(), &target_url, FollowStatus::Pending)
+                .await?;
+            return Ok(());
+        }
+
+        let handle = match target {
+            FollowTarget::Handle(h) => h.clone(),
+            FollowTarget::Identity(id) => match id {
+                SocialIdentity::Local(uid) => {
+                    let user = self
+                        .user_repo
+                        .find_by_id(uid)
+                        .await?
+                        .ok_or_else(|| DomainError::NotFound("User not found".into()))?;
+                    SocialIdentity::format_local_handle(user.username().value(), &self.base_url)
+                }
+                SocialIdentity::Remote { actor_url } => actor_url.clone(),
+            },
+        };
+        self.ap_service
+            .follow(follower.value(), &handle)
+            .await
+            .map_err(ap_err)
+    }
+
+    async fn unfollow(
+        &self,
+        follower: &UserId,
+        target: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(target);
+        match target {
+            SocialIdentity::Local(target_id) => {
+                let follower_url = self.local_actor_url(follower);
+                self.follow_command
+                    .remove_follow(follower.value(), &actor_url)
+                    .await?;
+                self.follow_command
+                    .remove_follower_record(target_id.value(), &follower_url)
+                    .await?;
+                Ok(())
+            }
+            SocialIdentity::Remote { .. } => self
+                .ap_service
+                .unfollow(follower.value(), &actor_url)
+                .await
+                .map_err(ap_err),
+        }
+    }
+
+    async fn accept_follow(
+        &self,
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(requester);
+        match requester {
+            SocialIdentity::Local(requester_id) => {
+                let owner_url = self.local_actor_url(owner);
+                self.follow_command
+                    .update_follower_status(owner.value(), &actor_url, FollowStatus::Accepted)
+                    .await?;
+                self.follow_command
+                    .update_follow_status(requester_id.value(), &owner_url, FollowStatus::Accepted)
+                    .await?;
+                Ok(())
+            }
+            SocialIdentity::Remote { .. } => self
+                .ap_service
+                .accept_follower(owner.value(), &actor_url)
+                .await
+                .map_err(ap_err),
+        }
+    }
+
+    async fn reject_follow(
+        &self,
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(requester);
+        match requester {
+            SocialIdentity::Local(requester_id) => {
+                let owner_url = self.local_actor_url(owner);
+                self.follow_command
+                    .update_follower_status(owner.value(), &actor_url, FollowStatus::Rejected)
+                    .await?;
+                self.follow_command
+                    .remove_follow(requester_id.value(), &owner_url)
+                    .await?;
+                Ok(())
+            }
+            SocialIdentity::Remote { .. } => self
+                .ap_service
+                .reject_follower(owner.value(), &actor_url)
+                .await
+                .map_err(ap_err),
+        }
+    }
+
+    async fn remove_follower(
+        &self,
+        owner: &UserId,
+        follower: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(follower);
+        match follower {
+            SocialIdentity::Local(follower_id) => {
+                let owner_url = self.local_actor_url(owner);
+                self.follow_command
+                    .remove_follower_record(owner.value(), &actor_url)
+                    .await?;
+                self.follow_command
+                    .remove_follow(follower_id.value(), &owner_url)
+                    .await?;
+                Ok(())
+            }
+            SocialIdentity::Remote { .. } => self
+                .ap_service
+                .remove_follower(owner.value(), &actor_url)
+                .await
+                .map_err(ap_err),
+        }
+    }
+
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(target);
+        self.ap_service
+            .block_actor(blocker.value(), &actor_url)
+            .await
+            .map_err(ap_err)
+    }
+
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
+        let actor_url = self.actor_url_from_identity(target);
+        self.ap_service
+            .unblock_actor(blocker.value(), &actor_url)
+            .await
+            .map_err(ap_err)
+    }
+}
+
+#[async_trait]
+impl SocialQuery for CompositeSocialAdapter {
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        self.follow_query
+            .get_following(user.value(), &self.base_url)
+            .await
+    }
+
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        self.follow_query
+            .get_followers(user.value(), &self.base_url)
+            .await
+    }
+
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        self.follow_query
+            .get_pending_followers(user.value(), &self.base_url)
+            .await
+    }
+
+    async fn count_following(&self, user: &UserId) -> Result<usize, DomainError> {
+        self.follow_query.count_following(user.value()).await
+    }
+
+    async fn count_followers(&self, user: &UserId) -> Result<usize, DomainError> {
+        self.follow_query.count_followers(user.value()).await
+    }
+
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        let actors = self
+            .ap_service
+            .get_blocked_actors(user.value())
+            .await
+            .map_err(ap_err)?;
+        Ok(actors
+            .into_iter()
+            .map(|a| {
+                let identity = SocialIdentity::from_actor_url(&a.url, &self.base_url);
+                SocialActor {
+                    identity,
+                    handle: a.handle,
+                    display_name: a.display_name,
+                    avatar_url: a.avatar_url,
+                }
+            })
+            .collect())
+    }
+
+    async fn is_following(
+        &self,
+        follower: &UserId,
+        target: &SocialIdentity,
+    ) -> Result<bool, DomainError> {
+        let actor_url = self.actor_url_from_identity(target);
+        self.follow_query
+            .is_following(follower.value(), &actor_url)
+            .await
+    }
+}

crates/adapters/activitypub/src/watchlist_handler.rs

@@ -7,7 +7,7 @@ use domain::{
     ports::{LocalApContentQuery, RemoteWatchlistRepository},
     value_objects::UserId,
 };
-use k_ap::{ApContentReader, ApObjectHandler};
+use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
 use url::Url;
 
 use crate::objects::{WatchlistApInput, WatchlistObject, watchlist_to_ap_object};
@@ -26,7 +26,7 @@ impl ApContentReader for WatchlistObjectHandler {
         user_id: uuid::Uuid,
         _before: Option<DateTime<chrono::Utc>>,
         _limit: usize,
-    ) -> anyhow::Result<Vec<(Url, serde_json::Value, DateTime<chrono::Utc>)>> {
+    ) -> anyhow::Result<Vec<LocalObject>> {
         let uid = UserId::from_uuid(user_id);
         let entries = self
             .content_query
@@ -35,6 +35,7 @@ impl ApContentReader for WatchlistObjectHandler {
             .map_err(|e| anyhow::anyhow!(e.to_string()))?;
 
         let actor = actor_url(&self.base_url, user_id);
+        let follower_cc = format!("{}/followers", actor);
         let mut results = Vec::new();
         for WatchlistWithMovie { entry, movie } in entries {
             let ap_id = watchlist_entry_url(&self.base_url, user_id, entry.movie_id.value());
@@ -54,7 +55,15 @@ impl ApContentReader for WatchlistObjectHandler {
                 added_at: published,
                 base_url: self.base_url.clone(),
             });
-            results.push((ap_id, serde_json::to_value(obj)?, published));
+            results.push(LocalObject {
+                ap_id,
+                object: serde_json::to_value(obj)?,
+                published_at: published,
+                to: vec![AS_PUBLIC.to_string()],
+                cc: vec![follower_cc.clone()],
+                bto: vec![],
+                bcc: vec![],
+            });
         }
         Ok(results)
     }

crates/adapters/event-payload/src/lib.rs

@@ -4,7 +4,8 @@ use domain::{
     events::DomainEvent,
     models::{ExternalPersonId, PersonId},
     value_objects::{
-        ExternalMetadataId, GoalId, MovieId, PosterPath, Rating, ReviewId, UserId, WrapUpId,
+        ExternalMetadataId, GoalId, MovieId, PosterPath, Rating, ReviewId, SocialIdentity, UserId,
+        WrapUpId,
     },
 };
 use serde::{Deserialize, Serialize};
@@ -61,10 +62,40 @@ pub enum EventPayload {
         user_id: String,
         movie_id: String,
     },
+    FollowRequested {
+        follower_id: String,
+        target_kind: String,
+        target_id: String,
+    },
     FollowAccepted {
-        local_user_id: String,
-        remote_actor_url: String,
-        outbox_url: String,
+        owner_id: String,
+        requester_kind: String,
+        requester_id: String,
+    },
+    FollowRejected {
+        owner_id: String,
+        requester_kind: String,
+        requester_id: String,
+    },
+    Unfollowed {
+        follower_id: String,
+        target_kind: String,
+        target_id: String,
+    },
+    FollowerRemoved {
+        owner_id: String,
+        follower_kind: String,
+        follower_id: String,
+    },
+    ActorBlocked {
+        blocker_id: String,
+        target_kind: String,
+        target_id: String,
+    },
+    ActorUnblocked {
+        blocker_id: String,
+        target_kind: String,
+        target_id: String,
     },
     BackfillFollower {
         owner_user_id: String,
@@ -136,7 +167,13 @@ impl EventPayload {
             EventPayload::ImageStored { .. } => "ImageStored",
             EventPayload::WatchlistEntryAdded { .. } => "WatchlistEntryAdded",
             EventPayload::WatchlistEntryRemoved { .. } => "WatchlistEntryRemoved",
+            EventPayload::FollowRequested { .. } => "FollowRequested",
             EventPayload::FollowAccepted { .. } => "FollowAccepted",
+            EventPayload::FollowRejected { .. } => "FollowRejected",
+            EventPayload::Unfollowed { .. } => "Unfollowed",
+            EventPayload::FollowerRemoved { .. } => "FollowerRemoved",
+            EventPayload::ActorBlocked { .. } => "ActorBlocked",
+            EventPayload::ActorUnblocked { .. } => "ActorUnblocked",
             EventPayload::BackfillFollower { .. } => "BackfillFollower",
             EventPayload::FederationDeliveryRequested { .. } => "FederationDeliveryRequested",
             EventPayload::WatchEventIngested { .. } => "WatchEventIngested",
@@ -158,6 +195,44 @@ fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
     Uuid::parse_str(s).map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
 }
 
+fn identity_to_payload(id: &SocialIdentity) -> (String, String) {
+    match id {
+        SocialIdentity::Local(uid) => ("local".into(), uid.value().to_string()),
+        SocialIdentity::Remote { actor_url } => ("remote".into(), actor_url.clone()),
+    }
+}
+
+fn follow_target_to_payload(target: &domain::value_objects::FollowTarget) -> (String, String) {
+    match target {
+        domain::value_objects::FollowTarget::Identity(id) => identity_to_payload(id),
+        domain::value_objects::FollowTarget::Handle(h) => ("handle".into(), h.clone()),
+    }
+}
+
+fn payload_to_identity(kind: &str, id: String) -> Result<SocialIdentity, DomainError> {
+    match kind {
+        "local" => Ok(SocialIdentity::Local(UserId::from_uuid(parse_uuid(
+            &id, "user_id",
+        )?))),
+        "remote" => Ok(SocialIdentity::Remote { actor_url: id }),
+        other => Err(DomainError::InfrastructureError(format!(
+            "unknown identity kind: {other}"
+        ))),
+    }
+}
+
+fn payload_to_follow_target(
+    kind: &str,
+    id: String,
+) -> Result<domain::value_objects::FollowTarget, DomainError> {
+    match kind {
+        "handle" => Ok(domain::value_objects::FollowTarget::Handle(id)),
+        other => Ok(domain::value_objects::FollowTarget::Identity(
+            payload_to_identity(other, id)?,
+        )),
+    }
+}
+
 fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
     chrono::DateTime::from_timestamp(ts, 0)
         .map(|dt| dt.naive_utc())
@@ -243,15 +318,62 @@ impl From<&DomainEvent> for EventPayload {
                     movie_id: movie_id.value().to_string(),
                 }
             }
-            DomainEvent::FollowAccepted {
-                local_user_id,
-                remote_actor_url,
-                outbox_url,
-            } => EventPayload::FollowAccepted {
-                local_user_id: local_user_id.value().to_string(),
-                remote_actor_url: remote_actor_url.clone(),
-                outbox_url: outbox_url.clone(),
-            },
+            DomainEvent::FollowRequested { follower, target } => {
+                let (kind, id) = follow_target_to_payload(target);
+                EventPayload::FollowRequested {
+                    follower_id: follower.value().to_string(),
+                    target_kind: kind,
+                    target_id: id,
+                }
+            }
+            DomainEvent::FollowAccepted { owner, requester } => {
+                let (kind, id) = identity_to_payload(requester);
+                EventPayload::FollowAccepted {
+                    owner_id: owner.value().to_string(),
+                    requester_kind: kind,
+                    requester_id: id,
+                }
+            }
+            DomainEvent::FollowRejected { owner, requester } => {
+                let (kind, id) = identity_to_payload(requester);
+                EventPayload::FollowRejected {
+                    owner_id: owner.value().to_string(),
+                    requester_kind: kind,
+                    requester_id: id,
+                }
+            }
+            DomainEvent::Unfollowed { follower, target } => {
+                let (kind, id) = identity_to_payload(target);
+                EventPayload::Unfollowed {
+                    follower_id: follower.value().to_string(),
+                    target_kind: kind,
+                    target_id: id,
+                }
+            }
+            DomainEvent::FollowerRemoved { owner, follower } => {
+                let (kind, id) = identity_to_payload(follower);
+                EventPayload::FollowerRemoved {
+                    owner_id: owner.value().to_string(),
+                    follower_kind: kind,
+                    follower_id: id,
+                }
+            }
+            DomainEvent::ActorBlocked { blocker, target } => {
+                let (kind, id) = identity_to_payload(target);
+                EventPayload::ActorBlocked {
+                    blocker_id: blocker.value().to_string(),
+                    target_kind: kind,
+                    target_id: id,
+                }
+            }
+            DomainEvent::ActorUnblocked { blocker, target } => {
+                let (kind, id) = identity_to_payload(target);
+                EventPayload::ActorUnblocked {
+                    blocker_id: blocker.value().to_string(),
+                    target_kind: kind,
+                    target_id: id,
+                }
+            }
             DomainEvent::BackfillFollower {
                 owner_user_id,
                 follower_inbox_url,
@@ -435,14 +557,61 @@ impl TryFrom<EventPayload> for DomainEvent {
                     movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
                 })
             }
+            EventPayload::FollowRequested {
+                follower_id,
+                target_kind,
+                target_id,
+            } => Ok(DomainEvent::FollowRequested {
+                follower: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                target: payload_to_follow_target(&target_kind, target_id)?,
+            }),
             EventPayload::FollowAccepted {
-                local_user_id,
-                remote_actor_url,
-                outbox_url,
+                owner_id,
+                requester_kind,
+                requester_id,
             } => Ok(DomainEvent::FollowAccepted {
-                local_user_id: UserId::from_uuid(parse_uuid(&local_user_id, "local_user_id")?),
-                remote_actor_url,
-                outbox_url,
+                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
+                requester: payload_to_identity(&requester_kind, requester_id)?,
+            }),
+            EventPayload::FollowRejected {
+                owner_id,
+                requester_kind,
+                requester_id,
+            } => Ok(DomainEvent::FollowRejected {
+                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
+                requester: payload_to_identity(&requester_kind, requester_id)?,
+            }),
+            EventPayload::Unfollowed {
+                follower_id,
+                target_kind,
+                target_id,
+            } => Ok(DomainEvent::Unfollowed {
+                follower: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                target: payload_to_identity(&target_kind, target_id)?,
+            }),
+            EventPayload::FollowerRemoved {
+                owner_id,
+                follower_kind,
+                follower_id,
+            } => Ok(DomainEvent::FollowerRemoved {
+                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
+                follower: payload_to_identity(&follower_kind, follower_id)?,
+            }),
+            EventPayload::ActorBlocked {
+                blocker_id,
+                target_kind,
+                target_id,
+            } => Ok(DomainEvent::ActorBlocked {
+                blocker: UserId::from_uuid(parse_uuid(&blocker_id, "blocker_id")?),
+                target: payload_to_identity(&target_kind, target_id)?,
+            }),
+            EventPayload::ActorUnblocked {
+                blocker_id,
+                target_kind,
+                target_id,
+            } => Ok(DomainEvent::ActorUnblocked {
+                blocker: UserId::from_uuid(parse_uuid(&blocker_id, "blocker_id")?),
+                target: payload_to_identity(&target_kind, target_id)?,
             }),
             EventPayload::BackfillFollower {
                 owner_user_id,

crates/adapters/nats/src/subject.rs

@@ -12,7 +12,13 @@ pub fn event_to_subject(prefix: &str, event: &DomainEvent) -> String {
         DomainEvent::ImageStored { .. } => "image.stored",
         DomainEvent::WatchlistEntryAdded { .. } => "watchlist.entry.added",
         DomainEvent::WatchlistEntryRemoved { .. } => "watchlist.entry.removed",
+        DomainEvent::FollowRequested { .. } => "follow.requested",
         DomainEvent::FollowAccepted { .. } => "follow.accepted",
+        DomainEvent::FollowRejected { .. } => "follow.rejected",
+        DomainEvent::Unfollowed { .. } => "follow.unfollowed",
+        DomainEvent::FollowerRemoved { .. } => "follower.removed",
+        DomainEvent::ActorBlocked { .. } => "actor.blocked",
+        DomainEvent::ActorUnblocked { .. } => "actor.unblocked",
         DomainEvent::BackfillFollower { .. } => "backfill.follower",
         DomainEvent::FederationDeliveryRequested { .. } => "federation.delivery.requested",
         DomainEvent::WatchEventIngested { .. } => "watch.event.ingested",

crates/adapters/postgres-federation/Cargo.toml

@@ -13,7 +13,7 @@ sqlx = { version = "0.8.6", features = [
 ] }
 activitypub = { workspace = true }
 adapter-common = { workspace = true }
-k-ap = { version = "0.4.1", registry = "gitea" }
+k-ap = { version = "0.5.0", registry = "gitea" }
 domain = { workspace = true }
 uuid = { workspace = true }
 chrono = { workspace = true }

crates/adapters/postgres-federation/src/actor.rs

@@ -1,43 +1,41 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{ActorRepository, RemoteActor};
+use k_ap::{AnnounceRepository, Keypair, KeypairRepository, RemoteActor, RemoteActorCache};
 use sqlx::Row;
 
 use super::{PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor};
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl ActorRepository for PostgresFederationRepository {
-    async fn get_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<Option<(String, String)>> {
+impl KeypairRepository for PostgresFederationRepository {
+    async fn get_local_actor_keypair(&self, user_id: uuid::Uuid) -> Result<Option<Keypair>> {
         let uid = user_id.to_string();
         let row =
             sqlx::query("SELECT public_key, private_key FROM ap_local_actors WHERE user_id = $1")
                 .bind(&uid)
                 .fetch_optional(&self.pool)
                 .await?;
-        Ok(row.map(|r| (r.get("public_key"), r.get("private_key"))))
+        Ok(row.map(|r| Keypair {
+            public_key: r.get("public_key"),
+            private_key: r.get("private_key"),
+        }))
     }
 
-    async fn save_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-        public_key: String,
-        private_key: String,
-    ) -> Result<()> {
+    async fn save_local_actor_keypair(&self, user_id: uuid::Uuid, keypair: Keypair) -> Result<()> {
         let uid = user_id.to_string();
         let now = Utc::now().naive_utc();
         let created_at = datetime_to_str(&now);
         sqlx::query(
             "INSERT INTO ap_local_actors (user_id, public_key, private_key, created_at) VALUES ($1, $2, $3, $4::timestamptz)
              ON CONFLICT(user_id) DO UPDATE SET public_key = EXCLUDED.public_key, private_key = EXCLUDED.private_key",
-        ).bind(&uid).bind(&public_key).bind(&private_key).bind(&created_at).execute(&self.pool).await?;
+        ).bind(&uid).bind(&keypair.public_key).bind(&keypair.private_key).bind(&created_at).execute(&self.pool).await?;
         Ok(())
     }
+}
 
+#[async_trait]
+impl RemoteActorCache for PostgresFederationRepository {
     async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()> {
         let now = Utc::now().naive_utc();
         let fetched_at = datetime_to_str(&now);
@@ -68,7 +66,10 @@ impl ActorRepository for PostgresFederationRepository {
             .await?;
         Ok(row.as_ref().map(|r| pg_remote_actor(r, "url")))
     }
+}
 
+#[async_trait]
+impl AnnounceRepository for PostgresFederationRepository {
     async fn add_announce(
         &self,
         activity_id: &str,

crates/adapters/postgres-federation/src/blocklist.rs

@@ -1,14 +1,14 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{BlockedDomain, BlocklistRepository};
+use k_ap::{ActorBlocklist, BlockedDomain, DomainBlocklist};
 use sqlx::Row;
 
 use super::PostgresFederationRepository;
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl BlocklistRepository for PostgresFederationRepository {
+impl DomainBlocklist for PostgresFederationRepository {
     async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()> {
         let ts = datetime_to_str(&Utc::now().naive_utc());
         sqlx::query("INSERT INTO blocked_domains (domain, reason, blocked_at) VALUES ($1, $2, $3) ON CONFLICT(domain) DO UPDATE SET reason = EXCLUDED.reason")
@@ -48,7 +48,10 @@ impl BlocklistRepository for PostgresFederationRepository {
                 .await?;
         Ok(count > 0)
     }
+}
 
+#[async_trait]
+impl ActorBlocklist for PostgresFederationRepository {
     async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
         let uid = local_user_id.to_string();
         let ts = datetime_to_str(&Utc::now().naive_utc());

crates/adapters/postgres-federation/src/follow/followers.rs

@@ -1,18 +1,16 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{
-    ActorRepository, FollowRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
-};
+use k_ap::{Follower, FollowerReader, FollowerStatus, FollowerWriter, RemoteActor};
 use sqlx::Row;
 
-use super::{
+use crate::{
     PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor, status_to_str, str_to_status,
 };
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl FollowRepository for PostgresFederationRepository {
+impl FollowerWriter for PostgresFederationRepository {
     async fn add_follower(
         &self,
         local_user_id: uuid::Uuid,
@@ -59,6 +57,25 @@ impl FollowRepository for PostgresFederationRepository {
         Ok(())
     }
 
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = status_to_str(&status);
+        let result = sqlx::query("UPDATE ap_followers SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
+            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
+        }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl FollowerReader for PostgresFederationRepository {
     async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>> {
         let uid = local_user_id.to_string();
         let q = format!(
@@ -116,22 +133,6 @@ impl FollowRepository for PostgresFederationRepository {
         Ok(count as usize)
     }
 
-    async fn update_follower_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowerStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = status_to_str(&status);
-        let result = sqlx::query("UPDATE ap_followers SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
-            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
-        }
-        Ok(())
-    }
-
     async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
         let uid = local_user_id.to_string();
         let q = format!(
@@ -193,129 +194,4 @@ impl FollowRepository for PostgresFederationRepository {
             .map(|row| pg_remote_actor(row, "remote_actor_url"))
             .collect())
     }
-
-    async fn add_following(
-        &self,
-        local_user_id: uuid::Uuid,
-        actor: RemoteActor,
-        follow_activity_id: &str,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let now = Utc::now().naive_utc();
-        let created_at = datetime_to_str(&now);
-        ActorRepository::upsert_remote_actor(self, actor.clone()).await?;
-        sqlx::query("INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at) VALUES ($1, $2, $3, $4::timestamptz) ON CONFLICT DO NOTHING")
-            .bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn get_follow_activity_id(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<String> = sqlx::query_scalar("SELECT follow_activity_id FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
-            .bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
-        Ok(row)
-    }
-
-    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
-        let uid = local_user_id.to_string();
-        sqlx::query("DELETE FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
-            .bind(&uid)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted'"
-        );
-        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
-    }
-
-    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await?;
-        Ok(count as usize)
-    }
-
-    async fn get_following_page(
-        &self,
-        local_user_id: uuid::Uuid,
-        offset: u32,
-        limit: usize,
-    ) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let q = format!(
-            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted' ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
-        );
-        let rows = sqlx::query(&q)
-            .bind(&uid)
-            .bind(limit as i64)
-            .bind(offset as i64)
-            .fetch_all(&self.pool)
-            .await?;
-        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
-    }
-
-    async fn update_following_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowingStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = match status {
-            FollowingStatus::Pending => "pending",
-            FollowingStatus::Accepted => "accepted",
-        };
-        let result = sqlx::query("UPDATE ap_following SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
-            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
-        }
-        Ok(())
-    }
-
-    async fn get_following_outbox_url(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<Option<String>> = sqlx::query_scalar(
-            "SELECT a.outbox_url FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.remote_actor_url = $2",
-        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
-        Ok(row.flatten())
-    }
-
-    async fn migrate_follower_actor(
-        &self,
-        old_actor_url: &str,
-        new_actor_url: &str,
-    ) -> Result<Vec<uuid::Uuid>> {
-        let candidates: Vec<String> = sqlx::query_scalar(
-            "SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $2)",
-        ).bind(old_actor_url).bind(new_actor_url).fetch_all(&self.pool).await?;
-        if candidates.is_empty() {
-            return Ok(vec![]);
-        }
-        sqlx::query("UPDATE ap_following SET remote_actor_url = $1 WHERE remote_actor_url = $2 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1)")
-            .bind(new_actor_url).bind(old_actor_url).execute(&self.pool).await?;
-        candidates
-            .into_iter()
-            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
-            .collect()
-    }
 }

crates/adapters/postgres-federation/src/follow/following.rs

@@ -0,0 +1,106 @@
+use crate::{PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor};
+use adapter_common::datetime_to_str;
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::{FollowingReader, FollowingStatus, FollowingWriter, RemoteActor, RemoteActorCache};
+
+#[async_trait]
+impl FollowingWriter for PostgresFederationRepository {
+    async fn add_following(
+        &self,
+        local_user_id: uuid::Uuid,
+        actor: RemoteActor,
+        follow_activity_id: &str,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let now = Utc::now().naive_utc();
+        let created_at = datetime_to_str(&now);
+        RemoteActorCache::upsert_remote_actor(self, actor.clone()).await?;
+        sqlx::query("INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at) VALUES ($1, $2, $3, $4::timestamptz) ON CONFLICT DO NOTHING")
+            .bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        let uid = local_user_id.to_string();
+        let row: Option<String> = sqlx::query_scalar("SELECT follow_activity_id FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
+        Ok(row)
+    }
+
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn update_following_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowingStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = match status {
+            FollowingStatus::Pending => "pending",
+            FollowingStatus::Accepted => "accepted",
+        };
+        let result = sqlx::query("UPDATE ap_following SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3")
+            .bind(status_str).bind(&uid).bind(remote_actor_url).execute(&self.pool).await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
+        }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl FollowingReader for PostgresFederationRepository {
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted'"
+        );
+        let rows = sqlx::query(&q).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
+    }
+
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(count as usize)
+    }
+
+    async fn get_following_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let q = format!(
+            "SELECT a.url, {PG_ACTOR_COLS} FROM ap_following f INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'accepted' ORDER BY f.created_at ASC LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query(&q)
+            .bind(&uid)
+            .bind(limit as i64)
+            .bind(offset as i64)
+            .fetch_all(&self.pool)
+            .await?;
+        Ok(rows.iter().map(|row| pg_remote_actor(row, "url")).collect())
+    }
+}

crates/adapters/postgres-federation/src/follow/migration.rs

@@ -0,0 +1,27 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use k_ap::FollowMigration;
+
+use crate::PostgresFederationRepository;
+
+#[async_trait]
+impl FollowMigration for PostgresFederationRepository {
+    async fn migrate_follower_actor(
+        &self,
+        old_actor_url: &str,
+        new_actor_url: &str,
+    ) -> Result<Vec<uuid::Uuid>> {
+        let candidates: Vec<String> = sqlx::query_scalar(
+            "SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $2)",
+        ).bind(old_actor_url).bind(new_actor_url).fetch_all(&self.pool).await?;
+        if candidates.is_empty() {
+            return Ok(vec![]);
+        }
+        sqlx::query("UPDATE ap_following SET remote_actor_url = $1 WHERE remote_actor_url = $2 AND local_user_id NOT IN (SELECT local_user_id FROM ap_following WHERE remote_actor_url = $1)")
+            .bind(new_actor_url).bind(old_actor_url).execute(&self.pool).await?;
+        candidates
+            .into_iter()
+            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
+            .collect()
+    }
+}

crates/adapters/postgres-federation/src/follow/mod.rs

@@ -0,0 +1,3 @@
+mod followers;
+mod following;
+mod migration;

crates/adapters/postgres-federation/src/follow_repository.rs

@@ -0,0 +1,303 @@
+use async_trait::async_trait;
+use chrono::Utc;
+use domain::{
+    errors::DomainError,
+    value_objects::{FollowStatus, SocialActor, SocialIdentity},
+};
+use sqlx::Row;
+
+use crate::PostgresFederationRepository;
+use adapter_common::datetime_to_str;
+
+fn follow_status_to_str(status: &FollowStatus) -> &'static str {
+    match status {
+        FollowStatus::Pending => "pending",
+        FollowStatus::Accepted => "accepted",
+        FollowStatus::Rejected => "rejected",
+    }
+}
+
+fn infra_err(e: impl std::fmt::Display) -> DomainError {
+    DomainError::InfrastructureError(e.to_string())
+}
+
+#[async_trait]
+impl domain::ports::FollowCommand for PostgresFederationRepository {
+    async fn add_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        let now = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query(
+            "INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at, status)
+             VALUES ($1, $2, '', $3::timestamptz, $4)
+             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET status = EXCLUDED.status",
+        )
+        .bind(&uid)
+        .bind(target_actor_url)
+        .bind(&now)
+        .bind(status_str)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn update_follow_status(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        sqlx::query(
+            "UPDATE ap_following SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(target_actor_url)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn remove_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        sqlx::query("DELETE FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid)
+            .bind(target_actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        let now = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query(
+            "INSERT INTO ap_followers (local_user_id, remote_actor_url, status, created_at, follow_activity_id)
+             VALUES ($1, $2, $3, $4::timestamptz, '')
+             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET status = EXCLUDED.status",
+        )
+        .bind(&uid)
+        .bind(follower_actor_url)
+        .bind(status_str)
+        .bind(&now)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        sqlx::query(
+            "UPDATE ap_followers SET status = $1 WHERE local_user_id = $2 AND remote_actor_url = $3",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(follower_actor_url)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn remove_follower_record(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_followers WHERE local_user_id = $1 AND remote_actor_url = $2")
+            .bind(&uid)
+            .bind(follower_actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(infra_err)?;
+        Ok(())
+    }
+}
+
+fn social_actor_from_row(row: &sqlx::postgres::PgRow, base_url: &str) -> SocialActor {
+    let actor_url: String = row.get("remote_actor_url");
+    let identity = SocialIdentity::from_actor_url(&actor_url, base_url);
+
+    let (handle, display_name, avatar_url) = match &identity {
+        SocialIdentity::Local(_) => {
+            let username: Option<String> = row.try_get("local_username").ok().flatten();
+            let display: Option<String> = row.try_get("local_display").ok().flatten();
+            let avatar: Option<String> = row
+                .try_get::<Option<String>, _>("local_avatar_path")
+                .ok()
+                .flatten()
+                .map(|p| format!("{}/images/{}", base_url, p));
+            let handle = username
+                .as_deref()
+                .map(|u| SocialIdentity::format_local_handle(u, base_url))
+                .unwrap_or_else(|| actor_url.clone());
+            (handle, display, avatar)
+        }
+        SocialIdentity::Remote { .. } => {
+            let handle: String = row
+                .try_get("remote_handle")
+                .ok()
+                .unwrap_or_else(|| actor_url.clone());
+            let display: Option<String> = row.try_get("remote_display").ok().flatten();
+            let avatar: Option<String> = row.try_get("remote_avatar").ok().flatten();
+            (handle, display, avatar)
+        }
+    };
+
+    SocialActor {
+        identity,
+        handle,
+        display_name,
+        avatar_url,
+    }
+}
+
+#[async_trait]
+impl domain::ports::FollowQuery for PostgresFederationRepository {
+    async fn get_following(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_following f
+             LEFT JOIN users u ON f.remote_actor_url = $1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = $2 AND f.status = 'accepted'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn get_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_followers f
+             LEFT JOIN users u ON f.remote_actor_url = $1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = $2 AND f.status = 'accepted'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn get_pending_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_followers f
+             LEFT JOIN users u ON f.remote_actor_url = $1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = $2 AND f.status = 'pending'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn count_following(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count as usize)
+    }
+
+    async fn count_followers(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count as usize)
+    }
+
+    async fn is_following(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<bool, DomainError> {
+        let uid = follower_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND remote_actor_url = $2 AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .bind(target_actor_url)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count > 0)
+    }
+}

crates/adapters/postgres-federation/src/lib.rs

@@ -4,6 +4,7 @@ pub mod ap_content;
 mod blocklist;
 mod federated_profile;
 mod follow;
+mod follow_repository;
 pub mod remote_goals;
 mod review;
 mod social;
@@ -79,13 +80,15 @@ pub fn create_federated_profile_query(
 
 pub fn wire(pool: PgPool) -> activitypub::FederationRepos {
     let fed = std::sync::Arc::new(PostgresFederationRepository::new(pool));
-    (
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        fed as _,
-    )
+    activitypub::FederationRepos {
+        activity: std::sync::Arc::clone(&fed) as _,
+        follow: std::sync::Arc::clone(&fed) as _,
+        actor: std::sync::Arc::clone(&fed) as _,
+        blocklist: std::sync::Arc::clone(&fed) as _,
+        admin_query: std::sync::Arc::clone(&fed) as _,
+        review_store: std::sync::Arc::clone(&fed) as _,
+        remote_watchlist: std::sync::Arc::clone(&fed) as _,
+        follow_command: std::sync::Arc::clone(&fed) as _,
+        follow_query: fed as _,
+    }
 }

crates/adapters/postgres-federation/src/social.rs

@@ -1,26 +1,10 @@
 use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    models::{PendingFollowerInfo, RemoteActorInfo},
-    ports::SocialQueryPort,
-    value_objects::UserId,
-};
+use domain::{errors::DomainError, models::RemoteActorInfo, ports::FederationAdminQuery};
 
 use super::PostgresFederationRepository;
 
 #[async_trait]
-impl SocialQueryPort for PostgresFederationRepository {
-    async fn get_accepted_following_urls(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<String>, DomainError> {
-        let user_id_str = user_id.value().to_string();
-        sqlx::query_scalar::<_, String>(
-            "SELECT remote_actor_url FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        ).bind(&user_id_str).fetch_all(&self.pool).await
-         .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-
+impl FederationAdminQuery for PostgresFederationRepository {
     async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError> {
         let rows = sqlx::query_as::<_, (String, String, Option<String>)>(
             "SELECT DISTINCT ar.url, ar.handle, ar.display_name FROM ap_remote_actors ar JOIN ap_following f ON f.remote_actor_url = ar.url WHERE f.status = 'accepted'",
@@ -34,49 +18,4 @@ impl SocialQueryPort for PostgresFederationRepository {
             })
             .collect())
     }
-
-    async fn count_following(&self, user_id: &UserId) -> Result<usize, DomainError> {
-        let uid = user_id.value().to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn count_accepted_followers(&self, user_id: &UserId) -> Result<usize, DomainError> {
-        let uid = user_id.value().to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = $1 AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn get_pending_followers(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<PendingFollowerInfo>, DomainError> {
-        let uid = user_id.value().to_string();
-        let rows = sqlx::query_as::<_, (String, String, Option<String>, Option<String>)>(
-            "SELECT ar.url, ar.handle, ar.display_name, ar.avatar_url FROM ap_followers f JOIN ap_remote_actors ar ON ar.url = f.remote_actor_url WHERE f.local_user_id = $1 AND f.status = 'pending'",
-        ).bind(&uid).fetch_all(&self.pool).await.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(rows
-            .into_iter()
-            .map(
-                |(url, handle, display_name, avatar_url)| PendingFollowerInfo {
-                    url,
-                    handle,
-                    display_name,
-                    avatar_url,
-                },
-            )
-            .collect())
-    }
 }

crates/adapters/postgres/src/models.rs

@@ -257,3 +257,21 @@ pub(crate) struct MonthlyRatingRow {
     pub avg_rating: f64,
     pub count: i64,
 }
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct GenreCountRow {
+    pub genre: String,
+    pub count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct RatingDistRow {
+    pub rating: i64,
+    pub count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct WatchMediumCountRow {
+    pub watch_medium: String,
+    pub count: i64,
+}

crates/adapters/postgres/src/stats.rs

@@ -7,7 +7,10 @@ use domain::{
 };
 use sqlx::PgPool;
 
-use crate::models::{DirectorCountRow, MonthlyRatingRow, UserTotalsRow};
+use crate::models::{
+    DirectorCountRow, GenreCountRow, MonthlyRatingRow, RatingDistRow, UserTotalsRow,
+    WatchMediumCountRow,
+};
 use adapter_common::format_year_month;
 
 pub struct PostgresStatsRepository {
@@ -97,7 +100,8 @@ impl StatsRepository for PostgresStatsRepository {
     async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError> {
         let uid = user_id.value().to_string();
 
-        let (rating_rows, director_rows) = tokio::try_join!(
+        let (rating_rows, director_rows, genre_rows, rating_dist_rows, medium_rows) =
+            tokio::try_join!(
                 sqlx::query_as::<_, MonthlyRatingRow>(
                     "SELECT to_char(watched_at AT TIME ZONE 'UTC', 'YYYY-MM') AS month,
                         AVG(rating::float) AS avg_rating,
@@ -119,6 +123,35 @@ impl StatsRepository for PostgresStatsRepository {
                  LIMIT 5"
                 )
                 .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, GenreCountRow>(
+                    "SELECT mg.name AS genre, COUNT(*) AS count
+                 FROM reviews r
+                 INNER JOIN movie_genres mg ON mg.movie_id = r.movie_id
+                 WHERE r.user_id = $1
+                 GROUP BY mg.name
+                 ORDER BY COUNT(*) DESC
+                 LIMIT 5"
+                )
+                .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, RatingDistRow>(
+                    "SELECT rating, COUNT(*) AS count
+                 FROM reviews
+                 WHERE user_id = $1
+                 GROUP BY rating
+                 ORDER BY rating ASC"
+                )
+                .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, WatchMediumCountRow>(
+                    "SELECT watch_medium, COUNT(*) AS count
+                 FROM reviews
+                 WHERE user_id = $1 AND watch_medium IS NOT NULL
+                 GROUP BY watch_medium
+                 ORDER BY COUNT(*) DESC"
+                )
+                .bind(&uid)
                 .fetch_all(&self.pool)
             )
             .map_err(adapter_common::map_sqlx_error)?;
@@ -143,10 +176,38 @@ impl StatsRepository for PostgresStatsRepository {
             })
             .collect();
 
+        let top_genres = genre_rows
+            .into_iter()
+            .map(|g| domain::models::stats::GenreStat {
+                genre: g.genre,
+                count: g.count,
+            })
+            .collect();
+
+        let rating_distribution = {
+            let mut dist = [0i64; 5];
+            for r in &rating_dist_rows {
+                let idx = (r.rating as usize).saturating_sub(1).min(4);
+                dist[idx] = r.count;
+            }
+            dist
+        };
+
+        let watch_medium_distribution = medium_rows
+            .into_iter()
+            .map(|m| domain::models::stats::WatchMediumStat {
+                medium: m.watch_medium,
+                count: m.count,
+            })
+            .collect();
+
         Ok(UserTrends {
             monthly_ratings,
             top_directors,
             max_director_count,
+            top_genres,
+            rating_distribution,
+            watch_medium_distribution,
         })
     }
 }

crates/adapters/postgres/src/wrapup.rs

@@ -289,7 +289,7 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
             "SELECT r.movie_id, m.title, m.release_year, m.director, m.poster_path, \
                     r.rating, \
                     to_char(r.watched_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS') AS watched_at, \
-                    r.user_id, \
+                    r.user_id, r.watch_medium, \
                     p.runtime_minutes, p.budget_usd, p.original_language \
              FROM reviews r \
              INNER JOIN movies m ON m.id = r.movie_id \
@@ -367,6 +367,9 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
             let original_language: Option<String> = row
                 .try_get("original_language")
                 .map_err(adapter_common::map_sqlx_error)?;
+            let watch_medium: Option<String> = row
+                .try_get("watch_medium")
+                .map_err(adapter_common::map_sqlx_error)?;
 
             let genres = genres_map.get(&movie_id_str).cloned().unwrap_or_default();
             let keywords = keywords_map.get(&movie_id_str).cloned().unwrap_or_default();
@@ -391,6 +394,7 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
                 runtime_minutes: runtime_minutes.map(|v| v as u32),
                 budget_usd,
                 original_language,
+                watch_medium,
                 genres,
                 keywords,
                 cast_names,

crates/adapters/sqlite-federation/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 sqlx = { workspace = true }
 activitypub = { workspace = true }
 adapter-common = { workspace = true }
-k-ap = { version = "0.4.1", registry = "gitea" }
+k-ap = { version = "0.5.0", registry = "gitea" }
 domain = { workspace = true }
 anyhow = { workspace = true }
 serde_json = { workspace = true }

crates/adapters/sqlite-federation/src/actor.rs

@@ -1,33 +1,28 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{ActorRepository, RemoteActor};
+use k_ap::{AnnounceRepository, Keypair, KeypairRepository, RemoteActor, RemoteActorCache};
 use sqlx::Row;
 
 use super::{SqliteFederationRepository, remote_actor_from_row};
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl ActorRepository for SqliteFederationRepository {
-    async fn get_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-    ) -> Result<Option<(String, String)>> {
+impl KeypairRepository for SqliteFederationRepository {
+    async fn get_local_actor_keypair(&self, user_id: uuid::Uuid) -> Result<Option<Keypair>> {
         let uid = user_id.to_string();
         let row =
             sqlx::query("SELECT public_key, private_key FROM ap_local_actors WHERE user_id = ?")
                 .bind(&uid)
                 .fetch_optional(&self.pool)
                 .await?;
-        Ok(row.map(|r| (r.get("public_key"), r.get("private_key"))))
+        Ok(row.map(|r| Keypair {
+            public_key: r.get("public_key"),
+            private_key: r.get("private_key"),
+        }))
     }
 
-    async fn save_local_actor_keypair(
-        &self,
-        user_id: uuid::Uuid,
-        public_key: String,
-        private_key: String,
-    ) -> Result<()> {
+    async fn save_local_actor_keypair(&self, user_id: uuid::Uuid, keypair: Keypair) -> Result<()> {
         let uid = user_id.to_string();
         let now = Utc::now().naive_utc();
         let created_at = datetime_to_str(&now);
@@ -39,14 +34,17 @@ impl ActorRepository for SqliteFederationRepository {
                  private_key = excluded.private_key",
         )
         .bind(&uid)
-        .bind(&public_key)
-        .bind(&private_key)
+        .bind(&keypair.public_key)
+        .bind(&keypair.private_key)
         .bind(&created_at)
         .execute(&self.pool)
         .await?;
         Ok(())
     }
+}
 
+#[async_trait]
+impl RemoteActorCache for SqliteFederationRepository {
     async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()> {
         let now = Utc::now().naive_utc();
         let fetched_at = datetime_to_str(&now);
@@ -84,7 +82,10 @@ impl ActorRepository for SqliteFederationRepository {
         ).bind(actor_url).fetch_optional(&self.pool).await?;
         Ok(row.as_ref().map(|r| remote_actor_from_row(r, "url")))
     }
+}
 
+#[async_trait]
+impl AnnounceRepository for SqliteFederationRepository {
     async fn add_announce(
         &self,
         activity_id: &str,

crates/adapters/sqlite-federation/src/blocklist.rs

@@ -1,14 +1,14 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{BlockedDomain, BlocklistRepository};
+use k_ap::{ActorBlocklist, BlockedDomain, DomainBlocklist};
 use sqlx::Row;
 
 use super::SqliteFederationRepository;
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl BlocklistRepository for SqliteFederationRepository {
+impl DomainBlocklist for SqliteFederationRepository {
     async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()> {
         let now = Utc::now().naive_utc();
         let ts = datetime_to_str(&now);
@@ -56,7 +56,10 @@ impl BlocklistRepository for SqliteFederationRepository {
                 .await?;
         Ok(count > 0)
     }
+}
 
+#[async_trait]
+impl ActorBlocklist for SqliteFederationRepository {
     async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
         let uid = local_user_id.to_string();
         let ts = datetime_to_str(&Utc::now().naive_utc());

crates/adapters/sqlite-federation/src/follow/followers.rs

@@ -1,16 +1,14 @@
 use anyhow::Result;
 use async_trait::async_trait;
 use chrono::Utc;
-use k_ap::{
-    ActorRepository, FollowRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
-};
+use k_ap::{Follower, FollowerReader, FollowerStatus, FollowerWriter, RemoteActor};
 use sqlx::Row;
 
-use super::{SqliteFederationRepository, remote_actor_from_row, status_to_str, str_to_status};
+use crate::{SqliteFederationRepository, remote_actor_from_row, status_to_str, str_to_status};
 use adapter_common::datetime_to_str;
 
 #[async_trait]
-impl FollowRepository for SqliteFederationRepository {
+impl FollowerWriter for SqliteFederationRepository {
     async fn add_follower(
         &self,
         local_user_id: uuid::Uuid,
@@ -69,6 +67,31 @@ impl FollowRepository for SqliteFederationRepository {
         Ok(())
     }
 
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = status_to_str(&status);
+        let result = sqlx::query(
+            "UPDATE ap_followers SET status = ? WHERE local_user_id = ? AND remote_actor_url = ?",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(remote_actor_url)
+        .execute(&self.pool)
+        .await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
+        }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl FollowerReader for SqliteFederationRepository {
     async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>> {
         let uid = local_user_id.to_string();
         let rows = sqlx::query(
@@ -138,28 +161,6 @@ impl FollowRepository for SqliteFederationRepository {
         Ok(count as usize)
     }
 
-    async fn update_follower_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowerStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = status_to_str(&status);
-        let result = sqlx::query(
-            "UPDATE ap_followers SET status = ? WHERE local_user_id = ? AND remote_actor_url = ?",
-        )
-        .bind(status_str)
-        .bind(&uid)
-        .bind(remote_actor_url)
-        .execute(&self.pool)
-        .await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_follower_status: no row found");
-        }
-        Ok(())
-    }
-
     async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
         let uid = local_user_id.to_string();
         let rows = sqlx::query(
@@ -232,173 +233,4 @@ impl FollowRepository for SqliteFederationRepository {
             .map(|row| remote_actor_from_row(row, "remote_actor_url"))
             .collect())
     }
-
-    async fn add_following(
-        &self,
-        local_user_id: uuid::Uuid,
-        actor: RemoteActor,
-        follow_activity_id: &str,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let now = Utc::now().naive_utc();
-        let created_at = datetime_to_str(&now);
-        ActorRepository::upsert_remote_actor(self, actor.clone()).await?;
-        sqlx::query(
-            "INSERT OR IGNORE INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at)
-             VALUES (?, ?, ?, ?)",
-        ).bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
-        Ok(())
-    }
-
-    async fn get_follow_activity_id(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<Option<String>> = sqlx::query_scalar(
-            "SELECT follow_activity_id FROM ap_following WHERE local_user_id = ? AND remote_actor_url = ?",
-        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
-        Ok(row.flatten())
-    }
-
-    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
-        let uid = local_user_id.to_string();
-        sqlx::query("DELETE FROM ap_following WHERE local_user_id = ? AND remote_actor_url = ?")
-            .bind(&uid)
-            .bind(actor_url)
-            .execute(&self.pool)
-            .await?;
-        Ok(())
-    }
-
-    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let rows = sqlx::query(
-            "SELECT a.url, a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url,
-                    a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at
-             FROM ap_following f
-             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = ? AND f.status = 'accepted'",
-        ).bind(&uid).fetch_all(&self.pool).await?;
-        Ok(rows
-            .iter()
-            .map(|row| remote_actor_from_row(row, "url"))
-            .collect())
-    }
-
-    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
-        let uid = local_user_id.to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = ? AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await?;
-        Ok(count as usize)
-    }
-
-    async fn get_following_page(
-        &self,
-        local_user_id: uuid::Uuid,
-        offset: u32,
-        limit: usize,
-    ) -> Result<Vec<RemoteActor>> {
-        let uid = local_user_id.to_string();
-        let rows = sqlx::query(
-            "SELECT a.url, a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url,
-                    a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at
-             FROM ap_following f
-             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = ? AND f.status = 'accepted'
-             ORDER BY f.created_at ASC LIMIT ? OFFSET ?",
-        ).bind(&uid).bind(limit as i64).bind(offset as i64).fetch_all(&self.pool).await?;
-        Ok(rows
-            .iter()
-            .map(|row| remote_actor_from_row(row, "url"))
-            .collect())
-    }
-
-    async fn update_following_status(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-        status: FollowingStatus,
-    ) -> Result<()> {
-        let uid = local_user_id.to_string();
-        let status_str = match status {
-            FollowingStatus::Pending => "pending",
-            FollowingStatus::Accepted => "accepted",
-        };
-        let result = sqlx::query(
-            "UPDATE ap_following SET status = ? WHERE local_user_id = ? AND remote_actor_url = ?",
-        )
-        .bind(status_str)
-        .bind(&uid)
-        .bind(remote_actor_url)
-        .execute(&self.pool)
-        .await?;
-        if result.rows_affected() == 0 {
-            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
-        }
-        Ok(())
-    }
-
-    async fn get_following_outbox_url(
-        &self,
-        local_user_id: uuid::Uuid,
-        remote_actor_url: &str,
-    ) -> Result<Option<String>> {
-        let uid = local_user_id.to_string();
-        let row: Option<Option<String>> = sqlx::query_scalar(
-            "SELECT a.outbox_url
-             FROM ap_following f
-             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
-             WHERE f.local_user_id = ? AND f.remote_actor_url = ?",
-        )
-        .bind(&uid)
-        .bind(remote_actor_url)
-        .fetch_optional(&self.pool)
-        .await?;
-        Ok(row.flatten())
-    }
-
-    async fn migrate_follower_actor(
-        &self,
-        old_actor_url: &str,
-        new_actor_url: &str,
-    ) -> Result<Vec<uuid::Uuid>> {
-        let candidates: Vec<String> = sqlx::query_scalar(
-            "SELECT local_user_id FROM ap_following
-             WHERE remote_actor_url = ?1
-               AND local_user_id NOT IN (
-                   SELECT local_user_id FROM ap_following WHERE remote_actor_url = ?2
-               )",
-        )
-        .bind(old_actor_url)
-        .bind(new_actor_url)
-        .fetch_all(&self.pool)
-        .await?;
-
-        if candidates.is_empty() {
-            return Ok(vec![]);
-        }
-
-        sqlx::query(
-            "UPDATE ap_following SET remote_actor_url = ?1
-             WHERE remote_actor_url = ?2
-               AND local_user_id NOT IN (
-                   SELECT local_user_id FROM ap_following WHERE remote_actor_url = ?1
-               )",
-        )
-        .bind(new_actor_url)
-        .bind(old_actor_url)
-        .execute(&self.pool)
-        .await?;
-
-        candidates
-            .into_iter()
-            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
-            .collect()
-    }
 }

crates/adapters/sqlite-federation/src/follow/following.rs

@@ -0,0 +1,124 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use k_ap::{FollowingReader, FollowingStatus, FollowingWriter, RemoteActor, RemoteActorCache};
+
+use crate::{SqliteFederationRepository, remote_actor_from_row};
+use adapter_common::datetime_to_str;
+
+#[async_trait]
+impl FollowingWriter for SqliteFederationRepository {
+    async fn add_following(
+        &self,
+        local_user_id: uuid::Uuid,
+        actor: RemoteActor,
+        follow_activity_id: &str,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let now = Utc::now().naive_utc();
+        let created_at = datetime_to_str(&now);
+        RemoteActorCache::upsert_remote_actor(self, actor.clone()).await?;
+        sqlx::query(
+            "INSERT OR IGNORE INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at)
+             VALUES (?, ?, ?, ?)",
+        ).bind(&uid).bind(&actor.url).bind(follow_activity_id).bind(&created_at).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        let uid = local_user_id.to_string();
+        let row: Option<Option<String>> = sqlx::query_scalar(
+            "SELECT follow_activity_id FROM ap_following WHERE local_user_id = ? AND remote_actor_url = ?",
+        ).bind(&uid).bind(remote_actor_url).fetch_optional(&self.pool).await?;
+        Ok(row.flatten())
+    }
+
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_following WHERE local_user_id = ? AND remote_actor_url = ?")
+            .bind(&uid)
+            .bind(actor_url)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn update_following_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowingStatus,
+    ) -> Result<()> {
+        let uid = local_user_id.to_string();
+        let status_str = match status {
+            FollowingStatus::Pending => "pending",
+            FollowingStatus::Accepted => "accepted",
+        };
+        let result = sqlx::query(
+            "UPDATE ap_following SET status = ? WHERE local_user_id = ? AND remote_actor_url = ?",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(remote_actor_url)
+        .execute(&self.pool)
+        .await?;
+        if result.rows_affected() == 0 {
+            tracing::warn!(local_user_id = %local_user_id, remote_actor_url, "update_following_status: no row found");
+        }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl FollowingReader for SqliteFederationRepository {
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT a.url, a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url,
+                    a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at
+             FROM ap_following f
+             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = ? AND f.status = 'accepted'",
+        ).bind(&uid).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .map(|row| remote_actor_from_row(row, "url"))
+            .collect())
+    }
+
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let uid = local_user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = ? AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(count as usize)
+    }
+
+    async fn get_following_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>> {
+        let uid = local_user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT a.url, a.handle, a.inbox_url, a.shared_inbox_url, a.display_name, a.avatar_url,
+                    a.outbox_url, a.bio, a.banner_url, a.followers_url, a.following_url, a.also_known_as, a.fetched_at
+             FROM ap_following f
+             INNER JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = ? AND f.status = 'accepted'
+             ORDER BY f.created_at ASC LIMIT ? OFFSET ?",
+        ).bind(&uid).bind(limit as i64).bind(offset as i64).fetch_all(&self.pool).await?;
+        Ok(rows
+            .iter()
+            .map(|row| remote_actor_from_row(row, "url"))
+            .collect())
+    }
+}

crates/adapters/sqlite-federation/src/follow/migration.rs

@@ -0,0 +1,47 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use k_ap::FollowMigration;
+
+use crate::SqliteFederationRepository;
+
+#[async_trait]
+impl FollowMigration for SqliteFederationRepository {
+    async fn migrate_follower_actor(
+        &self,
+        old_actor_url: &str,
+        new_actor_url: &str,
+    ) -> Result<Vec<uuid::Uuid>> {
+        let candidates: Vec<String> = sqlx::query_scalar(
+            "SELECT local_user_id FROM ap_following
+             WHERE remote_actor_url = ?1
+               AND local_user_id NOT IN (
+                   SELECT local_user_id FROM ap_following WHERE remote_actor_url = ?2
+               )",
+        )
+        .bind(old_actor_url)
+        .bind(new_actor_url)
+        .fetch_all(&self.pool)
+        .await?;
+
+        if candidates.is_empty() {
+            return Ok(vec![]);
+        }
+
+        sqlx::query(
+            "UPDATE ap_following SET remote_actor_url = ?1
+             WHERE remote_actor_url = ?2
+               AND local_user_id NOT IN (
+                   SELECT local_user_id FROM ap_following WHERE remote_actor_url = ?1
+               )",
+        )
+        .bind(new_actor_url)
+        .bind(old_actor_url)
+        .execute(&self.pool)
+        .await?;
+
+        candidates
+            .into_iter()
+            .map(|s| uuid::Uuid::parse_str(&s).map_err(|e| anyhow::anyhow!(e)))
+            .collect()
+    }
+}

crates/adapters/sqlite-federation/src/follow/mod.rs

@@ -0,0 +1,3 @@
+mod followers;
+mod following;
+mod migration;

crates/adapters/sqlite-federation/src/follow_repository.rs

@@ -0,0 +1,303 @@
+use async_trait::async_trait;
+use chrono::Utc;
+use domain::{
+    errors::DomainError,
+    value_objects::{FollowStatus, SocialActor, SocialIdentity},
+};
+use sqlx::Row;
+
+use crate::SqliteFederationRepository;
+use adapter_common::datetime_to_str;
+
+fn follow_status_to_str(status: &FollowStatus) -> &'static str {
+    match status {
+        FollowStatus::Pending => "pending",
+        FollowStatus::Accepted => "accepted",
+        FollowStatus::Rejected => "rejected",
+    }
+}
+
+fn infra_err(e: impl std::fmt::Display) -> DomainError {
+    DomainError::InfrastructureError(e.to_string())
+}
+
+#[async_trait]
+impl domain::ports::FollowCommand for SqliteFederationRepository {
+    async fn add_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        let now = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query(
+            "INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, created_at, status)
+             VALUES (?1, ?2, '', ?3, ?4)
+             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET status = excluded.status",
+        )
+        .bind(&uid)
+        .bind(target_actor_url)
+        .bind(&now)
+        .bind(status_str)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn update_follow_status(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        sqlx::query(
+            "UPDATE ap_following SET status = ?1 WHERE local_user_id = ?2 AND remote_actor_url = ?3",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(target_actor_url)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn remove_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<(), DomainError> {
+        let uid = follower_id.to_string();
+        sqlx::query("DELETE FROM ap_following WHERE local_user_id = ?1 AND remote_actor_url = ?2")
+            .bind(&uid)
+            .bind(target_actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        let now = datetime_to_str(&Utc::now().naive_utc());
+        sqlx::query(
+            "INSERT INTO ap_followers (local_user_id, remote_actor_url, status, created_at, follow_activity_id)
+             VALUES (?1, ?2, ?3, ?4, '')
+             ON CONFLICT(local_user_id, remote_actor_url) DO UPDATE SET status = excluded.status",
+        )
+        .bind(&uid)
+        .bind(follower_actor_url)
+        .bind(status_str)
+        .bind(&now)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        let status_str = follow_status_to_str(&status);
+        sqlx::query(
+            "UPDATE ap_followers SET status = ?1 WHERE local_user_id = ?2 AND remote_actor_url = ?3",
+        )
+        .bind(status_str)
+        .bind(&uid)
+        .bind(follower_actor_url)
+        .execute(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(())
+    }
+
+    async fn remove_follower_record(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+    ) -> Result<(), DomainError> {
+        let uid = local_user_id.to_string();
+        sqlx::query("DELETE FROM ap_followers WHERE local_user_id = ?1 AND remote_actor_url = ?2")
+            .bind(&uid)
+            .bind(follower_actor_url)
+            .execute(&self.pool)
+            .await
+            .map_err(infra_err)?;
+        Ok(())
+    }
+}
+
+fn social_actor_from_row(row: &sqlx::sqlite::SqliteRow, base_url: &str) -> SocialActor {
+    let actor_url: String = row.get("remote_actor_url");
+    let identity = SocialIdentity::from_actor_url(&actor_url, base_url);
+
+    let (handle, display_name, avatar_url) = match &identity {
+        SocialIdentity::Local(_) => {
+            let username: Option<String> = row.try_get("local_username").ok().flatten();
+            let display: Option<String> = row.try_get("local_display").ok().flatten();
+            let avatar: Option<String> = row
+                .try_get::<Option<String>, _>("local_avatar_path")
+                .ok()
+                .flatten()
+                .map(|p| format!("{}/images/{}", base_url, p));
+            let handle = username
+                .as_deref()
+                .map(|u| SocialIdentity::format_local_handle(u, base_url))
+                .unwrap_or_else(|| actor_url.clone());
+            (handle, display, avatar)
+        }
+        SocialIdentity::Remote { .. } => {
+            let handle: String = row
+                .try_get("remote_handle")
+                .ok()
+                .unwrap_or_else(|| actor_url.clone());
+            let display: Option<String> = row.try_get("remote_display").ok().flatten();
+            let avatar: Option<String> = row.try_get("remote_avatar").ok().flatten();
+            (handle, display, avatar)
+        }
+    };
+
+    SocialActor {
+        identity,
+        handle,
+        display_name,
+        avatar_url,
+    }
+}
+
+#[async_trait]
+impl domain::ports::FollowQuery for SqliteFederationRepository {
+    async fn get_following(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_following f
+             LEFT JOIN users u ON f.remote_actor_url = ?1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = ?2 AND f.status = 'accepted'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn get_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_followers f
+             LEFT JOIN users u ON f.remote_actor_url = ?1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = ?2 AND f.status = 'accepted'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn get_pending_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError> {
+        let uid = user_id.to_string();
+        let rows = sqlx::query(
+            "SELECT f.remote_actor_url,
+                    u.username AS local_username, u.display_name AS local_display, u.avatar_path AS local_avatar_path,
+                    a.handle AS remote_handle, a.display_name AS remote_display, a.avatar_url AS remote_avatar
+             FROM ap_followers f
+             LEFT JOIN users u ON f.remote_actor_url = ?1 || '/users/' || u.id
+             LEFT JOIN ap_remote_actors a ON a.url = f.remote_actor_url
+             WHERE f.local_user_id = ?2 AND f.status = 'pending'",
+        )
+        .bind(base_url)
+        .bind(&uid)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(rows
+            .iter()
+            .map(|r| social_actor_from_row(r, base_url))
+            .collect())
+    }
+
+    async fn count_following(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = ? AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count as usize)
+    }
+
+    async fn count_followers(&self, user_id: uuid::Uuid) -> Result<usize, DomainError> {
+        let uid = user_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = ? AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count as usize)
+    }
+
+    async fn is_following(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<bool, DomainError> {
+        let uid = follower_id.to_string();
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = ? AND remote_actor_url = ? AND status = 'accepted'",
+        )
+        .bind(&uid)
+        .bind(target_actor_url)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(infra_err)?;
+        Ok(count > 0)
+    }
+}

crates/adapters/sqlite-federation/src/lib.rs

@@ -3,6 +3,7 @@ mod actor;
 mod blocklist;
 mod federated_profile;
 mod follow;
+mod follow_repository;
 mod review;
 mod social;
 mod watchlist;
@@ -91,21 +92,19 @@ pub fn create_federated_profile_query(
 
 pub fn wire(pool: SqlitePool) -> activitypub::FederationRepos {
     let fed = std::sync::Arc::new(SqliteFederationRepository::new(pool));
-    (
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        std::sync::Arc::clone(&fed) as _,
-        fed as _,
-    )
+    activitypub::FederationRepos {
+        activity: std::sync::Arc::clone(&fed) as _,
+        follow: std::sync::Arc::clone(&fed) as _,
+        actor: std::sync::Arc::clone(&fed) as _,
+        blocklist: std::sync::Arc::clone(&fed) as _,
+        admin_query: std::sync::Arc::clone(&fed) as _,
+        review_store: std::sync::Arc::clone(&fed) as _,
+        remote_watchlist: std::sync::Arc::clone(&fed) as _,
+        follow_command: std::sync::Arc::clone(&fed) as _,
+        follow_query: fed as _,
+    }
 }
 
-#[cfg(test)]
-#[path = "tests/outbox_url.rs"]
-mod outbox_url_tests;
-
 #[cfg(test)]
 #[path = "tests/actor_block_tests.rs"]
 mod actor_block_tests;

crates/adapters/sqlite-federation/src/social.rs

@@ -1,26 +1,10 @@
 use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    models::{PendingFollowerInfo, RemoteActorInfo},
-    ports::SocialQueryPort,
-    value_objects::UserId,
-};
+use domain::{errors::DomainError, models::RemoteActorInfo, ports::FederationAdminQuery};
 
 use super::SqliteFederationRepository;
 
 #[async_trait]
-impl SocialQueryPort for SqliteFederationRepository {
-    async fn get_accepted_following_urls(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<String>, DomainError> {
-        let user_id_str = user_id.value().to_string();
-        sqlx::query_scalar::<_, String>(
-            "SELECT remote_actor_url FROM ap_following WHERE local_user_id = ? AND status = 'accepted'",
-        ).bind(&user_id_str).fetch_all(&self.pool).await
-         .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-
+impl FederationAdminQuery for SqliteFederationRepository {
     async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError> {
         let rows = sqlx::query_as::<_, (String, String, Option<String>)>(
             "SELECT DISTINCT ar.url, ar.handle, ar.display_name
@@ -40,56 +24,4 @@ impl SocialQueryPort for SqliteFederationRepository {
             })
             .collect())
     }
-
-    async fn count_following(&self, user_id: &UserId) -> Result<usize, DomainError> {
-        let uid = user_id.value().to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_following WHERE local_user_id = ? AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn count_accepted_followers(&self, user_id: &UserId) -> Result<usize, DomainError> {
-        let uid = user_id.value().to_string();
-        let count: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM ap_followers WHERE local_user_id = ? AND status = 'accepted'",
-        )
-        .bind(&uid)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(count as usize)
-    }
-
-    async fn get_pending_followers(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<PendingFollowerInfo>, DomainError> {
-        let uid = user_id.value().to_string();
-        let rows = sqlx::query_as::<_, (String, String, Option<String>, Option<String>)>(
-            "SELECT ar.url, ar.handle, ar.display_name, ar.avatar_url
-             FROM ap_followers f
-             JOIN ap_remote_actors ar ON ar.url = f.remote_actor_url
-             WHERE f.local_user_id = ? AND f.status = 'pending'",
-        )
-        .bind(&uid)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(rows
-            .into_iter()
-            .map(
-                |(url, handle, display_name, avatar_url)| PendingFollowerInfo {
-                    url,
-                    handle,
-                    display_name,
-                    avatar_url,
-                },
-            )
-            .collect())
-    }
 }

crates/adapters/sqlite-federation/src/tests/actor_block_tests.rs

@@ -1,5 +1,5 @@
 use super::*;
-use k_ap::BlocklistRepository;
+use k_ap::ActorBlocklist;
 use sqlx::SqlitePool;
 
 async fn test_pool() -> SqlitePool {

crates/adapters/sqlite-federation/src/tests/domain_block_tests.rs

@@ -1,5 +1,5 @@
 use super::*;
-use k_ap::BlocklistRepository;
+use k_ap::DomainBlocklist;
 use sqlx::SqlitePool;
 
 async fn test_pool() -> SqlitePool {

crates/adapters/sqlite-federation/src/tests/lib.rs

@@ -1,7 +1,7 @@
 use super::*;
 use chrono::Utc;
-use domain::ports::SocialQueryPort;
-use k_ap::ActorRepository;
+use domain::ports::FederationAdminQuery;
+use k_ap::AnnounceRepository;
 use sqlx::SqlitePool;
 
 async fn test_pool() -> SqlitePool {
@@ -79,30 +79,6 @@ async fn setup_db(pool: &SqlitePool) {
     .unwrap();
 }
 
-#[tokio::test]
-async fn test_get_accepted_following_urls_returns_only_accepted() {
-    let pool = SqlitePool::connect(":memory:").await.unwrap();
-    setup_db(&pool).await;
-    let repo = SqliteFederationRepository::new(pool.clone());
-    let user_id = uuid::Uuid::new_v4();
-
-    sqlx::query(
-        "INSERT INTO ap_following (local_user_id, remote_actor_url, follow_activity_id, status)
-         VALUES (?, 'https://other.social/users/alice', 'act1', 'accepted'),
-                (?, 'https://other.social/users/bob', 'act2', 'pending')",
-    )
-    .bind(user_id.to_string())
-    .bind(user_id.to_string())
-    .execute(&pool)
-    .await
-    .unwrap();
-
-    let uid = domain::value_objects::UserId::from_uuid(user_id);
-    let urls = repo.get_accepted_following_urls(&uid).await.unwrap();
-    assert_eq!(urls.len(), 1);
-    assert_eq!(urls[0], "https://other.social/users/alice");
-}
-
 #[tokio::test]
 async fn test_list_all_followed_remote_actors_deduplicates() {
     let pool = SqlitePool::connect(":memory:").await.unwrap();

crates/adapters/sqlite-federation/src/tests/outbox_url.rs

@@ -1,76 +0,0 @@
-use super::*;
-use k_ap::{FollowRepository, FollowingStatus, RemoteActor};
-
-async fn setup_pool() -> SqlitePool {
-    let pool = SqlitePool::connect(":memory:").await.unwrap();
-    sqlx::query(
-        "CREATE TABLE ap_remote_actors (
-            url TEXT PRIMARY KEY, handle TEXT NOT NULL, inbox_url TEXT NOT NULL,
-            shared_inbox_url TEXT, display_name TEXT, avatar_url TEXT,
-            outbox_url TEXT, bio TEXT, banner_url TEXT, followers_url TEXT,
-            following_url TEXT, also_known_as TEXT, fetched_at TEXT NOT NULL
-         );
-         CREATE TABLE ap_following (
-            local_user_id TEXT NOT NULL, remote_actor_url TEXT NOT NULL,
-            follow_activity_id TEXT, created_at TEXT NOT NULL,
-            status TEXT NOT NULL DEFAULT 'pending',
-            PRIMARY KEY (local_user_id, remote_actor_url)
-         );",
-    )
-    .execute(&pool)
-    .await
-    .unwrap();
-    pool
-}
-
-#[tokio::test]
-async fn get_following_outbox_url_returns_stored_url() {
-    let pool = setup_pool().await;
-    let repo = SqliteFederationRepository::new(pool);
-    let local_user = uuid::Uuid::new_v4();
-    let actor = RemoteActor {
-        url: "https://remote.example/users/alice".to_string(),
-        handle: "alice@remote.example".to_string(),
-        inbox_url: "https://remote.example/users/alice/inbox".to_string(),
-        shared_inbox_url: None,
-        display_name: None,
-        avatar_url: None,
-        outbox_url: Some("https://remote.example/users/alice/outbox".to_string()),
-        bio: None,
-        banner_url: None,
-        followers_url: None,
-        following_url: None,
-        also_known_as: vec![],
-        fetched_at: None,
-    };
-    repo.add_following(local_user, actor, "https://local/activities/1")
-        .await
-        .unwrap();
-    repo.update_following_status(
-        local_user,
-        "https://remote.example/users/alice",
-        FollowingStatus::Accepted,
-    )
-    .await
-    .unwrap();
-
-    let result = repo
-        .get_following_outbox_url(local_user, "https://remote.example/users/alice")
-        .await
-        .unwrap();
-    assert_eq!(
-        result,
-        Some("https://remote.example/users/alice/outbox".to_string())
-    );
-}
-
-#[tokio::test]
-async fn get_following_outbox_url_returns_none_when_not_following() {
-    let pool = setup_pool().await;
-    let repo = SqliteFederationRepository::new(pool);
-    let result = repo
-        .get_following_outbox_url(uuid::Uuid::new_v4(), "https://remote.example/users/alice")
-        .await
-        .unwrap();
-    assert_eq!(result, None);
-}

crates/adapters/sqlite/src/models.rs

@@ -264,6 +264,24 @@ pub(crate) struct MonthlyRatingRow {
     pub count: i64,
 }
 
+#[derive(sqlx::FromRow)]
+pub(crate) struct GenreCountRow {
+    pub genre: String,
+    pub count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct RatingDistRow {
+    pub rating: i64,
+    pub count: i64,
+}
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct WatchMediumCountRow {
+    pub watch_medium: String,
+    pub count: i64,
+}
+
 #[derive(sqlx::FromRow)]
 pub(crate) struct WatchlistRow {
     pub id: String,

crates/adapters/sqlite/src/stats.rs

@@ -7,7 +7,10 @@ use domain::{
 };
 use sqlx::SqlitePool;
 
-use crate::models::{DirectorCountRow, MonthlyRatingRow, UserTotalsRow};
+use crate::models::{
+    DirectorCountRow, GenreCountRow, MonthlyRatingRow, RatingDistRow, UserTotalsRow,
+    WatchMediumCountRow,
+};
 
 pub struct SqliteStatsRepository {
     pool: SqlitePool,
@@ -98,7 +101,8 @@ impl StatsRepository for SqliteStatsRepository {
     async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError> {
         let uid = user_id.value().to_string();
 
-        let (rating_rows, director_rows) = tokio::try_join!(
+        let (rating_rows, director_rows, genre_rows, rating_dist_rows, medium_rows) =
+            tokio::try_join!(
                 sqlx::query_as::<_, MonthlyRatingRow>(
                     "SELECT strftime('%Y-%m', watched_at) AS month,
                         AVG(CAST(rating AS REAL)) AS avg_rating,
@@ -121,6 +125,35 @@ impl StatsRepository for SqliteStatsRepository {
                  LIMIT 5",
                 )
                 .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, GenreCountRow>(
+                    "SELECT mg.name AS genre, COUNT(*) AS count
+                 FROM reviews r
+                 INNER JOIN movie_genres mg ON mg.movie_id = r.movie_id
+                 WHERE r.user_id = ?
+                 GROUP BY mg.name
+                 ORDER BY COUNT(*) DESC
+                 LIMIT 5",
+                )
+                .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, RatingDistRow>(
+                    "SELECT rating, COUNT(*) AS count
+                 FROM reviews
+                 WHERE user_id = ?
+                 GROUP BY rating
+                 ORDER BY rating ASC",
+                )
+                .bind(&uid)
+                .fetch_all(&self.pool),
+                sqlx::query_as::<_, WatchMediumCountRow>(
+                    "SELECT watch_medium, COUNT(*) AS count
+                 FROM reviews
+                 WHERE user_id = ? AND watch_medium IS NOT NULL
+                 GROUP BY watch_medium
+                 ORDER BY COUNT(*) DESC",
+                )
+                .bind(&uid)
                 .fetch_all(&self.pool)
             )
             .map_err(adapter_common::map_sqlx_error)?;
@@ -145,10 +178,38 @@ impl StatsRepository for SqliteStatsRepository {
             })
             .collect();
 
+        let top_genres = genre_rows
+            .into_iter()
+            .map(|g| domain::models::stats::GenreStat {
+                genre: g.genre,
+                count: g.count,
+            })
+            .collect();
+
+        let rating_distribution = {
+            let mut dist = [0i64; 5];
+            for r in &rating_dist_rows {
+                let idx = (r.rating as usize).saturating_sub(1).min(4);
+                dist[idx] = r.count;
+            }
+            dist
+        };
+
+        let watch_medium_distribution = medium_rows
+            .into_iter()
+            .map(|m| domain::models::stats::WatchMediumStat {
+                medium: m.watch_medium,
+                count: m.count,
+            })
+            .collect();
+
         Ok(UserTrends {
             monthly_ratings,
             top_directors,
             max_director_count,
+            top_genres,
+            rating_distribution,
+            watch_medium_distribution,
         })
     }
 }

crates/adapters/sqlite/src/wrapup.rs

@@ -301,7 +301,7 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
 
         let sql = format!(
             "SELECT r.movie_id, m.title, m.release_year, m.director, m.poster_path, \
-                    r.rating, r.watched_at, r.user_id, \
+                    r.rating, r.watched_at, r.user_id, r.watch_medium, \
                     p.runtime_minutes, p.budget_usd, p.original_language \
              FROM reviews r \
              INNER JOIN movies m ON m.id = r.movie_id \
@@ -379,6 +379,9 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
             let original_language: Option<String> = row
                 .try_get("original_language")
                 .map_err(adapter_common::map_sqlx_error)?;
+            let watch_medium: Option<String> = row
+                .try_get("watch_medium")
+                .map_err(adapter_common::map_sqlx_error)?;
 
             let genres = genres_map.get(&movie_id_str).cloned().unwrap_or_default();
             let keywords = keywords_map.get(&movie_id_str).cloned().unwrap_or_default();
@@ -403,6 +406,7 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
                 runtime_minutes: runtime_minutes.map(|v| v as u32),
                 budget_usd,
                 original_language,
+                watch_medium,
                 genres,
                 keywords,
                 cast_names,

crates/api-types/src/users.rs

@@ -60,11 +60,26 @@ pub struct DirectorStatDto {
     pub count: i64,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct GenreStatDto {
+    pub genre: String,
+    pub count: i64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct WatchMediumStatDto {
+    pub medium: String,
+    pub count: i64,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 pub struct UserTrendsDto {
     pub monthly_ratings: Vec<MonthlyRatingDto>,
     pub top_directors: Vec<DirectorStatDto>,
     pub max_director_count: i64,
+    pub top_genres: Vec<GenreStatDto>,
+    pub rating_distribution: [i64; 5],
+    pub watch_medium_distribution: Vec<WatchMediumStatDto>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]

crates/application/src/diary/deps.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use domain::ports::{
     DiaryQuery, EventPublisher, MovieCommand, MovieProfileRepository, MovieQuery, ReviewRepository,
-    SocialQueryPort,
+    SocialQuery,
 };
 
 use crate::config::AppConfig;
@@ -27,6 +27,6 @@ pub struct GetMovieSocialPageDeps {
 
 pub struct GetActivityFeedDeps {
     pub diary: Arc<dyn DiaryQuery>,
-    pub social_query: Arc<dyn SocialQueryPort>,
+    pub social_query: Arc<dyn SocialQuery>,
     pub config: AppConfig,
 }

crates/application/src/diary/get_activity_feed.rs

@@ -6,7 +6,7 @@ use domain::{
         FeedEntry,
         collections::{PageParams, Paginated},
     },
-    value_objects::UserId,
+    value_objects::{SocialIdentity, UserId},
 };
 
 pub async fn execute(
@@ -36,28 +36,24 @@ async fn build_following_filter(
     }
     let viewer_id = query.viewer_user_id?;
     let viewer = UserId::from_uuid(viewer_id);
-    let urls = deps
+    let actors = deps
         .social_query
-        .get_accepted_following_urls(&viewer)
+        .get_following(&viewer)
         .await
         .unwrap_or_default();
-    if urls.is_empty() {
+    if actors.is_empty() {
         return Some(FollowingFilter {
             local_user_ids: vec![viewer_id],
             remote_actor_urls: vec![],
         });
     }
-    let base_url = &deps.config.base_url;
     let mut local_ids = vec![viewer_id];
     let mut remote_urls = Vec::new();
-    for url in urls {
-        if let Some(suffix) = url.strip_prefix(&format!("{}/users/", base_url))
-            && let Ok(parsed_id) = uuid::Uuid::parse_str(suffix)
-        {
-            local_ids.push(parsed_id);
-            continue;
+    for actor in actors {
+        match actor.identity {
+            SocialIdentity::Local(uid) => local_ids.push(uid.value()),
+            SocialIdentity::Remote { actor_url } => remote_urls.push(actor_url),
         }
-        remote_urls.push(url);
     }
     Some(FollowingFilter {
         local_user_ids: local_ids,

crates/application/src/diary/tests/get_activity_feed.rs

@@ -2,7 +2,8 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use domain::errors::DomainError;
-use domain::testing::{FakeDiaryQuery, NoopSocialQueryPort};
+use domain::testing::InMemorySocialRepository;
+use domain::value_objects::{SocialActor, SocialIdentity, UserId};
 
 use crate::{
     config::AppConfig, diary::deps::GetActivityFeedDeps, diary::get_activity_feed,
@@ -11,8 +12,8 @@ use crate::{
 
 fn default_deps() -> GetActivityFeedDeps {
     GetActivityFeedDeps {
-        diary: FakeDiaryQuery::new() as _,
-        social_query: Arc::new(NoopSocialQueryPort),
+        diary: domain::testing::FakeDiaryQuery::new() as _,
+        social_query: InMemorySocialRepository::new() as _,
         config: TestContextBuilder::new().config,
     }
 }
@@ -59,60 +60,62 @@ async fn returns_feed_with_following_filter() {
     .await
     .unwrap();
 
-    // NoopSocialQueryPort returns empty following, so FollowingFilter
-    // contains only the viewer's id. Feed is empty but the code path is hit.
     assert!(result.items.is_empty());
 }
 
-struct FakeSocialWithFollowing(Vec<String>);
+struct FakeSocialWithFollowing(Vec<SocialActor>);
 
 #[async_trait]
-impl domain::ports::SocialQueryPort for FakeSocialWithFollowing {
-    async fn get_accepted_following_urls(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<String>, DomainError> {
+impl domain::ports::SocialQuery for FakeSocialWithFollowing {
+    async fn get_following(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
         Ok(self.0.clone())
     }
-    async fn count_following(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        Ok(0)
-    }
-    async fn count_accepted_followers(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        Ok(0)
-    }
-    async fn get_pending_followers(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<domain::models::PendingFollowerInfo>, DomainError> {
+    async fn get_followers(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
         Ok(vec![])
     }
-    async fn list_all_followed_remote_actors(
-        &self,
-    ) -> Result<Vec<domain::models::RemoteActorInfo>, DomainError> {
+    async fn get_pending_followers(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
         Ok(vec![])
     }
+    async fn count_following(&self, _: &UserId) -> Result<usize, DomainError> {
+        Ok(0)
+    }
+    async fn count_followers(&self, _: &UserId) -> Result<usize, DomainError> {
+        Ok(0)
+    }
+    async fn get_blocked(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        Ok(vec![])
+    }
+    async fn is_following(&self, _: &UserId, _: &SocialIdentity) -> Result<bool, DomainError> {
+        Ok(false)
+    }
 }
 
 #[tokio::test]
-async fn following_filter_parses_local_and_remote_urls() {
+async fn following_filter_separates_local_and_remote() {
     let viewer = uuid::Uuid::new_v4();
     let local_friend = uuid::Uuid::new_v4();
 
-    let following_urls = vec![
-        format!("http://localhost:3000/users/{}", local_friend),
-        "https://remote.example/actor/1".to_string(),
+    let following = vec![
+        SocialActor {
+            identity: SocialIdentity::Local(UserId::from_uuid(local_friend)),
+            handle: "friend".into(),
+            display_name: None,
+            avatar_url: None,
+        },
+        SocialActor {
+            identity: SocialIdentity::Remote {
+                actor_url: "https://remote.example/actor/1".into(),
+            },
+            handle: "@alice@remote.example".into(),
+            display_name: None,
+            avatar_url: None,
+        },
     ];
 
-    let social = Arc::new(FakeSocialWithFollowing(following_urls));
+    let social = Arc::new(FakeSocialWithFollowing(following));
 
     let deps = GetActivityFeedDeps {
-        diary: FakeDiaryQuery::new() as _,
+        diary: domain::testing::FakeDiaryQuery::new() as _,
         social_query: social as _,
         config: AppConfig {
             allow_registration: true,
@@ -141,8 +144,6 @@ async fn following_filter_parses_local_and_remote_urls() {
     .await
     .unwrap();
 
-    // Feed is empty (no data seeded), but the build_following_filter code path
-    // with actual URL parsing ran without errors.
     assert!(result.items.is_empty());
 }
 
@@ -164,6 +165,5 @@ async fn following_filter_without_viewer_returns_none() {
     .await
     .unwrap();
 
-    // filter_following=true but viewer_user_id=None → build_following_filter returns None
     assert!(result.items.is_empty());
 }

crates/application/src/lib.rs

@@ -11,6 +11,7 @@ pub mod integrations;
 pub mod movies;
 pub mod person;
 pub mod search;
+pub mod social;
 pub mod users;
 pub mod watchlist;
 pub mod wrapup;

crates/application/src/social/commands.rs

@@ -0,0 +1,33 @@
+use domain::value_objects::{FollowTarget, SocialIdentity};
+use uuid::Uuid;
+
+pub enum SocialCmd {
+    Follow {
+        follower_id: Uuid,
+        target: FollowTarget,
+    },
+    Unfollow {
+        follower_id: Uuid,
+        target: SocialIdentity,
+    },
+    AcceptFollow {
+        owner_id: Uuid,
+        requester: SocialIdentity,
+    },
+    RejectFollow {
+        owner_id: Uuid,
+        requester: SocialIdentity,
+    },
+    RemoveFollower {
+        owner_id: Uuid,
+        follower: SocialIdentity,
+    },
+    Block {
+        blocker_id: Uuid,
+        target: SocialIdentity,
+    },
+    Unblock {
+        blocker_id: Uuid,
+        target: SocialIdentity,
+    },
+}

crates/application/src/social/deps.rs

@@ -0,0 +1,13 @@
+use std::sync::Arc;
+
+use domain::ports::{EventPublisher, SocialCommand, SocialQuery};
+
+pub struct SocialCommandDeps {
+    pub social_command: Arc<dyn SocialCommand>,
+    pub social_query: Arc<dyn SocialQuery>,
+    pub event_publisher: Arc<dyn EventPublisher>,
+}
+
+pub struct SocialQueryDeps {
+    pub social_query: Arc<dyn SocialQuery>,
+}

crates/application/src/social/execute.rs

@@ -0,0 +1,92 @@
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    value_objects::{SocialActor, UserId},
+};
+
+use super::{
+    commands::SocialCmd,
+    deps::{SocialCommandDeps, SocialQueryDeps},
+    queries::SocialQry,
+};
+
+pub async fn execute_command(deps: &SocialCommandDeps, cmd: SocialCmd) -> Result<(), DomainError> {
+    let event = match cmd {
+        SocialCmd::Follow {
+            follower_id,
+            target,
+        } => {
+            let follower = UserId::from_uuid(follower_id);
+            deps.social_command.follow(&follower, &target).await?;
+            DomainEvent::FollowRequested { follower, target }
+        }
+        SocialCmd::Unfollow {
+            follower_id,
+            target,
+        } => {
+            let follower = UserId::from_uuid(follower_id);
+            deps.social_command.unfollow(&follower, &target).await?;
+            DomainEvent::Unfollowed { follower, target }
+        }
+        SocialCmd::AcceptFollow {
+            owner_id,
+            requester,
+        } => {
+            let owner = UserId::from_uuid(owner_id);
+            deps.social_command
+                .accept_follow(&owner, &requester)
+                .await?;
+            DomainEvent::FollowAccepted { owner, requester }
+        }
+        SocialCmd::RejectFollow {
+            owner_id,
+            requester,
+        } => {
+            let owner = UserId::from_uuid(owner_id);
+            deps.social_command
+                .reject_follow(&owner, &requester)
+                .await?;
+            DomainEvent::FollowRejected { owner, requester }
+        }
+        SocialCmd::RemoveFollower { owner_id, follower } => {
+            let owner = UserId::from_uuid(owner_id);
+            deps.social_command
+                .remove_follower(&owner, &follower)
+                .await?;
+            DomainEvent::FollowerRemoved { owner, follower }
+        }
+        SocialCmd::Block { blocker_id, target } => {
+            let blocker = UserId::from_uuid(blocker_id);
+            deps.social_command.block(&blocker, &target).await?;
+            DomainEvent::ActorBlocked { blocker, target }
+        }
+        SocialCmd::Unblock { blocker_id, target } => {
+            let blocker = UserId::from_uuid(blocker_id);
+            deps.social_command.unblock(&blocker, &target).await?;
+            DomainEvent::ActorUnblocked { blocker, target }
+        }
+    };
+    deps.event_publisher.publish(&event).await
+}
+
+pub async fn execute_query(
+    deps: &SocialQueryDeps,
+    query: SocialQry,
+) -> Result<Vec<SocialActor>, DomainError> {
+    let user_id = match &query {
+        SocialQry::GetFollowing { user_id }
+        | SocialQry::GetFollowers { user_id }
+        | SocialQry::GetPending { user_id }
+        | SocialQry::GetBlocked { user_id } => UserId::from_uuid(*user_id),
+    };
+    match query {
+        SocialQry::GetFollowing { .. } => deps.social_query.get_following(&user_id).await,
+        SocialQry::GetFollowers { .. } => deps.social_query.get_followers(&user_id).await,
+        SocialQry::GetPending { .. } => deps.social_query.get_pending_followers(&user_id).await,
+        SocialQry::GetBlocked { .. } => deps.social_query.get_blocked(&user_id).await,
+    }
+}
+
+#[cfg(test)]
+#[path = "tests/execute.rs"]
+mod tests;

crates/application/src/social/mod.rs

@@ -0,0 +1,4 @@
+pub mod commands;
+pub mod deps;
+pub mod execute;
+pub mod queries;

crates/application/src/social/queries.rs

@@ -0,0 +1,8 @@
+use uuid::Uuid;
+
+pub enum SocialQry {
+    GetFollowing { user_id: Uuid },
+    GetFollowers { user_id: Uuid },
+    GetPending { user_id: Uuid },
+    GetBlocked { user_id: Uuid },
+}

crates/application/src/social/tests/execute.rs

@@ -0,0 +1,449 @@
+use std::sync::Arc;
+
+use domain::{
+    events::DomainEvent,
+    testing::{InMemorySocialRepository, NoopEventPublisher},
+    value_objects::{FollowTarget, SocialIdentity, UserId},
+};
+use uuid::Uuid;
+
+use crate::social::{
+    commands::SocialCmd,
+    deps::{SocialCommandDeps, SocialQueryDeps},
+    execute::{execute_command, execute_query},
+    queries::SocialQry,
+};
+
+fn make_cmd_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
+    let social = InMemorySocialRepository::new();
+    let events = NoopEventPublisher::new();
+    let deps = SocialCommandDeps {
+        social_command: Arc::clone(&social) as _,
+        social_query: Arc::clone(&social) as _,
+        event_publisher: Arc::clone(&events) as _,
+    };
+    (social, events, deps)
+}
+
+// ── Follow ──────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn follow_emits_follow_requested_event() {
+    let (_social, events, deps) = make_cmd_deps();
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id: Uuid::new_v4(),
+            target: FollowTarget::Identity(SocialIdentity::Local(
+                UserId::from_uuid(Uuid::new_v4()),
+            )),
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowRequested { .. }))
+    );
+}
+
+#[tokio::test]
+async fn cannot_follow_yourself() {
+    let (_social, _events, deps) = make_cmd_deps();
+    let user_id = Uuid::new_v4();
+
+    let result = execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id: user_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(user_id))),
+        },
+    )
+    .await;
+
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn cannot_follow_same_target_twice() {
+    let (_social, _events, deps) = make_cmd_deps();
+    let follower_id = Uuid::new_v4();
+    let target = FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(Uuid::new_v4())));
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: target.clone(),
+        },
+    )
+    .await
+    .unwrap();
+
+    let result = execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target,
+        },
+    )
+    .await;
+
+    assert!(result.is_err());
+}
+
+// ── Unfollow ────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn unfollow_emits_unfollowed_event() {
+    let (_social, events, deps) = make_cmd_deps();
+    let follower_id = Uuid::new_v4();
+    let target = SocialIdentity::Local(UserId::from_uuid(Uuid::new_v4()));
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(target.clone()),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &deps,
+        SocialCmd::Unfollow {
+            follower_id,
+            target,
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::Unfollowed { .. }))
+    );
+}
+
+// ── Accept ──────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn accept_follow_emits_follow_accepted_event() {
+    let (_social, events, deps) = make_cmd_deps();
+    let follower_id = Uuid::new_v4();
+    let owner_id = Uuid::new_v4();
+    let requester = SocialIdentity::Local(UserId::from_uuid(follower_id));
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(owner_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &deps,
+        SocialCmd::AcceptFollow {
+            owner_id,
+            requester,
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowAccepted { .. }))
+    );
+}
+
+// ── Reject ──────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn reject_follow_emits_follow_rejected_event() {
+    let (_social, events, deps) = make_cmd_deps();
+    let follower_id = Uuid::new_v4();
+    let owner_id = Uuid::new_v4();
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(owner_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &deps,
+        SocialCmd::RejectFollow {
+            owner_id,
+            requester: SocialIdentity::Local(UserId::from_uuid(follower_id)),
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowRejected { .. }))
+    );
+}
+
+// ── Remove follower ─────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn remove_follower_emits_follower_removed_event() {
+    let (_social, events, deps) = make_cmd_deps();
+    let follower_id = Uuid::new_v4();
+    let owner_id = Uuid::new_v4();
+
+    execute_command(
+        &deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(owner_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &deps,
+        SocialCmd::AcceptFollow {
+            owner_id,
+            requester: SocialIdentity::Local(UserId::from_uuid(follower_id)),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &deps,
+        SocialCmd::RemoveFollower {
+            owner_id,
+            follower: SocialIdentity::Local(UserId::from_uuid(follower_id)),
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowerRemoved { .. }))
+    );
+}
+
+// ── Block ───────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn block_emits_actor_blocked_event() {
+    let (_social, events, deps) = make_cmd_deps();
+
+    execute_command(
+        &deps,
+        SocialCmd::Block {
+            blocker_id: Uuid::new_v4(),
+            target: SocialIdentity::Local(UserId::from_uuid(Uuid::new_v4())),
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::ActorBlocked { .. }))
+    );
+}
+
+// ── Unblock ─────────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn unblock_emits_actor_unblocked_event() {
+    let (_social, events, deps) = make_cmd_deps();
+    let target = SocialIdentity::Local(UserId::from_uuid(Uuid::new_v4()));
+    let blocker_id = Uuid::new_v4();
+
+    execute_command(
+        &deps,
+        SocialCmd::Block {
+            blocker_id,
+            target: target.clone(),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(&deps, SocialCmd::Unblock { blocker_id, target })
+        .await
+        .unwrap();
+
+    let published = events.published();
+    assert!(
+        published
+            .iter()
+            .any(|e| matches!(e, DomainEvent::ActorUnblocked { .. }))
+    );
+}
+
+// ── Get following ───────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn returns_accepted_follows() {
+    let social = InMemorySocialRepository::new();
+    let events = NoopEventPublisher::new();
+    let cmd_deps = SocialCommandDeps {
+        social_command: Arc::clone(&social) as _,
+        social_query: Arc::clone(&social) as _,
+        event_publisher: Arc::clone(&events) as _,
+    };
+    let query_deps = SocialQueryDeps {
+        social_query: Arc::clone(&social) as _,
+    };
+
+    let follower_id = Uuid::new_v4();
+    let target_id = Uuid::new_v4();
+
+    execute_command(
+        &cmd_deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(target_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    // Pending follow should not appear
+    let following = execute_query(
+        &query_deps,
+        SocialQry::GetFollowing {
+            user_id: follower_id,
+        },
+    )
+    .await
+    .unwrap();
+    assert!(following.is_empty());
+
+    // Accept, then it should appear
+    execute_command(
+        &cmd_deps,
+        SocialCmd::AcceptFollow {
+            owner_id: target_id,
+            requester: SocialIdentity::Local(UserId::from_uuid(follower_id)),
+        },
+    )
+    .await
+    .unwrap();
+
+    let following = execute_query(
+        &query_deps,
+        SocialQry::GetFollowing {
+            user_id: follower_id,
+        },
+    )
+    .await
+    .unwrap();
+    assert_eq!(following.len(), 1);
+}
+
+// ── Get followers ───────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn returns_accepted_followers() {
+    let social = InMemorySocialRepository::new();
+    let events = NoopEventPublisher::new();
+    let cmd_deps = SocialCommandDeps {
+        social_command: Arc::clone(&social) as _,
+        social_query: Arc::clone(&social) as _,
+        event_publisher: Arc::clone(&events) as _,
+    };
+    let query_deps = SocialQueryDeps {
+        social_query: Arc::clone(&social) as _,
+    };
+
+    let follower_id = Uuid::new_v4();
+    let owner_id = Uuid::new_v4();
+
+    execute_command(
+        &cmd_deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(owner_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    execute_command(
+        &cmd_deps,
+        SocialCmd::AcceptFollow {
+            owner_id,
+            requester: SocialIdentity::Local(UserId::from_uuid(follower_id)),
+        },
+    )
+    .await
+    .unwrap();
+
+    let followers = execute_query(&query_deps, SocialQry::GetFollowers { user_id: owner_id })
+        .await
+        .unwrap();
+    assert_eq!(followers.len(), 1);
+}
+
+// ── Get pending ─────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn returns_only_pending_followers() {
+    let social = InMemorySocialRepository::new();
+    let events = NoopEventPublisher::new();
+    let cmd_deps = SocialCommandDeps {
+        social_command: Arc::clone(&social) as _,
+        social_query: Arc::clone(&social) as _,
+        event_publisher: Arc::clone(&events) as _,
+    };
+    let query_deps = SocialQueryDeps {
+        social_query: Arc::clone(&social) as _,
+    };
+
+    let follower_id = Uuid::new_v4();
+    let owner_id = Uuid::new_v4();
+
+    execute_command(
+        &cmd_deps,
+        SocialCmd::Follow {
+            follower_id,
+            target: FollowTarget::Identity(SocialIdentity::Local(UserId::from_uuid(owner_id))),
+        },
+    )
+    .await
+    .unwrap();
+
+    let pending = execute_query(&query_deps, SocialQry::GetPending { user_id: owner_id })
+        .await
+        .unwrap();
+    assert_eq!(pending.len(), 1);
+}

crates/application/src/test_helpers.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
 use domain::testing::{
-    InMemoryGoalRepository, InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, NoopSocialQueryPort,
+    InMemoryGoalRepository, InMemorySocialRepository, InMemoryWrapUpRepository,
+    InMemoryWrapUpStatsQuery, NoopFederationAdminQuery,
 };
 use domain::{
     ports::{
@@ -72,7 +73,9 @@ pub struct TestContextBuilder {
     pub goal_query: Arc<dyn GoalQuery>,
     pub user_settings_repo: Arc<dyn UserSettingsRepository>,
     pub review_logger: Arc<dyn ReviewLogger>,
-    pub social_query: Arc<dyn domain::ports::SocialQueryPort>,
+    pub social_command: Arc<dyn domain::ports::SocialCommand>,
+    pub social_query_unified: Arc<dyn domain::ports::SocialQuery>,
+    pub federation_admin: Arc<dyn domain::ports::FederationAdminQuery>,
     pub refresh_session_repo: Arc<dyn RefreshSessionRepository>,
     pub config: AppConfig,
 }
@@ -88,6 +91,7 @@ impl TestContextBuilder {
         let movies = InMemoryMovieRepository::new();
         let watch_events = InMemoryWatchEventRepository::new();
         let goals = InMemoryGoalRepository::new();
+        let social = InMemorySocialRepository::new();
         Self {
             movie_command: Arc::clone(&movies) as _,
             movie_query: movies as _,
@@ -121,7 +125,9 @@ impl TestContextBuilder {
             goal_query: goals as _,
             user_settings_repo: InMemoryUserSettingsRepository::new(),
             review_logger: Arc::new(NoopReviewLogger),
-            social_query: Arc::new(NoopSocialQueryPort),
+            social_command: Arc::clone(&social) as _,
+            social_query_unified: Arc::clone(&social) as _,
+            federation_admin: Arc::new(NoopFederationAdminQuery),
             refresh_session_repo: InMemoryRefreshSessionRepository::new(),
             config: AppConfig {
                 allow_registration: true,
@@ -267,11 +273,6 @@ impl TestContextBuilder {
         self
     }
 
-    pub fn with_social_query(mut self, r: Arc<dyn domain::ports::SocialQueryPort>) -> Self {
-        self.social_query = r;
-        self
-    }
-
     pub fn with_wrapup_repo(mut self, r: Arc<dyn WrapUpRepository>) -> Self {
         self.wrapup_repo = r;
         self

crates/application/src/tests/worker.rs

@@ -72,7 +72,13 @@ impl EventHandler for RecordingHandler {
             DomainEvent::WatchlistEntryAdded { .. } | DomainEvent::WatchlistEntryRemoved { .. } => {
                 "watchlist"
             }
+            DomainEvent::FollowRequested { .. } => "follow_requested",
             DomainEvent::FollowAccepted { .. } => "follow_accepted",
+            DomainEvent::FollowRejected { .. } => "follow_rejected",
+            DomainEvent::Unfollowed { .. } => "unfollowed",
+            DomainEvent::FollowerRemoved { .. } => "follower_removed",
+            DomainEvent::ActorBlocked { .. } => "actor_blocked",
+            DomainEvent::ActorUnblocked { .. } => "actor_unblocked",
             DomainEvent::BackfillFollower { .. } => "backfill_follower",
             DomainEvent::FederationDeliveryRequested { .. } => "federation_delivery",
             DomainEvent::WatchEventIngested { .. } => "watch_event_ingested",

crates/application/src/users/deps.rs

@@ -1,13 +1,19 @@
 use std::sync::Arc;
 
 use domain::ports::{
-    DiaryQuery, EventPublisher, ObjectStorage, SocialQueryPort, StatsRepository, UserRepository,
+    DiaryQuery, EventPublisher, FederationAdminQuery, ObjectStorage, SocialQuery, StatsRepository,
+    UserRepository,
 };
 
 pub struct GetProfileDeps {
     pub stats: Arc<dyn StatsRepository>,
     pub diary: Arc<dyn DiaryQuery>,
-    pub social_query: Arc<dyn SocialQueryPort>,
+    pub social_query: Arc<dyn SocialQuery>,
+}
+
+pub struct GetUsersListDeps {
+    pub user: Arc<dyn UserRepository>,
+    pub federation_admin: Arc<dyn FederationAdminQuery>,
 }
 
 pub struct UpdateProfileDeps {

crates/application/src/users/get_profile.rs

@@ -86,7 +86,7 @@ async fn load_social_counts(
         .unwrap_or(0);
     let followers = deps
         .social_query
-        .count_accepted_followers(user_id)
+        .count_followers(user_id)
         .await
         .unwrap_or(0);
     if !is_own_profile {
@@ -98,11 +98,19 @@ async fn load_social_counts(
         .await
         .unwrap_or_default()
         .into_iter()
-        .map(|p| PendingFollowerView {
-            url: p.url,
+        .map(|p| {
+            let url = match &p.identity {
+                domain::value_objects::SocialIdentity::Remote { actor_url } => actor_url.clone(),
+                domain::value_objects::SocialIdentity::Local(uid) => {
+                    format!("local:{}", uid.value())
+                }
+            };
+            PendingFollowerView {
+                url,
                 handle: p.handle,
                 display_name: p.display_name,
                 avatar_url: p.avatar_url,
+            }
         })
         .collect();
     (following, followers, pending)

crates/application/src/users/get_users.rs

@@ -1,10 +1,7 @@
-use std::sync::Arc;
-
-use crate::users::queries::GetUsersQuery;
+use crate::users::{deps::GetUsersListDeps, queries::GetUsersQuery};
 use domain::{
     errors::DomainError,
     models::{RemoteActorInfo, UserSummary},
-    ports::{SocialQueryPort, UserRepository},
 };
 
 pub struct UsersListData {
@@ -13,13 +10,12 @@ pub struct UsersListData {
 }
 
 pub async fn execute(
-    user: Arc<dyn UserRepository>,
-    social_query: Arc<dyn SocialQueryPort>,
+    deps: &GetUsersListDeps,
     _query: GetUsersQuery,
 ) -> Result<UsersListData, DomainError> {
     let (users_result, actors_result) = tokio::join!(
-        user.list_with_stats(),
-        social_query.list_all_followed_remote_actors()
+        deps.user.list_with_stats(),
+        deps.federation_admin.list_all_followed_remote_actors()
     );
 
     Ok(UsersListData {
@@ -27,7 +23,3 @@ pub async fn execute(
         remote_actors: actors_result?,
     })
 }
-
-#[cfg(test)]
-#[path = "tests/get_users.rs"]
-mod tests;

crates/application/src/users/tests/get_profile.rs

@@ -35,7 +35,7 @@ async fn returns_profile_with_empty_stats() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "profile@test.com", "profuser").await;
@@ -70,7 +70,7 @@ async fn returns_history_view() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "hist@test.com", "histuser").await;
@@ -107,7 +107,7 @@ async fn returns_trends_view() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "trends@test.com", "trendsuser").await;
@@ -144,7 +144,7 @@ async fn returns_ratings_view() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "ratings@test.com", "ratingsuser").await;
@@ -179,7 +179,7 @@ async fn returns_recent_with_search() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "search@test.com", "searchuser").await;
@@ -214,7 +214,7 @@ async fn non_own_profile_skips_pending_followers() {
     let deps = GetProfileDeps {
         stats: b.stats_repo.clone(),
         diary: b.diary_repo.clone(),
-        social_query: b.social_query.clone(),
+        social_query: b.social_query_unified.clone(),
     };
 
     setup_user(&b, "other@test.com", "otheruser").await;

crates/application/src/wrapup/tests/compute.rs

@@ -27,6 +27,7 @@ fn make_row(title: &str, rating: u8, watched_at: &str) -> WrapUpMovieRow {
         keywords: vec!["heist".to_string()],
         cast_names: vec![("Actor A".to_string(), 1, 12345)],
         cast_profile_paths: vec![None],
+        watch_medium: None,
     }
 }
 

crates/domain/src/events.rs

@@ -63,10 +63,33 @@ pub enum DomainEvent {
         user_id: UserId,
         movie_id: MovieId,
     },
+    FollowRequested {
+        follower: UserId,
+        target: crate::value_objects::FollowTarget,
+    },
     FollowAccepted {
-        local_user_id: UserId,
-        remote_actor_url: String,
-        outbox_url: String,
+        owner: UserId,
+        requester: crate::value_objects::SocialIdentity,
+    },
+    FollowRejected {
+        owner: UserId,
+        requester: crate::value_objects::SocialIdentity,
+    },
+    Unfollowed {
+        follower: UserId,
+        target: crate::value_objects::SocialIdentity,
+    },
+    FollowerRemoved {
+        owner: UserId,
+        follower: crate::value_objects::SocialIdentity,
+    },
+    ActorBlocked {
+        blocker: UserId,
+        target: crate::value_objects::SocialIdentity,
+    },
+    ActorUnblocked {
+        blocker: UserId,
+        target: crate::value_objects::SocialIdentity,
     },
     BackfillFollower {
         owner_user_id: UserId,

crates/domain/src/models/mod.rs

@@ -4,7 +4,7 @@ mod feed;
 mod movie;
 mod refresh_session;
 mod review;
-mod stats;
+pub mod stats;
 mod user;
 
 pub mod collections;
@@ -26,7 +26,7 @@ pub use federation::*;
 pub use feed::*;
 pub use movie::*;
 pub use review::*;
-pub use stats::*;
+pub use stats::{DirectorStat, MonthActivity, MonthlyRating, MovieStats, UserStats, UserTrends};
 pub use user::*;
 
 pub use goal::{Goal, GoalWithProgress};

crates/domain/src/models/stats.rs

@@ -30,11 +30,26 @@ pub struct DirectorStat {
     pub count: i64,
 }
 
+#[derive(Clone, Debug)]
+pub struct GenreStat {
+    pub genre: String,
+    pub count: i64,
+}
+
+#[derive(Clone, Debug)]
+pub struct WatchMediumStat {
+    pub medium: String,
+    pub count: i64,
+}
+
 #[derive(Clone, Debug)]
 pub struct UserTrends {
     pub monthly_ratings: Vec<MonthlyRating>,
     pub top_directors: Vec<DirectorStat>,
     pub max_director_count: i64,
+    pub top_genres: Vec<GenreStat>,
+    pub rating_distribution: [i64; 5],
+    pub watch_medium_distribution: Vec<WatchMediumStat>,
 }
 
 #[derive(Clone, Debug)]

crates/domain/src/models/wrapup.rs

@@ -17,6 +17,7 @@ pub struct WrapUpMovieRow {
     pub runtime_minutes: Option<u32>,
     pub budget_usd: Option<i64>,
     pub original_language: Option<String>,
+    pub watch_medium: Option<String>,
     pub genres: Vec<String>,
     pub keywords: Vec<String>,
     pub cast_names: Vec<(String, u32, i64)>,
@@ -95,6 +96,12 @@ pub struct LangStat {
     pub count: u32,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct WatchMediumStat {
+    pub medium: String,
+    pub count: u32,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MonthCount {
     pub year_month: String,
@@ -142,6 +149,7 @@ pub struct WrapUpReport {
     pub total_budget_watched: Option<i64>,
     pub avg_budget: Option<i64>,
     pub language_distribution: Vec<LangStat>,
+    pub watch_medium_distribution: Vec<WatchMediumStat>,
     pub oldest_movie: Option<MovieRef>,
     pub newest_movie: Option<MovieRef>,
 

crates/domain/src/ports/follow.rs

@@ -0,0 +1,80 @@
+use async_trait::async_trait;
+
+use crate::{
+    errors::DomainError,
+    value_objects::{FollowStatus, SocialActor},
+};
+
+#[async_trait]
+pub trait FollowCommand: Send + Sync {
+    async fn add_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError>;
+
+    async fn update_follow_status(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError>;
+
+    async fn remove_follow(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<(), DomainError>;
+
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError>;
+
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+        status: FollowStatus,
+    ) -> Result<(), DomainError>;
+
+    async fn remove_follower_record(
+        &self,
+        local_user_id: uuid::Uuid,
+        follower_actor_url: &str,
+    ) -> Result<(), DomainError>;
+}
+
+#[async_trait]
+pub trait FollowQuery: Send + Sync {
+    async fn get_following(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn get_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn get_pending_followers(
+        &self,
+        user_id: uuid::Uuid,
+        base_url: &str,
+    ) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn count_following(&self, user_id: uuid::Uuid) -> Result<usize, DomainError>;
+
+    async fn count_followers(&self, user_id: uuid::Uuid) -> Result<usize, DomainError>;
+
+    async fn is_following(
+        &self,
+        follower_id: uuid::Uuid,
+        target_actor_url: &str,
+    ) -> Result<bool, DomainError>;
+}

crates/domain/src/ports/mod.rs

@@ -2,6 +2,7 @@ pub mod auth;
 pub mod diary;
 pub mod events;
 pub mod federated_profile;
+pub mod follow;
 pub mod goals;
 pub mod image_fetcher;
 pub mod images;
@@ -21,6 +22,7 @@ pub use auth::*;
 pub use diary::*;
 pub use events::*;
 pub use federated_profile::*;
+pub use follow::*;
 pub use goals::*;
 pub use image_fetcher::*;
 pub use images::*;

crates/domain/src/ports/noop.rs

@@ -1,6 +1,9 @@
 use async_trait::async_trait;
 
-use crate::{errors::DomainError, value_objects::UserId};
+use crate::{
+    errors::DomainError,
+    value_objects::{SocialActor, SocialIdentity, UserId},
+};
 
 // ── NoopRemoteWatchlistRepository ─────────────────────────────────────────────
 
@@ -32,31 +35,78 @@ impl super::RemoteWatchlistRepository for NoopRemoteWatchlistRepository {
     }
 }
 
-// ── NoopSocialQueryPort ───────────────────────────────────────────────────────
+// ── NoopSocialCommand ────────────────────────────────────────────────────────
 
-/// Stub used when federation is disabled — returns empty results.
-pub struct NoopSocialQueryPort;
+pub struct NoopSocialCommand;
 
 #[async_trait]
-impl super::SocialQueryPort for NoopSocialQueryPort {
-    async fn get_accepted_following_urls(&self, _: &UserId) -> Result<Vec<String>, DomainError> {
+impl super::SocialCommand for NoopSocialCommand {
+    async fn follow(
+        &self,
+        _: &UserId,
+        _: &crate::value_objects::FollowTarget,
+    ) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn unfollow(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn accept_follow(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn reject_follow(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn remove_follower(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn block(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn unblock(&self, _: &UserId, _: &SocialIdentity) -> Result<(), DomainError> {
+        Ok(())
+    }
+}
+
+// ── NoopSocialQuery ─────────────────────────────────────────────────────────
+
+pub struct NoopSocialQuery;
+
+#[async_trait]
+impl super::SocialQuery for NoopSocialQuery {
+    async fn get_following(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
         Ok(vec![])
     }
-    async fn list_all_followed_remote_actors(
-        &self,
-    ) -> Result<Vec<crate::models::RemoteActorInfo>, DomainError> {
+    async fn get_followers(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        Ok(vec![])
+    }
+    async fn get_pending_followers(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
         Ok(vec![])
     }
     async fn count_following(&self, _: &UserId) -> Result<usize, DomainError> {
         Ok(0)
     }
-    async fn count_accepted_followers(&self, _: &UserId) -> Result<usize, DomainError> {
+    async fn count_followers(&self, _: &UserId) -> Result<usize, DomainError> {
         Ok(0)
     }
-    async fn get_pending_followers(
+    async fn get_blocked(&self, _: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        Ok(vec![])
+    }
+    async fn is_following(&self, _: &UserId, _: &SocialIdentity) -> Result<bool, DomainError> {
+        Ok(false)
+    }
+}
+
+// ── NoopFederationAdminQuery ─────────────────────────────────────────────────
+
+/// Stub used when federation is disabled — returns empty results.
+pub struct NoopFederationAdminQuery;
+
+#[async_trait]
+impl super::FederationAdminQuery for NoopFederationAdminQuery {
+    async fn list_all_followed_remote_actors(
         &self,
-        _: &UserId,
-    ) -> Result<Vec<crate::models::PendingFollowerInfo>, DomainError> {
+    ) -> Result<Vec<crate::models::RemoteActorInfo>, DomainError> {
         Ok(vec![])
     }
 }

crates/domain/src/ports/social.rs

@@ -4,25 +4,68 @@ use chrono::NaiveDateTime;
 use crate::{
     errors::DomainError,
     models::{
-        DiaryEntry, FederationFlags, PendingFollowerInfo, RemoteActorInfo, RemoteGoalEntry,
-        RemoteWatchlistEntry, WatchlistWithMovie,
+        DiaryEntry, FederationFlags, RemoteActorInfo, RemoteGoalEntry, RemoteWatchlistEntry,
+        WatchlistWithMovie,
     },
-    value_objects::{MovieId, UserId},
+    value_objects::{FollowTarget, MovieId, SocialActor, SocialIdentity, UserId},
 };
 
+// ── Unified social ports (ADR-0002) ─────────────────────────────────────────
+
 #[async_trait]
-pub trait SocialQueryPort: Send + Sync {
-    async fn get_accepted_following_urls(
+pub trait SocialCommand: Send + Sync {
+    async fn follow(&self, follower: &UserId, target: &FollowTarget) -> Result<(), DomainError>;
+
+    async fn unfollow(&self, follower: &UserId, target: &SocialIdentity)
+    -> Result<(), DomainError>;
+
+    async fn accept_follow(
         &self,
-        user_id: &UserId,
-    ) -> Result<Vec<String>, DomainError>;
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError>;
+
+    async fn reject_follow(
+        &self,
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError>;
+
+    async fn remove_follower(
+        &self,
+        owner: &UserId,
+        follower: &SocialIdentity,
+    ) -> Result<(), DomainError>;
+
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError>;
+
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError>;
+}
+
+#[async_trait]
+pub trait SocialQuery: Send + Sync {
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn count_following(&self, user: &UserId) -> Result<usize, DomainError>;
+
+    async fn count_followers(&self, user: &UserId) -> Result<usize, DomainError>;
+
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
+
+    async fn is_following(
+        &self,
+        follower: &UserId,
+        target: &SocialIdentity,
+    ) -> Result<bool, DomainError>;
+}
+
+#[async_trait]
+pub trait FederationAdminQuery: Send + Sync {
     async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError>;
-    async fn count_following(&self, user_id: &UserId) -> Result<usize, DomainError>;
-    async fn count_accepted_followers(&self, user_id: &UserId) -> Result<usize, DomainError>;
-    async fn get_pending_followers(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<PendingFollowerInfo>, DomainError>;
 }
 
 #[async_trait]
@@ -39,7 +82,6 @@ pub trait RemoteWatchlistRepository: Send + Sync {
         actor_url: &str,
     ) -> Result<Vec<RemoteWatchlistEntry>, DomainError>;
     async fn remove_all_by_actor(&self, actor_url: &str) -> Result<(), DomainError>;
-    /// Find entries for a remote actor whose URL hashes (v5 UUID) to the given UUID.
     async fn get_by_derived_uuid(
         &self,
         uuid: uuid::Uuid,
@@ -60,10 +102,6 @@ pub trait RemoteGoalRepository: Send + Sync {
     async fn get_by_actor_url(&self, actor_url: &str) -> Result<Vec<RemoteGoalEntry>, DomainError>;
 }
 
-/// Federation-specific read-only queries that have no equivalent on the
-/// standard domain ports (e.g. unpaginated watchlist, local-only review
-/// listings). Generic lookups (get_movie_by_id, get_review_by_id, etc.)
-/// live on MovieRepository, ReviewRepository, and the other domain ports.
 #[async_trait]
 pub trait LocalApContentQuery: Send + Sync {
     async fn get_local_watchlist_for_user(

crates/domain/src/services/tests/wrapup_analyzer.rs

@@ -23,6 +23,7 @@ fn row(title: &str, rating: u8, ym: &str) -> WrapUpMovieRow {
         runtime_minutes: Some(100),
         budget_usd: None,
         original_language: Some("en".to_string()),
+        watch_medium: None,
         genres: vec!["Action".to_string()],
         keywords: vec![],
         cast_names: vec![],

crates/domain/src/services/wrapup_analyzer.rs

@@ -7,6 +7,8 @@ use crate::models::WrapUpMovieRow;
 use crate::models::wrapup::*;
 use crate::models::{ExternalPersonId, PersonId};
 
+const MIN_PERSON_COUNT: u32 = 2;
+
 pub fn build_report(
     scope: WrapUpScope,
     date_range: DateRange,
@@ -53,6 +55,7 @@ pub fn build_report(
 
     let (total_budget_watched, avg_budget) = compute_budget_stats(rows);
     let language_distribution = compute_language_stats(rows);
+    let watch_medium_distribution = compute_watch_medium_stats(rows);
 
     let (total_rewatches, most_rewatched_movie, avg_rating_change_on_rewatch) =
         compute_rewatch_stats(rows);
@@ -91,6 +94,7 @@ pub fn build_report(
         total_budget_watched,
         avg_budget,
         language_distribution,
+        watch_medium_distribution,
         oldest_movie,
         newest_movie,
         total_rewatches,
@@ -226,6 +230,7 @@ fn compute_director_stats(rows: &[WrapUpMovieRow]) -> (Vec<PersonStat>, u32) {
             }
         })
         .collect();
+    stats.retain(|s| s.count > MIN_PERSON_COUNT);
     stats.sort_by(|a, b| {
         b.count
             .cmp(&a.count)
@@ -270,6 +275,7 @@ fn compute_actor_stats(rows: &[WrapUpMovieRow]) -> (Vec<PersonStat>, u32, Vec<St
             }
         })
         .collect();
+    stats.retain(|s| s.count > MIN_PERSON_COUNT);
     stats.sort_by(|a, b| {
         b.count
             .cmp(&a.count)
@@ -315,7 +321,7 @@ fn compute_genre_stats(
         .map(|g| g.genre.clone());
     let lowest = stats
         .iter()
-        .filter(|g| g.count >= 3)
+        .filter(|g| g.count > 3)
         .min_by(|a, b| a.avg_rating.total_cmp(&b.avg_rating))
         .map(|g| g.genre.clone());
     stats.truncate(5);
@@ -367,6 +373,21 @@ fn compute_language_stats(rows: &[WrapUpMovieRow]) -> Vec<LangStat> {
     stats
 }
 
+fn compute_watch_medium_stats(rows: &[WrapUpMovieRow]) -> Vec<WatchMediumStat> {
+    let mut counts: HashMap<String, u32> = HashMap::new();
+    for r in rows {
+        if let Some(ref medium) = r.watch_medium {
+            *counts.entry(medium.clone()).or_default() += 1;
+        }
+    }
+    let mut stats: Vec<WatchMediumStat> = counts
+        .into_iter()
+        .map(|(medium, count)| WatchMediumStat { medium, count })
+        .collect();
+    stats.sort_by_key(|s| std::cmp::Reverse(s.count));
+    stats
+}
+
 fn compute_rewatch_stats(rows: &[WrapUpMovieRow]) -> (u32, Option<MovieRef>, Option<f64>) {
     let mut movie_reviews: HashMap<Uuid, Vec<&WrapUpMovieRow>> = HashMap::new();
     for r in rows {

crates/domain/src/testing/fakes.rs

@@ -226,6 +226,9 @@ impl StatsRepository for FakeStatsRepository {
             monthly_ratings: vec![],
             top_directors: vec![],
             max_director_count: 0,
+            top_genres: vec![],
+            rating_distribution: [0; 5],
+            watch_medium_distribution: vec![],
         })
     }
 

crates/domain/src/testing/in_memory.rs

@@ -19,13 +19,14 @@ use crate::{
     ports::{
         GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository, MovieCommand,
         MovieProfileRepository, MovieQuery, RefreshSessionRepository, ReviewRepository,
-        UserFederationSettingsQuery, UserProfileFieldsRepository, UserRepository,
-        UserSettingsRepository, WatchEventCommand, WatchEventQuery, WatchlistRepository,
-        WebhookTokenRepository,
+        SocialCommand, SocialQuery, UserFederationSettingsQuery, UserProfileFieldsRepository,
+        UserRepository, UserSettingsRepository, WatchEventCommand, WatchEventQuery,
+        WatchlistRepository, WebhookTokenRepository,
     },
     value_objects::{
         Email, ExternalMetadataId, GoalId, ImportProfileId, ImportSessionId, MovieId, MovieTitle,
-        ReleaseYear, ReviewId, UserId, Username, WatchEventId, WebhookTokenId,
+        ReleaseYear, ReviewId, SocialActor, SocialIdentity, UserId, Username, WatchEventId,
+        WebhookTokenId,
     },
 };
 
@@ -854,3 +855,254 @@ impl RefreshSessionRepository for InMemoryRefreshSessionRepository {
         Ok((before - store.len()) as u64)
     }
 }
+
+// ── InMemorySocialRepository ────────────────────────────────────────────────
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum FollowState {
+    Pending,
+    Accepted,
+}
+
+pub struct InMemorySocialRepository {
+    follows: Mutex<Vec<(Uuid, SocialIdentity, FollowState)>>,
+    blocked: Mutex<Vec<(Uuid, SocialIdentity)>>,
+}
+
+impl InMemorySocialRepository {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            follows: Mutex::new(Vec::new()),
+            blocked: Mutex::new(Vec::new()),
+        })
+    }
+
+    fn identity_to_actor(identity: &SocialIdentity) -> SocialActor {
+        let handle = match identity {
+            SocialIdentity::Local(uid) => format!("user-{}", uid.value()),
+            SocialIdentity::Remote { actor_url } => actor_url.clone(),
+        };
+        SocialActor {
+            identity: identity.clone(),
+            handle,
+            display_name: None,
+            avatar_url: None,
+        }
+    }
+}
+
+#[async_trait]
+impl SocialCommand for InMemorySocialRepository {
+    async fn follow(
+        &self,
+        follower: &UserId,
+        target: &crate::value_objects::FollowTarget,
+    ) -> Result<(), DomainError> {
+        let identity = match target {
+            crate::value_objects::FollowTarget::Identity(id) => id.clone(),
+            crate::value_objects::FollowTarget::Handle(h) => SocialIdentity::Remote {
+                actor_url: h.clone(),
+            },
+        };
+        if let SocialIdentity::Local(target_id) = &identity
+            && follower == target_id
+        {
+            return Err(DomainError::ValidationError(
+                "Cannot follow yourself".into(),
+            ));
+        }
+        let mut store = self.follows.lock().unwrap();
+        let already = store
+            .iter()
+            .any(|(f, t, _)| *f == follower.value() && *t == identity);
+        if already {
+            return Err(DomainError::ValidationError("Already following".into()));
+        }
+        store.push((follower.value(), identity, FollowState::Pending));
+        Ok(())
+    }
+
+    async fn unfollow(
+        &self,
+        follower: &UserId,
+        target: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let mut store = self.follows.lock().unwrap();
+        let before = store.len();
+        store.retain(|(f, t, _)| !(*f == follower.value() && t == target));
+        if store.len() == before {
+            return Err(DomainError::NotFound(
+                "Follow relationship not found".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    async fn accept_follow(
+        &self,
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let mut store = self.follows.lock().unwrap();
+        let target_identity = SocialIdentity::Local(owner.clone());
+        for (f, t, state) in store.iter_mut() {
+            let requester_matches = match requester {
+                SocialIdentity::Local(uid) => *f == uid.value(),
+                SocialIdentity::Remote { actor_url } => {
+                    if let SocialIdentity::Remote {
+                        actor_url: stored_url,
+                    } = requester
+                    {
+                        stored_url == actor_url
+                    } else {
+                        false
+                    }
+                }
+            };
+            if requester_matches && *t == target_identity && *state == FollowState::Pending {
+                *state = FollowState::Accepted;
+                return Ok(());
+            }
+        }
+        Err(DomainError::NotFound(
+            "Pending follow request not found".into(),
+        ))
+    }
+
+    async fn reject_follow(
+        &self,
+        owner: &UserId,
+        requester: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let mut store = self.follows.lock().unwrap();
+        let target_identity = SocialIdentity::Local(owner.clone());
+        let before = store.len();
+        store.retain(|(f, t, state)| {
+            let requester_matches = match requester {
+                SocialIdentity::Local(uid) => *f == uid.value(),
+                SocialIdentity::Remote { .. } => {
+                    // For remote, match by checking the stored requester identity
+                    false // simplified: reject removes by follower uuid match
+                }
+            };
+            !(requester_matches && *t == target_identity && *state == FollowState::Pending)
+        });
+        if store.len() == before {
+            return Err(DomainError::NotFound(
+                "Pending follow request not found".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    async fn remove_follower(
+        &self,
+        owner: &UserId,
+        follower: &SocialIdentity,
+    ) -> Result<(), DomainError> {
+        let mut store = self.follows.lock().unwrap();
+        let target_identity = SocialIdentity::Local(owner.clone());
+        let before = store.len();
+        store.retain(|(f, t, _)| {
+            let follower_matches = match follower {
+                SocialIdentity::Local(uid) => *f == uid.value(),
+                SocialIdentity::Remote { .. } => false,
+            };
+            !(follower_matches && *t == target_identity)
+        });
+        if store.len() == before {
+            return Err(DomainError::NotFound("Follower not found".into()));
+        }
+        Ok(())
+    }
+
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
+        let mut store = self.blocked.lock().unwrap();
+        store.push((blocker.value(), target.clone()));
+        // Also remove any existing follow relationships
+        let mut follows = self.follows.lock().unwrap();
+        follows.retain(|(f, t, _)| !(*f == blocker.value() && t == target));
+        Ok(())
+    }
+
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
+        let mut store = self.blocked.lock().unwrap();
+        store.retain(|(b, t)| !(*b == blocker.value() && t == target));
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl SocialQuery for InMemorySocialRepository {
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        let store = self.follows.lock().unwrap();
+        Ok(store
+            .iter()
+            .filter(|(f, _, state)| *f == user.value() && *state == FollowState::Accepted)
+            .map(|(_, t, _)| Self::identity_to_actor(t))
+            .collect())
+    }
+
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        let store = self.follows.lock().unwrap();
+        let target = SocialIdentity::Local(user.clone());
+        Ok(store
+            .iter()
+            .filter(|(_, t, state)| *t == target && *state == FollowState::Accepted)
+            .map(|(f, _, _)| {
+                let id = SocialIdentity::Local(UserId::from_uuid(*f));
+                Self::identity_to_actor(&id)
+            })
+            .collect())
+    }
+
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        let store = self.follows.lock().unwrap();
+        let target = SocialIdentity::Local(user.clone());
+        Ok(store
+            .iter()
+            .filter(|(_, t, state)| *t == target && *state == FollowState::Pending)
+            .map(|(f, _, _)| {
+                let id = SocialIdentity::Local(UserId::from_uuid(*f));
+                Self::identity_to_actor(&id)
+            })
+            .collect())
+    }
+
+    async fn count_following(&self, user: &UserId) -> Result<usize, DomainError> {
+        let store = self.follows.lock().unwrap();
+        Ok(store
+            .iter()
+            .filter(|(f, _, state)| *f == user.value() && *state == FollowState::Accepted)
+            .count())
+    }
+
+    async fn count_followers(&self, user: &UserId) -> Result<usize, DomainError> {
+        let store = self.follows.lock().unwrap();
+        let target = SocialIdentity::Local(user.clone());
+        Ok(store
+            .iter()
+            .filter(|(_, t, state)| *t == target && *state == FollowState::Accepted)
+            .count())
+    }
+
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
+        let store = self.blocked.lock().unwrap();
+        Ok(store
+            .iter()
+            .filter(|(b, _)| *b == user.value())
+            .map(|(_, t)| Self::identity_to_actor(t))
+            .collect())
+    }
+
+    async fn is_following(
+        &self,
+        follower: &UserId,
+        target: &SocialIdentity,
+    ) -> Result<bool, DomainError> {
+        let store = self.follows.lock().unwrap();
+        Ok(store.iter().any(|(f, t, state)| {
+            *f == follower.value() && t == target && *state == FollowState::Accepted
+        }))
+    }
+}

crates/domain/src/testing/noops.rs

@@ -64,8 +64,8 @@ impl ObjectStorage for NoopObjectStorage {
 
 // Re-export production noop types so test code that imports from
 // `domain::testing` keeps compiling without changes.
+pub use crate::ports::noop::NoopFederationAdminQuery;
 pub use crate::ports::noop::NoopRemoteWatchlistRepository;
-pub use crate::ports::noop::NoopSocialQueryPort;
 
 // ── NoopGoalCommand ───────────────────────────────────────────────────────────
 

crates/domain/src/testing/panics.rs

@@ -6,8 +6,8 @@ use crate::{
         AnnotatedRow, DiaryEntry, DiaryFilter, EntityType, ExportFormat, ExternalPersonId,
         FeedEntry, FeedSortBy, FieldMapping, FileFormat, FollowingFilter, ImportError,
         ImportProfile, ImportSession, IndexableDocument, MovieProfile, MovieStats, ParsedFile,
-        PendingFollowerInfo, Person, PersonCredits, PersonEnrichmentData, PersonId, RefreshSession,
-        RemoteActorInfo, ReviewHistory, SearchQuery, SearchResults, UserStats, UserTrends,
+        Person, PersonCredits, PersonEnrichmentData, PersonId, RefreshSession, RemoteActorInfo,
+        ReviewHistory, SearchQuery, SearchResults, UserStats, UserTrends,
         collections::{PageParams, Paginated},
     },
     ports::{
@@ -326,36 +326,12 @@ impl UserProfileFieldsRepository for PanicProfileFieldsRepo {
     }
 }
 
-pub struct PanicSocialQueryPort;
+pub struct PanicFederationAdminQuery;
 
 #[async_trait]
-impl crate::ports::SocialQueryPort for PanicSocialQueryPort {
-    async fn get_accepted_following_urls(
-        &self,
-        _: &crate::value_objects::UserId,
-    ) -> Result<Vec<String>, DomainError> {
-        panic!("PanicSocialQueryPort called")
-    }
+impl crate::ports::FederationAdminQuery for PanicFederationAdminQuery {
     async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError> {
-        panic!("PanicSocialQueryPort called")
-    }
-    async fn count_following(
-        &self,
-        _: &crate::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        panic!("PanicSocialQueryPort called")
-    }
-    async fn count_accepted_followers(
-        &self,
-        _: &crate::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        panic!("PanicSocialQueryPort called")
-    }
-    async fn get_pending_followers(
-        &self,
-        _: &crate::value_objects::UserId,
-    ) -> Result<Vec<PendingFollowerInfo>, DomainError> {
-        panic!("PanicSocialQueryPort called")
+        panic!("PanicFederationAdminQuery called")
     }
 }
 

crates/domain/src/tests/events.rs

@@ -1,16 +1,55 @@
 use super::*;
-use crate::value_objects::UserId;
+use crate::value_objects::{FollowTarget, SocialIdentity, UserId};
 
 #[test]
 fn follow_accepted_matches() {
     let uid = UserId::from_uuid(uuid::Uuid::new_v4());
     let event = DomainEvent::FollowAccepted {
-        local_user_id: uid.clone(),
-        remote_actor_url: "https://remote.example/users/alice".to_string(),
-        outbox_url: "https://remote.example/users/alice/outbox".to_string(),
+        owner: uid.clone(),
+        requester: SocialIdentity::Remote {
+            actor_url: "https://remote.example/users/alice".to_string(),
+        },
     };
-    let DomainEvent::FollowAccepted { outbox_url, .. } = event else {
+    let DomainEvent::FollowAccepted { requester, .. } = event else {
         panic!("wrong variant");
     };
-    assert_eq!(outbox_url, "https://remote.example/users/alice/outbox");
+    assert_eq!(
+        requester,
+        SocialIdentity::Remote {
+            actor_url: "https://remote.example/users/alice".to_string()
+        }
+    );
+}
+
+#[test]
+fn follow_requested_with_identity() {
+    let follower = UserId::from_uuid(uuid::Uuid::new_v4());
+    let target = UserId::from_uuid(uuid::Uuid::new_v4());
+    let event = DomainEvent::FollowRequested {
+        follower: follower.clone(),
+        target: FollowTarget::Identity(SocialIdentity::Local(target.clone())),
+    };
+    assert!(matches!(
+        event,
+        DomainEvent::FollowRequested {
+            target: FollowTarget::Identity(SocialIdentity::Local(_)),
+            ..
+        }
+    ));
+}
+
+#[test]
+fn follow_requested_with_handle() {
+    let follower = UserId::from_uuid(uuid::Uuid::new_v4());
+    let event = DomainEvent::FollowRequested {
+        follower: follower.clone(),
+        target: FollowTarget::Handle("@alice@remote.example".into()),
+    };
+    assert!(matches!(
+        event,
+        DomainEvent::FollowRequested {
+            target: FollowTarget::Handle(_),
+            ..
+        }
+    ));
 }

crates/domain/src/tests/value_objects.rs

@@ -9,13 +9,14 @@ fn movie_id_generate_unique() {
 
 #[test]
 fn rating_valid_range() {
-    assert!(Rating::new(0).is_ok());
+    assert!(Rating::new(1).is_ok());
     assert!(Rating::new(5).is_ok());
     assert_eq!(Rating::new(3).unwrap().value(), 3);
 }
 
 #[test]
 fn rating_invalid() {
+    assert!(Rating::new(0).is_err());
     assert!(Rating::new(6).is_err());
     assert!(Rating::new(255).is_err());
 }

crates/domain/src/value_objects/mod.rs

@@ -1,11 +1,13 @@
 mod ids;
 mod movie;
 mod review;
+mod social;
 mod user;
 
 pub use ids::*;
 pub use movie::*;
 pub use review::*;
+pub use social::*;
 pub use user::*;
 
 #[cfg(test)]

crates/domain/src/value_objects/review.rs

@@ -86,10 +86,11 @@ pub fn format_watched_at(dt: &chrono::NaiveDateTime) -> String {
 pub struct Rating(u8);
 
 impl Rating {
+    const MIN: u8 = 1;
     const MAX: u8 = 5;
 
     pub fn new(value: u8) -> Result<Self, DomainError> {
-        if value <= Self::MAX {
+        if (Self::MIN..=Self::MAX).contains(&value) {
             Ok(Self(value))
         } else {
             Err(DomainError::InvalidRating {

crates/domain/src/value_objects/social.rs

@@ -0,0 +1,63 @@
+use super::UserId;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum SocialIdentity {
+    Local(UserId),
+    Remote { actor_url: String },
+}
+
+impl SocialIdentity {
+    pub fn from_actor_url(actor_url: &str, base_url: &str) -> Self {
+        let prefix = format!("{}/users/", base_url);
+        if let Some(uuid_str) = actor_url.strip_prefix(&prefix)
+            && let Ok(uuid) = uuid::Uuid::parse_str(uuid_str)
+        {
+            return Self::Local(UserId::from_uuid(uuid));
+        }
+        Self::Remote {
+            actor_url: actor_url.to_string(),
+        }
+    }
+
+    pub fn is_local(&self) -> bool {
+        matches!(self, Self::Local(_))
+    }
+
+    pub fn is_remote(&self) -> bool {
+        matches!(self, Self::Remote { .. })
+    }
+
+    pub fn format_local_handle(username: &str, base_url: &str) -> String {
+        let host = Self::host_from_base_url(base_url);
+        format!("@{}@{}", username, host)
+    }
+
+    pub fn host_from_base_url(base_url: &str) -> &str {
+        base_url
+            .split("://")
+            .nth(1)
+            .and_then(|s| s.split('/').next())
+            .unwrap_or("localhost")
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FollowStatus {
+    Pending,
+    Accepted,
+    Rejected,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FollowTarget {
+    Identity(SocialIdentity),
+    Handle(String),
+}
+
+#[derive(Clone, Debug)]
+pub struct SocialActor {
+    pub identity: SocialIdentity,
+    pub handle: String,
+    pub display_name: Option<String>,
+    pub avatar_url: Option<String>,
+}

crates/infra-wiring/src/config.rs

@@ -19,8 +19,10 @@ impl AppConfig {
         let allow_registration = std::env::var("ALLOW_REGISTRATION")
             .map(|v| v == "true" || v == "1")
             .unwrap_or(false);
-        let base_url =
-            std::env::var("BASE_URL").unwrap_or_else(|_| "http://localhost:3000".to_string());
+        let base_url = std::env::var("BASE_URL")
+            .unwrap_or_else(|_| "http://localhost:3000".to_string())
+            .trim_end_matches('/')
+            .to_string();
         let rate_limit = std::env::var("RATE_LIMIT")
             .ok()
             .and_then(|v| v.parse().ok())

crates/presentation/src/context.rs

@@ -2,13 +2,14 @@ use std::sync::Arc;
 
 use domain::ports::{
     AuthService, DiaryExporter, DiaryQuery, DocumentParser, EventPublisher, FederatedProfileQuery,
-    GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository, MetadataClient,
-    MovieCommand, MovieProfileRepository, MovieQuery, ObjectStorage, PasswordHasher, PersonCommand,
-    PersonEnrichmentClient, PersonQuery, PosterFetcherClient, RefreshSessionRepository,
-    RemoteGoalRepository, RemoteWatchlistRepository, ReviewRepository, SearchCommand, SearchPort,
-    SocialQueryPort, StatsRepository, UserProfileFieldsRepository, UserRepository,
-    UserSettingsRepository, WatchEventCommand, WatchEventQuery, WatchlistRepository,
-    WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
+    FederationAdminQuery, GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository,
+    MetadataClient, MovieCommand, MovieProfileRepository, MovieQuery, ObjectStorage,
+    PasswordHasher, PersonCommand, PersonEnrichmentClient, PersonQuery, PosterFetcherClient,
+    RefreshSessionRepository, RemoteGoalRepository, RemoteWatchlistRepository, ReviewRepository,
+    SearchCommand, SearchPort, SocialCommand, SocialQuery, StatsRepository,
+    UserProfileFieldsRepository, UserRepository, UserSettingsRepository, WatchEventCommand,
+    WatchEventQuery, WatchlistRepository, WebhookTokenRepository, WrapUpRepository,
+    WrapUpStatsQuery,
 };
 
 use application::config::AppConfig;
@@ -35,7 +36,9 @@ pub struct Repositories {
     pub search_command: Arc<dyn SearchCommand>,
     pub profile_fields: Arc<dyn UserProfileFieldsRepository>,
     pub remote_watchlist: Arc<dyn RemoteWatchlistRepository>,
-    pub social_query: Arc<dyn SocialQueryPort>,
+    pub social_command: Arc<dyn SocialCommand>,
+    pub social_query_unified: Arc<dyn SocialQuery>,
+    pub federation_admin: Arc<dyn FederationAdminQuery>,
     pub wrapup_stats: Arc<dyn WrapUpStatsQuery>,
     pub wrapup_repo: Arc<dyn WrapUpRepository>,
     pub goal_command: Arc<dyn GoalCommand>,
@@ -58,6 +61,8 @@ pub struct Services {
     pub document_parser: Arc<dyn DocumentParser>,
     pub review_logger: Arc<dyn ReviewLogger>,
     pub person_enrichment: Option<Arc<dyn PersonEnrichmentClient>>,
+    #[cfg(feature = "federation")]
+    pub ap_service: Arc<dyn activitypub::ActivityPubPort>,
 }
 
 #[derive(Clone)]

crates/presentation/src/handlers/diary.rs

@@ -182,7 +182,7 @@ pub async fn get_activity_feed(
 ) -> Result<Json<ActivityFeedResponse>, ApiError> {
     let deps = GetActivityFeedDeps {
         diary: state.app_ctx.repos.diary.clone(),
-        social_query: state.app_ctx.repos.social_query.clone(),
+        social_query: state.app_ctx.repos.social_query_unified.clone(),
         config: state.app_ctx.config.clone(),
     };
     let page = get_feed_uc::execute(
@@ -312,8 +312,7 @@ pub async fn get_activity_feed_html(
     let limit = params.limit.unwrap_or(20);
     let offset = params.offset.unwrap_or(0);
 
-    let filter_following =
-        cfg!(feature = "federation") && params.filter == "following" && user_id.is_some();
+    let filter_following = params.filter == "following" && user_id.is_some();
     let filter_str = if filter_following { "following" } else { "all" };
 
     let sort_by_str = match params.sort_by.as_str() {
@@ -338,7 +337,7 @@ pub async fn get_activity_feed_html(
 
     let deps = GetActivityFeedDeps {
         diary: state.app_ctx.repos.diary.clone(),
-        social_query: state.app_ctx.repos.social_query.clone(),
+        social_query: state.app_ctx.repos.social_query_unified.clone(),
         config: state.app_ctx.config.clone(),
     };
 

crates/presentation/src/handlers/social.rs

@@ -19,8 +19,10 @@ use crate::{
 };
 use api_types::{
     ActorListResponse, ActorUrlRequest, AddBlockedDomainRequest, BlockedActorResponse,
-    BlockedDomainResponse, FollowRequest,
+    BlockedDomainResponse, FollowRequest, RemoteActorDto,
 };
+use application::social::deps::{SocialCommandDeps, SocialQueryDeps};
+use domain::value_objects::{FollowTarget, SocialActor, SocialIdentity};
 use template_askama::{
     BlockedActorsTemplate, BlockedDomainsTemplate, FollowersTemplate, FollowingTemplate,
     RemoteActorData,
@@ -28,11 +30,62 @@ use template_askama::{
 
 use super::helpers::{build_page_context, encode_error};
 
+impl From<&AppState> for SocialCommandDeps {
+    fn from(state: &AppState) -> Self {
+        Self {
+            social_command: state.app_ctx.repos.social_command.clone(),
+            social_query: state.app_ctx.repos.social_query_unified.clone(),
+            event_publisher: state.app_ctx.services.event_publisher.clone(),
+        }
+    }
+}
+
+impl From<&AppState> for SocialQueryDeps {
+    fn from(state: &AppState) -> Self {
+        Self {
+            social_query: state.app_ctx.repos.social_query_unified.clone(),
+        }
+    }
+}
+
 fn ap_to_domain(e: anyhow::Error) -> domain::errors::DomainError {
     tracing::error!("ActivityPub error: {:?}", e);
     domain::errors::DomainError::InfrastructureError(e.to_string())
 }
 
+fn actor_url(identity: &SocialIdentity) -> String {
+    match identity {
+        SocialIdentity::Remote { actor_url } => actor_url.clone(),
+        SocialIdentity::Local(uid) => format!("local:{}", uid.value()),
+    }
+}
+
+fn social_actor_to_dto(actor: SocialActor) -> RemoteActorDto {
+    RemoteActorDto {
+        url: actor_url(&actor.identity),
+        handle: actor.handle,
+        display_name: actor.display_name,
+    }
+}
+
+fn social_actor_to_blocked_dto(actor: SocialActor) -> BlockedActorResponse {
+    BlockedActorResponse {
+        url: actor_url(&actor.identity),
+        handle: actor.handle,
+        display_name: actor.display_name,
+        avatar_url: actor.avatar_url,
+    }
+}
+
+fn social_actor_to_template(actor: SocialActor) -> RemoteActorData {
+    RemoteActorData {
+        url: actor_url(&actor.identity),
+        handle: actor.handle,
+        display_name: actor.display_name,
+        avatar_url: actor.avatar_url,
+    }
+}
+
 // ── API ──────────────────────────────────────────────────────────────────────
 
 #[utoipa::path(
@@ -49,6 +102,8 @@ pub async fn get_blocked_domains_admin(
     _admin: AdminApiUser,
 ) -> Result<Json<Vec<BlockedDomainResponse>>, ApiError> {
     let domains = state
+        .app_ctx
+        .services
         .ap_service
         .get_blocked_domains()
         .await
@@ -81,6 +136,8 @@ pub async fn add_blocked_domain_admin(
     axum::Json(body): axum::Json<AddBlockedDomainRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
     state
+        .app_ctx
+        .services
         .ap_service
         .add_blocked_domain(&body.domain, body.reason.as_deref())
         .await
@@ -104,6 +161,8 @@ pub async fn remove_blocked_domain_admin(
     axum::extract::Path(domain): axum::extract::Path<String>,
 ) -> Result<impl IntoResponse, ApiError> {
     state
+        .app_ctx
+        .services
         .ap_service
         .remove_blocked_domain(&domain)
         .await
@@ -125,11 +184,15 @@ pub async fn block_actor_api(
     user: AuthenticatedUser,
     axum::Json(body): axum::Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .block_actor(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Block {
+            blocker_id: user.0.value(),
+            target: SocialIdentity::from_actor_url(&body.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
+    .await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -147,11 +210,15 @@ pub async fn unblock_actor_api(
     user: AuthenticatedUser,
     axum::Json(body): axum::Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .unblock_actor(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Unblock {
+            blocker_id: user.0.value(),
+            target: SocialIdentity::from_actor_url(&body.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
+    .await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
@@ -167,20 +234,18 @@ pub async fn get_blocked_actors_api(
     State(state): State<AppState>,
     user: AuthenticatedUser,
 ) -> Result<Json<Vec<BlockedActorResponse>>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_blocked_actors(user.0.value())
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetBlocked {
+            user_id: user.0.value(),
+        },
+    )
+    .await?;
     Ok(Json(
-        actors
+        identities
             .into_iter()
-            .map(|a| BlockedActorResponse {
-                url: a.url,
-                handle: a.handle,
-                display_name: a.display_name,
-                avatar_url: a.avatar_url,
-            })
+            .map(social_actor_to_blocked_dto)
             .collect(),
     ))
 }
@@ -197,16 +262,16 @@ pub async fn get_following(
     State(state): State<AppState>,
     user: AuthenticatedUser,
 ) -> Result<Json<ActorListResponse>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_following(user.0.value())
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowing {
+            user_id: user.0.value(),
+        },
+    )
+    .await?;
     Ok(Json(ActorListResponse {
-        actors: actors
-            .into_iter()
-            .map(crate::mappers::social::remote_actor_to_dto)
-            .collect(),
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
     }))
 }
 
@@ -222,16 +287,16 @@ pub async fn get_followers(
     State(state): State<AppState>,
     user: AuthenticatedUser,
 ) -> Result<Json<ActorListResponse>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_accepted_followers(user.0.value())
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowers {
+            user_id: user.0.value(),
+        },
+    )
+    .await?;
     Ok(Json(ActorListResponse {
-        actors: actors
-            .into_iter()
-            .map(crate::mappers::social::remote_actor_to_dto)
-            .collect(),
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
     }))
 }
 
@@ -240,16 +305,14 @@ pub async fn get_user_following(
     _user: AuthenticatedUser,
     Path(user_id): Path<Uuid>,
 ) -> Result<Json<ActorListResponse>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_following(user_id)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowing { user_id },
+    )
+    .await?;
     Ok(Json(ActorListResponse {
-        actors: actors
-            .into_iter()
-            .map(crate::mappers::social::remote_actor_to_dto)
-            .collect(),
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
     }))
 }
 
@@ -258,16 +321,14 @@ pub async fn get_user_followers(
     _user: AuthenticatedUser,
     Path(user_id): Path<Uuid>,
 ) -> Result<Json<ActorListResponse>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_accepted_followers(user_id)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowers { user_id },
+    )
+    .await?;
     Ok(Json(ActorListResponse {
-        actors: actors
-            .into_iter()
-            .map(crate::mappers::social::remote_actor_to_dto)
-            .collect(),
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
     }))
 }
 
@@ -285,11 +346,15 @@ pub async fn follow(
     user: AuthenticatedUser,
     Json(body): Json<FollowRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .follow(user.0.value(), &body.handle)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Follow {
+            follower_id: user.0.value(),
+            target: FollowTarget::Handle(body.handle),
+        },
+    )
+    .await?;
     Ok(StatusCode::OK)
 }
 
@@ -307,11 +372,15 @@ pub async fn unfollow(
     user: AuthenticatedUser,
     Json(body): Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .unfollow(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Unfollow {
+            follower_id: user.0.value(),
+            target: SocialIdentity::from_actor_url(&body.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
+    .await?;
     Ok(StatusCode::OK)
 }
 
@@ -329,11 +398,18 @@ pub async fn accept_follower(
     user: AuthenticatedUser,
     Json(body): Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .accept_follower(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::AcceptFollow {
+            owner_id: user.0.value(),
+            requester: SocialIdentity::from_actor_url(
+                &body.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
+    .await?;
     Ok(StatusCode::OK)
 }
 
@@ -351,11 +427,18 @@ pub async fn reject_follower(
     user: AuthenticatedUser,
     Json(body): Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .reject_follower(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::RejectFollow {
+            owner_id: user.0.value(),
+            requester: SocialIdentity::from_actor_url(
+                &body.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
+    .await?;
     Ok(StatusCode::OK)
 }
 
@@ -373,11 +456,18 @@ pub async fn remove_follower(
     user: AuthenticatedUser,
     Json(body): Json<ActorUrlRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
-    state
-        .ap_service
-        .remove_follower(user.0.value(), &body.actor_url)
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialCommandDeps::from(&state);
+    application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::RemoveFollower {
+            owner_id: user.0.value(),
+            follower: SocialIdentity::from_actor_url(
+                &body.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
+    .await?;
     Ok(StatusCode::OK)
 }
 
@@ -393,16 +483,16 @@ pub async fn get_pending_followers(
     State(state): State<AppState>,
     user: AuthenticatedUser,
 ) -> Result<Json<ActorListResponse>, ApiError> {
-    let actors = state
-        .ap_service
-        .get_pending_followers(user.0.value())
-        .await
-        .map_err(ap_to_domain)?;
+    let deps = SocialQueryDeps::from(&state);
+    let identities = application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetPending {
+            user_id: user.0.value(),
+        },
+    )
+    .await?;
     Ok(Json(ActorListResponse {
-        actors: actors
-            .into_iter()
-            .map(crate::mappers::social::remote_actor_to_dto)
-            .collect(),
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
     }))
 }
 
@@ -428,7 +518,16 @@ pub async fn follow_remote_user(
         .unwrap_or(&format!("/users/{}", profile_user_uuid))
         .to_string();
 
-    match state.ap_service.follow(user_id.value(), &form.handle).await {
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Follow {
+            follower_id: user_id.value(),
+            target: FollowTarget::Handle(form.handle),
+        },
+    )
+    .await
+    {
         Ok(()) => Redirect::to(&redirect_base).into_response(),
         Err(e) => {
             tracing::error!("follow error: {:?}", e);
@@ -456,9 +555,14 @@ pub async fn unfollow_remote_user(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .unfollow(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Unfollow {
+            follower_id: user_id.value(),
+            target: SocialIdentity::from_actor_url(&form.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
     .await
     {
         Ok(()) => {
@@ -488,9 +592,17 @@ pub async fn accept_follower_html(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .accept_follower(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::AcceptFollow {
+            owner_id: user_id.value(),
+            requester: SocialIdentity::from_actor_url(
+                &form.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
     .await
     {
         Ok(_) => Redirect::to(&format!("/users/{}", profile_user_uuid)).into_response(),
@@ -514,9 +626,17 @@ pub async fn reject_follower_html(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .reject_follower(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::RejectFollow {
+            owner_id: user_id.value(),
+            requester: SocialIdentity::from_actor_url(
+                &form.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
     .await
     {
         Ok(_) => Redirect::to(&format!("/users/{}", profile_user_uuid)).into_response(),
@@ -540,6 +660,8 @@ pub async fn get_followers_collection(
     if accept.contains("application/activity+json") || accept.contains("application/ld+json") {
         let page = params.get("page").and_then(|p| p.parse::<u32>().ok());
         return match state
+            .app_ctx
+            .services
             .ap_service
             .followers_collection_json(user_id, page)
             .await
@@ -571,6 +693,8 @@ pub async fn get_following_collection(
     if accept.contains("application/activity+json") || accept.contains("application/ld+json") {
         let page = params.get("page").and_then(|p| p.parse::<u32>().ok());
         return match state
+            .app_ctx
+            .services
             .ap_service
             .following_collection_json(user_id, page)
             .await
@@ -605,16 +729,19 @@ pub async fn get_following_page(
         "{}/users/{}/following-list",
         state.app_ctx.config.base_url, profile_user_uuid
     );
-    match state.ap_service.get_following(user_id.value()).await {
+    let deps = SocialQueryDeps::from(&state);
+    match application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowing {
+            user_id: user_id.value(),
+        },
+    )
+    .await
+    {
         Ok(following) => {
             let actors: Vec<RemoteActorData> = following
                 .into_iter()
-                .map(|a| RemoteActorData {
-                    handle: a.handle,
-                    display_name: a.display_name,
-                    url: a.url,
-                    avatar_url: a.avatar_url.clone(),
-                })
+                .map(social_actor_to_template)
                 .collect();
             render_page(FollowingTemplate {
                 ctx,
@@ -651,20 +778,19 @@ pub async fn get_followers_page(
         "{}/users/{}/followers-list",
         state.app_ctx.config.base_url, profile_user_uuid
     );
-    match state
-        .ap_service
-        .get_accepted_followers(user_id.value())
+    let deps = SocialQueryDeps::from(&state);
+    match application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetFollowers {
+            user_id: user_id.value(),
+        },
+    )
     .await
     {
         Ok(followers) => {
             let actors: Vec<RemoteActorData> = followers
                 .into_iter()
-                .map(|a| RemoteActorData {
-                    handle: a.handle,
-                    display_name: a.display_name,
-                    url: a.url,
-                    avatar_url: a.avatar_url.clone(),
-                })
+                .map(social_actor_to_template)
                 .collect();
             render_page(FollowersTemplate {
                 ctx,
@@ -698,9 +824,17 @@ pub async fn remove_follower_html(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .remove_follower(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::RemoveFollower {
+            owner_id: user_id.value(),
+            follower: SocialIdentity::from_actor_url(
+                &form.actor_url,
+                &state.app_ctx.config.base_url,
+            ),
+        },
+    )
     .await
     {
         Ok(_) => {
@@ -725,7 +859,13 @@ pub async fn get_blocked_domains_page(
     let mut ctx = build_page_context(&state, Some(user_id), csrf.0).await;
     ctx.page_title = "Blocked Domains — Movies Diary".to_string();
     ctx.canonical_url = format!("{}/admin/blocked-domains", state.app_ctx.config.base_url);
-    match state.ap_service.get_blocked_domains().await {
+    match state
+        .app_ctx
+        .services
+        .ap_service
+        .get_blocked_domains()
+        .await
+    {
         Ok(domains) => {
             let entries: Vec<template_askama::BlockedDomainEntry> = domains
                 .into_iter()
@@ -763,6 +903,8 @@ pub async fn post_blocked_domain(
     }
     let reason = form.reason.as_deref().filter(|s| !s.trim().is_empty());
     match state
+        .app_ctx
+        .services
         .ap_service
         .add_blocked_domain(&form.domain, reason)
         .await
@@ -784,7 +926,13 @@ pub async fn post_remove_blocked_domain(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state.ap_service.remove_blocked_domain(&form.domain).await {
+    match state
+        .app_ctx
+        .services
+        .ap_service
+        .remove_blocked_domain(&form.domain)
+        .await
+    {
         Ok(()) => Redirect::to("/admin/blocked-domains").into_response(),
         Err(e) => {
             tracing::error!("remove_blocked_domain error: {:?}", e);
@@ -801,12 +949,20 @@ pub async fn get_blocked_actors_page(
     let mut ctx = build_page_context(&state, Some(user_id.clone()), csrf.0).await;
     ctx.page_title = "Blocked Users — Movies Diary".to_string();
     ctx.canonical_url = format!("{}/social/blocked", state.app_ctx.config.base_url);
-    match state.ap_service.get_blocked_actors(user_id.value()).await {
-        Ok(actors) => {
-            let entries: Vec<template_askama::BlockedActorEntry> = actors
+    let deps = SocialQueryDeps::from(&state);
+    match application::social::execute::execute_query(
+        &deps,
+        application::social::queries::SocialQry::GetBlocked {
+            user_id: user_id.value(),
+        },
+    )
+    .await
+    {
+        Ok(blocked) => {
+            let entries: Vec<template_askama::BlockedActorEntry> = blocked
                 .into_iter()
                 .map(|a| template_askama::BlockedActorEntry {
-                    url: a.url,
+                    url: actor_url(&a.identity),
                     handle: a.handle,
                     display_name: a.display_name,
                     avatar_url: a.avatar_url,
@@ -838,9 +994,14 @@ pub async fn post_block_actor_html(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .block_actor(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Block {
+            blocker_id: user_id.value(),
+            target: SocialIdentity::from_actor_url(&form.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
     .await
     {
         Ok(()) => Redirect::to("/social/blocked").into_response(),
@@ -860,9 +1021,14 @@ pub async fn post_unblock_actor(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state
-        .ap_service
-        .unblock_actor(user_id.value(), &form.actor_url)
+    let deps = SocialCommandDeps::from(&state);
+    match application::social::execute::execute_command(
+        &deps,
+        application::social::commands::SocialCmd::Unblock {
+            blocker_id: user_id.value(),
+            target: SocialIdentity::from_actor_url(&form.actor_url, &state.app_ctx.config.base_url),
+        },
+    )
     .await
     {
         Ok(()) => Redirect::to("/social/blocked").into_response(),

crates/presentation/src/handlers/users.rs

@@ -24,9 +24,9 @@ use crate::{
     state::AppState,
 };
 use api_types::{
-    DiaryResponse, DirectorStatDto, MonthActivityDto, MonthlyRatingDto, ProfileResponse,
-    UserProfileQueryParams, UserProfileResponse, UserStatsDto, UserSummaryDto, UserTrendsDto,
-    UsersResponse,
+    DiaryResponse, DirectorStatDto, GenreStatDto, MonthActivityDto, MonthlyRatingDto,
+    ProfileResponse, UserProfileQueryParams, UserProfileResponse, UserStatsDto, UserSummaryDto,
+    UserTrendsDto, UsersResponse, WatchMediumStatDto,
 };
 use template_askama::{
     EmbedProfileTemplate, MonthlyRatingRow, ProfileSettingsTemplate, ProfileTemplate,
@@ -176,12 +176,11 @@ pub async fn update_profile_fields_handler(
     responses((status = 200, body = UsersResponse)),
 )]
 pub async fn list_users(State(state): State<AppState>) -> Result<Json<UsersResponse>, ApiError> {
-    let result = get_users::execute(
-        state.app_ctx.repos.user.clone(),
-        state.app_ctx.repos.social_query.clone(),
-        GetUsersQuery,
-    )
-    .await?;
+    let deps = application::users::deps::GetUsersListDeps {
+        user: state.app_ctx.repos.user.clone(),
+        federation_admin: state.app_ctx.repos.federation_admin.clone(),
+    };
+    let result = get_users::execute(&deps, GetUsersQuery).await?;
     Ok(Json(UsersResponse {
         users: result
             .users
@@ -248,7 +247,7 @@ pub async fn get_user_profile(
     let get_profile_deps = GetProfileDeps {
         stats: state.app_ctx.repos.stats.clone(),
         diary: state.app_ctx.repos.diary.clone(),
-        social_query: state.app_ctx.repos.social_query.clone(),
+        social_query: state.app_ctx.repos.social_query_unified.clone(),
     };
     let profile = match get_user_profile_uc::execute(
         &get_profile_deps,
@@ -298,32 +297,10 @@ pub async fn get_user_profile(
                 })
                 .collect(),
         })
-    } else if let Some(t) = profile.trends {
-        Some(api_types::ProfileViewData::Trends {
-            trends: UserTrendsDto {
-                monthly_ratings: t
-                    .monthly_ratings
-                    .into_iter()
-                    .map(|r| MonthlyRatingDto {
-                        year_month: r.year_month,
-                        month_label: r.month_label,
-                        avg_rating: r.avg_rating,
-                        count: r.count,
-                    })
-                    .collect(),
-                top_directors: t
-                    .top_directors
-                    .into_iter()
-                    .map(|d| DirectorStatDto {
-                        director: d.director,
-                        count: d.count,
-                    })
-                    .collect(),
-                max_director_count: t.max_director_count,
-            },
-        })
     } else {
-        None
+        profile.trends.map(|t| api_types::ProfileViewData::Trends {
+            trends: trends_to_dto(t),
+        })
     };
 
     Json(UserProfileResponse {
@@ -381,7 +358,7 @@ async fn build_federated_profile_response(
     let get_profile_deps = GetProfileDeps {
         stats: state.app_ctx.repos.stats.clone(),
         diary: state.app_ctx.repos.diary.clone(),
-        social_query: state.app_ctx.repos.social_query.clone(),
+        social_query: state.app_ctx.repos.social_query_unified.clone(),
     };
     let profile = match get_user_profile_uc::execute(
         &get_profile_deps,
@@ -415,32 +392,10 @@ async fn build_federated_profile_response(
                 offset: p.offset,
             },
         })
-    } else if let Some(t) = profile.trends {
-        Some(api_types::ProfileViewData::Trends {
-            trends: UserTrendsDto {
-                monthly_ratings: t
-                    .monthly_ratings
-                    .into_iter()
-                    .map(|r| MonthlyRatingDto {
-                        year_month: r.year_month,
-                        month_label: r.month_label,
-                        avg_rating: r.avg_rating,
-                        count: r.count,
-                    })
-                    .collect(),
-                top_directors: t
-                    .top_directors
-                    .into_iter()
-                    .map(|d| DirectorStatDto {
-                        director: d.director,
-                        count: d.count,
-                    })
-                    .collect(),
-                max_director_count: t.max_director_count,
-            },
-        })
     } else {
-        None
+        profile.trends.map(|t| api_types::ProfileViewData::Trends {
+            trends: trends_to_dto(t),
+        })
     };
 
     let username = fed
@@ -474,6 +429,47 @@ async fn build_federated_profile_response(
     .into_response()
 }
 
+fn trends_to_dto(t: domain::models::UserTrends) -> UserTrendsDto {
+    UserTrendsDto {
+        monthly_ratings: t
+            .monthly_ratings
+            .into_iter()
+            .map(|r| MonthlyRatingDto {
+                year_month: r.year_month,
+                month_label: r.month_label,
+                avg_rating: r.avg_rating,
+                count: r.count,
+            })
+            .collect(),
+        top_directors: t
+            .top_directors
+            .into_iter()
+            .map(|d| DirectorStatDto {
+                director: d.director,
+                count: d.count,
+            })
+            .collect(),
+        max_director_count: t.max_director_count,
+        top_genres: t
+            .top_genres
+            .into_iter()
+            .map(|g| GenreStatDto {
+                genre: g.genre,
+                count: g.count,
+            })
+            .collect(),
+        rating_distribution: t.rating_distribution,
+        watch_medium_distribution: t
+            .watch_medium_distribution
+            .into_iter()
+            .map(|m| WatchMediumStatDto {
+                medium: m.medium,
+                count: m.count,
+            })
+            .collect(),
+    }
+}
+
 // ── HTML ─────────────────────────────────────────────────────────────────────
 
 pub async fn get_users_list(
@@ -485,9 +481,12 @@ pub async fn get_users_list(
     ctx.page_title = "Members — Movies Diary".to_string();
     ctx.canonical_url = format!("{}/users", state.app_ctx.config.base_url);
 
+    let users_deps = application::users::deps::GetUsersListDeps {
+        user: state.app_ctx.repos.user.clone(),
+        federation_admin: state.app_ctx.repos.federation_admin.clone(),
+    };
     match application::users::get_users::execute(
-        state.app_ctx.repos.user.clone(),
-        state.app_ctx.repos.social_query.clone(),
+        &users_deps,
         application::users::queries::GetUsersQuery,
     )
     .await
@@ -647,6 +646,8 @@ pub async fn get_user_profile_html(
             .unwrap_or("");
         if accept.contains("application/activity+json") || accept.contains("application/ld+json") {
             return match state
+                .app_ctx
+                .services
                 .ap_service
                 .actor_json(&profile_user_uuid.to_string())
                 .await
@@ -729,7 +730,7 @@ pub async fn get_user_profile_html(
     let html_profile_deps = GetProfileDeps {
         stats: state.app_ctx.repos.stats.clone(),
         diary: state.app_ctx.repos.diary.clone(),
-        social_query: state.app_ctx.repos.social_query.clone(),
+        social_query: state.app_ctx.repos.social_query_unified.clone(),
     };
     match application::users::get_profile::execute(&html_profile_deps, query).await {
         Ok(profile) => {

crates/presentation/src/main.rs

@@ -66,16 +66,16 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
     let event_bus = EventBusBackend::from_env()?;
 
     #[cfg(feature = "federation")]
-    let (event_publisher_arc, ap_router, ap_service, social_query, remote_watchlist_repo) = {
     let (
-            activity_repo,
-            follow_repo,
-            actor_repo,
-            blocklist_repo,
-            social_query_arc,
-            review_store,
+        event_publisher_arc,
+        ap_router,
+        ap_service,
+        social_query,
         remote_watchlist_repo,
-        ) = match &db_pool {
+        social_command_arc,
+        social_query_unified_arc,
+    ) = {
+        let fed_repos = match &db_pool {
             #[cfg(feature = "postgres-federation")]
             factory::DbPool::Postgres(pool) => postgres_federation::wire(pool.clone()),
             #[cfg(feature = "sqlite-federation")]
@@ -89,12 +89,12 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
         let ep = create_event_publisher(event_bus, &db_pool).await?;
 
         let ap = activitypub::wire(activitypub::ActivityPubDeps {
-            activity_repo,
-            follow_repo,
-            actor_repo,
-            blocklist_repo,
-            review_store,
-            remote_watchlist_repo: remote_watchlist_repo.clone(),
+            activity_repo: fed_repos.activity,
+            follow_repo: fed_repos.follow,
+            actor_repo: fed_repos.actor,
+            blocklist_repo: fed_repos.blocklist,
+            review_store: fed_repos.review_store,
+            remote_watchlist_repo: fed_repos.remote_watchlist.clone(),
             remote_goal_repo: Arc::clone(&db.remote_goal),
             local_ap_content: Arc::clone(&ap_content_repo),
             movie_repo: Arc::clone(&db.movie_query),
@@ -104,6 +104,8 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
             stats_repo: Arc::clone(&db.stats),
             user_repo: Arc::clone(&db.user),
             federation_settings: std::sync::Arc::clone(&db.federation_settings),
+            follow_command: Arc::clone(&fed_repos.follow_command),
+            follow_query: Arc::clone(&fed_repos.follow_query),
             base_url: app_config.base_url.clone(),
             allow_registration: app_config.allow_registration,
             event_publisher: Arc::clone(&ep),
@@ -112,12 +114,22 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
         let ap_router = ap.router;
         let ap_service_arc = ap.service;
 
+        let composite_social = Arc::new(activitypub::CompositeSocialAdapter::new(
+            Arc::clone(&ap_service_arc),
+            Arc::clone(&db.user),
+            fed_repos.follow_command,
+            fed_repos.follow_query,
+            app_config.base_url.clone(),
+        ));
+
         (
             ep,
             ap_router,
             ap_service_arc,
-            social_query_arc,
-            remote_watchlist_repo,
+            fed_repos.admin_query,
+            fed_repos.remote_watchlist,
+            composite_social.clone() as Arc<dyn domain::ports::SocialCommand>,
+            composite_social as Arc<dyn domain::ports::SocialQuery>,
         )
     };
 
@@ -125,6 +137,12 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
     let event_publisher_arc = create_event_publisher(event_bus, &db_pool).await?;
     #[cfg(not(feature = "federation"))]
     let ap_router = axum::Router::new();
+    #[cfg(not(feature = "federation"))]
+    let social_command_arc: Arc<dyn domain::ports::SocialCommand> =
+        Arc::new(domain::ports::noop::NoopSocialCommand);
+    #[cfg(not(feature = "federation"))]
+    let social_query_unified_arc: Arc<dyn domain::ports::SocialQuery> =
+        Arc::new(domain::ports::noop::NoopSocialQuery);
 
     let review_logger = Arc::new(application::diary::review_logger::DefaultReviewLogger::new(
         Arc::clone(&db.movie_command),
@@ -159,10 +177,12 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
             remote_watchlist: remote_watchlist_repo,
             #[cfg(not(feature = "federation"))]
             remote_watchlist: Arc::new(domain::ports::noop::NoopRemoteWatchlistRepository),
+            social_command: social_command_arc,
+            social_query_unified: social_query_unified_arc,
             #[cfg(feature = "federation")]
-            social_query: social_query.clone(),
+            federation_admin: social_query.clone(),
             #[cfg(not(feature = "federation"))]
-            social_query: Arc::new(domain::ports::noop::NoopSocialQueryPort),
+            federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery),
             wrapup_stats: db.wrapup_stats,
             wrapup_repo: db.wrapup_repo,
             goal_command: db.goal_command,
@@ -199,6 +219,8 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
             document_parser: Arc::new(ImporterDocumentParser) as Arc<dyn DocumentParser>,
             review_logger,
             person_enrichment: None,
+            #[cfg(feature = "federation")]
+            ap_service,
         },
         config: app_config,
     };
@@ -208,8 +230,6 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
         rss_renderer: Arc::new(RssAdapter::new(
             std::env::var("BASE_URL").unwrap_or_else(|_| "http://localhost:3000".into()),
         )),
-        #[cfg(feature = "federation")]
-        ap_service,
     };
     Ok((state, ap_router))
 }

crates/presentation/src/state.rs

@@ -8,6 +8,4 @@ use domain::ports::RssFeedRenderer;
 pub struct AppState {
     pub app_ctx: AppContext,
     pub rss_renderer: Arc<dyn RssFeedRenderer>,
-    #[cfg(feature = "federation")]
-    pub ap_service: Arc<dyn activitypub::ActivityPubPort>,
 }

crates/presentation/src/tests/extractors.rs

@@ -154,30 +154,6 @@ impl DiaryQuery for Panic {
         panic!()
     }
 }
-#[cfg(feature = "federation")]
-#[async_trait::async_trait]
-impl domain::ports::SocialQueryPort for Panic {
-    async fn get_accepted_following_urls(&self, _: &UserId) -> Result<Vec<String>, DomainError> {
-        panic!()
-    }
-    async fn list_all_followed_remote_actors(
-        &self,
-    ) -> Result<Vec<domain::models::RemoteActorInfo>, DomainError> {
-        panic!()
-    }
-    async fn count_following(&self, _: &UserId) -> Result<usize, DomainError> {
-        panic!()
-    }
-    async fn count_accepted_followers(&self, _: &UserId) -> Result<usize, DomainError> {
-        panic!()
-    }
-    async fn get_pending_followers(
-        &self,
-        _: &UserId,
-    ) -> Result<Vec<domain::models::PendingFollowerInfo>, DomainError> {
-        panic!()
-    }
-}
 #[async_trait::async_trait]
 impl StatsRepository for Panic {
     async fn get_user_stats(&self, _: &UserId) -> Result<UserStats, DomainError> {
@@ -811,7 +787,9 @@ pub fn make_test_state(auth_service: Arc<dyn AuthService>) -> crate::state::AppS
                 search_port: Arc::clone(&repo) as _,
                 search_command: Arc::clone(&repo) as _,
                 remote_watchlist: Arc::clone(&repo) as _,
-                social_query: Arc::clone(&repo) as _,
+                social_command: Arc::new(domain::ports::noop::NoopSocialCommand) as _,
+                social_query_unified: Arc::new(domain::ports::noop::NoopSocialQuery) as _,
+                federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery) as _,
                 wrapup_stats: Arc::clone(&repo) as _,
                 wrapup_repo: Arc::clone(&repo) as _,
                 goal_command: Arc::clone(&repo) as _,
@@ -832,6 +810,8 @@ pub fn make_test_state(auth_service: Arc<dyn AuthService>) -> crate::state::AppS
                 document_parser: Arc::clone(&repo) as _,
                 review_logger: Arc::clone(&repo) as _,
                 person_enrichment: None,
+                #[cfg(feature = "federation")]
+                ap_service: Arc::new(activitypub::NoopActivityPubService),
             },
             config: AppConfig {
                 allow_registration: false,
@@ -846,8 +826,6 @@ pub fn make_test_state(auth_service: Arc<dyn AuthService>) -> crate::state::AppS
             },
         },
         rss_renderer: Arc::new(Panic),
-        #[cfg(feature = "federation")]
-        ap_service: Arc::new(activitypub::NoopActivityPubService),
     }
 }
 

crates/presentation/tests/api_test.rs

@@ -372,9 +372,6 @@ impl SearchCommand for PanicSearchCommand {
     }
 }
 
-#[cfg(feature = "federation")]
-struct PanicSocialQuery;
-
 #[cfg(feature = "federation")]
 struct PanicRemoteWatchlist;
 #[cfg(feature = "federation")]
@@ -402,40 +399,6 @@ impl domain::ports::RemoteWatchlistRepository for PanicRemoteWatchlist {
         Ok(vec![])
     }
 }
-#[cfg(feature = "federation")]
-#[async_trait::async_trait]
-impl domain::ports::SocialQueryPort for PanicSocialQuery {
-    async fn get_accepted_following_urls(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<String>, DomainError> {
-        panic!()
-    }
-    async fn list_all_followed_remote_actors(
-        &self,
-    ) -> Result<Vec<domain::models::RemoteActorInfo>, DomainError> {
-        panic!()
-    }
-    async fn count_following(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        panic!()
-    }
-    async fn count_accepted_followers(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<usize, DomainError> {
-        panic!()
-    }
-    async fn get_pending_followers(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<domain::models::PendingFollowerInfo>, DomainError> {
-        panic!()
-    }
-}
-
 async fn test_app() -> Router {
     let pool = SqlitePool::connect("sqlite::memory:")
         .await
@@ -464,7 +427,9 @@ async fn test_app() -> Router {
                 search_port: Arc::new(PanicSearchPort),
                 search_command: Arc::new(PanicSearchCommand),
                 remote_watchlist: Arc::new(PanicRemoteWatchlist),
-                social_query: Arc::new(PanicSocialQuery),
+                social_command: Arc::new(domain::ports::noop::NoopSocialCommand),
+                social_query_unified: Arc::new(domain::ports::noop::NoopSocialQuery),
+                federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery) as _,
                 wrapup_stats: Arc::new(domain::testing::PanicWrapUpStatsQuery) as _,
                 wrapup_repo: Arc::new(domain::testing::PanicWrapUpRepository) as _,
                 goal_command: Arc::new(domain::testing::NoopGoalCommand),
@@ -485,6 +450,8 @@ async fn test_app() -> Router {
                 document_parser: Arc::new(PanicDocumentParser),
                 review_logger: Arc::new(PanicReviewLogger),
                 person_enrichment: None,
+                #[cfg(feature = "federation")]
+                ap_service: Arc::new(activitypub::NoopActivityPubService),
             },
             config: AppConfig {
                 allow_registration: false,
@@ -499,8 +466,6 @@ async fn test_app() -> Router {
             },
         },
         rss_renderer: Arc::new(RssAdapter::new("http://localhost:3000".into())),
-        #[cfg(feature = "federation")]
-        ap_service: Arc::new(activitypub::NoopActivityPubService),
     };
 
     routes::build_router(state, axum::Router::new())

crates/worker/src/follow_backfill_handler.rs

@@ -1,7 +1,9 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use domain::{errors::DomainError, events::DomainEvent, ports::EventHandler};
+use domain::{
+    errors::DomainError, events::DomainEvent, ports::EventHandler, value_objects::SocialIdentity,
+};
 
 pub struct FollowBackfillHandler {
     pub ap_service: Arc<dyn activitypub::ActivityPubPort>,
@@ -12,15 +14,27 @@ impl EventHandler for FollowBackfillHandler {
     async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
         match event {
             DomainEvent::FollowAccepted {
-                remote_actor_url,
-                outbox_url,
-                ..
+                owner,
+                requester: SocialIdentity::Remote { actor_url },
             } => {
-                tracing::info!(actor = %remote_actor_url, outbox = %outbox_url, "importing remote outbox");
-                self.ap_service
-                    .import_remote_outbox(outbox_url, remote_actor_url)
+                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()))
+                    .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 {
                 owner_user_id,

crates/worker/src/main.rs

@@ -61,15 +61,7 @@ async fn main() -> anyhow::Result<()> {
     );
     // Wire federation repos early to get remote_watchlist_repo for AppContext.
     #[cfg(feature = "federation")]
-    let (
-        fed_activity_repo,
-        fed_follow_repo,
-        fed_actor_repo,
-        fed_blocklist_repo,
-        _fed_social_query,
-        fed_review_store,
-        fed_remote_watchlist_repo,
-    ) = match &db.db_pool {
+    let fed_repos = match &db.db_pool {
         #[cfg(feature = "sqlite-federation")]
         db::DbPool::Sqlite(pool) => sqlite_federation::wire(pool.clone()),
         #[cfg(feature = "postgres-federation")]
@@ -244,12 +236,12 @@ async fn main() -> anyhow::Result<()> {
         #[cfg(feature = "federation")]
         {
             let ap_wire = activitypub::wire(activitypub::ActivityPubDeps {
-                activity_repo: fed_activity_repo,
-                follow_repo: fed_follow_repo,
-                actor_repo: fed_actor_repo,
-                blocklist_repo: fed_blocklist_repo,
-                review_store: fed_review_store,
-                remote_watchlist_repo: fed_remote_watchlist_repo,
+                activity_repo: fed_repos.activity,
+                follow_repo: fed_repos.follow,
+                actor_repo: fed_repos.actor,
+                blocklist_repo: fed_repos.blocklist,
+                review_store: fed_repos.review_store,
+                remote_watchlist_repo: fed_repos.remote_watchlist,
                 remote_goal_repo: Arc::clone(&remote_goal),
                 local_ap_content: fed_ap_content,
                 movie_repo: fed_movie_repo,
@@ -258,6 +250,8 @@ async fn main() -> anyhow::Result<()> {
                 goal_repo: fed_goal_repo,
                 stats_repo: fed_stats_repo,
                 user_repo: fed_user_repo,
+                follow_command: fed_repos.follow_command,
+                follow_query: fed_repos.follow_query,
                 base_url,
                 allow_registration,
                 event_publisher: Arc::clone(&event_publisher),

docs/adr/0002-unified-social-identity-layer.md

@@ -0,0 +1,11 @@
+# Unified social identity layer — wrap k_ap, don't gut it
+
+Social interactions (follow, unfollow, block, etc.) bypassed the application layer entirely — handlers called the ActivityPub adapter (`k_ap`) directly, and there was no concept of a local-only follow. Every social operation was implicitly federated, with no domain-level orchestration, no CQRS split, and no domain events for most actions. This made it impossible to add local social features without duplicating logic, and meant the codebase would drift as federation and local paths diverged.
+
+We introduce a `SocialIdentity` value object (`Local(UserId)` | `Remote { actor_url }`) in the domain layer. Social command and query ports (`SocialCommand` / `SocialQuery`) accept `SocialIdentity` instead of raw UUIDs or actor URLs. Application-layer use cases follow the existing CQRS pattern (command/query structs, separate deps, one file per use case, domain events on mutations). The adapter implementing `SocialCommand` branches on the identity variant: local goes straight to the database, remote delegates to `k_ap`. `k_ap` stays batteries-included and unchanged — this project just wraps it rather than reaching through it.
+
+## Considered Options
+
+- **Gut `k_ap` into a thin transport layer** — rejected because `k_ap` is shared with other projects (`thoughts`) that rely on its batteries-included API. Forcing all consumers to rewrite social orchestration defeats the purpose of the library.
+- **Two-tier API in `k_ap`** (high-level + low-level primitives) — rejected because it adds complexity to `k_ap` for one consumer's needs. Wrapping at the adapter boundary in movies-diary is simpler and keeps `k_ap` focused.
+- **Keep the status quo, add local branches in handlers** — rejected because it perpetuates the "no application layer for social" problem and guarantees local/remote drift.

docs/adr/0003-local-follow-direct-db.md

@@ -0,0 +1,20 @@
+# Local follows bypass ActivityPub, share storage
+
+ADR-0002 introduced `SocialIdentity` so the domain never branches on local vs remote, but the adapter (`CompositeSocialAdapter`) still routed everything through k_ap — meaning a local user following another local user triggered WebFinger resolution, HTTP signature verification, and inbox delivery to the same instance. Wasteful on any hardware, unacceptable on an N100.
+
+## Decision
+
+**Commands branch in the adapter, queries don't.**
+
+- `SocialCommand` methods in `CompositeSocialAdapter` check the `SocialIdentity` variant. Local targets get direct SQL writes to the `ap_followers`/`ap_following` tables (via a domain `FollowRepository` port). Remote targets delegate to `k_ap::ActivityPubService` as before.
+- `SocialQuery` methods go through the domain port only — a single SQL query that left-joins `ap_followers`/`ap_following` against both `users` (local) and `ap_remote_actors` (remote), returning `SocialActor` directly.
+- Local follows store the full actor URL (`https://instance.example/users/{uuid}`) in `remote_actor_url`, same format as remote follows. k_ap's AP collection endpoints read from these tables unchanged, so local relationships are visible to the fediverse automatically.
+- Local user metadata (display name, avatar) is resolved from the `users` table at query time — no duplication into `ap_remote_actors`.
+- Follow acceptance is required for both local and remote — no behavioral divergence.
+- Local follow events (`FollowRequested`, `FollowAccepted`) are not broadcast as AP activities. The fediverse discovers local relationships passively via collection endpoints.
+
+## Considered Options
+
+- **Keep routing local through k_ap** — rejected because it wastes CPU/network on self-delivery and creates an unnecessary runtime dependency on federation for local social features.
+- **Separate `local_follows` table** — rejected because it creates two sources of truth for the same concept and requires merging in collection endpoints.
+- **Insert local users into `ap_remote_actors`** — rejected because it duplicates profile data and requires sync when local users update their profile.