docs: ActivityPubRepository port implementation plan

docs/superpowers/plans/2026-05-14-activitypub-repository-port.md

@@ -0,0 +1,639 @@
+# ActivityPubRepository Port Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Eliminate the `activitypub` → `postgres` dependency violation by extracting an `ActivityPubRepository` port into domain and implementing it in the postgres adapter.
+
+**Architecture:** `ActivityPubRepository` (9 methods, federation vocabulary) is added to `domain/src/ports.rs`. `PgActivityPubRepository` in `postgres/src/activitypub.rs` implements it with all the SQL that currently lives in `activitypub/src/handler.rs`. `ThoughtsObjectHandler` drops its `PgPool` and receives `Arc<dyn ActivityPubRepository>` instead. The dependency chain becomes `activitypub → domain` only; `postgres` drops off the `activitypub` Cargo.toml entirely.
+
+**Tech Stack:** Rust, sqlx 0.8, async-trait, existing domain value objects
+
+---
+
+## File Map
+
+```
+Modify: crates/domain/src/ports.rs             ← add OutboxEntry struct + ActivityPubRepository trait
+Modify: crates/domain/src/testing.rs           ← add TestStore impl ActivityPubRepository
+Create: crates/adapters/postgres/src/activitypub.rs  ← PgActivityPubRepository (all 9 methods)
+Modify: crates/adapters/postgres/src/lib.rs    ← pub mod activitypub
+Modify: crates/adapters/activitypub/src/handler.rs   ← replace PgPool with Arc<dyn ActivityPubRepository>
+Modify: crates/adapters/activitypub/Cargo.toml ← remove postgres + sqlx deps
+Modify: crates/presentation/src/lib.rs         ← wire PgActivityPubRepository into ThoughtsObjectHandler
+```
+
+---
+
+### Task 1: Domain — OutboxEntry + ActivityPubRepository trait
+
+**Files:**
+- Modify: `crates/domain/src/ports.rs`
+- Modify: `crates/domain/src/testing.rs`
+
+- [ ] **Write the failing test** — add to bottom of `crates/domain/src/testing.rs` inside the existing `#[cfg(any(test, feature = "test-helpers"))]` scope:
+
+```rust
+#[cfg(test)]
+mod ap_repo_tests {
+    use super::*;
+    use crate::models::thought::{Thought, Visibility};
+    use crate::value_objects::*;
+
+    #[tokio::test]
+    async fn test_store_outbox_returns_empty() {
+        let store = TestStore::default();
+        let result = store.outbox_entries_for_actor(&UserId::new()).await.unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_store_intern_creates_placeholder() {
+        let store = TestStore::default();
+        let url = url::Url::parse("https://example.com/users/alice").unwrap();
+        let id1 = store.intern_remote_actor(&url).await.unwrap();
+        let id2 = store.intern_remote_actor(&url).await.unwrap();
+        assert_eq!(id1, id2, "intern must be idempotent");
+    }
+}
+```
+
+- [ ] **Run:** `cargo test -p domain` — Expected: FAIL (ActivityPubRepository not defined).
+
+- [ ] **Add `OutboxEntry` and `ActivityPubRepository` to `crates/domain/src/ports.rs`** — append after the `SearchPort` trait:
+
+```rust
+/// 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: crate::models::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, stopping 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: &url::Url,
+    ) -> 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: &url::Url,
+    ) -> Result<UserId, DomainError>;
+
+    // ── Inbox processing (remote → local) ───────────────────────────
+
+    /// Persist an incoming remote Note. Idempotent on ap_id.
+    async fn accept_note(
+        &self,
+        ap_id: &url::Url,
+        author_id: &UserId,
+        content: &str,
+        published: chrono::DateTime<chrono::Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+    ) -> Result<(), DomainError>;
+
+    /// Apply an Update to a previously accepted remote Note.
+    async fn apply_note_update(
+        &self,
+        ap_id: &url::Url,
+        new_content: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Remove a specific remote Note (Delete activity). Only touches
+    /// remotely-originated thoughts.
+    async fn retract_note(&self, ap_id: &url::Url) -> Result<(), DomainError>;
+
+    /// Remove all Notes from a remote actor (actor-level Delete/Tombstone).
+    async fn retract_actor_notes(
+        &self,
+        actor_ap_url: &url::Url,
+    ) -> Result<(), DomainError>;
+
+    // ── Node-level stats ─────────────────────────────────────────────
+
+    /// Total locally-authored thought count for NodeInfo responses.
+    async fn count_local_notes(&self) -> Result<u64, DomainError>;
+}
+```
+
+The imports already present in `ports.rs` cover `DomainError`, `UserId`, `Username`, `async_trait`. The `url::Url` and `chrono::DateTime` types need to be in scope — add these use statements at the top of `ports.rs` if not already present:
+
+```rust
+use chrono::{DateTime, Utc};
+use url::Url;
+```
+
+Note: `url` and `chrono` are already in `domain/Cargo.toml`. No dep changes needed.
+
+- [ ] **Add `TestStore impl ActivityPubRepository`** in `crates/domain/src/testing.rs` — append after `impl SearchPort for TestStore`:
+
+```rust
+#[async_trait] impl ActivityPubRepository for TestStore {
+    async fn outbox_entries_for_actor(&self, _uid: &UserId) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+        Ok(vec![])
+    }
+    async fn outbox_page_for_actor(&self, _uid: &UserId, _before: Option<chrono::DateTime<chrono::Utc>>, _limit: usize) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+        Ok(vec![])
+    }
+    async fn find_remote_actor_id(&self, actor_ap_url: &url::Url) -> Result<Option<UserId>, DomainError> {
+        let url = actor_ap_url.to_string();
+        Ok(self.users.lock().unwrap().iter().find(|u| u.ap_id.as_deref() == Some(&url)).map(|u| u.id.clone()))
+    }
+    async fn intern_remote_actor(&self, actor_ap_url: &url::Url) -> Result<UserId, DomainError> {
+        if let Some(uid) = self.find_remote_actor_id(actor_ap_url).await? {
+            return Ok(uid);
+        }
+        let uid = UserId::new();
+        let handle = actor_ap_url.path().trim_start_matches('/').replace('/', "_");
+        let user = crate::models::user::User {
+            id: uid.clone(),
+            username: Username::from_trusted(handle.clone()),
+            email: Email::from_trusted(format!("{}@remote", uid)),
+            password_hash: PasswordHash("".into()),
+            display_name: None, bio: None, avatar_url: None, header_url: None,
+            custom_css: None, local: false,
+            ap_id: Some(actor_ap_url.to_string()),
+            inbox_url: None, public_key: None, private_key: None,
+            created_at: chrono::Utc::now(), updated_at: chrono::Utc::now(),
+        };
+        self.users.lock().unwrap().push(user);
+        Ok(uid)
+    }
+    async fn accept_note(&self, _ap_id: &url::Url, _author_id: &UserId, _content: &str, _published: chrono::DateTime<chrono::Utc>, _sensitive: bool, _content_warning: Option<String>) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn apply_note_update(&self, _ap_id: &url::Url, _new_content: &str) -> Result<(), DomainError> { Ok(()) }
+    async fn retract_note(&self, _ap_id: &url::Url) -> Result<(), DomainError> { Ok(()) }
+    async fn retract_actor_notes(&self, _actor_ap_url: &url::Url) -> Result<(), DomainError> { Ok(()) }
+    async fn count_local_notes(&self) -> Result<u64, DomainError> {
+        Ok(self.thoughts.lock().unwrap().iter().filter(|t| t.local).count() as u64)
+    }
+}
+```
+
+- [ ] **Run:** `cargo test -p domain` — Expected: all tests pass including 2 new ap_repo tests.
+
+- [ ] **Commit:**
+```bash
+git add crates/domain/
+git commit -m "feat(domain): ActivityPubRepository port with federation vocabulary"
+```
+
+---
+
+### Task 2: Postgres — PgActivityPubRepository
+
+**Files:**
+- Create: `crates/adapters/postgres/src/activitypub.rs`
+- Modify: `crates/adapters/postgres/src/lib.rs`
+
+- [ ] **Write integration tests** at the bottom of the new `crates/adapters/postgres/src/activitypub.rs` (create the file with tests first):
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::ports::ActivityPubRepository;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let url = url::Url::parse("https://mastodon.social/users/alice").unwrap();
+        let id1 = repo.intern_remote_actor(&url).await.unwrap();
+        let id2 = repo.intern_remote_actor(&url).await.unwrap();
+        assert_eq!(id1, id2);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_and_retract_note(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let actor_url = url::Url::parse("https://remote.example/users/bob").unwrap();
+        let ap_id = url::Url::parse("https://remote.example/notes/1").unwrap();
+        let author = repo.intern_remote_actor(&actor_url).await.unwrap();
+        repo.accept_note(&ap_id, &author, "hello from remote", chrono::Utc::now(), false, None)
+            .await.unwrap();
+        repo.retract_note(&ap_id).await.unwrap();
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn count_local_notes_excludes_remote(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        assert_eq!(repo.count_local_notes().await.unwrap(), 0);
+    }
+}
+```
+
+- [ ] **Run:** `cargo test -p postgres activitypub` — Expected: FAIL (module does not exist).
+
+- [ ] **Write `crates/adapters/postgres/src/activitypub.rs`:**
+
+```rust
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use url::Url;
+
+use domain::{errors::DomainError, ports::{ActivityPubRepository, OutboxEntry}, value_objects::{Content, ThoughtId, UserId, Username}};
+use domain::models::thought::{Thought, Visibility};
+
+pub struct PgActivityPubRepository { pool: PgPool }
+impl PgActivityPubRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl ActivityPubRepository for PgActivityPubRepository {
+    async fn outbox_entries_for_actor(&self, user_id: &UserId) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, content: String, created_at: DateTime<Utc>, in_reply_to_id: Option<uuid::Uuid>, content_warning: Option<String>, sensitive: bool, username: String, updated_at: Option<DateTime<Utc>> }
+        sqlx::query_as::<_, Row>(
+            "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+             FROM thoughts t JOIN users u ON u.id=t.user_id
+             WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+             ORDER BY t.created_at DESC"
+        )
+        .bind(user_id.as_uuid())
+        .fetch_all(&self.pool).await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|rows| rows.into_iter().map(|r| OutboxEntry {
+            thought: Thought {
+                id: ThoughtId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id),
+                content: Content::new_remote(r.content), in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                in_reply_to_url: None, ap_id: None, visibility: Visibility::Public,
+                content_warning: r.content_warning, sensitive: r.sensitive, local: true,
+                created_at: r.created_at, updated_at: r.updated_at,
+            },
+            author_username: Username::from_trusted(r.username),
+        }).collect())
+    }
+
+    async fn outbox_page_for_actor(&self, user_id: &UserId, before: Option<DateTime<Utc>>, limit: usize) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, content: String, created_at: DateTime<Utc>, in_reply_to_id: Option<uuid::Uuid>, content_warning: Option<String>, sensitive: bool, username: String, updated_at: Option<DateTime<Utc>> }
+        let rows = if let Some(before) = before {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public' AND t.created_at < $2
+                 ORDER BY t.created_at DESC LIMIT $3"
+            ).bind(user_id.as_uuid()).bind(before).bind(limit as i64).fetch_all(&self.pool).await
+        } else {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+                 ORDER BY t.created_at DESC LIMIT $2"
+            ).bind(user_id.as_uuid()).bind(limit as i64).fetch_all(&self.pool).await
+        }.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(rows.into_iter().map(|r| OutboxEntry {
+            thought: Thought {
+                id: ThoughtId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id),
+                content: Content::new_remote(r.content), in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                in_reply_to_url: None, ap_id: None, visibility: Visibility::Public,
+                content_warning: r.content_warning, sensitive: r.sensitive, local: true,
+                created_at: r.created_at, updated_at: r.updated_at,
+            },
+            author_username: Username::from_trusted(r.username),
+        }).collect())
+    }
+
+    async fn find_remote_actor_id(&self, actor_ap_url: &Url) -> Result<Option<UserId>, DomainError> {
+        sqlx::query_scalar::<_, uuid::Uuid>("SELECT id FROM users WHERE ap_id=$1")
+            .bind(actor_ap_url.as_str())
+            .fetch_optional(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(UserId::from_uuid))
+    }
+
+    async fn intern_remote_actor(&self, actor_ap_url: &Url) -> Result<UserId, DomainError> {
+        // Fast path
+        if let Some(id) = self.find_remote_actor_id(actor_ap_url).await? {
+            return Ok(id);
+        }
+        let new_id = uuid::Uuid::new_v4();
+        let handle = actor_ap_url.path().trim_start_matches('/').replace('/', "_");
+        sqlx::query(
+            "INSERT INTO users(id,username,email,password_hash,local,ap_id,created_at,updated_at)
+             VALUES($1,$2,$3,'',false,$4,NOW(),NOW()) ON CONFLICT(ap_id) DO NOTHING"
+        )
+        .bind(new_id).bind(&handle).bind(format!("{}@remote", new_id)).bind(actor_ap_url.as_str())
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        // Re-fetch to get whichever id won the race
+        self.find_remote_actor_id(actor_ap_url).await?
+            .ok_or_else(|| DomainError::Internal("intern_remote_actor: insert succeeded but row not found".into()))
+    }
+
+    async fn accept_note(&self, ap_id: &Url, author_id: &UserId, content: &str, published: DateTime<Utc>, sensitive: bool, content_warning: Option<String>) -> Result<(), DomainError> {
+        let capped: String = content.chars().take(500).collect();
+        sqlx::query(
+            "INSERT INTO thoughts(id,user_id,content,ap_id,visibility,sensitive,local,content_warning,created_at)
+             VALUES($1,$2,$3,$4,'public',$5,false,$6,$7) ON CONFLICT(ap_id) DO NOTHING"
+        )
+        .bind(uuid::Uuid::new_v4()).bind(author_id.as_uuid()).bind(&capped)
+        .bind(ap_id.as_str()).bind(sensitive).bind(content_warning).bind(published)
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn apply_note_update(&self, ap_id: &Url, new_content: &str) -> Result<(), DomainError> {
+        let capped: String = new_content.chars().take(500).collect();
+        sqlx::query("UPDATE thoughts SET content=$2,updated_at=NOW() WHERE ap_id=$1 AND local=false")
+            .bind(ap_id.as_str()).bind(&capped)
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn retract_note(&self, ap_id: &Url) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM thoughts WHERE ap_id=$1 AND local=false")
+            .bind(ap_id.as_str())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn retract_actor_notes(&self, actor_ap_url: &Url) -> Result<(), DomainError> {
+        sqlx::query(
+            "DELETE FROM thoughts WHERE local=false AND user_id=(SELECT id FROM users WHERE ap_id=$1)"
+        )
+        .bind(actor_ap_url.as_str())
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn count_local_notes(&self) -> Result<u64, DomainError> {
+        let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM thoughts WHERE local=true")
+            .fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(n as u64)
+    }
+}
+```
+
+- [ ] **Add `pub mod activitypub;`** to `crates/adapters/postgres/src/lib.rs` — append alongside the other module declarations.
+
+- [ ] **Run:** `DATABASE_URL=postgres://postgres:postgres@localhost:5434/postgres cargo test -p postgres activitypub`
+  Expected: 3 tests pass.
+
+- [ ] **Commit:**
+```bash
+git add crates/adapters/postgres/src/activitypub.rs crates/adapters/postgres/src/lib.rs
+git commit -m "feat(postgres): PgActivityPubRepository implementing ActivityPubRepository port"
+```
+
+---
+
+### Task 3: activitypub adapter — use the port, drop postgres dep
+
+**Files:**
+- Modify: `crates/adapters/activitypub/src/handler.rs`
+- Modify: `crates/adapters/activitypub/Cargo.toml`
+
+- [ ] **Rewrite `crates/adapters/activitypub/src/handler.rs`:**
+
+```rust
+use std::sync::Arc;
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use url::Url;
+
+use activitypub_base::ApObjectHandler;
+use domain::ports::ActivityPubRepository;
+use domain::value_objects::UserId;
+use crate::note::ThoughtNote;
+use crate::urls::ThoughtsUrls;
+
+pub struct ThoughtsObjectHandler {
+    repo: Arc<dyn ActivityPubRepository>,
+    urls: ThoughtsUrls,
+}
+
+impl ThoughtsObjectHandler {
+    pub fn new(repo: Arc<dyn ActivityPubRepository>, base_url: &str) -> Self {
+        Self { repo, urls: ThoughtsUrls::new(base_url) }
+    }
+}
+
+#[async_trait]
+impl ApObjectHandler for ThoughtsObjectHandler {
+    async fn get_local_objects_for_user(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Vec<(Url, serde_json::Value)>> {
+        let uid = UserId::from_uuid(user_id);
+        let entries = self.repo.outbox_entries_for_actor(&uid).await
+            .map_err(|e| anyhow!("{e}"))?;
+        entries.into_iter().map(|e| {
+            let note_url    = self.urls.thought_url(e.thought.id.as_uuid());
+            let actor_url   = self.urls.user_url(e.author_username.as_str());
+            let followers   = self.urls.user_followers(e.author_username.as_str());
+            let in_reply_to = e.thought.in_reply_to_id.map(|id| self.urls.thought_url(id.as_uuid()));
+            let note = ThoughtNote::new_public(
+                note_url.clone(), actor_url,
+                e.thought.content.as_str().to_owned(),
+                e.thought.created_at, in_reply_to,
+                e.thought.sensitive, e.thought.content_warning, followers,
+            );
+            Ok((note_url, serde_json::to_value(&note)?))
+        }).collect()
+    }
+
+    async fn get_local_objects_page(
+        &self,
+        user_id: uuid::Uuid,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> Result<Vec<(Url, serde_json::Value, DateTime<Utc>)>> {
+        let uid = UserId::from_uuid(user_id);
+        let entries = self.repo.outbox_page_for_actor(&uid, before, limit).await
+            .map_err(|e| anyhow!("{e}"))?;
+        entries.into_iter().map(|e| {
+            let created_at  = e.thought.created_at;
+            let note_url    = self.urls.thought_url(e.thought.id.as_uuid());
+            let actor_url   = self.urls.user_url(e.author_username.as_str());
+            let followers   = self.urls.user_followers(e.author_username.as_str());
+            let in_reply_to = e.thought.in_reply_to_id.map(|id| self.urls.thought_url(id.as_uuid()));
+            let note = ThoughtNote::new_public(
+                note_url.clone(), actor_url,
+                e.thought.content.as_str().to_owned(),
+                created_at, in_reply_to,
+                e.thought.sensitive, e.thought.content_warning, followers,
+            );
+            Ok((note_url, serde_json::to_value(&note)?, created_at))
+        }).collect()
+    }
+
+    async fn on_create(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> Result<()> {
+        let note: ThoughtNote = serde_json::from_value(object)?;
+        let author_id = self.repo.intern_remote_actor(actor_url).await
+            .map_err(|e| anyhow!("{e}"))?;
+        self.repo.accept_note(
+            ap_id, &author_id,
+            &note.content,
+            note.published,
+            note.sensitive,
+            note.summary,
+        ).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_update(
+        &self,
+        ap_id: &Url,
+        _actor_url: &Url,
+        object: serde_json::Value,
+    ) -> Result<()> {
+        let note: ThoughtNote = serde_json::from_value(object)?;
+        self.repo.apply_note_update(ap_id, &note.content).await
+            .map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_delete(&self, ap_id: &Url, _actor_url: &Url) -> Result<()> {
+        self.repo.retract_note(ap_id).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_actor_removed(&self, actor_url: &Url) -> Result<()> {
+        self.repo.retract_actor_notes(actor_url).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn count_local_posts(&self) -> Result<u64> {
+        self.repo.count_local_notes().await.map_err(|e| anyhow!("{e}"))
+    }
+}
+```
+
+- [ ] **Rewrite `crates/adapters/activitypub/Cargo.toml`** — remove `postgres` and `sqlx`:
+
+```toml
+[package]
+name = "activitypub"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+activitypub-base       = { workspace = true }
+activitypub_federation = "0.7.0-beta.11"
+domain                 = { workspace = true }
+url                    = { workspace = true }
+serde                  = { workspace = true }
+serde_json             = { workspace = true }
+anyhow                 = { workspace = true }
+chrono                 = { workspace = true }
+uuid                   = { workspace = true }
+async-trait            = { workspace = true }
+tracing                = { workspace = true }
+```
+
+- [ ] **Run:** `cargo check -p activitypub`
+  Expected: no errors. If there are unused import warnings for `sqlx` or `PgPool` — those are now gone, so the check should be clean.
+
+- [ ] **Run full test suite:** `DATABASE_URL=postgres://postgres:postgres@localhost:5434/postgres cargo test --workspace`
+  Expected: all 67 tests pass (handler.rs has no unit tests of its own, but the workspace test suite must stay green).
+
+- [ ] **Commit:**
+```bash
+git add crates/adapters/activitypub/
+git commit -m "refactor(activitypub): ThoughtsObjectHandler uses ActivityPubRepository port, drops postgres dep"
+```
+
+---
+
+### Task 4: Presentation — wire PgActivityPubRepository
+
+**Files:**
+- Modify: `crates/presentation/src/lib.rs`
+
+The current `build_state` in `src/lib.rs` calls `ThoughtsObjectHandler::new(pool.clone(), &base_url)`. After Task 3, the signature changed to `ThoughtsObjectHandler::new(repo: Arc<dyn ActivityPubRepository>, base_url: &str)`.
+
+- [ ] **Update the import and wiring in `crates/presentation/src/lib.rs`:**
+
+Find the existing import line:
+```rust
+use activitypub::ThoughtsObjectHandler;
+```
+
+Add alongside it:
+```rust
+use postgres::activitypub::PgActivityPubRepository;
+```
+
+Find the existing call:
+```rust
+std::sync::Arc::new(ThoughtsObjectHandler::new(pool.clone(), &base_url)),
+```
+
+Replace with:
+```rust
+std::sync::Arc::new(ThoughtsObjectHandler::new(
+    std::sync::Arc::new(PgActivityPubRepository::new(pool.clone())),
+    &base_url,
+)),
+```
+
+- [ ] **Run:** `cargo build -p presentation`
+  Expected: clean build, no errors.
+
+- [ ] **Run full test suite:**
+```bash
+DATABASE_URL=postgres://postgres:postgres@localhost:5434/postgres cargo test --workspace 2>&1 | tail -3
+```
+  Expected: all tests pass.
+
+- [ ] **Verify dependency is gone:**
+```bash
+cargo tree -p activitypub | grep postgres
+```
+  Expected: no output — `activitypub` no longer depends on `postgres`.
+
+- [ ] **Commit:**
+```bash
+git add crates/presentation/src/lib.rs
+git commit -m "fix: wire PgActivityPubRepository into ThoughtsObjectHandler — closes activitypub→postgres violation"
+```
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- ✅ `OutboxEntry` struct with `thought: Thought` + `author_username: Username`
+- ✅ `ActivityPubRepository` trait in `domain/src/ports.rs` — 9 methods with federation vocabulary
+- ✅ `TestStore impl ActivityPubRepository` — idempotent `intern_remote_actor`, empty stubs for others
+- ✅ 2 domain unit tests covering idempotency and empty outbox
+- ✅ `PgActivityPubRepository` in `postgres/src/activitypub.rs` — all 9 methods
+- ✅ 3 postgres integration tests
+- ✅ `ThoughtsObjectHandler` drops `PgPool`, receives `Arc<dyn ActivityPubRepository>`
+- ✅ `activitypub/Cargo.toml` removes `postgres` and `sqlx` deps
+- ✅ Presentation wires `PgActivityPubRepository` → `ThoughtsObjectHandler`
+- ✅ `cargo tree` verification confirms violation is resolved
+
+**Placeholder scan:** None.
+
+**Type consistency:**
+- `OutboxEntry` defined in `domain/src/ports.rs`, imported as `domain::ports::OutboxEntry` in postgres — consistent
+- `ThoughtsObjectHandler::new(repo: Arc<dyn ActivityPubRepository>, base_url: &str)` — matches presentation wiring
+- `PgActivityPubRepository::new(pool: PgPool)` — matches presentation wiring
+- All 9 method signatures identical between trait definition (Task 1) and impl (Task 2) and handler calls (Task 3)