diff --git a/lib/selectors/thread-selectors.js b/lib/selectors/thread-selectors.js
index af8dc6f83..b91d08490 100644
--- a/lib/selectors/thread-selectors.js
+++ b/lib/selectors/thread-selectors.js
@@ -1,380 +1,330 @@
 // @flow
 
-import invariant from 'invariant';
 import _compact from 'lodash/fp/compact';
 import _filter from 'lodash/fp/filter';
 import _flow from 'lodash/fp/flow';
 import _map from 'lodash/fp/map';
 import _mapValues from 'lodash/fp/mapValues';
 import _orderBy from 'lodash/fp/orderBy';
 import _some from 'lodash/fp/some';
 import _sortBy from 'lodash/fp/sortBy';
 import _memoize from 'lodash/memoize';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import { createEntryInfo } from '../shared/entry-utils';
 import { getMostRecentNonLocalMessageID } from '../shared/message-utils';
 import {
   threadInHomeChatList,
   threadInBackgroundChatList,
   threadInFilterList,
   threadInfoFromRawThreadInfo,
   threadHasPermission,
   threadInChatList,
   threadHasAdminRole,
   roleIsAdminRole,
-  getPendingPersonalThreadOtherUser,
 } from '../shared/thread-utils';
 import type { EntryInfo } from '../types/entry-types';
 import type { MessageStore, RawMessageInfo } from '../types/message-types';
 import type { BaseAppState } from '../types/redux-types';
 import {
   type ThreadInfo,
   type RawThreadInfo,
   type RelativeMemberInfo,
   threadPermissions,
   threadTypes,
   type SidebarInfo,
 } from '../types/thread-types';
 import { dateString, dateFromString } from '../utils/date-utils';
 import { values } from '../utils/objects';
 import {
   filteredThreadIDsSelector,
   includeDeletedSelector,
 } from './calendar-filter-selectors';
 import { relativeMemberInfoSelectorForMembersOfThread } from './user-selectors';
 
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 type ThreadInfoSelectorType = (
   state: BaseAppState<*>,
 ) => { [id: string]: ThreadInfo };
 const threadInfoSelector: ThreadInfoSelectorType = createObjectSelector(
   (state: BaseAppState<*>) => state.threadStore.threadInfos,
   (state: BaseAppState<*>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<*>) => state.userStore.userInfos,
   threadInfoFromRawThreadInfo,
 );
 
-type ThreadSelectorType = (
-  possiblyPendingThread: ThreadInfo,
-) => (state: BaseAppState<*>) => ?ThreadInfo;
-const possiblyPendingThreadInfoSelector: ThreadSelectorType = (
-  possiblyPendingThread: ThreadInfo,
-) =>
-  createSelector(
-    threadInfoSelector,
-    (state: BaseAppState<*>) => state.currentUserInfo?.id,
-    (threadInfos: { [id: string]: ThreadInfo }, currentUserID: ?string) => {
-      const threadInfoFromState = threadInfos[possiblyPendingThread.id];
-      if (threadInfoFromState) {
-        return threadInfoFromState;
-      }
-      if (possiblyPendingThread.type !== threadTypes.PERSONAL) {
-        return undefined;
-      }
-      if (!currentUserID) {
-        return possiblyPendingThread;
-      }
-
-      const otherUserID = getPendingPersonalThreadOtherUser(
-        possiblyPendingThread,
-      );
-
-      if (!otherUserID) {
-        return possiblyPendingThread;
-      }
-
-      for (const threadID in threadInfos) {
-        const threadInfo = threadInfos[threadID];
-        if (threadInfo.type !== threadTypes.PERSONAL) {
-          continue;
-        }
-        invariant(
-          threadInfo.members.length === 2,
-          'Personal thread should have exactly two members',
-        );
-        const members = new Set(threadInfo.members.map((member) => member.id));
-        if (members.has(currentUserID) && members.has(otherUserID)) {
-          return threadInfo;
-        }
-      }
-      return possiblyPendingThread;
-    },
-  );
-
 const canBeOnScreenThreadInfos: (
   state: BaseAppState<*>,
 ) => ThreadInfo[] = createSelector(
   threadInfoSelector,
   (threadInfos: { [id: string]: ThreadInfo }) => {
     const result = [];
     for (let threadID in threadInfos) {
       const threadInfo = threadInfos[threadID];
       if (!threadInFilterList(threadInfo)) {
         continue;
       }
       result.push(threadInfo);
     }
     return result;
   },
 );
 
 const onScreenThreadInfos: (
   state: BaseAppState<*>,
 ) => ThreadInfo[] = createSelector(
   filteredThreadIDsSelector,
   canBeOnScreenThreadInfos,
   (inputThreadIDs: ?Set<string>, threadInfos: ThreadInfo[]) => {
     const threadIDs = inputThreadIDs;
     if (!threadIDs) {
       return threadInfos;
     }
     return threadInfos.filter((threadInfo) => threadIDs.has(threadInfo.id));
   },
 );
 
 const onScreenEntryEditableThreadInfos: (
   state: BaseAppState<*>,
 ) => ThreadInfo[] = createSelector(
   onScreenThreadInfos,
   (threadInfos: ThreadInfo[]) =>
     threadInfos.filter((threadInfo) =>
       threadHasPermission(threadInfo, threadPermissions.EDIT_ENTRIES),
     ),
 );
 
 const entryInfoSelector: (
   state: BaseAppState<*>,
 ) => { [id: string]: EntryInfo } = createObjectSelector(
   (state: BaseAppState<*>) => state.entryStore.entryInfos,
   (state: BaseAppState<*>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<*>) => state.userStore.userInfos,
   createEntryInfo,
 );
 
 // "current" means within startDate/endDate range, not deleted, and in
 // onScreenThreadInfos
 const currentDaysToEntries: (
   state: BaseAppState<*>,
 ) => { [dayString: string]: EntryInfo[] } = createSelector(
   entryInfoSelector,
   (state: BaseAppState<*>) => state.entryStore.daysToEntries,
   (state: BaseAppState<*>) => state.navInfo.startDate,
   (state: BaseAppState<*>) => state.navInfo.endDate,
   onScreenThreadInfos,
   includeDeletedSelector,
   (
     entryInfos: { [id: string]: EntryInfo },
     daysToEntries: { [day: string]: string[] },
     startDateString: string,
     endDateString: string,
     onScreen: ThreadInfo[],
     includeDeleted: boolean,
   ) => {
     const allDaysWithinRange = {},
       startDate = dateFromString(startDateString),
       endDate = dateFromString(endDateString);
     for (
       const curDate = startDate;
       curDate <= endDate;
       curDate.setDate(curDate.getDate() + 1)
     ) {
       allDaysWithinRange[dateString(curDate)] = [];
     }
     return _mapValuesWithKeys((_: string[], dayString: string) =>
       _flow(
         _map((entryID: string) => entryInfos[entryID]),
         _compact,
         _filter(
           (entryInfo: EntryInfo) =>
             (includeDeleted || !entryInfo.deleted) &&
             _some(['id', entryInfo.threadID])(onScreen),
         ),
         _sortBy('creationTime'),
       )(daysToEntries[dayString] ? daysToEntries[dayString] : []),
     )(allDaysWithinRange);
   },
 );
 
 const childThreadInfos: (
   state: BaseAppState<*>,
 ) => { [id: string]: $ReadOnlyArray<ThreadInfo> } = createSelector(
   threadInfoSelector,
   (threadInfos: { [id: string]: ThreadInfo }) => {
     const result = {};
     for (let id in threadInfos) {
       const threadInfo = threadInfos[id];
       const parentThreadID = threadInfo.parentThreadID;
       if (parentThreadID === null || parentThreadID === undefined) {
         continue;
       }
       if (result[parentThreadID] === undefined) {
         result[parentThreadID] = [];
       }
       result[parentThreadID].push(threadInfo);
     }
     return result;
   },
 );
 
 function getMostRecentRawMessageInfo(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
 ): ?RawMessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (let messageID of thread.messageIDs) {
     return messageStore.messages[messageID];
   }
   return null;
 }
 
 const sidebarInfoSelector: (
   state: BaseAppState<*>,
 ) => { [id: string]: $ReadOnlyArray<SidebarInfo> } = createObjectSelector(
   childThreadInfos,
   (state: BaseAppState<*>) => state.messageStore,
   (childThreads: $ReadOnlyArray<ThreadInfo>, messageStore: MessageStore) => {
     const sidebarInfos = [];
     for (const childThreadInfo of childThreads) {
       if (
         !threadInChatList(childThreadInfo) ||
         childThreadInfo.type !== threadTypes.SIDEBAR
       ) {
         continue;
       }
       const mostRecentRawMessageInfo = getMostRecentRawMessageInfo(
         childThreadInfo,
         messageStore,
       );
       const lastUpdatedTime =
         mostRecentRawMessageInfo?.time ?? childThreadInfo.creationTime;
       const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
         childThreadInfo,
         messageStore,
       );
       sidebarInfos.push({
         threadInfo: childThreadInfo,
         lastUpdatedTime,
         mostRecentNonLocalMessage,
       });
     }
     return _orderBy('lastUpdatedTime')('desc')(sidebarInfos);
   },
 );
 
 const unreadCount: (state: BaseAppState<*>) => number = createSelector(
   (state: BaseAppState<*>) => state.threadStore.threadInfos,
   (threadInfos: { [id: string]: RawThreadInfo }): number =>
     values(threadInfos).filter(
       (threadInfo) =>
         threadInHomeChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const unreadBackgroundCount: (
   state: BaseAppState<*>,
 ) => number = createSelector(
   (state: BaseAppState<*>) => state.threadStore.threadInfos,
   (threadInfos: { [id: string]: RawThreadInfo }): number =>
     values(threadInfos).filter(
       (threadInfo) =>
         threadInBackgroundChatList(threadInfo) && threadInfo.currentUser.unread,
     ).length,
 );
 
 const baseOtherUsersButNoOtherAdmins = (threadID: string) =>
   createSelector(
     (state: BaseAppState<*>) => state.threadStore.threadInfos[threadID],
     relativeMemberInfoSelectorForMembersOfThread(threadID),
     (
       threadInfo: ?RawThreadInfo,
       members: $ReadOnlyArray<RelativeMemberInfo>,
     ): boolean => {
       if (!threadInfo) {
         return false;
       }
       if (!threadHasAdminRole(threadInfo)) {
         return false;
       }
       let otherUsersExist = false;
       let otherAdminsExist = false;
       for (let member of members) {
         const role = member.role;
         if (role === undefined || role === null || member.isViewer) {
           continue;
         }
         otherUsersExist = true;
         if (roleIsAdminRole(threadInfo?.roles[role])) {
           otherAdminsExist = true;
           break;
         }
       }
       return otherUsersExist && !otherAdminsExist;
     },
   );
 
 const otherUsersButNoOtherAdmins: (
   threadID: string,
 ) => (state: BaseAppState<*>) => boolean = _memoize(
   baseOtherUsersButNoOtherAdmins,
 );
 
 function mostRecentReadThread(
   messageStore: MessageStore,
   threadInfos: { [id: string]: RawThreadInfo },
 ): ?string {
   let mostRecent = null;
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (threadInfo.currentUser.unread) {
       continue;
     }
     const threadMessageInfo = messageStore.threads[threadID];
     if (!threadMessageInfo) {
       continue;
     }
     const mostRecentMessageTime =
       threadMessageInfo.messageIDs.length === 0
         ? threadInfo.creationTime
         : messageStore.messages[threadMessageInfo.messageIDs[0]].time;
     if (mostRecent && mostRecent.time >= mostRecentMessageTime) {
       continue;
     }
 
     const topLevelThreadID =
       threadInfo.type === threadTypes.SIDEBAR
         ? threadInfo.parentThreadID
         : threadID;
     mostRecent = { threadID: topLevelThreadID, time: mostRecentMessageTime };
   }
   return mostRecent ? mostRecent.threadID : null;
 }
 
 const mostRecentReadThreadSelector: (
   state: BaseAppState<*>,
 ) => ?string = createSelector(
   (state: BaseAppState<*>) => state.messageStore,
   (state: BaseAppState<*>) => state.threadStore.threadInfos,
   mostRecentReadThread,
 );
 
 export {
   threadInfoSelector,
   onScreenThreadInfos,
   onScreenEntryEditableThreadInfos,
   entryInfoSelector,
   currentDaysToEntries,
   childThreadInfos,
   unreadCount,
   unreadBackgroundCount,
   otherUsersButNoOtherAdmins,
   mostRecentReadThread,
   mostRecentReadThreadSelector,
-  possiblyPendingThreadInfoSelector,
   sidebarInfoSelector,
 };
diff --git a/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index f8b2d7631..35d55d32c 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,644 +1,645 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find';
 import tinycolor from 'tinycolor2';
 
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions';
 import type { ChatThreadItem } from '../selectors/chat-selectors';
 import { userRelationshipStatus } from '../types/relationship-types';
 import {
   type RawThreadInfo,
   type ThreadInfo,
   type ThreadPermission,
   type MemberInfo,
   type ServerThreadInfo,
   type RelativeMemberInfo,
   type ThreadCurrentUserInfo,
   type RoleInfo,
   type ServerMemberInfo,
   type ThreadPermissionsInfo,
   threadTypes,
   threadPermissions,
 } from '../types/thread-types';
 import { type UpdateInfo, updateTypes } from '../types/update-types';
 import type { GlobalAccountUserInfo, UserInfos } from '../types/user-types';
 import { pluralize } from '../utils/text-utils';
 
 function colorIsDark(color: string) {
   return tinycolor(`#${color}`).isDark();
 }
 
 // Randomly distributed in RGB-space
 const hexNumerals = '0123456789abcdef';
 function generateRandomColor() {
   let color = '';
   for (let i = 0; i < 6; i++) {
     color += hexNumerals[Math.floor(Math.random() * 16)];
   }
   return color;
 }
 
 function generatePendingThreadColor(userID: string, viewerID: string) {
   const ids =
     userID < viewerID ? `${userID}#${viewerID}` : `${viewerID}#${userID}`;
   let hash = 0;
   for (let i = 0; i < ids.length; i++) {
     hash = 1009 * hash + ids.charCodeAt(i) * 83;
     hash %= 1000000007;
   }
   const hashString = hash.toString(16);
   return hashString.substring(hashString.length - 6).padStart(6, '8');
 }
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
   permission: ThreadPermission,
 ): boolean {
   invariant(
     !permissionsDisabledByBlock.has(permission) || threadInfo?.uiName,
     `${permission} can be disabled by a block, but threadHasPermission can't ` +
       'check for a block on RawThreadInfo. Please pass in ThreadInfo instead!',
   );
   if (!threadInfo || !threadInfo.currentUser.permissions[permission]) {
     return false;
   }
   return threadInfo.currentUser.permissions[permission].value;
 }
 
 function viewerIsMember(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function threadIsInHome(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(ThreadInfo | RawThreadInfo)): boolean {
   return !!(
     threadInChatList(threadInfo) &&
     threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function userIsMember(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   return threadInfo.members.some(
     (member) =>
       member.id === userID && member.role !== null && member.role !== undefined,
   );
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(
       (memberInfo) => memberInfo.role !== null && memberInfo.role !== undefined,
     )
     .map((memberInfo) => memberInfo.id);
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo | RawThreadInfo) {
   return (
     threadInfo.members.filter(
       (member) =>
         member.role || member.permissions[threadPermissions.VOICED]?.value,
     ).length > 2
   );
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return threadInfo.members.length > 2;
 }
 
 function threadIsPending(threadID: ?string) {
   return threadID?.startsWith('pending');
 }
 
 function threadIsPersonalAndPending(threadInfo: ?(ThreadInfo | RawThreadInfo)) {
   return (
     threadInfo?.type === threadTypes.PERSONAL && threadIsPending(threadInfo?.id)
   );
 }
 
 function getPendingPersonalThreadOtherUser(
   threadInfo: ThreadInfo | RawThreadInfo,
 ) {
   invariant(
     threadIsPersonalAndPending(threadInfo),
     'Thread should be personal and pending',
   );
 
   const otherUserID = threadInfo.id.split('/')[1];
   invariant(
     otherUserID,
     'Pending thread should contain other member id in its id',
   );
   return otherUserID;
 }
 
 function getSingleOtherUser(
   threadInfo: ThreadInfo | RawThreadInfo,
   viewerID: ?string,
 ) {
   if (!viewerID) {
     return undefined;
   }
 
   const otherMemberIDs = threadInfo.members
     .map((member) => member.id)
     .filter((id) => id !== viewerID);
   if (otherMemberIDs.length !== 1) {
     return undefined;
   }
   return otherMemberIDs[0];
 }
 
 function createPendingThreadItem(
   viewerID: string,
   user: GlobalAccountUserInfo,
 ): ChatThreadItem {
   const now = Date.now();
   const threadID = `pending/${user.id}`;
 
   const permissions = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadTypes.PERSONAL),
     threadID,
   );
   const role = {
     id: `${threadID}/role`,
     name: 'Members',
     permissions,
     isDefault: true,
   };
 
   const rawThreadInfo = {
     id: threadID,
     type: threadTypes.PERSONAL,
     name: null,
     description: null,
     color: generatePendingThreadColor(user.id, viewerID),
     creationTime: now,
     parentThreadID: null,
     members: [
       {
         id: viewerID,
         role: role.id,
         permissions: membershipPermissions,
       },
       {
         id: user.id,
         role: role.id,
         permissions: membershipPermissions,
       },
     ],
     roles: {
       [role.id]: role,
     },
     currentUser: {
       role: role.id,
       permissions: membershipPermissions,
       subscription: {
         pushNotifs: false,
         home: false,
       },
       unread: false,
     },
   };
 
   return {
     type: 'chatThreadItem',
     threadInfo: threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, {
       [user.id]: user,
     }),
     mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: now,
     lastUpdatedTimeIncludingSidebars: now,
     sidebars: [],
     pendingPersonalThreadUserInfo: {
       id: user.id,
       username: user.username,
     },
   };
 }
 
 type RawThreadInfoOptions = {|
   +includeVisibilityRules?: ?boolean,
   +filterMemberList?: ?boolean,
 |};
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?RawThreadInfo {
   const includeVisibilityRules = options?.includeVisibilityRules;
   const filterMemberList = options?.filterMemberList;
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       filterMemberList &&
       serverMember.id !== viewerID &&
       !serverMember.role &&
       !memberHasAdminPowers(serverMember)
     ) {
       continue;
     }
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: serverMember.permissions,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: serverMember.permissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = getAllThreadPermissions(null, serverThreadInfo.id);
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: {
         home: false,
         pushNotifs: false,
       },
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rawThreadInfo = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: serverThreadInfo.roles,
     currentUser,
   };
   if (!includeVisibilityRules) {
     return rawThreadInfo;
   }
   return ({
     ...rawThreadInfo,
     visibilityRules: rawThreadInfo.type,
   }: any);
 }
 
 function robotextName(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): string {
   const threadUsernames: string[] = threadInfo.members
     .filter(
       (threadMember) =>
         threadMember.id !== viewerID &&
         (threadMember.role || memberHasAdminPowers(threadMember)),
     )
     .map(
       (threadMember) =>
         userInfos[threadMember.id] && userInfos[threadMember.id].username,
     )
     .filter(Boolean);
   if (threadUsernames.length === 0) {
     return 'just you';
   }
   return pluralize(threadUsernames);
 }
 
 function threadUIName(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): string {
   if (threadInfo.name) {
     return threadInfo.name;
   }
   return robotextName(threadInfo, viewerID, userInfos);
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadInfo {
   return {
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: threadUIName(rawThreadInfo, viewerID, userInfos),
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     members: rawThreadInfo.members,
     roles: rawThreadInfo.roles,
     currentUser: getCurrentUser(rawThreadInfo, viewerID, userInfos),
   };
 }
 
 function getCurrentUser(
-  rawThreadInfo: RawThreadInfo,
+  threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadCurrentUserInfo {
-  if (!threadFrozenDueToBlock(rawThreadInfo, viewerID, userInfos)) {
-    return rawThreadInfo.currentUser;
+  if (!threadFrozenDueToBlock(threadInfo, viewerID, userInfos)) {
+    return threadInfo.currentUser;
   }
 
   return {
-    ...rawThreadInfo.currentUser,
+    ...threadInfo.currentUser,
     permissions: {
-      ...rawThreadInfo.currentUser.permissions,
+      ...threadInfo.currentUser.permissions,
       ...disabledPermissions,
     },
   };
 }
 
 function threadIsWithBlockedUserOnly(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock?: boolean,
 ): boolean {
   if (
     threadOrParentThreadIsGroupChat(threadInfo) ||
     threadOrParentThreadHasAdminRole(threadInfo)
   ) {
     return false;
   }
 
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER ||
     otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_VIEWER ||
     otherUserRelationshipStatus === userRelationshipStatus.BOTH_BLOCKED
   );
 }
 
 function threadFrozenDueToBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos);
 }
 
 function threadFrozenDueToViewerBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos, true);
 }
 
 function rawThreadInfoFromThreadInfo(threadInfo: ThreadInfo): RawThreadInfo {
   return {
     id: threadInfo.id,
     type: threadInfo.type,
     name: threadInfo.name,
     description: threadInfo.description,
     color: threadInfo.color,
     creationTime: threadInfo.creationTime,
     parentThreadID: threadInfo.parentThreadID,
     members: threadInfo.members,
     roles: threadInfo.roles,
     currentUser: threadInfo.currentUser,
   };
 }
 
 const threadTypeDescriptions = {
   [threadTypes.CHAT_NESTED_OPEN]:
     'Anybody in the parent thread can see an open child thread.',
   [threadTypes.CHAT_SECRET]:
     'Only visible to its members and admins of ancestor threads.',
 };
 
 function usersInThreadInfo(threadInfo: RawThreadInfo | ThreadInfo): string[] {
   const userIDs = new Set();
   for (let member of threadInfo.members) {
     userIDs.add(member.id);
   }
   return [...userIDs];
 }
 
 function memberIsAdmin(
   memberInfo: RelativeMemberInfo | MemberInfo,
   threadInfo: ThreadInfo | RawThreadInfo,
 ) {
   return memberInfo.role && roleIsAdminRole(threadInfo.roles[memberInfo.role]);
 }
 
 // Since we don't have access to all of the ancestor ThreadInfos, we approximate
 // "parent admin" as anybody with CHANGE_ROLE permissions.
 function memberHasAdminPowers(
   memberInfo: RelativeMemberInfo | MemberInfo | ServerMemberInfo,
 ): boolean {
   return !!memberInfo.permissions[threadPermissions.CHANGE_ROLE]?.value;
 }
 
 function roleIsAdminRole(roleInfo: ?RoleInfo) {
   return roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins';
 }
 
 function threadHasAdminRole(
   threadInfo: ?(RawThreadInfo | ThreadInfo | ServerThreadInfo),
 ) {
   if (!threadInfo) {
     return false;
   }
   return _find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function threadOrParentThreadHasAdminRole(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return (
     threadInfo.members.filter((member) => memberHasAdminPowers(member)).length >
     0
   );
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<UpdateInfo>,
 ): Set<string> {
   const invalidated = new Set();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = [
   threadPermissions.VOICED,
   threadPermissions.EDIT_ENTRIES,
   threadPermissions.EDIT_THREAD,
   threadPermissions.CREATE_SUBTHREADS,
   threadPermissions.CREATE_SIDEBARS,
   threadPermissions.JOIN_THREAD,
   threadPermissions.EDIT_PERMISSIONS,
   threadPermissions.ADD_MEMBERS,
   threadPermissions.REMOVE_MEMBERS,
 ];
 
 const permissionsDisabledByBlock: Set<ThreadPermission> = new Set(
   permissionsDisabledByBlockArray,
 );
 
 const disabledPermissions: ThreadPermissionsInfo = permissionsDisabledByBlockArray.reduce(
   (permissions: ThreadPermissionsInfo, permission: string) => ({
     ...permissions,
     [permission]: { value: false, source: null },
   }),
   {},
 );
 
 // Consider updating itemHeight in native/chat/chat-thread-list.react.js
 // if you change this
 const emptyItemText =
   `Background threads are just like normal threads, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a thread over here, switch the “Background” option in its settings.`;
 
 const threadSearchText = (
   threadInfo: RawThreadInfo | ThreadInfo,
   userInfos: UserInfos,
 ): string => {
   const searchTextArray = [];
   if (threadInfo.name) {
     searchTextArray.push(threadInfo.name);
   }
   if (threadInfo.description) {
     searchTextArray.push(threadInfo.description);
   }
   for (let member of threadInfo.members) {
     const userInfo = userInfos[member.id];
     if (userInfo && userInfo.username) {
       searchTextArray.push(userInfo.username);
     }
   }
   return searchTextArray.join(' ');
 };
 
 export {
   colorIsDark,
   generateRandomColor,
   generatePendingThreadColor,
   threadHasPermission,
   viewerIsMember,
   threadInChatList,
   threadIsTopLevel,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPersonalAndPending,
   getPendingPersonalThreadOtherUser,
   getSingleOtherUser,
   createPendingThreadItem,
+  getCurrentUser,
   threadFrozenDueToBlock,
   threadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   robotextName,
   threadInfoFromRawThreadInfo,
   rawThreadInfoFromThreadInfo,
   threadTypeDescriptions,
   usersInThreadInfo,
   memberIsAdmin,
   memberHasAdminPowers,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadSearchText,
 };
diff --git a/native/chat/message-list-container.react.js b/native/chat/message-list-container.react.js
index 13047d35e..e0fad214b 100644
--- a/native/chat/message-list-container.react.js
+++ b/native/chat/message-list-container.react.js
@@ -1,300 +1,342 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import {
   type ChatMessageItem,
   messageListData,
 } from 'lib/selectors/chat-selectors';
-import { possiblyPendingThreadInfoSelector } from 'lib/selectors/thread-selectors';
+import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { messageID } from 'lib/shared/message-utils';
+import {
+  getPendingPersonalThreadOtherUser,
+  getCurrentUser,
+  threadIsPersonalAndPending,
+} from 'lib/shared/thread-utils';
 import { messageTypes } from 'lib/types/message-types';
-import type { ThreadInfo } from 'lib/types/thread-types';
+import { type ThreadInfo, threadTypes } from 'lib/types/thread-types';
 
 import ContentLoading from '../components/content-loading.react';
 import NodeHeightMeasurer from '../components/node-height-measurer.react';
 import { type InputState, InputStateContext } from '../input/input-state';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context';
 import type { NavigationRoute } from '../navigation/route-names';
 import { useSelector } from '../redux/redux-utils';
 import { type Colors, useColors, useStyles } from '../themes/colors';
 import ChatInputBar from './chat-input-bar.react';
 import { chatMessageItemKey } from './chat-list.react';
 import type { ChatNavigationProp } from './chat.react';
 import { composedMessageMaxWidthSelector } from './composed-message-width';
 import { dummyNodeForTextMessageHeightMeasurement } from './inner-text-message.react';
 import {
   MessageListContext,
   useMessageListContext,
 } from './message-list-types';
 import MessageList from './message-list.react';
 import type { ChatMessageInfoItemWithHeight } from './message.react';
 import { multimediaMessageContentSizes } from './multimedia-message.react';
 import { dummyNodeForRobotextMessageHeightMeasurement } from './robotext-message.react';
-
 export type ChatMessageItemWithHeight =
   | {| itemType: 'loader' |}
   | ChatMessageInfoItemWithHeight;
 
 type BaseProps = {|
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 |};
 type Props = {|
   ...BaseProps,
   // Redux state
-  +threadInfo: ?ThreadInfo,
+  +threadInfo: ThreadInfo,
   +messageListData: $ReadOnlyArray<ChatMessageItem>,
   +composedMessageMaxWidth: number,
   +colors: Colors,
   +styles: typeof unboundStyles,
   // withInputState
   +inputState: ?InputState,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
 |};
 type State = {|
   +listDataWithHeights: ?$ReadOnlyArray<ChatMessageItemWithHeight>,
 |};
 class MessageListContainer extends React.PureComponent<Props, State> {
   state: State = {
     listDataWithHeights: null,
   };
   pendingListDataWithHeights: ?$ReadOnlyArray<ChatMessageItemWithHeight>;
 
-  static getThreadInfo(props: Props): ThreadInfo {
-    const { threadInfo } = props;
-    if (threadInfo) {
-      return threadInfo;
-    }
-    return props.route.params.threadInfo;
-  }
-
   get frozen() {
     const { overlayContext } = this.props;
     invariant(
       overlayContext,
       'MessageListContainer should have OverlayContext',
     );
     return overlayContext.scrollBlockingModalStatus !== 'closed';
   }
 
   componentDidUpdate(prevProps: Props) {
-    const oldReduxThreadInfo = prevProps.threadInfo;
-    const newReduxThreadInfo = this.props.threadInfo;
-    if (newReduxThreadInfo && newReduxThreadInfo !== oldReduxThreadInfo) {
-      this.props.navigation.setParams({ threadInfo: newReduxThreadInfo });
-    }
-
     const oldListData = prevProps.messageListData;
     const newListData = this.props.messageListData;
     if (!newListData && oldListData) {
       this.setState({ listDataWithHeights: null });
     }
 
     if (!this.frozen && this.pendingListDataWithHeights) {
       this.setState({ listDataWithHeights: this.pendingListDataWithHeights });
       this.pendingListDataWithHeights = undefined;
     }
   }
 
   render() {
-    const threadInfo = MessageListContainer.getThreadInfo(this.props);
+    const { threadInfo } = this.props;
     const { listDataWithHeights } = this.state;
 
     let messageList;
     if (listDataWithHeights) {
       messageList = (
         <MessageList
           threadInfo={threadInfo}
           messageListData={listDataWithHeights}
           navigation={this.props.navigation}
           route={this.props.route}
         />
       );
     } else {
       messageList = (
         <ContentLoading fillType="flex" colors={this.props.colors} />
       );
     }
 
     return (
       <View style={this.props.styles.container}>
         <NodeHeightMeasurer
           listData={this.props.messageListData}
           itemToID={this.heightMeasurerID}
           itemToMeasureKey={this.heightMeasurerKey}
           itemToDummy={this.heightMeasurerDummy}
           mergeItemWithHeight={this.heightMeasurerMergeItem}
           allHeightsMeasured={this.allHeightsMeasured}
           inputState={this.props.inputState}
           composedMessageMaxWidth={this.props.composedMessageMaxWidth}
         />
         {messageList}
         <ChatInputBar
           threadInfo={threadInfo}
           navigation={this.props.navigation}
           route={this.props.route}
         />
       </View>
     );
   }
 
   heightMeasurerID = (item: ChatMessageItem) => {
     return chatMessageItemKey(item);
   };
 
   heightMeasurerKey = (item: ChatMessageItem) => {
     if (item.itemType !== 'message') {
       return null;
     }
     const { messageInfo } = item;
     if (messageInfo.type === messageTypes.TEXT) {
       return messageInfo.text;
     } else if (item.robotext && typeof item.robotext === 'string') {
       return item.robotext;
     }
     return null;
   };
 
   heightMeasurerDummy = (item: ChatMessageItem) => {
     invariant(
       item.itemType === 'message',
       'NodeHeightMeasurer asked for dummy for non-message item',
     );
     const { messageInfo } = item;
     if (messageInfo.type === messageTypes.TEXT) {
       return dummyNodeForTextMessageHeightMeasurement(messageInfo.text);
     } else if (item.robotext && typeof item.robotext === 'string') {
       return dummyNodeForRobotextMessageHeightMeasurement(item.robotext);
     }
     invariant(false, 'NodeHeightMeasurer asked for dummy for non-text message');
   };
 
   heightMeasurerMergeItem = (item: ChatMessageItem, height: ?number) => {
     if (item.itemType !== 'message') {
       return item;
     }
 
     const { messageInfo } = item;
-    const threadInfo = MessageListContainer.getThreadInfo(this.props);
+    const { threadInfo } = this.props;
     if (
       messageInfo.type === messageTypes.IMAGES ||
       messageInfo.type === messageTypes.MULTIMEDIA
     ) {
       const { inputState } = this.props;
       // Conditional due to Flow...
       const localMessageInfo = item.localMessageInfo
         ? item.localMessageInfo
         : null;
       const id = messageID(messageInfo);
       const pendingUploads =
         inputState &&
         inputState.pendingUploads &&
         inputState.pendingUploads[id];
       const sizes = multimediaMessageContentSizes(
         messageInfo,
         this.props.composedMessageMaxWidth,
       );
       return {
         itemType: 'message',
         messageShapeType: 'multimedia',
         messageInfo,
         localMessageInfo,
         threadInfo,
         startsConversation: item.startsConversation,
         startsCluster: item.startsCluster,
         endsCluster: item.endsCluster,
         pendingUploads,
         ...sizes,
       };
     }
 
     invariant(height !== null && height !== undefined, 'height should be set');
     if (messageInfo.type === messageTypes.TEXT) {
       // Conditional due to Flow...
       const localMessageInfo = item.localMessageInfo
         ? item.localMessageInfo
         : null;
       return {
         itemType: 'message',
         messageShapeType: 'text',
         messageInfo,
         localMessageInfo,
         threadInfo,
         startsConversation: item.startsConversation,
         startsCluster: item.startsCluster,
         endsCluster: item.endsCluster,
         contentHeight: height,
       };
     } else {
       invariant(
         typeof item.robotext === 'string',
         "Flow can't handle our fancy types :(",
       );
       return {
         itemType: 'message',
         messageShapeType: 'robotext',
         messageInfo,
         threadInfo,
         startsConversation: item.startsConversation,
         startsCluster: item.startsCluster,
         endsCluster: item.endsCluster,
         robotext: item.robotext,
         contentHeight: height,
       };
     }
   };
 
   allHeightsMeasured = (
     listDataWithHeights: $ReadOnlyArray<ChatMessageItemWithHeight>,
   ) => {
     if (this.frozen) {
       this.pendingListDataWithHeights = listDataWithHeights;
     } else {
       this.setState({ listDataWithHeights });
     }
   };
 }
 
 const unboundStyles = {
   container: {
     backgroundColor: 'listBackground',
     flex: 1,
   },
 };
 
 export default React.memo<BaseProps>(function ConnectedMessageListContainer(
   props: BaseProps,
 ) {
-  const threadInfo = useSelector(
-    possiblyPendingThreadInfoSelector(props.route.params.threadInfo),
+  const viewerID = useSelector(
+    (state) => state.currentUserInfo && state.currentUserInfo.id,
   );
-  const threadID = threadInfo?.id ?? props.route.params.threadInfo.id;
+  const threadInfos = useSelector(threadInfoSelector);
+  const userInfos = useSelector((state) => state.userStore.userInfos);
+  const threadInfoRef = React.useRef(props.route.params.threadInfo);
+  const originalThreadInfoRef = React.useRef(props.route.params.threadInfo);
+  const originalThreadInfo = originalThreadInfoRef.current;
+
+  const latestThreadInfo = React.useMemo(() => {
+    const threadInfoFromParams = originalThreadInfo;
+    const threadInfoFromStore = threadInfos[threadInfoFromParams.id];
+
+    if (threadInfoFromStore) {
+      return threadInfoFromStore;
+    } else if (!viewerID || !threadIsPersonalAndPending(threadInfoFromParams)) {
+      return undefined;
+    }
+
+    const otherMemberID = getPendingPersonalThreadOtherUser(
+      threadInfoFromParams,
+    );
+    for (const threadID in threadInfos) {
+      const currentThreadInfo = threadInfos[threadID];
+      if (currentThreadInfo.type !== threadTypes.PERSONAL) {
+        continue;
+      }
+      invariant(
+        currentThreadInfo.members.length === 2,
+        'Personal thread should have exactly two members',
+      );
+      const members = new Set(
+        currentThreadInfo.members.map((member) => member.id),
+      );
+      if (members.has(viewerID) && members.has(otherMemberID)) {
+        return currentThreadInfo;
+      }
+    }
+
+    return {
+      ...threadInfoFromParams,
+      currentUser: getCurrentUser(threadInfoFromParams, viewerID, userInfos),
+    };
+  }, [threadInfos, userInfos, viewerID, originalThreadInfo]);
+
+  if (latestThreadInfo) {
+    threadInfoRef.current = latestThreadInfo;
+  }
+
+  const threadInfo = threadInfoRef.current;
+  const { setParams } = props.navigation;
+  React.useEffect(() => {
+    setParams({ threadInfo });
+  }, [setParams, threadInfo]);
+
+  const threadID = threadInfoRef.current.id;
   const boundMessageListData = useSelector(messageListData(threadID));
   const composedMessageMaxWidth = useSelector(composedMessageMaxWidthSelector);
   const colors = useColors();
   const styles = useStyles(unboundStyles);
   const inputState = React.useContext(InputStateContext);
   const overlayContext = React.useContext(OverlayContext);
   const messageListContext = useMessageListContext(threadID);
   return (
     <MessageListContext.Provider value={messageListContext}>
       <MessageListContainer
         {...props}
-        threadInfo={threadInfo}
+        threadInfo={threadInfoRef.current}
         messageListData={boundMessageListData}
         composedMessageMaxWidth={composedMessageMaxWidth}
         colors={colors}
         styles={styles}
         inputState={inputState}
         overlayContext={overlayContext}
       />
     </MessageListContext.Provider>
   );
 });