diff --git a/lib/components/farcaster-data-handler.react.js b/lib/components/farcaster-data-handler.react.js
index e75b7c921..473b1579e 100644
--- a/lib/components/farcaster-data-handler.react.js
+++ b/lib/components/farcaster-data-handler.react.js
@@ -1,99 +1,118 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   updateRelationships as serverUpdateRelationships,
   updateRelationshipsActionTypes,
 } from '../actions/relationship-actions.js';
 import { NeynarClientContext } from '../components/neynar-client-provider.react.js';
 import { cookieSelector } from '../selectors/keyserver-selectors.js';
-import { isLoggedIn } from '../selectors/user-selectors.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import { relationshipActions } from '../types/relationship-types.js';
 import { useLegacyAshoatKeyserverCall } from '../utils/action-utils.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { useCurrentUserFID } from '../utils/farcaster-utils.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { usingCommServicesAccessToken } from '../utils/services-utils.js';
 
 function FarcasterDataHandler(): React.Node {
   const isActive = useSelector(state => state.lifecycleState !== 'background');
 
-  const hasCurrentUserInfo = useSelector(isLoggedIn);
   const cookie = useSelector(cookieSelector(authoritativeKeyserverID()));
   const hasUserCookie = !!(cookie && cookie.startsWith('user='));
-  const loggedIn = hasCurrentUserInfo && hasUserCookie;
+  const currentUserID = useSelector(state => state.currentUserInfo?.id);
+  const loggedIn = !!currentUserID && hasUserCookie;
 
   const neynarClient = React.useContext(NeynarClientContext)?.client;
 
   const identityServiceClient = React.useContext(IdentityClientContext);
   const getFarcasterUsers =
     identityServiceClient?.identityClient.getFarcasterUsers;
 
   const dispatchActionPromise = useDispatchActionPromise();
   const updateRelationships = useLegacyAshoatKeyserverCall(
     serverUpdateRelationships,
   );
   const createThreadsAndRobotextForFarcasterMutuals = React.useCallback(
-    (userIDs: $ReadOnlyArray<string>) =>
+    (userIDsToFID: { +[userID: string]: string }) =>
       updateRelationships({
         action: relationshipActions.FARCASTER_MUTUAL,
-        userIDs,
+        userIDsToFID,
       }),
     [updateRelationships],
   );
 
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const fid = useCurrentUserFID();
 
   const prevCanQueryRef = React.useRef<?boolean>();
   React.useEffect(() => {
     if (!usingCommServicesAccessToken) {
       return;
     }
 
     const canQuery = isActive && !!fid && loggedIn;
     if (canQuery === prevCanQueryRef.current) {
       return;
     }
     prevCanQueryRef.current = canQuery;
 
-    if (!loggedIn || !isActive || !fid || !neynarClient || !getFarcasterUsers) {
+    if (
+      !loggedIn ||
+      !isActive ||
+      !fid ||
+      !neynarClient ||
+      !getFarcasterUsers ||
+      !currentUserID
+    ) {
       return;
     }
 
     void (async () => {
       const followerFIDs = await neynarClient.fetchFriendFIDs(fid);
 
       const commFCUsers = await getFarcasterUsers(followerFIDs);
 
-      const commUserIDs = commFCUsers.map(({ userID }) => userID);
+      const newCommUsers = commFCUsers.filter(
+        ({ userID }) => !userInfos[userID],
+      );
 
-      const newCommUserIDs = commUserIDs.filter(userID => !userInfos[userID]);
-      if (newCommUserIDs.length === 0) {
+      if (newCommUsers.length === 0) {
         return;
       }
 
+      const userIDsToFID: { +[userID: string]: string } = Object.fromEntries(
+        newCommUsers.map(({ userID, farcasterID }) => [userID, farcasterID]),
+      );
+
+      const userIDsToFIDIncludingCurrentUser: { +[userID: string]: string } = {
+        ...userIDsToFID,
+        [(currentUserID: string)]: fid,
+      };
+
       void dispatchActionPromise(
         updateRelationshipsActionTypes,
-        createThreadsAndRobotextForFarcasterMutuals(newCommUserIDs),
+        createThreadsAndRobotextForFarcasterMutuals(
+          userIDsToFIDIncludingCurrentUser,
+        ),
       );
     })();
   }, [
     isActive,
     fid,
     loggedIn,
     neynarClient,
     getFarcasterUsers,
     userInfos,
     dispatchActionPromise,
     createThreadsAndRobotextForFarcasterMutuals,
+    currentUserID,
   ]);
 
   return null;
 }
 
 export { FarcasterDataHandler };