diff --git a/lib/selectors/chat-selectors.js b/lib/selectors/chat-selectors.js
index 630c96fbb..a308251bf 100644
--- a/lib/selectors/chat-selectors.js
+++ b/lib/selectors/chat-selectors.js
@@ -1,461 +1,460 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter';
 import _flow from 'lodash/fp/flow';
 import _map from 'lodash/fp/map';
 import _orderBy from 'lodash/fp/orderBy';
 import * as React from 'react';
 import { useSelector } from 'react-redux';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import {
   messageKey,
   robotextForMessageInfo,
   createMessageInfo,
   getMostRecentNonLocalMessageID,
   sortMessageInfoList,
 } from '../shared/message-utils';
 import { threadIsTopLevel, threadInChatList } from '../shared/thread-utils';
 import {
   type MessageInfo,
   type MessageStore,
   type ComposableMessageInfo,
   type RobotextMessageInfo,
   type LocalMessageInfo,
   messageTypes,
   isComposableMessageType,
 } from '../types/message-types';
 import type { BaseAppState } from '../types/redux-types';
 import {
   type ThreadInfo,
   type RawThreadInfo,
   type SidebarInfo,
   maxReadSidebars,
   maxUnreadSidebars,
   threadTypes,
 } from '../types/thread-types';
 import type { UserInfo, AccountUserInfo } from '../types/user-types';
 import { threeDays } from '../utils/date-utils';
 import memoize2 from '../utils/memoize';
 import {
   threadInfoSelector,
   sidebarInfoSelector,
   threadInfoFromSourceMessageIDSelector,
 } from './thread-selectors';
 
 export type SidebarItem =
   | {|
       ...SidebarInfo,
       +type: 'sidebar',
     |}
   | {|
       +type: 'seeMore',
       +unread: boolean,
       +showingSidebarsInline: boolean,
     |};
 
 export type ChatThreadItem = {|
   +type: 'chatThreadItem',
   +threadInfo: ThreadInfo,
   +mostRecentMessageInfo: ?MessageInfo,
   +mostRecentNonLocalMessage: ?string,
   +lastUpdatedTime: number,
   +lastUpdatedTimeIncludingSidebars: number,
   +sidebars: $ReadOnlyArray<SidebarItem>,
   +pendingPersonalThreadUserInfo?: UserInfo,
 |};
 
 const messageInfoSelector: (
   state: BaseAppState<*>,
 ) => { [id: string]: MessageInfo } = createObjectSelector(
   (state: BaseAppState<*>) => state.messageStore.messages,
   (state: BaseAppState<*>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<*>) => state.userStore.userInfos,
   threadInfoSelector,
   createMessageInfo,
 );
 
 function getMostRecentMessageInfo(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { [id: string]: MessageInfo },
 ): ?MessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (const messageID of thread.messageIDs) {
     const messageInfo = messages[messageID];
     if (messageInfo) {
       return messageInfo;
     }
   }
   return null;
 }
 
 function getLastUpdatedTime(
   threadInfo: ThreadInfo,
   mostRecentMessageInfo: ?MessageInfo,
 ): number {
   return mostRecentMessageInfo
     ? mostRecentMessageInfo.time
     : threadInfo.creationTime;
 }
 
 function createChatThreadItem(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { [id: string]: MessageInfo },
   sidebarInfos: ?$ReadOnlyArray<SidebarInfo>,
 ): ChatThreadItem {
   const mostRecentMessageInfo = getMostRecentMessageInfo(
     threadInfo,
     messageStore,
     messages,
   );
   const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
     threadInfo.id,
     messageStore,
   );
   const lastUpdatedTime = getLastUpdatedTime(threadInfo, mostRecentMessageInfo);
 
   const sidebars = sidebarInfos ?? [];
   const allSidebarItems = sidebars.map((sidebarInfo) => ({
     type: 'sidebar',
     ...sidebarInfo,
   }));
   const lastUpdatedTimeIncludingSidebars =
     allSidebarItems.length > 0
       ? Math.max(lastUpdatedTime, allSidebarItems[0].lastUpdatedTime)
       : lastUpdatedTime;
 
   const numUnreadSidebars = allSidebarItems.filter(
     (sidebar) => sidebar.threadInfo.currentUser.unread,
   ).length;
   let numReadSidebarsToShow = maxReadSidebars - numUnreadSidebars;
   const threeDaysAgo = Date.now() - threeDays;
 
   const sidebarItems = [];
   for (const sidebar of allSidebarItems) {
     if (sidebarItems.length >= maxUnreadSidebars) {
       break;
     } else if (sidebar.threadInfo.currentUser.unread) {
       sidebarItems.push(sidebar);
     } else if (
       sidebar.lastUpdatedTime > threeDaysAgo &&
       numReadSidebarsToShow > 0
     ) {
       sidebarItems.push(sidebar);
       numReadSidebarsToShow--;
     }
   }
 
   if (sidebarItems.length < allSidebarItems.length) {
     sidebarItems.push({
       type: 'seeMore',
       unread: numUnreadSidebars > maxUnreadSidebars,
       showingSidebarsInline: sidebarItems.length !== 0,
     });
   }
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo,
     mostRecentNonLocalMessage,
     lastUpdatedTime,
     lastUpdatedTimeIncludingSidebars,
     sidebars: sidebarItems,
   };
 }
 
 const chatListData: (
   state: BaseAppState<*>,
 ) => $ReadOnlyArray<ChatThreadItem> = createSelector(
   threadInfoSelector,
   (state: BaseAppState<*>) => state.messageStore,
   messageInfoSelector,
   sidebarInfoSelector,
   (
     threadInfos: { [id: string]: ThreadInfo },
     messageStore: MessageStore,
     messageInfos: { [id: string]: MessageInfo },
     sidebarInfos: { [id: string]: $ReadOnlyArray<SidebarInfo> },
   ): $ReadOnlyArray<ChatThreadItem> =>
     getChatThreadItems(
       threadInfos,
       messageStore,
       messageInfos,
       sidebarInfos,
       threadIsTopLevel,
     ),
 );
 
 function useFlattenedChatListData(): $ReadOnlyArray<ChatThreadItem> {
   const threadInfos = useSelector(threadInfoSelector);
   const messageInfos = useSelector(messageInfoSelector);
   const sidebarInfos = useSelector(sidebarInfoSelector);
   const messageStore = useSelector((state) => state.messageStore);
 
   return React.useMemo(
     () =>
       getChatThreadItems(
         threadInfos,
         messageStore,
         messageInfos,
         sidebarInfos,
         threadInChatList,
       ),
     [messageInfos, messageStore, sidebarInfos, threadInfos],
   );
 }
 
 function getChatThreadItems(
   threadInfos: { [id: string]: ThreadInfo },
   messageStore: MessageStore,
   messageInfos: { [id: string]: MessageInfo },
   sidebarInfos: { [id: string]: $ReadOnlyArray<SidebarInfo> },
   filterFunction: (threadInfo: ?(ThreadInfo | RawThreadInfo)) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   return _flow(
     _filter(filterFunction),
     _map((threadInfo: ThreadInfo): ChatThreadItem =>
       createChatThreadItem(
         threadInfo,
         messageStore,
         messageInfos,
         sidebarInfos[threadInfo.id],
       ),
     ),
     _orderBy('lastUpdatedTimeIncludingSidebars')('desc'),
   )(threadInfos);
 }
 
 export type RobotextChatMessageInfoItem = {|
   +itemType: 'message',
   +messageInfo: RobotextMessageInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   endsCluster: boolean,
   +robotext: string,
   +threadCreatedFromMessage: ?ThreadInfo,
 |};
 export type ChatMessageInfoItem =
   | RobotextChatMessageInfoItem
   | {|
       +itemType: 'message',
       +messageInfo: ComposableMessageInfo,
       +localMessageInfo: ?LocalMessageInfo,
       +startsConversation: boolean,
       +startsCluster: boolean,
       endsCluster: boolean,
       +threadCreatedFromMessage: ?ThreadInfo,
     |};
 export type ChatMessageItem = {| itemType: 'loader' |} | ChatMessageInfoItem;
 const msInFiveMinutes = 5 * 60 * 1000;
 function createChatMessageItems(
   threadID: string,
   messageStore: MessageStore,
   messageInfos: { [id: string]: MessageInfo },
   threadInfos: { [id: string]: ThreadInfo },
   threadInfoFromSourceMessageID: { [id: string]: ThreadInfo },
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ): ChatMessageItem[] {
   const thread = messageStore.threads[threadID];
 
   const threadMessageInfos = (thread?.messageIDs ?? [])
     .map((messageID: string) => messageInfos[messageID])
     .filter(Boolean);
   const messages =
     additionalMessages.length > 0
       ? sortMessageInfoList([...threadMessageInfos, ...additionalMessages])
       : threadMessageInfos;
   if (messages.length === 0) {
     return [];
   }
 
   const chatMessageItems = [];
   let lastMessageInfo = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     const originalMessageInfo =
       messageInfo.type === messageTypes.SIDEBAR_SOURCE
         ? messageInfo.sourceMessage
         : messageInfo;
     let startsConversation = true;
     let startsCluster = true;
     if (
       lastMessageInfo &&
       lastMessageInfo.time + msInFiveMinutes > originalMessageInfo.time
     ) {
       startsConversation = false;
       if (
         isComposableMessageType(lastMessageInfo.type) &&
         isComposableMessageType(originalMessageInfo.type) &&
         lastMessageInfo.creator.id === originalMessageInfo.creator.id
       ) {
         startsCluster = false;
       }
     }
     if (startsCluster && chatMessageItems.length > 0) {
       const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
       invariant(lastMessageItem.itemType === 'message', 'should be message');
       lastMessageItem.endsCluster = true;
     }
     const threadCreatedFromMessage =
       messageInfo.id && threadInfos[threadID]?.type !== threadTypes.SIDEBAR
         ? threadInfoFromSourceMessageID[messageInfo.id]
         : undefined;
     if (isComposableMessageType(originalMessageInfo.type)) {
       // We use these invariants instead of just checking the messageInfo.type
       // directly in the conditional above so that isComposableMessageType can
       // be the source of truth
       invariant(
         originalMessageInfo.type === messageTypes.TEXT ||
           originalMessageInfo.type === messageTypes.IMAGES ||
           originalMessageInfo.type === messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const localMessageInfo =
         messageStore.local[messageKey(originalMessageInfo)];
       chatMessageItems.push({
         itemType: 'message',
         messageInfo: originalMessageInfo,
         localMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
       });
     } else {
       invariant(
         originalMessageInfo.type !== messageTypes.TEXT &&
           originalMessageInfo.type !== messageTypes.IMAGES &&
           originalMessageInfo.type !== messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const robotext = robotextForMessageInfo(
         originalMessageInfo,
         threadInfos[threadID],
       );
       chatMessageItems.push({
         itemType: 'message',
         messageInfo: originalMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         robotext,
       });
     }
     lastMessageInfo = originalMessageInfo;
   }
   if (chatMessageItems.length > 0) {
     const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
     invariant(lastMessageItem.itemType === 'message', 'should be message');
     lastMessageItem.endsCluster = true;
   }
   chatMessageItems.reverse();
   if (thread?.startReached ?? true) {
     return chatMessageItems;
   }
   return [...chatMessageItems, ({ itemType: 'loader' }: ChatMessageItem)];
 }
 
 const baseMessageListData = (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) =>
   createSelector(
     (state: BaseAppState<*>) => state.messageStore,
     messageInfoSelector,
     threadInfoSelector,
     threadInfoFromSourceMessageIDSelector,
     (
       messageStore: MessageStore,
       messageInfos: { [id: string]: MessageInfo },
       threadInfos: { [id: string]: ThreadInfo },
       threadInfoFromSourceMessageID: { [id: string]: ThreadInfo },
     ): ?(ChatMessageItem[]) => {
       if (!threadID) {
         return null;
       }
       return createChatMessageItems(
         threadID,
         messageStore,
         messageInfos,
         threadInfos,
         threadInfoFromSourceMessageID,
         additionalMessages,
       );
     },
   );
 const messageListData: (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) => (state: BaseAppState<*>) => ?(ChatMessageItem[]) = memoize2(
   baseMessageListData,
 );
 
 type UseMessageListDataArgs = {|
-  +sourceMessageID: ?string,
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +threadInfo: ?ThreadInfo,
 |};
 
 function useMessageListData({
-  sourceMessageID,
   searching,
   userInfoInputArray,
   threadInfo,
 }: UseMessageListDataArgs) {
   const pendingSidebarSourceMessageInfo = useSelector((state) => {
+    const sourceMessageID = threadInfo?.sourceMessageID;
     if (threadInfo?.type !== threadTypes.SIDEBAR || !sourceMessageID) {
       return null;
     }
     const thread = threadInfo && state.messageStore.threads[threadInfo.id];
     const messageInfos = messageInfoSelector(state);
     const shouldSourceBeAdded =
       !thread ||
       (thread.startReached &&
         thread.messageIDs.every(
           (id) => messageInfos[id]?.type !== messageTypes.SIDEBAR_SOURCE,
         ));
     return shouldSourceBeAdded ? messageInfos[sourceMessageID] : null;
   });
 
   invariant(
     !pendingSidebarSourceMessageInfo ||
       pendingSidebarSourceMessageInfo.type !== messageTypes.SIDEBAR_SOURCE,
     'sidebars can not be created from sidebar_source message',
   );
 
   const additionalMessages = React.useMemo(
     () =>
       pendingSidebarSourceMessageInfo ? [pendingSidebarSourceMessageInfo] : [],
     [pendingSidebarSourceMessageInfo],
   );
   const boundMessageListData = useSelector(
     messageListData(threadInfo?.id, additionalMessages),
   );
 
   return React.useMemo(() => {
     if (searching && userInfoInputArray.length === 0) {
       return [];
     }
     return boundMessageListData;
   }, [searching, userInfoInputArray.length, boundMessageListData]);
 }
 
 export {
   messageInfoSelector,
   createChatThreadItem,
   chatListData,
   createChatMessageItems,
   messageListData,
   useFlattenedChatListData,
   useMessageListData,
 };
diff --git a/native/chat/message-list-container.react.js b/native/chat/message-list-container.react.js
index 574bbb258..7d9bf237c 100644
--- a/native/chat/message-list-container.react.js
+++ b/native/chat/message-list-container.react.js
@@ -1,404 +1,403 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import {
   type ChatMessageItem,
   useMessageListData,
 } from 'lib/selectors/chat-selectors';
 import {
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
 } from 'lib/selectors/user-selectors';
 import { messageID } from 'lib/shared/message-utils';
 import { getPotentialMemberItems } from 'lib/shared/search-utils';
 import { useCurrentThreadInfo } from 'lib/shared/thread-utils';
 import { messageTypes } from 'lib/types/message-types';
 import type { ThreadInfo } from 'lib/types/thread-types';
 import type { AccountUserInfo, UserListItem } from 'lib/types/user-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 { dummyNodeForRobotextMessageHeightMeasurement } from './inner-robotext-message.react';
 import { dummyNodeForTextMessageHeightMeasurement } from './inner-text-message.react';
 import MessageListThreadSearch from './message-list-thread-search.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';
 export type ChatMessageItemWithHeight =
   | {| itemType: 'loader' |}
   | ChatMessageInfoItemWithHeight;
 
 type BaseProps = {|
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 |};
 type Props = {|
   ...BaseProps,
   // Redux state
   +usernameInputText: string,
   +updateUsernameInput: (text: string) => void,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +updateTagInput: (items: $ReadOnlyArray<AccountUserInfo>) => void,
   +otherUserInfos: { [id: string]: AccountUserInfo },
   +userSearchResults: $ReadOnlyArray<UserListItem>,
   +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>;
 
   get frozen() {
     const { overlayContext } = this.props;
     invariant(
       overlayContext,
       'MessageListContainer should have OverlayContext',
     );
     return overlayContext.scrollBlockingModalStatus !== 'closed';
   }
 
   componentDidUpdate(prevProps: Props) {
     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, styles } = this.props;
     const { listDataWithHeights } = this.state;
     const { searching } = this.props.route.params;
 
     let searchComponent = null;
     if (searching) {
       searchComponent = (
         <MessageListThreadSearch
           usernameInputText={this.props.usernameInputText}
           updateUsernameInput={this.props.updateUsernameInput}
           userInfoInputArray={this.props.userInfoInputArray}
           updateTagInput={this.props.updateTagInput}
           otherUserInfos={this.props.otherUserInfos}
           userSearchResults={this.props.userSearchResults}
         />
       );
     }
 
     const showMessageList =
       !searching || this.props.userInfoInputArray.length > 0;
     let threadContent = null;
     if (showMessageList) {
       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} />
         );
       }
 
       threadContent = (
         <View style={styles.threadContent}>
           {messageList}
           <ChatInputBar
             threadInfo={threadInfo}
             navigation={this.props.navigation}
             route={this.props.route}
           />
         </View>
       );
     }
 
     return (
       <View style={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}
         />
         {searchComponent}
         {threadContent}
       </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;
     invariant(
       messageInfo.type !== messageTypes.SIDEBAR_SOURCE,
       'Sidebar source messages should be replaced by sourceMessage before being measured',
     );
     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,
         threadCreatedFromMessage: item.threadCreatedFromMessage,
         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,
         threadCreatedFromMessage: item.threadCreatedFromMessage,
         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,
         threadCreatedFromMessage: item.threadCreatedFromMessage,
         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,
   },
   threadContent: {
     flex: 1,
   },
 };
 
 export default React.memo<BaseProps>(function ConnectedMessageListContainer(
   props: BaseProps,
 ) {
   const [usernameInputText, setUsernameInputText] = React.useState('');
   const [userInfoInputArray, setUserInfoInputArray] = React.useState<
     $ReadOnlyArray<AccountUserInfo>,
   >([]);
   const updateTagInput = React.useCallback(
     (input: $ReadOnlyArray<AccountUserInfo>) => setUserInfoInputArray(input),
     [],
   );
   const updateUsernameInput = React.useCallback(
     (text: string) => setUsernameInputText(text),
     [],
   );
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
 
   const userSearchResults = React.useMemo(
     () =>
       getPotentialMemberItems(
         usernameInputText,
         otherUserInfos,
         userSearchIndex,
         userInfoInputArray.map((userInfo) => userInfo.id),
       ),
     [usernameInputText, otherUserInfos, userSearchIndex, userInfoInputArray],
   );
 
   const [baseThreadInfo, setBaseThreadInfo] = React.useState(
     props.route.params.threadInfo,
   );
 
-  const { searching, sourceMessageID } = props.route.params;
+  const { searching } = props.route.params;
   const threadInfo = useCurrentThreadInfo({
     baseThreadInfo,
     searching: !!searching,
     userInfoInputArray,
   });
   invariant(threadInfo, 'threadInfo must be specified in messageListContainer');
 
   const inputState = React.useContext(InputStateContext);
   const hideSearch = React.useCallback(() => {
     setBaseThreadInfo(threadInfo);
     props.navigation.setParams({
       searching: false,
     });
   }, [props.navigation, threadInfo]);
   React.useEffect(() => {
     if (!searching) {
       return;
     }
     inputState?.registerSendCallback(hideSearch);
     return () => inputState?.unregisterSendCallback(hideSearch);
   }, [hideSearch, inputState, searching]);
 
   const { setParams } = props.navigation;
   React.useEffect(() => {
     setParams({ threadInfo });
   }, [setParams, threadInfo]);
 
   const threadID = threadInfo.id;
   const messageListData = useMessageListData({
-    sourceMessageID,
     searching: !!searching,
     userInfoInputArray,
     threadInfo,
   });
   invariant(
     messageListData,
     'messageListData must be specified in messageListContainer',
   );
   const composedMessageMaxWidth = useSelector(composedMessageMaxWidthSelector);
   const colors = useColors();
   const styles = useStyles(unboundStyles);
   const overlayContext = React.useContext(OverlayContext);
   const messageListContext = useMessageListContext(threadID);
   return (
     <MessageListContext.Provider value={messageListContext}>
       <MessageListContainer
         {...props}
         usernameInputText={usernameInputText}
         updateUsernameInput={updateUsernameInput}
         userInfoInputArray={userInfoInputArray}
         updateTagInput={updateTagInput}
         otherUserInfos={otherUserInfos}
         userSearchResults={userSearchResults}
         threadInfo={threadInfo}
         messageListData={messageListData}
         composedMessageMaxWidth={composedMessageMaxWidth}
         colors={colors}
         styles={styles}
         inputState={inputState}
         overlayContext={overlayContext}
       />
     </MessageListContext.Provider>
   );
 });
diff --git a/web/chat/chat-message-list.react.js b/web/chat/chat-message-list.react.js
index 6e53e1554..57605926d 100644
--- a/web/chat/chat-message-list.react.js
+++ b/web/chat/chat-message-list.react.js
@@ -1,475 +1,473 @@
 // @flow
 
 import classNames from 'classnames';
 import { detect as detectBrowser } from 'detect-browser';
 import invariant from 'invariant';
 import * as React from 'react';
 import { useDrop } from 'react-dnd';
 import { NativeTypes } from 'react-dnd-html5-backend';
 
 import {
   fetchMessagesBeforeCursorActionTypes,
   fetchMessagesBeforeCursor,
   fetchMostRecentMessagesActionTypes,
 } from 'lib/actions/message-actions';
 import { registerFetchKey } from 'lib/reducers/loading-reducer';
 import {
   type ChatMessageItem,
   useMessageListData,
 } from 'lib/selectors/chat-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { messageKey } from 'lib/shared/message-utils';
 import { useWatchThread, useCurrentThreadInfo } from 'lib/shared/thread-utils';
 import type { FetchMessageInfosPayload } from 'lib/types/message-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import { type InputState, InputStateContext } from '../input/input-state';
 import LoadingIndicator from '../loading-indicator.react';
 import { useTextMessageRulesFunc } from '../markdown/rules.react';
 import { useSelector } from '../redux/redux-utils';
 import ChatInputBar from './chat-input-bar.react';
 import css from './chat-message-list.css';
 import { MessageListContext } from './message-list-types';
 import MessageTimestampTooltip from './message-timestamp-tooltip.react';
 import Message from './message.react';
 import type {
   OnMessagePositionWithContainerInfo,
   MessagePositionInfo,
 } from './position-types';
 
 type BaseProps = {|
   +setModal: (modal: ?React.Node) => void,
 |};
 type PassedProps = {|
   ...BaseProps,
   // Redux state
   +activeChatThreadID: ?string,
   +threadInfo: ?ThreadInfo,
   +messageListData: ?$ReadOnlyArray<ChatMessageItem>,
   +startReached: boolean,
   +timeZone: ?string,
   +supportsReverseFlex: boolean,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +fetchMessagesBeforeCursor: (
     threadID: string,
     beforeMessageID: string,
   ) => Promise<FetchMessageInfosPayload>,
   // withInputState
   +inputState: ?InputState,
 |};
 type ReactDnDProps = {|
   isActive: boolean,
   connectDropTarget: (node: React.Node) => React.Node,
 |};
 type Props = {|
   ...PassedProps,
   ...ReactDnDProps,
 |};
 type State = {|
   +mouseOverMessagePosition: ?OnMessagePositionWithContainerInfo,
 |};
 type Snapshot = {|
   +scrollTop: number,
   +scrollHeight: number,
 |};
 class ChatMessageList extends React.PureComponent<Props, State> {
   state: State = {
     mouseOverMessagePosition: null,
   };
   container: ?HTMLDivElement;
   messageContainer: ?HTMLDivElement;
   loadingFromScroll = false;
 
   componentDidMount() {
     this.scrollToBottom();
   }
 
   getSnapshotBeforeUpdate(prevProps: Props) {
     if (
       ChatMessageList.hasNewMessage(this.props, prevProps) &&
       this.messageContainer
     ) {
       const { scrollTop, scrollHeight } = this.messageContainer;
       return { scrollTop, scrollHeight };
     }
     return null;
   }
 
   static hasNewMessage(props: Props, prevProps: Props) {
     const { messageListData } = props;
     if (!messageListData || messageListData.length === 0) {
       return false;
     }
     const prevMessageListData = prevProps.messageListData;
     if (!prevMessageListData || prevMessageListData.length === 0) {
       return true;
     }
     return (
       ChatMessageList.keyExtractor(prevMessageListData[0]) !==
       ChatMessageList.keyExtractor(messageListData[0])
     );
   }
 
   componentDidUpdate(prevProps: Props, prevState: State, snapshot: ?Snapshot) {
     const { messageListData } = this.props;
     const prevMessageListData = prevProps.messageListData;
 
     if (
       this.loadingFromScroll &&
       messageListData &&
       (!prevMessageListData ||
         messageListData.length > prevMessageListData.length ||
         this.props.startReached)
     ) {
       this.loadingFromScroll = false;
     }
 
     const { messageContainer } = this;
     if (messageContainer && prevMessageListData !== messageListData) {
       this.onScroll();
     }
 
     // We'll scroll to the bottom if the user was already scrolled to the bottom
     // before the new message, or if the new message was composed locally
     const hasNewMessage = ChatMessageList.hasNewMessage(this.props, prevProps);
     if (
       this.props.activeChatThreadID !== prevProps.activeChatThreadID ||
       (hasNewMessage &&
         messageListData &&
         messageListData[0].itemType === 'message' &&
         messageListData[0].messageInfo.localID) ||
       (hasNewMessage && snapshot && Math.abs(snapshot.scrollTop) <= 1)
     ) {
       this.scrollToBottom();
     } else if (hasNewMessage && messageContainer && snapshot) {
       const { scrollTop, scrollHeight } = messageContainer;
       if (
         scrollHeight > snapshot.scrollHeight &&
         scrollTop === snapshot.scrollTop
       ) {
         const newHeight = scrollHeight - snapshot.scrollHeight;
         const newScrollTop = Math.abs(scrollTop) + newHeight;
         if (this.props.supportsReverseFlex) {
           messageContainer.scrollTop = -1 * newScrollTop;
         } else {
           messageContainer.scrollTop = newScrollTop;
         }
       }
     }
   }
 
   scrollToBottom() {
     if (this.messageContainer) {
       this.messageContainer.scrollTop = 0;
     }
   }
 
   static keyExtractor(item: ChatMessageItem) {
     if (item.itemType === 'loader') {
       return 'loader';
     }
     return messageKey(item.messageInfo);
   }
 
   renderItem = (item) => {
     if (item.itemType === 'loader') {
       return (
         <div key="loader" className={css.loading}>
           <LoadingIndicator status="loading" size="large" color="black" />
         </div>
       );
     }
     const { threadInfo, setModal } = this.props;
     invariant(threadInfo, 'ThreadInfo should be set if messageListData is');
     return (
       <Message
         item={item}
         threadInfo={threadInfo}
         setMouseOverMessagePosition={this.setMouseOverMessagePosition}
         mouseOverMessagePosition={this.state.mouseOverMessagePosition}
         setModal={setModal}
         timeZone={this.props.timeZone}
         key={ChatMessageList.keyExtractor(item)}
       />
     );
   };
 
   setMouseOverMessagePosition = (messagePositionInfo: MessagePositionInfo) => {
     if (!this.messageContainer) {
       return;
     }
     if (messagePositionInfo.type === 'off') {
       this.setState({ mouseOverMessagePosition: null });
       return;
     }
     const {
       top: containerTop,
       bottom: containerBottom,
       left: containerLeft,
       right: containerRight,
       height: containerHeight,
       width: containerWidth,
     } = this.messageContainer.getBoundingClientRect();
     const mouseOverMessagePosition = {
       ...messagePositionInfo,
       messagePosition: {
         ...messagePositionInfo.messagePosition,
         top: messagePositionInfo.messagePosition.top - containerTop,
         bottom: messagePositionInfo.messagePosition.bottom - containerTop,
         left: messagePositionInfo.messagePosition.left - containerLeft,
         right: messagePositionInfo.messagePosition.right - containerLeft,
       },
       containerPosition: {
         top: containerTop,
         bottom: containerBottom,
         left: containerLeft,
         right: containerRight,
         height: containerHeight,
         width: containerWidth,
       },
     };
     this.setState({ mouseOverMessagePosition });
   };
 
   render() {
     const {
       messageListData,
       threadInfo,
       inputState,
       connectDropTarget,
       isActive,
     } = this.props;
     if (!messageListData) {
       return <div className={css.container} />;
     }
     invariant(threadInfo, 'ThreadInfo should be set if messageListData is');
     invariant(inputState, 'InputState should be set');
     const messages = messageListData.map(this.renderItem);
     const containerStyle = classNames({
       [css.container]: true,
       [css.activeContainer]: isActive,
     });
 
     let tooltip;
     if (this.state.mouseOverMessagePosition) {
       const messagePositionInfo = this.state.mouseOverMessagePosition;
       tooltip = (
         <MessageTimestampTooltip
           messagePositionInfo={messagePositionInfo}
           timeZone={this.props.timeZone}
         />
       );
     }
 
     const messageContainerStyle = classNames({
       [css.messageContainer]: true,
       [css.mirroredMessageContainer]: !this.props.supportsReverseFlex,
     });
     return connectDropTarget(
       <div className={containerStyle} ref={this.containerRef}>
         <div className={css.outerMessageContainer}>
           <div className={messageContainerStyle} ref={this.messageContainerRef}>
             {messages}
           </div>
           {tooltip}
         </div>
         <ChatInputBar threadInfo={threadInfo} inputState={inputState} />
       </div>,
     );
   }
 
   containerRef = (container: ?HTMLDivElement) => {
     if (container) {
       container.addEventListener('paste', this.onPaste);
     }
     this.container = container;
   };
 
   onPaste = (e: ClipboardEvent) => {
     const { inputState } = this.props;
     if (!inputState) {
       return;
     }
     const { clipboardData } = e;
     if (!clipboardData) {
       return;
     }
     const { files } = clipboardData;
     if (files.length === 0) {
       return;
     }
     e.preventDefault();
     inputState.appendFiles([...files]);
   };
 
   messageContainerRef = (messageContainer: ?HTMLDivElement) => {
     this.messageContainer = messageContainer;
     // In case we already have all the most recent messages,
     // but they're not enough
     this.possiblyLoadMoreMessages();
     if (messageContainer) {
       messageContainer.addEventListener('scroll', this.onScroll);
     }
   };
 
   onScroll = () => {
     if (!this.messageContainer) {
       return;
     }
     if (this.state.mouseOverMessagePosition) {
       this.setState({ mouseOverMessagePosition: null });
     }
     this.possiblyLoadMoreMessages();
   };
 
   possiblyLoadMoreMessages() {
     if (!this.messageContainer) {
       return;
     }
     const { scrollTop, scrollHeight, clientHeight } = this.messageContainer;
     if (
       this.props.startReached ||
       Math.abs(scrollTop) + clientHeight + 55 < scrollHeight
     ) {
       return;
     }
     const oldestMessageServerID = this.oldestMessageServerID();
     if (!oldestMessageServerID) {
       return;
     }
     if (this.loadingFromScroll) {
       return;
     }
     this.loadingFromScroll = true;
     const threadID = this.props.activeChatThreadID;
     invariant(threadID, 'should be set');
     this.props.dispatchActionPromise(
       fetchMessagesBeforeCursorActionTypes,
       this.props.fetchMessagesBeforeCursor(threadID, oldestMessageServerID),
     );
   }
 
   oldestMessageServerID(): ?string {
     const data = this.props.messageListData;
     invariant(data, 'should be set');
     for (let i = data.length - 1; i >= 0; i--) {
       if (data[i].itemType === 'message' && data[i].messageInfo.id) {
         return data[i].messageInfo.id;
       }
     }
     return null;
   }
 }
 
 registerFetchKey(fetchMessagesBeforeCursorActionTypes);
 registerFetchKey(fetchMostRecentMessagesActionTypes);
 
 export default React.memo<BaseProps>(function ConnectedChatMessageList(
   props: BaseProps,
 ) {
   const userAgent = useSelector((state) => state.userAgent);
   const supportsReverseFlex = React.useMemo(() => {
     const browser = detectBrowser(userAgent);
     return (
       !browser || browser.name !== 'firefox' || parseInt(browser.version) >= 81
     );
   }, [userAgent]);
 
   const timeZone = useSelector((state) => state.timeZone);
 
   const activeChatThreadID = useSelector(
     (state) => state.navInfo.activeChatThreadID,
   );
   const baseThreadInfo = useSelector((state) => {
     const activeID = state.navInfo.activeChatThreadID;
     if (!activeID) {
       return null;
     }
     return threadInfoSelector(state)[activeID] ?? state.navInfo.pendingThread;
   });
-  const sourceMessageID = useSelector((state) => state.navInfo.sourceMessageID);
   const threadInfo = useCurrentThreadInfo({
     baseThreadInfo,
     searching: false,
     userInfoInputArray: [],
   });
 
   const messageListData = useMessageListData({
-    sourceMessageID,
+    threadInfo,
     searching: false,
     userInfoInputArray: [],
-    threadInfo,
   });
 
   const startReached = useSelector((state) => {
     const activeID = state.navInfo.activeChatThreadID;
     if (!activeID) {
       return null;
     }
 
     if (state.navInfo.pendingThread) {
       return true;
     }
 
     const threadMessageInfo = state.messageStore.threads[activeID];
     if (!threadMessageInfo) {
       return null;
     }
     return threadMessageInfo.startReached;
   });
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callFetchMessagesBeforeCursor = useServerCall(
     fetchMessagesBeforeCursor,
   );
 
   const inputState = React.useContext(InputStateContext);
   const [dndProps, connectDropTarget] = useDrop({
     accept: NativeTypes.FILE,
     drop: (item) => {
       const { files } = item;
       if (inputState && files.length > 0) {
         inputState.appendFiles(files);
       }
     },
     collect: (monitor) => ({
       isActive: monitor.isOver() && monitor.canDrop(),
     }),
   });
 
   const getTextMessageMarkdownRules = useTextMessageRulesFunc(threadInfo?.id);
   const messageListContext = React.useMemo(() => {
     if (!getTextMessageMarkdownRules) {
       return undefined;
     }
     return { getTextMessageMarkdownRules };
   }, [getTextMessageMarkdownRules]);
 
   useWatchThread(threadInfo);
 
   return (
     <MessageListContext.Provider value={messageListContext}>
       <ChatMessageList
         {...props}
         activeChatThreadID={activeChatThreadID}
         threadInfo={threadInfo}
         messageListData={messageListData}
         startReached={startReached}
         timeZone={timeZone}
         supportsReverseFlex={supportsReverseFlex}
         inputState={inputState}
         dispatchActionPromise={dispatchActionPromise}
         fetchMessagesBeforeCursor={callFetchMessagesBeforeCursor}
         {...dndProps}
         connectDropTarget={connectDropTarget}
       />
     </MessageListContext.Provider>
   );
 });