diff --git a/lib/selectors/thread-selectors.js b/lib/selectors/thread-selectors.js
index 387fa7ef9..cd87772e2 100644
--- a/lib/selectors/thread-selectors.js
+++ b/lib/selectors/thread-selectors.js
@@ -1,370 +1,376 @@
 // @flow
 
 import type { BaseAppState } from '../types/redux-types';
 import {
   type ThreadInfo,
   type RawThreadInfo,
   type RelativeMemberInfo,
   threadPermissions,
   threadTypes,
   type SidebarInfo,
 } from '../types/thread-types';
 import type { EntryInfo } from '../types/entry-types';
 import type { MessageStore, RawMessageInfo } from '../types/message-types';
 
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 import _flow from 'lodash/fp/flow';
 import _some from 'lodash/fp/some';
 import _mapValues from 'lodash/fp/mapValues';
 import _map from 'lodash/fp/map';
 import _compact from 'lodash/fp/compact';
 import _filter from 'lodash/fp/filter';
 import _sortBy from 'lodash/fp/sortBy';
 import _memoize from 'lodash/memoize';
 import _orderBy from 'lodash/fp/orderBy';
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 import invariant from 'invariant';
 
 import { dateString, dateFromString } from '../utils/date-utils';
 import { values } from '../utils/objects';
 import { createEntryInfo } from '../shared/entry-utils';
 import {
   threadInHomeChatList,
   threadInBackgroundChatList,
   threadInFilterList,
   threadInfoFromRawThreadInfo,
   threadHasPermission,
   threadInChatList,
   threadHasAdminRole,
   roleIsAdminRole,
 } from '../shared/thread-utils';
 import { relativeMemberInfoSelectorForMembersOfThread } from './user-selectors';
 import {
   filteredThreadIDsSelector,
   includeDeletedSelector,
 } from './calendar-filter-selectors';
 import { getMostRecentNonLocalMessageID } from '../shared/message-utils';
 
 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 otherMemberID = possiblyPendingThread.id.split('/')[1];
       invariant(
         otherMemberID,
         'Pending thread should contain other member id in its id',
       );
       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(otherMemberID)) {
           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 (let threadID in threadInfos) {
+  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) {
-      mostRecent = { threadID, time: mostRecentMessageTime };
+    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,
 };