# Federation Gaps — Round 2 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:** Fix seven federation gaps: HTML content format, hashtag federation, Undo(Like) inbound, Update(Actor) on profile change, @mention notifications, remote posts in home feed, and orphaned reply parent display. **Architecture:** Backend changes span the AP adapter layer (activities.rs, service.rs, handler.rs), application layer (use cases, event service), and postgres adapter (feed.rs). Frontend changes are limited to api.ts and thought-card.tsx. All changes follow the existing hexagonal pattern — no business logic in presentation, domain events for cross-cutting concerns. **Tech Stack:** Rust / axum / sqlx / activitypub_federation crate; Next.js 15 / TypeScript / Zod. --- ## Files Modified | Task | File | Change | |------|------|--------| | 1 | `crates/adapters/activitypub-base/src/service.rs` | Wrap content in `

` tags with HTML escaping | | 2 | `crates/adapters/activitypub/src/note.rs` | Add `tag` field to ThoughtNote | | 2 | `crates/adapters/activitypub-base/src/service.rs` | Extract hashtags and add to Note JSON | | 3 | `crates/adapters/activitypub-base/src/activities.rs` | Add "Like" arm to UndoActivity::receive | | 4 | `crates/domain/src/ports.rs` | Add `broadcast_actor_update` to OutboundFederationPort | | 4 | `crates/domain/src/events.rs` | Add `ProfileUpdated` variant | | 4 | `crates/domain/src/testing.rs` | Add SpyPort stub for broadcast_actor_update | | 4 | `crates/application/src/use_cases/profile.rs` | Publish ProfileUpdated from update_profile | | 4 | `crates/application/src/services/federation_event.rs` | Handle ProfileUpdated → broadcast_actor_update | | 4 | `crates/adapters/activitypub-base/src/service.rs` | Implement broadcast_actor_update port method | | 5 | `crates/adapters/activitypub/src/note.rs` | Add `tag` deserialization field | | 5 | `crates/adapters/activitypub-base/src/content.rs` | Add `on_mention` to ApObjectHandler | | 5 | `crates/adapters/activitypub/src/handler.rs` | Parse Mention tags, implement on_mention | | 5 | `crates/domain/src/events.rs` | Add `MentionReceived` variant | | 5 | `crates/domain/src/testing.rs` | No-op on_mention in TestStore impl | | 5 | `crates/application/src/services/notification_event.rs` | Handle MentionReceived | | 6 | `crates/adapters/postgres/src/feed.rs` | Extend home_feed SQL to include federation_following | | 7 | `crates/api-types/src/responses.rs` | Add `in_reply_to_url` to ThoughtResponse | | 7 | `crates/presentation/src/handlers/feed.rs` | Map in_reply_to_url into response | | 7 | `thoughts-frontend/lib/api.ts` | Add replyToUrl to ThoughtSchema | | 7 | `thoughts-frontend/components/thought-card.tsx` | Show external reply link when replyToUrl set | --- ## Task 1: HTML content in outbound Notes Mastodon and other AP servers expect HTML, not plain text. Wrap content in `

` tags and escape HTML entities. Multi-paragraph posts (newlines) get multiple `

` elements. **Files:** - Modify: `crates/adapters/activitypub-base/src/service.rs` (function `thought_note_json`) - [ ] **Step 1: Add a private HTML-escaping helper near the top of service.rs** Read `crates/adapters/activitypub-base/src/service.rs`. Find `fn thought_note_json`. Add this private function just before it: ```rust fn content_to_html(text: &str) -> String { let escaped = text .replace('&', "&") .replace('<', "<") .replace('>', ">") .replace('"', """); let paragraphs: Vec<&str> = escaped.split('\n').filter(|s| !s.is_empty()).collect(); if paragraphs.is_empty() { format!("

{}

", escaped) } else { paragraphs .iter() .map(|p| format!("

{}

", p)) .collect::>() .join("") } } ``` - [ ] **Step 2: Use `content_to_html` in `thought_note_json`** In `thought_note_json`, find: ```rust "content": thought.content.as_str(), ``` Replace with: ```rust "content": content_to_html(thought.content.as_str()), ``` - [ ] **Step 3: Verify compilation** ```bash cd /mnt/drive/dev/thoughts && cargo build -p activitypub-base 2>&1 | grep "^error" ``` Expected: no errors. - [ ] **Step 4: Commit** ```bash git add crates/adapters/activitypub-base/src/service.rs git commit -m "fix(ap): wrap outbound Note content in HTML paragraph tags" ``` --- ## Task 2: Hashtag federation Outbound Notes must include a `tag` array with Hashtag objects so Mastodon can index posts by hashtag. Extract `#word` patterns from content and add to the Note JSON. **Files:** - Modify: `crates/adapters/activitypub-base/src/service.rs` (`thought_note_json`) - [ ] **Step 1: Add a hashtag-extraction helper in service.rs** Add this function near `content_to_html` (already added in Task 1): ```rust fn extract_hashtag_tags(content: &str, base_url: &str) -> Vec { 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('#') { if !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 } ``` - [ ] **Step 2: Add hashtag tags to the Note JSON in `thought_note_json`** In `thought_note_json`, after the closing `}` of `let mut note = serde_json::json!({...})`, add: ```rust let hashtag_tags = extract_hashtag_tags(thought.content.as_str(), base_url); if !hashtag_tags.is_empty() { note["tag"] = serde_json::json!(hashtag_tags); } ``` Note: `base_url` is already a parameter of `thought_note_json(&self, thought, local_actor, base_url)` — use it directly. - [ ] **Step 3: Verify compilation** ```bash cd /mnt/drive/dev/thoughts && cargo build -p activitypub-base 2>&1 | grep "^error" ``` - [ ] **Step 4: Commit** ```bash git add crates/adapters/activitypub-base/src/service.rs git commit -m "feat(ap): add hashtag tag array to outbound Notes" ``` --- ## Task 3: Undo(Like) inbound handler When a remote user unlikes a local post, we should acknowledge it. Add a "Like" arm to `UndoActivity::receive` that calls `on_unlike` on the object handler. The `on_unlike` impl will be a no-op (we don't store remote likes in the likes table, only notifications — removing them requires more infrastructure). This prevents the "ignoring Undo of unknown activity type" log spam. **Files:** - Modify: `crates/adapters/activitypub-base/src/activities.rs` - Modify: `crates/adapters/activitypub-base/src/content.rs` - Modify: `crates/adapters/activitypub/src/handler.rs` - [ ] **Step 1: Add `on_unlike` to `ApObjectHandler` trait in `content.rs`** Read `crates/adapters/activitypub-base/src/content.rs`. Find `ApObjectHandler`. Add after `on_announce_received`: ```rust /// Called when a remote actor removes a Like from a local thought. async fn on_unlike(&self, object_url: &Url, actor_url: &Url) -> anyhow::Result<()>; ``` - [ ] **Step 2: Add no-op `on_unlike` to `ThoughtsObjectHandler` in `handler.rs`** Read `crates/adapters/activitypub/src/handler.rs`. Add after `on_announce_received`: ```rust async fn on_unlike(&self, _object_url: &Url, _actor_url: &Url) -> anyhow::Result<()> { Ok(()) } ``` - [ ] **Step 3: Add "Like" arm to `UndoActivity::receive` in `activities.rs`** Read `crates/adapters/activitypub-base/src/activities.rs`. Find `UndoActivity::receive`. Find the `match obj_type` block. Add before the `other =>` catch-all: ```rust "Like" => { if let Some(obj_url_str) = self.object.get("object").and_then(|o| o.as_str()) && let Ok(obj_url) = Url::parse(obj_url_str) && obj_url.host_str().unwrap_or("") == data.domain { data.object_handler .on_unlike(&obj_url, self.actor.inner()) .await .unwrap_or_else(|e| { tracing::warn!(error = %e, "failed to process unlike"); }); } tracing::info!(actor = %self.actor.inner(), "received Undo(Like)"); } ``` - [ ] **Step 4: Verify compilation** ```bash cd /mnt/drive/dev/thoughts && cargo build 2>&1 | grep "^error" ``` - [ ] **Step 5: Commit** ```bash git add crates/adapters/activitypub-base/src/activities.rs \ crates/adapters/activitypub-base/src/content.rs \ crates/adapters/activitypub/src/handler.rs git commit -m "feat(ap): handle Undo(Like) inbound activity" ``` --- ## Task 4: Update(Actor) outbound on profile change When a user updates their profile (display name, bio, avatar), broadcast an `Update(Actor)` activity to their AP followers. The `broadcast_actor_update` method already exists on `ActivityPubService` — it just needs to be exposed as a port method and wired through the event system. **Files:** - Modify: `crates/domain/src/ports.rs` — add to OutboundFederationPort - Modify: `crates/domain/src/events.rs` — add ProfileUpdated variant - Modify: `crates/domain/src/testing.rs` — SpyPort stub - Modify: `crates/application/src/use_cases/profile.rs` — publish event - Modify: `crates/application/src/services/federation_event.rs` — handle event - Modify: `crates/adapters/activitypub-base/src/service.rs` — implement port method - [ ] **Step 1: Add `ProfileUpdated` to `DomainEvent` in `crates/domain/src/events.rs`** Read the file. Add to the enum: ```rust ProfileUpdated { user_id: UserId }, ``` - [ ] **Step 2: Add `broadcast_actor_update` to `OutboundFederationPort` in `crates/domain/src/ports.rs`** Find `OutboundFederationPort`. Add after `broadcast_undo_like`: ```rust /// Broadcast Update(Actor) to all accepted followers when a user updates their profile. async fn broadcast_actor_update( &self, user_id: &UserId, ) -> Result<(), DomainError>; ``` - [ ] **Step 3: Add stub to `SpyPort` in `crates/application/src/services/federation_event.rs`** Find `SpyPort` struct. Add field: ```rust actor_updated: Mutex>, ``` Find `impl OutboundFederationPort for SpyPort`. Add: ```rust async fn broadcast_actor_update(&self, user_id: &UserId) -> Result<(), DomainError> { self.actor_updated.lock().unwrap().push(user_id.clone()); Ok(()) } ``` - [ ] **Step 4: Add `EventPublisher` to `update_profile` use case in `crates/application/src/use_cases/profile.rs`** Read the file. Find `pub async fn update_profile(...)`. Add `events: &dyn EventPublisher` as a parameter and import it. Publish `ProfileUpdated` after the update: ```rust pub async fn update_profile( users: &dyn UserRepository, events: &dyn EventPublisher, user_id: &UserId, display_name: Option, bio: Option, avatar_url: Option, header_url: Option, custom_css: Option, ) -> Result<(), DomainError> { users .update_profile(user_id, display_name, bio, avatar_url, header_url, custom_css) .await?; events .publish(&DomainEvent::ProfileUpdated { user_id: user_id.clone(), }) .await?; Ok(()) } ``` Make sure `DomainEvent` and `EventPublisher` are imported at the top of profile.rs. Check the existing imports and add what's missing. - [ ] **Step 5: Update all callers of `update_profile` to pass `&*s.events`** `update_profile` is called from `crates/presentation/src/handlers/users.rs`. Read that file. Find the `patch_profile` handler call to `update_profile`. Add `&*s.events` as the second argument: ```rust update_profile( &*s.users, &*s.events, &uid, body.display_name, body.bio, body.avatar_url, body.header_url, body.custom_css, ) .await?; ``` - [ ] **Step 6: Implement `broadcast_actor_update` port method in `ActivityPubService` in `crates/adapters/activitypub-base/src/service.rs`** Find `impl domain::ports::OutboundFederationPort for ActivityPubService`. Add after `broadcast_undo_like`: ```rust async fn broadcast_actor_update( &self, user_id: &domain::value_objects::UserId, ) -> Result<(), domain::errors::DomainError> { self.broadcast_actor_update(user_id.as_uuid()) .await .map_err(|e| domain::errors::DomainError::Internal(e.to_string())) } ``` Note: this calls the existing private `broadcast_actor_update(uuid)` method on `ActivityPubService`. - [ ] **Step 7: Handle `ProfileUpdated` in `federation_event.rs`** Find the `match event` block. Add before the catch-all `_ => Ok(())`: ```rust DomainEvent::ProfileUpdated { user_id } => { self.ap.broadcast_actor_update(user_id).await } ``` - [ ] **Step 8: Verify build and tests** ```bash cd /mnt/drive/dev/thoughts && cargo build 2>&1 | grep "^error" | head -5 cargo test -p domain -p application 2>&1 | tail -5 ``` - [ ] **Step 9: Commit** ```bash git add crates/domain/src/events.rs \ crates/domain/src/ports.rs \ crates/domain/src/testing.rs \ crates/application/src/use_cases/profile.rs \ crates/application/src/services/federation_event.rs \ crates/presentation/src/handlers/users.rs \ crates/adapters/activitypub-base/src/service.rs git commit -m "feat(ap): broadcast Update(Actor) when user updates their profile" ``` --- ## Task 5: @mention notification When a remote Note arrives with a Mention tag pointing to a local user, create a notification. The Note's `tag` array contains objects like `{"type":"Mention","href":"https://our.instance/users/{uuid}","name":"@user@domain"}`. **Files:** - Modify: `crates/adapters/activitypub/src/note.rs` — add tag field - Modify: `crates/adapters/activitypub-base/src/content.rs` — add on_mention to trait - Modify: `crates/adapters/activitypub/src/handler.rs` — parse tags, implement on_mention - Modify: `crates/domain/src/events.rs` — add MentionReceived - Modify: `crates/domain/src/testing.rs` — no-op on_mention - Modify: `crates/application/src/services/notification_event.rs` — handle MentionReceived - [ ] **Step 1: Add `tag` field to `ThoughtNote` in `crates/adapters/activitypub/src/note.rs`** Read the file. Add to the `ThoughtNote` struct: ```rust #[serde(skip_serializing_if = "Vec::is_empty", default)] pub tag: Vec, ``` - [ ] **Step 2: Add `MentionReceived` to `DomainEvent` in `crates/domain/src/events.rs`** Add to the enum: ```rust MentionReceived { thought_id: ThoughtId, mentioned_user_id: UserId, author_user_id: UserId, }, ``` - [ ] **Step 3: Add `on_mention` to `ApObjectHandler` in `crates/adapters/activitypub-base/src/content.rs`** Add after `on_unlike`: ```rust /// Called once per @mention of a local user in a remote Note. /// `thought_ap_id` is the AP URL of the Note, `mentioned_user_id` is the UUID /// of the local user being mentioned, `actor_url` is the remote author's AP URL. async fn on_mention( &self, thought_ap_id: &Url, mentioned_user_uuid: uuid::Uuid, actor_url: &Url, ) -> anyhow::Result<()>; ``` - [ ] **Step 4: Add no-op `on_mention` to `TestStore`'s `ApObjectHandler` impl in `crates/domain/src/testing.rs`** Note: `TestStore` does NOT implement `ApObjectHandler` — that's `ThoughtsObjectHandler` in the activitypub adapter. Instead, find if there is a test double or just implement in handler.rs directly (step 5 below covers it). - [ ] **Step 5: Implement `on_mention` in `ThoughtsObjectHandler` in `crates/adapters/activitypub/src/handler.rs`** Add after `on_unlike`: ```rust async fn on_mention( &self, thought_ap_id: &url::Url, mentioned_user_uuid: uuid::Uuid, actor_url: &url::Url, ) -> anyhow::Result<()> { // Resolve remote author to a local user ID. let author_user_id = match self .repo .find_remote_actor_id(actor_url) .await .map_err(|e| anyhow::anyhow!("{e}"))? { Some(id) => id, None => return Ok(()), }; // Extract thought UUID from /thoughts/{uuid} path. let thought_uuid = thought_ap_id .path() .strip_prefix("/thoughts/") .and_then(|s| s.split('/').next()) .and_then(|s| uuid::Uuid::parse_str(s).ok()); let thought_uuid = match thought_uuid { Some(u) => u, None => return Ok(()), }; if let Some(ep) = &self.event_publisher { ep.publish(&domain::events::DomainEvent::MentionReceived { thought_id: domain::value_objects::ThoughtId::from_uuid(thought_uuid), mentioned_user_id: domain::value_objects::UserId::from_uuid(mentioned_user_uuid), author_user_id, }) .await .map_err(|e| anyhow::anyhow!("{e}"))?; } Ok(()) } ``` - [ ] **Step 6: Parse Mention tags and call `on_mention` in `ThoughtsObjectHandler::on_create`** Find `on_create`. After the `accept_note(...)` call, add: ```rust // Fire mention notifications for any local @mentions in the note's tag array. let local_domain = self.urls.base_url().host_str().unwrap_or(""); for tag in ¬e.tag { if tag.get("type").and_then(|t| t.as_str()) != Some("Mention") { continue; } let href = match tag.get("href").and_then(|h| h.as_str()) { Some(h) => h, None => continue, }; let href_url = match url::Url::parse(href) { Ok(u) => u, Err(_) => continue, }; // Only process mentions of local users (UUID-based /users/{uuid} paths). if href_url.host_str().unwrap_or("") != local_domain { continue; } let user_uuid = href_url .path() .strip_prefix("/users/") .and_then(|s| s.split('/').next()) .and_then(|s| uuid::Uuid::parse_str(s).ok()); if let Some(uuid) = user_uuid { self.on_mention(ap_id, uuid, actor_url) .await .unwrap_or_else(|e| { tracing::warn!(error = %e, "failed to process mention notification"); }); } } ``` Note: `self.urls.base_url()` — check `ThoughtsUrls` for how to get the base URL `Url`. If not available, parse `self.urls` fields or add a helper. Check the `ThoughtsUrls` struct in `crates/adapters/activitypub/src/urls.rs`. - [ ] **Step 7: Handle `MentionReceived` in `crates/application/src/services/notification_event.rs`** Find the `match event` block. Add before the `_ => Ok(())` catch-all: ```rust DomainEvent::MentionReceived { thought_id, mentioned_user_id, author_user_id, } => { self.notifications .save(&Notification { id: NotificationId::new(), user_id: mentioned_user_id.clone(), notification_type: NotificationType::Mention, from_user_id: Some(author_user_id.clone()), thought_id: Some(thought_id.clone()), read: false, created_at: Utc::now(), }) .await } ``` Make sure `NotificationType::Mention` is a variant — check `crates/domain/src/models/notification.rs`. It already has `Mention` variant. - [ ] **Step 8: Verify build and tests** ```bash cd /mnt/drive/dev/thoughts && cargo build 2>&1 | grep "^error" | head -10 cargo test -p domain -p application 2>&1 | tail -5 ``` - [ ] **Step 9: Commit** ```bash git add crates/adapters/activitypub/src/note.rs \ crates/adapters/activitypub-base/src/content.rs \ crates/adapters/activitypub/src/handler.rs \ crates/domain/src/events.rs \ crates/application/src/services/notification_event.rs git commit -m "feat(ap): @mention notification from inbound remote Notes" ``` --- ## Task 6: Remote posts in home feed The `home_feed` SQL currently only includes thoughts from users in the `follows` table (local follows). Remote follows are in `federation_following`, so remote users' posts never appear. Extend the SQL to also include thoughts from users whose AP URL is in `federation_following` for the viewer. **Files:** - Modify: `crates/adapters/postgres/src/feed.rs` - [ ] **Step 1: Read `crates/adapters/postgres/src/feed.rs` in full** Focus on `fn feed_select(viewer: Option) -> String` and `async fn home_feed(...)`. Key insight: `feed_select` embeds `viewer` UUID directly into the SQL string (not as a bind parameter). The home_feed SQL uses `$1` (following_ids), `$2` (limit), `$3` (offset) as bind params. - [ ] **Step 2: Add `follower` parameter to `feed_select`** Change the signature to: ```rust fn feed_select(viewer: Option, follower: Option) -> String ``` At the top of the function body, generate a federation following subquery: ```rust let federation_clause = match follower { Some(fid) => format!( "OR t.user_id IN ( SELECT u2.id FROM users u2 JOIN federation_following ff ON u2.ap_id = ff.remote_actor_url WHERE ff.local_user_id = '{fid}' )" ), None => String::new(), }; ``` This string is used in step 3's WHERE clause modification. Since `feed_select` generates only the SELECT part (not WHERE), the `federation_clause` needs to be returned somehow. Options: - Return a tuple `(select_str, federation_clause)` from `feed_select` - Or add a separate helper `fn federation_following_clause(follower: Option) -> String` Use option B — separate helper — to avoid changing `feed_select`'s return type: ```rust fn federation_following_clause(follower: Option) -> String { match follower { Some(fid) => format!( " OR t.user_id IN ( SELECT u2.id FROM users u2 JOIN federation_following ff ON u2.ap_id = ff.remote_actor_url WHERE ff.local_user_id = '{fid}' )" ), None => String::new(), } } ``` Leave `feed_select` signature unchanged. - [ ] **Step 3: Modify `home_feed` to use `federation_following_clause`** Find the `home_feed` method. The viewer_id is the feed owner (the logged-in user), which is also the person whose federation_following we want. Replace: ```rust let viewer = viewer_id.map(|v| v.as_uuid()); // ... let total: i64 = sqlx::query_scalar( "SELECT COUNT(*) FROM thoughts t WHERE t.user_id=ANY($1) AND t.visibility != 'direct'", ) ``` With: ```rust let viewer = viewer_id.map(|v| v.as_uuid()); let fed_clause = federation_following_clause(viewer); let total: i64 = sqlx::query_scalar(&format!( "SELECT COUNT(*) FROM thoughts t WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'", fed_clause )) ``` And replace: ```rust let sql = format!("{sel} WHERE t.user_id=ANY($1) AND t.visibility != 'direct' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3"); ``` With: ```rust 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); ``` The rest of the bindings (`$1`, `$2`, `$3`) stay unchanged. - [ ] **Step 4: Verify compilation** ```bash cd /mnt/drive/dev/thoughts && cargo build -p postgres 2>&1 | grep "^error" | head -5 ``` - [ ] **Step 5: Run all tests** ```bash cd /mnt/drive/dev/thoughts && cargo test -p domain -p application 2>&1 | tail -5 ``` - [ ] **Step 6: Commit** ```bash git add crates/adapters/postgres/src/feed.rs git commit -m "feat(feed): include remote following posts in home feed" ``` --- ## Task 7: Reply parent display + API field Remote posts that are replies show without context because: 1. `ThoughtResponse` doesn't expose `in_reply_to_url` (the external URL of the parent) 2. The frontend doesn't link to the parent when it's external **Files:** - Modify: `crates/api-types/src/responses.rs` - Modify: `crates/presentation/src/handlers/feed.rs` (or wherever `to_thought_response` is defined) - Modify: `thoughts-frontend/lib/api.ts` - Modify: `thoughts-frontend/components/thought-card.tsx` - [ ] **Step 1: Add `in_reply_to_url` to `ThoughtResponse` in `crates/api-types/src/responses.rs`** Read the file. Find `ThoughtResponse` struct. Add after `reply_to_id`: ```rust #[serde(rename = "replyToUrl", skip_serializing_if = "Option::is_none")] pub in_reply_to_url: Option, ``` - [ ] **Step 2: Map `in_reply_to_url` in the response builder** Find where `ThoughtResponse` is constructed from a `Thought` (search for `ThoughtResponse {` or `to_thought_response`). Add the mapping: ```rust in_reply_to_url: thought.in_reply_to_url.clone(), ``` - [ ] **Step 3: Verify backend compilation** ```bash cd /mnt/drive/dev/thoughts && cargo build 2>&1 | grep "^error" | head -5 ``` - [ ] **Step 4: Add `replyToUrl` to `ThoughtSchema` in `thoughts-frontend/lib/api.ts`** Find `ThoughtSchema`. Add: ```typescript replyToUrl: z.string().url().nullable().optional(), ``` - [ ] **Step 5: Update `thought-card.tsx` to show external reply link** Read `thoughts-frontend/components/thought-card.tsx`. Find the section that renders `thought.replyToId`. It currently shows "Replying to parent thought" with a hash link only when `isReply` is true. Add an external reply link for when the thought has a `replyToUrl` but no local `replyToId`: ```tsx {thought.replyToId && isReply && (
Replying to{" "} parent thought
)} {!thought.replyToId && thought.replyToUrl && (
Replying to{" "} original post ↗
)} ``` - [ ] **Step 6: Type check frontend** ```bash cd /mnt/drive/dev/thoughts/thoughts-frontend && npx tsc --noEmit 2>&1 | grep "error TS" | head -5 ``` - [ ] **Step 7: Final build + tests** ```bash cd /mnt/drive/dev/thoughts && cargo build 2>&1 | grep "^error" cargo test -p domain -p application 2>&1 | tail -5 ``` - [ ] **Step 8: Commit** ```bash git add crates/api-types/src/responses.rs \ thoughts-frontend/lib/api.ts \ thoughts-frontend/components/thought-card.tsx git commit -m "feat: expose replyToUrl in API + show external parent link on remote reply posts" ``` --- ## Notes - **Task 5 (mentions)**: `self.urls.base_url()` — if `ThoughtsUrls` doesn't expose the base URL as a `Url`, parse it from `self.urls.base_url` string. Check `crates/adapters/activitypub/src/urls.rs` for the exact field. - **Task 6 (feed)**: The embedded UUID in the SQL is a UUID type (hex + hyphens only), safe to format-string without SQL injection risk. - **Task 7 (reply)**: The `to_thought_response` builder might be in `handlers/feed.rs`, `handlers/thoughts.rs`, or a shared module — search the codebase for where `ThoughtResponse` is constructed. - **Profile update (Task 4)**: If tests in `application` call `update_profile` directly, they'll need to pass a `TestStore` as the `events` parameter (TestStore implements EventPublisher).