refactor: 5 architectural improvements (Tasks 2-5 + Task 6 fix)

- feat(domain): Hashtag value object with canonical extract() — unifies two
  divergent private implementations; fields pre-compute raw/normalized/url_slug/ap_name

- feat(presentation): Deps<S: FromAppState> extractor — each handler now
  declares its exact dependency surface; AppState unchanged; handlers
  become unit-testable without mocking all 20 deps

- refactor(feed): replace 5 flat FeedRepository methods with FeedQuery/FeedScope
  — single query() method; SQL shared logic lives once; adding feed types
  no longer requires 5 edits

- refactor(activitypub): ActivityPubRepository + OutboundFederationPort moved
  out of domain::ports into activitypub-base::ap_ports — domain crate no
  longer knows about AP IDs, inboxes, or actor URLs

- fix(outbox): OutboxRelay now opens a per-row transaction so FOR UPDATE
  SKIP LOCKED actually holds the lock during publish + mark_delivered

crates/adapters/activitypub-base/src/ap_ports.rs

@@ -0,0 +1,167 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::thought::Thought,
+    value_objects::{ThoughtId, UserId, Username},
+};
+
+/// AP-protocol endpoints for a locally-stored user (local or interned remote).
+#[derive(Debug, Clone)]
+pub struct ActorApUrls {
+    pub ap_id: String,
+    pub inbox_url: String,
+}
+
+/// A local thought ready for AP serialization, with the author's username
+/// pre-joined so the handler can build AP URLs without a second query.
+#[derive(Debug, Clone)]
+pub struct OutboxEntry {
+    pub thought: Thought,
+    pub author_username: Username,
+}
+
+#[async_trait]
+pub trait ActivityPubRepository: Send + Sync {
+    // ── Outbox (local → remote) ──────────────────────────────────────
+
+    /// All public local thoughts for this actor. Used for outbox totals
+    /// and full-collection delivery.
+    async fn outbox_entries_for_actor(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    /// Cursor page of public local thoughts, newest-first, before `before`.
+    /// Used for OrderedCollectionPage responses.
+    async fn outbox_page_for_actor(
+        &self,
+        user_id: &UserId,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        limit: usize,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    // ── Remote actor resolution ──────────────────────────────────────
+
+    /// Find the local UserId for a remote actor by its AP URL.
+    async fn find_remote_actor_id(&self, actor_ap_url: &str)
+        -> Result<Option<UserId>, DomainError>;
+
+    /// Ensure a remote actor placeholder exists; create one if absent.
+    /// Idempotent — safe to call multiple times with the same URL.
+    async fn intern_remote_actor(&self, actor_ap_url: &str) -> Result<UserId, DomainError>;
+
+    /// Update display_name and avatar_url for an already-interned remote actor.
+    async fn update_remote_actor_display(
+        &self,
+        user_id: &UserId,
+        display_name: Option<&str>,
+        avatar_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    // ── Inbox processing (remote → local) ───────────────────────────
+
+    /// Persist an incoming remote Note. Idempotent on ap_id.
+    #[allow(clippy::too_many_arguments)]
+    async fn accept_note(
+        &self,
+        ap_id: &str,
+        author_id: &UserId,
+        content: &str,
+        published: chrono::DateTime<chrono::Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+        visibility: &str,
+        in_reply_to: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    /// Apply an Update to a previously accepted remote Note.
+    async fn apply_note_update(&self, ap_id: &str, new_content: &str) -> Result<(), DomainError>;
+
+    /// Remove a specific remote Note (Delete activity). Only touches
+    /// remotely-originated thoughts.
+    async fn retract_note(&self, ap_id: &str) -> Result<(), DomainError>;
+
+    /// Remove all Notes from a remote actor (actor-level Delete/Tombstone).
+    async fn retract_actor_notes(&self, actor_ap_url: &str) -> Result<(), DomainError>;
+
+    // ── Node-level stats ─────────────────────────────────────────────
+
+    /// Total locally-authored thought count for NodeInfo responses.
+    async fn count_local_notes(&self) -> Result<u64, DomainError>;
+
+    /// Return the ActivityPub object URL for a thought, if one is stored.
+    /// Returns None for local thoughts (caller constructs URL from base_url + thought_id).
+    async fn get_thought_ap_id(
+        &self,
+        thought_id: &ThoughtId,
+    ) -> Result<Option<String>, DomainError>;
+
+    /// Return the AP actor URL and inbox URL for a user, if stored.
+    /// Returns None for users that have not been federated.
+    async fn get_actor_ap_urls(&self, user_id: &UserId)
+        -> Result<Option<ActorApUrls>, DomainError>;
+}
+
+#[async_trait]
+pub trait OutboundFederationPort: Send + Sync {
+    /// Fan out a new local Note to all accepted followers.
+    async fn broadcast_create(
+        &self,
+        author_user_id: &UserId,
+        thought: &Thought,
+        author_username: &str,
+        in_reply_to_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out a Delete tombstone for a now-deleted local Note.
+    /// `thought_ap_id` is pre-constructed by the caller because the thought
+    /// has already been deleted from the DB when this fires.
+    async fn broadcast_delete(
+        &self,
+        author_user_id: &UserId,
+        thought_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Update(Note) for an edited local thought.
+    async fn broadcast_update(
+        &self,
+        author_user_id: &UserId,
+        thought: &Thought,
+        author_username: &str,
+        in_reply_to_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Announce(object_ap_id) for a boost.
+    async fn broadcast_announce(
+        &self,
+        booster_user_id: &UserId,
+        object_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Undo(Announce) to followers when a boost is removed.
+    async fn broadcast_undo_announce(
+        &self,
+        booster_user_id: &UserId,
+        object_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Send a Like activity to a remote thought author's inbox.
+    /// Only called when a LOCAL user likes a REMOTE thought (one with an ap_id).
+    async fn broadcast_like(
+        &self,
+        liker_user_id: &UserId,
+        object_ap_id: &str,
+        author_inbox_url: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Send Undo(Like) to a remote thought author's inbox.
+    async fn broadcast_undo_like(
+        &self,
+        liker_user_id: &UserId,
+        object_ap_id: &str,
+        author_inbox_url: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Update(Actor) to all accepted followers after a profile change.
+    async fn broadcast_actor_update(&self, user_id: &UserId) -> Result<(), DomainError>;
+}

crates/adapters/activitypub-base/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod activities;
 pub mod actor_handler;
 pub mod actors;
+pub mod ap_ports;
 pub mod content;
 pub mod data;
 pub mod error;
@@ -17,6 +18,7 @@ pub mod user;
 pub mod webfinger;
 
 pub use activitypub_federation::kinds::object::NoteType;
+pub use ap_ports::{ActorApUrls, ActivityPubRepository, OutboxEntry, OutboundFederationPort};
 pub use content::ApObjectHandler;
 pub use data::FederationData;
 pub use error::Error;

crates/adapters/activitypub-base/src/service.rs

@@ -50,26 +50,6 @@ fn content_to_html(text: &str) -> String {
     }
 }
 
-fn extract_hashtag_tags(content: &str, base_url: &str) -> Vec<serde_json::Value> {
-    let mut seen = std::collections::HashSet::new();
-    let mut tags = Vec::new();
-    for word in content.split_whitespace() {
-        let tag = word.trim_matches(|c: char| !c.is_alphanumeric() && c != '#');
-        if let Some(name) = tag.strip_prefix('#')
-            && !name.is_empty()
-            && seen.insert(name.to_lowercase())
-        {
-            let lower = name.to_lowercase();
-            tags.push(serde_json::json!({
-                "type": "Hashtag",
-                "name": format!("#{}", lower),
-                "href": format!("{}/tags/{}", base_url, lower),
-            }));
-        }
-    }
-    tags
-}
-
 fn thought_note_json(
     thought: &domain::models::thought::Thought,
     local_actor: &crate::actors::DbActor,
@@ -114,9 +94,19 @@ fn thought_note_json(
     if let Some(updated_at) = thought.updated_at {
         note["updated"] = serde_json::json!(updated_at.to_rfc3339());
     }
-    let hashtag_tags = extract_hashtag_tags(thought.content.as_str(), base_url);
-    if !hashtag_tags.is_empty() {
-        note["tag"] = serde_json::json!(hashtag_tags);
+    let hashtags = domain::hashtag::extract(thought.content.as_str());
+    if !hashtags.is_empty() {
+        let ap_tags: Vec<serde_json::Value> = hashtags
+            .iter()
+            .map(|h| {
+                serde_json::json!({
+                    "type": "Hashtag",
+                    "name": h.ap_name,
+                    "href": format!("{}/{}", base_url, h.url_slug),
+                })
+            })
+            .collect();
+        note["tag"] = serde_json::json!(ap_tags);
     }
     Ok((ap_id, note))
 }
@@ -1405,7 +1395,7 @@ impl ActivityPubService {
 }
 
 #[async_trait::async_trait]
-impl domain::ports::OutboundFederationPort for ActivityPubService {
+impl crate::ap_ports::OutboundFederationPort for ActivityPubService {
     // Actor identity (ap_id, followers_url) comes from federation config via get_local_actor.
     // author_username is provided by the caller but not needed here.
     async fn broadcast_create(

crates/adapters/activitypub/src/handler.rs

@@ -9,8 +9,8 @@ use url::Url;
 
 use crate::note::ThoughtNote;
 use crate::urls::ThoughtsUrls;
-use activitypub_base::ApObjectHandler;
-use domain::ports::{ActivityPubRepository, EventPublisher};
+use activitypub_base::{ActivityPubRepository, ApObjectHandler};
+use domain::ports::EventPublisher;
 use domain::value_objects::UserId;
 
 pub struct ThoughtsObjectHandler {

crates/adapters/postgres/Cargo.toml

@@ -4,9 +4,10 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-domain        = { workspace = true }
-event-payload = { workspace = true }
-sqlx          = { workspace = true }
+domain           = { workspace = true }
+activitypub-base = { workspace = true }
+event-payload    = { workspace = true }
+sqlx             = { workspace = true }
 uuid        = { workspace = true }
 serde_json  = { workspace = true }
 chrono      = { workspace = true }

crates/adapters/postgres/src/activitypub.rs

@@ -6,10 +6,10 @@ const THOUGHTS_PATH_PREFIX: &str = "/thoughts/";
 use chrono::{DateTime, Utc};
 use sqlx::PgPool;
 
+use activitypub_base::{ActivityPubRepository, ActorApUrls, OutboxEntry};
 use domain::{
     errors::DomainError,
     models::thought::{Thought, Visibility},
-    ports::{ActivityPubRepository, ActorApUrls, OutboxEntry},
     value_objects::{Content, ThoughtId, UserId, Username},
 };
 
@@ -328,7 +328,7 @@ impl ActivityPubRepository for PgActivityPubRepository {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use domain::ports::ActivityPubRepository;
+    use activitypub_base::ActivityPubRepository;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {

crates/adapters/postgres/src/feed.rs

@@ -5,11 +5,11 @@ use chrono::{DateTime, Utc};
 use domain::{
     errors::DomainError,
     models::{
-        feed::{FeedEntry, PageParams, Paginated},
+        feed::{FeedEntry, Paginated},
         thought::{Thought, Visibility},
         user::User,
     },
-    ports::FeedRepository,
+    ports::{FeedQuery, FeedRepository, FeedScope},
     value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
 };
 use sqlx::PgPool;
@@ -150,201 +150,178 @@ fn row_to_entry(r: FeedRow, viewer: Option<uuid::Uuid>) -> Result<FeedEntry, Dom
 
 #[async_trait]
 impl FeedRepository for PgFeedRepository {
-    async fn home_feed(
-        &self,
-        following_ids: &[UserId],
-        page: &PageParams,
-        viewer_id: Option<&UserId>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        let ids: Vec<uuid::Uuid> = following_ids.iter().map(|id| id.as_uuid()).collect();
-        let viewer = viewer_id.map(|v| v.as_uuid());
-        let fed_clause = federation_following_clause(viewer);
-        let count_sql = format!(
-            "SELECT COUNT(*) FROM thoughts t WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'",
-            fed_clause
-        );
-        let total: i64 = sqlx::query_scalar(&count_sql)
-            .bind(&ids)
-            .fetch_one(&self.pool)
-            .await
-            .into_domain()?;
+    async fn query(&self, q: &FeedQuery) -> Result<Paginated<FeedEntry>, DomainError> {
+        let viewer = q.viewer_id.as_ref().map(|v| v.as_uuid());
+        let page = &q.page;
 
-        let sel = feed_select(viewer);
-        let sql = format!("{sel} WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3", fed_clause);
-        let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(&ids)
-            .bind(page.limit())
-            .bind(page.offset())
-            .fetch_all(&self.pool)
-            .await
-            .into_domain()?;
+        match &q.scope {
+            FeedScope::Home { following_ids } => {
+                let ids: Vec<uuid::Uuid> = following_ids.iter().map(|id| id.as_uuid()).collect();
+                let fed_clause = federation_following_clause(viewer);
+                let count_sql = format!(
+                    "SELECT COUNT(*) FROM thoughts t WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'",
+                    fed_clause
+                );
+                let total: i64 = sqlx::query_scalar(&count_sql)
+                    .bind(&ids)
+                    .fetch_one(&self.pool)
+                    .await
+                    .into_domain()?;
 
-        Ok(Paginated {
-            items: rows
-                .into_iter()
-                .map(|r| row_to_entry(r, viewer))
-                .collect::<Result<Vec<_>, _>>()?,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
-    }
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3", fed_clause);
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
+                    .bind(&ids)
+                    .bind(page.limit())
+                    .bind(page.offset())
+                    .fetch_all(&self.pool)
+                    .await
+                    .into_domain()?;
 
-    async fn public_feed(
-        &self,
-        page: &PageParams,
-        viewer_id: Option<&UserId>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        let viewer = viewer_id.map(|v| v.as_uuid());
-        let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'",
-        )
-        .fetch_one(&self.pool)
-        .await
-        .into_domain()?;
+                Ok(Paginated {
+                    items: rows
+                        .into_iter()
+                        .map(|r| row_to_entry(r, viewer))
+                        .collect::<Result<Vec<_>, _>>()?,
+                    total,
+                    page: page.page,
+                    per_page: page.per_page,
+                })
+            }
 
-        let sel = feed_select(viewer);
-        let sql = format!("{sel} WHERE t.local=true AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $1 OFFSET $2");
-        let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(page.limit())
-            .bind(page.offset())
-            .fetch_all(&self.pool)
-            .await
-            .into_domain()?;
+            FeedScope::Public => {
+                let total: i64 = sqlx::query_scalar(
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'",
+                )
+                .fetch_one(&self.pool)
+                .await
+                .into_domain()?;
 
-        Ok(Paginated {
-            items: rows
-                .into_iter()
-                .map(|r| row_to_entry(r, viewer))
-                .collect::<Result<Vec<_>, _>>()?,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
-    }
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.local=true AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $1 OFFSET $2");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
+                    .bind(page.limit())
+                    .bind(page.offset())
+                    .fetch_all(&self.pool)
+                    .await
+                    .into_domain()?;
 
-    async fn search(
-        &self,
-        query: &str,
-        page: &PageParams,
-        viewer_id: Option<&UserId>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        let viewer = viewer_id.map(|v| v.as_uuid());
-        let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'",
-        )
-        .bind(query)
-        .fetch_one(&self.pool)
-        .await
-        .into_domain()?;
+                Ok(Paginated {
+                    items: rows
+                        .into_iter()
+                        .map(|r| row_to_entry(r, viewer))
+                        .collect::<Result<Vec<_>, _>>()?,
+                    total,
+                    page: page.page,
+                    per_page: page.per_page,
+                })
+            }
 
-        let sel = feed_select(viewer);
-        let sql = format!("{sel} WHERE t.content % $1 AND t.visibility='public' ORDER BY similarity(t.content, $1) DESC LIMIT $2 OFFSET $3");
-        let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(query)
-            .bind(page.limit())
-            .bind(page.offset())
-            .fetch_all(&self.pool)
-            .await
-            .into_domain()?;
+            FeedScope::Search { query } => {
+                let total: i64 = sqlx::query_scalar(
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'",
+                )
+                .bind(query)
+                .fetch_one(&self.pool)
+                .await
+                .into_domain()?;
 
-        Ok(Paginated {
-            items: rows
-                .into_iter()
-                .map(|r| row_to_entry(r, viewer))
-                .collect::<Result<Vec<_>, _>>()?,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
-    }
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.content % $1 AND t.visibility='public' ORDER BY similarity(t.content, $1) DESC LIMIT $2 OFFSET $3");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
+                    .bind(query)
+                    .bind(page.limit())
+                    .bind(page.offset())
+                    .fetch_all(&self.pool)
+                    .await
+                    .into_domain()?;
 
-    async fn tag_feed(
-        &self,
-        tag_name: &str,
-        page: &PageParams,
-        viewer_id: Option<&UserId>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        let viewer = viewer_id.map(|v| v.as_uuid());
-        let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t
-             JOIN thought_tags tt ON tt.thought_id = t.id
-             JOIN tags tg ON tg.id = tt.tag_id
-             WHERE tg.name = $1 AND t.visibility = 'public'",
-        )
-        .bind(tag_name)
-        .fetch_one(&self.pool)
-        .await
-        .into_domain()?;
+                Ok(Paginated {
+                    items: rows
+                        .into_iter()
+                        .map(|r| row_to_entry(r, viewer))
+                        .collect::<Result<Vec<_>, _>>()?,
+                    total,
+                    page: page.page,
+                    per_page: page.per_page,
+                })
+            }
 
-        let sel = feed_select(viewer);
-        let sql = format!(
-            "{sel}
-             JOIN thought_tags tt ON tt.thought_id = t.id
-             JOIN tags tg ON tg.id = tt.tag_id
-             WHERE tg.name = $1 AND t.visibility = 'public'
-             ORDER BY t.created_at DESC LIMIT $2 OFFSET $3"
-        );
-        let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(tag_name)
-            .bind(page.limit())
-            .bind(page.offset())
-            .fetch_all(&self.pool)
-            .await
-            .into_domain()?;
+            FeedScope::Tag { tag_name } => {
+                let total: i64 = sqlx::query_scalar(
+                    "SELECT COUNT(*) FROM thoughts t
+                     JOIN thought_tags tt ON tt.thought_id = t.id
+                     JOIN tags tg ON tg.id = tt.tag_id
+                     WHERE tg.name = $1 AND t.visibility = 'public'",
+                )
+                .bind(tag_name)
+                .fetch_one(&self.pool)
+                .await
+                .into_domain()?;
 
-        Ok(Paginated {
-            items: rows
-                .into_iter()
-                .map(|r| row_to_entry(r, viewer))
-                .collect::<Result<Vec<_>, _>>()?,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
-    }
+                let sel = feed_select(viewer);
+                let sql = format!(
+                    "{sel}
+                     JOIN thought_tags tt ON tt.thought_id = t.id
+                     JOIN tags tg ON tg.id = tt.tag_id
+                     WHERE tg.name = $1 AND t.visibility = 'public'
+                     ORDER BY t.created_at DESC LIMIT $2 OFFSET $3"
+                );
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
+                    .bind(tag_name)
+                    .bind(page.limit())
+                    .bind(page.offset())
+                    .fetch_all(&self.pool)
+                    .await
+                    .into_domain()?;
 
-    async fn user_feed(
-        &self,
-        user_id: &UserId,
-        page: &PageParams,
-        viewer_id: Option<&UserId>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        let viewer = viewer_id.map(|v| v.as_uuid());
-        let uid = user_id.as_uuid();
+                Ok(Paginated {
+                    items: rows
+                        .into_iter()
+                        .map(|r| row_to_entry(r, viewer))
+                        .collect::<Result<Vec<_>, _>>()?,
+                    total,
+                    page: page.page,
+                    per_page: page.per_page,
+                })
+            }
 
-        // Use nil UUID for unauthenticated viewers — won't match owner or follower checks.
-        let viewer_uuid = viewer.unwrap_or(uuid::Uuid::nil());
+            FeedScope::User { user_id } => {
+                let uid = user_id.as_uuid();
+                // Use nil UUID for unauthenticated viewers — won't match owner or follower checks.
+                let viewer_uuid = viewer.unwrap_or(uuid::Uuid::nil());
 
-        let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND ($2::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $2 AND following_id = $1 AND state = 'accepted')))))",
-        )
-        .bind(uid)
-        .bind(viewer_uuid)
-        .fetch_one(&self.pool)
-        .await
-        .into_domain()?;
+                let total: i64 = sqlx::query_scalar(
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND ($2::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $2 AND following_id = $1 AND state = 'accepted')))))",
+                )
+                .bind(uid)
+                .bind(viewer_uuid)
+                .fetch_one(&self.pool)
+                .await
+                .into_domain()?;
 
-        let sel = feed_select(viewer);
-        let sql = format!("{sel} WHERE t.user_id = $1 AND ($4::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $4 AND following_id = $1 AND state = 'accepted'))))) ORDER BY t.created_at DESC LIMIT $2 OFFSET $3");
-        let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(uid)
-            .bind(page.limit())
-            .bind(page.offset())
-            .bind(viewer_uuid)
-            .fetch_all(&self.pool)
-            .await
-            .into_domain()?;
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.user_id = $1 AND ($4::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $4 AND following_id = $1 AND state = 'accepted'))))) ORDER BY t.created_at DESC LIMIT $2 OFFSET $3");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
+                    .bind(uid)
+                    .bind(page.limit())
+                    .bind(page.offset())
+                    .bind(viewer_uuid)
+                    .fetch_all(&self.pool)
+                    .await
+                    .into_domain()?;
 
-        Ok(Paginated {
-            items: rows
-                .into_iter()
-                .map(|r| row_to_entry(r, viewer))
-                .collect::<Result<Vec<_>, _>>()?,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
+                Ok(Paginated {
+                    items: rows
+                        .into_iter()
+                        .map(|r| row_to_entry(r, viewer))
+                        .collect::<Result<Vec<_>, _>>()?,
+                    total,
+                    page: page.page,
+                    per_page: page.per_page,
+                })
+            }
+        }
     }
 }
 
@@ -354,10 +331,11 @@ mod tests {
     use crate::{thought::PgThoughtRepository, user::PgUserRepository};
     use domain::{
         models::{
+            feed::PageParams,
             thought::{Thought, Visibility},
             user::User,
         },
-        ports::{ThoughtRepository, UserWriter},
+        ports::{FeedQuery, ThoughtRepository, UserWriter},
         value_objects::*,
     };
 
@@ -389,13 +367,10 @@ mod tests {
         let (_, _) = seed(&pool, "alice", "hello").await;
         let repo = PgFeedRepository::new(pool);
         let result = repo
-            .public_feed(
-                &PageParams {
-                    page: 1,
-                    per_page: 20,
-                },
+            .query(&FeedQuery::public(
+                PageParams { page: 1, per_page: 20 },
                 None,
-            )
+            ))
             .await
             .unwrap();
         assert_eq!(result.total, 1);
@@ -408,14 +383,11 @@ mod tests {
         let (_, _) = seed(&pool, "bob", "goodbye world").await;
         let repo = PgFeedRepository::new(pool);
         let result = repo
-            .search(
+            .query(&FeedQuery::search(
                 "hello world",
-                &PageParams {
-                    page: 1,
-                    per_page: 20,
-                },
+                PageParams { page: 1, per_page: 20 },
                 None,
-            )
+            ))
             .await
             .unwrap();
         assert!(result.total >= 1);