diff --git a/native/chat/multimedia-message-tooltip-modal.react.js b/native/chat/multimedia-message-tooltip-modal.react.js
index 7da06ecc8..532cfb811 100644
--- a/native/chat/multimedia-message-tooltip-modal.react.js
+++ b/native/chat/multimedia-message-tooltip-modal.react.js
@@ -1,48 +1,43 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   createTooltip,
   type TooltipParams,
   type BaseTooltipProps,
 } from '../navigation/tooltip.react';
 import type { ChatMultimediaMessageInfoItem } from '../types/chat-types';
 import type { VerticalBounds } from '../types/layout-types';
 import { onPressReport } from './message-report-utils';
 import MultimediaMessageTooltipButton from './multimedia-message-tooltip-button.react';
 import { navigateToSidebar } from './sidebar-navigation';
 
 export type MultimediaMessageTooltipModalParams = TooltipParams<{
   +item: ChatMultimediaMessageInfoItem,
   +verticalBounds: VerticalBounds,
 }>;
 
 const spec = {
   entries: [
     {
-      id: 'create_sidebar',
-      text: 'Create thread',
-      onPress: navigateToSidebar,
-    },
-    {
-      id: 'open_sidebar',
-      text: 'Go to thread',
+      id: 'sidebar',
+      text: 'Thread',
       onPress: navigateToSidebar,
     },
     {
       id: 'report',
       text: 'Report',
       onPress: onPressReport,
     },
   ],
 };
 
 const MultimediaMessageTooltipModal: React.ComponentType<
   BaseTooltipProps<'MultimediaMessageTooltipModal'>,
 > = createTooltip<'MultimediaMessageTooltipModal'>(
   MultimediaMessageTooltipButton,
   spec,
 );
 
 export default MultimediaMessageTooltipModal;
diff --git a/native/chat/multimedia-message.react.js b/native/chat/multimedia-message.react.js
index 78add0cca..855085947 100644
--- a/native/chat/multimedia-message.react.js
+++ b/native/chat/multimedia-message.react.js
@@ -1,238 +1,239 @@
 // @flow
 
 import type {
   LeafRoute,
   NavigationProp,
   ParamListBase,
 } from '@react-navigation/native';
 import { useNavigation, useRoute } from '@react-navigation/native';
 import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
 import { messageKey } from 'lib/shared/message-utils';
 import { useCanCreateSidebarFromMessage } from 'lib/shared/thread-utils';
 import type { MediaInfo } from 'lib/types/media-types';
 
 import { OverlayContext } from '../navigation/overlay-context';
 import type { OverlayContextType } from '../navigation/overlay-context';
 import {
   ImageModalRouteName,
   MultimediaMessageTooltipModalRouteName,
   VideoPlaybackModalRouteName,
 } from '../navigation/route-names';
 import { fixedTooltipHeight } from '../navigation/tooltip.react';
 import type { ChatMultimediaMessageInfoItem } from '../types/chat-types';
 import { type VerticalBounds } from '../types/layout-types';
 import type { LayoutCoordinates } from '../types/layout-types';
 import ComposedMessage from './composed-message.react';
 import { InnerMultimediaMessage } from './inner-multimedia-message.react';
 import {
   getMediaKey,
   multimediaMessageSendFailed,
 } from './multimedia-message-utils';
 import { getMessageTooltipKey } from './utils';
 
 type BaseProps = {
   ...React.ElementConfig<typeof View>,
   +item: ChatMultimediaMessageInfoItem,
   +focused: boolean,
   +toggleFocus: (messageKey: string) => void,
   +verticalBounds: ?VerticalBounds,
 };
 type Props = {
   ...BaseProps,
   +navigation: NavigationProp<ParamListBase>,
   +route: LeafRoute<>,
   +overlayContext: ?OverlayContextType,
   +canCreateSidebarFromMessage: boolean,
 };
 type State = {
   +clickable: boolean,
 };
 class MultimediaMessage extends React.PureComponent<Props, State> {
   state: State = {
     clickable: true,
   };
   view: ?React.ElementRef<typeof View>;
 
   setClickable = (clickable: boolean) => {
     this.setState({ clickable });
   };
 
   onPressMultimedia = (
     mediaInfo: MediaInfo,
     initialCoordinates: LayoutCoordinates,
   ) => {
     const { navigation, item, route, verticalBounds } = this.props;
     navigation.navigate<'VideoPlaybackModal' | 'ImageModal'>({
       name:
         mediaInfo.type === 'video'
           ? VideoPlaybackModalRouteName
           : ImageModalRouteName,
       key: getMediaKey(item, mediaInfo),
       params: {
         presentedFrom: route.key,
         mediaInfo,
         item,
         initialCoordinates,
         verticalBounds,
       },
     });
   };
 
   visibleEntryIDs() {
     const result = [];
 
-    if (this.props.item.threadCreatedFromMessage) {
-      result.push('open_sidebar');
-    } else if (this.props.canCreateSidebarFromMessage) {
-      result.push('create_sidebar');
+    if (
+      this.props.item.threadCreatedFromMessage ||
+      this.props.canCreateSidebarFromMessage
+    ) {
+      result.push('sidebar');
     }
 
     if (!this.props.item.messageInfo.creator.isViewer) {
       result.push('report');
     }
 
     return result;
   }
 
   onLayout = () => {};
 
   viewRef = (view: ?React.ElementRef<typeof View>) => {
     this.view = view;
   };
 
   onLongPress = () => {
     const visibleEntryIDs = this.visibleEntryIDs();
     if (visibleEntryIDs.length === 0) {
       return;
     }
 
     const {
       view,
       props: { verticalBounds },
     } = this;
     if (!view || !verticalBounds) {
       return;
     }
 
     if (!this.state.clickable) {
       return;
     }
     this.setClickable(false);
 
     const { item } = this.props;
     if (!this.props.focused) {
       this.props.toggleFocus(messageKey(item.messageInfo));
     }
 
     this.props.overlayContext?.setScrollBlockingModalStatus('open');
 
     view.measure((x, y, width, height, pageX, pageY) => {
       const coordinates = { x: pageX, y: pageY, width, height };
 
       const multimediaTop = pageY;
       const multimediaBottom = pageY + height;
       const boundsTop = verticalBounds.y;
       const boundsBottom = verticalBounds.y + verticalBounds.height;
 
       const belowMargin = 20;
       const belowSpace = fixedTooltipHeight + belowMargin;
       const { isViewer } = item.messageInfo.creator;
       const aboveMargin = isViewer ? 30 : 50;
       const aboveSpace = fixedTooltipHeight + aboveMargin;
 
       let margin = belowMargin;
       if (
         multimediaBottom + belowSpace > boundsBottom &&
         multimediaTop - aboveSpace > boundsTop
       ) {
         margin = aboveMargin;
       }
 
       this.props.navigation.navigate<'MultimediaMessageTooltipModal'>({
         name: MultimediaMessageTooltipModalRouteName,
         params: {
           presentedFrom: this.props.route.key,
           item,
           initialCoordinates: coordinates,
           verticalBounds,
           location: 'fixed',
           margin,
           visibleEntryIDs,
         },
         key: getMessageTooltipKey(item),
       });
     });
   };
 
   canNavigateToSidebar() {
     return (
       this.props.item.threadCreatedFromMessage ||
       this.props.canCreateSidebarFromMessage
     );
   }
 
   render() {
     const {
       item,
       focused,
       toggleFocus,
       verticalBounds,
       navigation,
       route,
       overlayContext,
       canCreateSidebarFromMessage,
       ...viewProps
     } = this.props;
     return (
       <ComposedMessage
         item={item}
         sendFailed={multimediaMessageSendFailed(item)}
         focused={focused}
         swipeOptions={this.canNavigateToSidebar() ? 'sidebar' : 'none'}
         {...viewProps}
       >
         <View style={styles.expand} onLayout={this.onLayout} ref={this.viewRef}>
           <InnerMultimediaMessage
             item={item}
             verticalBounds={verticalBounds}
             onPressMultimedia={this.onPressMultimedia}
             clickable={this.state.clickable}
             setClickable={this.setClickable}
             onLongPress={this.onLongPress}
           />
         </View>
       </ComposedMessage>
     );
   }
 }
 
 const styles = StyleSheet.create({
   expand: {
     flex: 1,
   },
 });
 
 const ConnectedMultimediaMessage: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedMultimediaMessage(props: BaseProps) {
     const navigation = useNavigation();
     const route = useRoute();
     const overlayContext = React.useContext(OverlayContext);
     const canCreateSidebarFromMessage = useCanCreateSidebarFromMessage(
       props.item.threadInfo,
       props.item.messageInfo,
     );
     return (
       <MultimediaMessage
         {...props}
         navigation={navigation}
         route={route}
         overlayContext={overlayContext}
         canCreateSidebarFromMessage={canCreateSidebarFromMessage}
       />
     );
   },
 );
 
 export default ConnectedMultimediaMessage;
diff --git a/native/chat/robotext-message-tooltip-modal.react.js b/native/chat/robotext-message-tooltip-modal.react.js
index c4ae9a342..27c7a4578 100644
--- a/native/chat/robotext-message-tooltip-modal.react.js
+++ b/native/chat/robotext-message-tooltip-modal.react.js
@@ -1,40 +1,35 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   createTooltip,
   type TooltipParams,
   type BaseTooltipProps,
 } from '../navigation/tooltip.react';
 import type { ChatRobotextMessageInfoItemWithHeight } from '../types/chat-types';
 import RobotextMessageTooltipButton from './robotext-message-tooltip-button.react';
 import { navigateToSidebar } from './sidebar-navigation';
 
 export type RobotextMessageTooltipModalParams = TooltipParams<{
   +item: ChatRobotextMessageInfoItemWithHeight,
 }>;
 
 const spec = {
   entries: [
     {
-      id: 'create_sidebar',
-      text: 'Create thread',
-      onPress: navigateToSidebar,
-    },
-    {
-      id: 'open_sidebar',
-      text: 'Go to thread',
+      id: 'sidebar',
+      text: 'Thread',
       onPress: navigateToSidebar,
     },
   ],
 };
 
 const RobotextMessageTooltipModal: React.ComponentType<
   BaseTooltipProps<'RobotextMessageTooltipModal'>,
 > = createTooltip<'RobotextMessageTooltipModal'>(
   RobotextMessageTooltipButton,
   spec,
 );
 
 export default RobotextMessageTooltipModal;
diff --git a/native/chat/robotext-message.react.js b/native/chat/robotext-message.react.js
index 5f6d47d2d..186c761fd 100644
--- a/native/chat/robotext-message.react.js
+++ b/native/chat/robotext-message.react.js
@@ -1,196 +1,194 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import { messageKey } from 'lib/shared/message-utils';
 import { useCanCreateSidebarFromMessage } from 'lib/shared/thread-utils';
 
 import { KeyboardContext } from '../keyboard/keyboard-state';
 import { OverlayContext } from '../navigation/overlay-context';
 import { RobotextMessageTooltipModalRouteName } from '../navigation/route-names';
 import type { NavigationRoute } from '../navigation/route-names';
 import { fixedTooltipHeight } from '../navigation/tooltip.react';
 import { useStyles } from '../themes/colors';
 import type { ChatRobotextMessageInfoItemWithHeight } from '../types/chat-types';
 import type { VerticalBounds } from '../types/layout-types';
 import { AnimatedView } from '../types/styles';
 import { inlineSidebarCenterStyle } from './chat-constants';
 import type { ChatNavigationProp } from './chat.react';
 import { InlineSidebar } from './inline-sidebar.react';
 import { InnerRobotextMessage } from './inner-robotext-message.react';
 import { Timestamp } from './timestamp.react';
 import { getMessageTooltipKey, useContentAndHeaderOpacity } from './utils';
 
 type Props = {
   ...React.ElementConfig<typeof View>,
   +item: ChatRobotextMessageInfoItemWithHeight,
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
   +focused: boolean,
   +toggleFocus: (messageKey: string) => void,
   +verticalBounds: ?VerticalBounds,
 };
 function RobotextMessage(props: Props): React.Node {
   const {
     item,
     navigation,
     route,
     focused,
     toggleFocus,
     verticalBounds,
     ...viewProps
   } = props;
 
   let timestamp = null;
   if (focused || item.startsConversation) {
     timestamp = (
       <Timestamp time={item.messageInfo.time} display="lowContrast" />
     );
   }
 
   const styles = useStyles(unboundStyles);
   let inlineSidebar = null;
   if (item.threadCreatedFromMessage) {
     inlineSidebar = (
       <View style={styles.sidebar}>
         <InlineSidebar threadInfo={item.threadCreatedFromMessage} />
       </View>
     );
   }
 
   const keyboardState = React.useContext(KeyboardContext);
   const key = messageKey(item.messageInfo);
   const onPress = React.useCallback(() => {
     const didDismiss =
       keyboardState && keyboardState.dismissKeyboardIfShowing();
     if (!didDismiss) {
       toggleFocus(key);
     }
   }, [keyboardState, toggleFocus, key]);
 
   const overlayContext = React.useContext(OverlayContext);
   const viewRef = React.useRef<?React.ElementRef<typeof View>>();
 
   const canCreateSidebarFromMessage = useCanCreateSidebarFromMessage(
     item.threadInfo,
     item.messageInfo,
   );
   const visibleEntryIDs = React.useMemo(() => {
-    if (item.threadCreatedFromMessage) {
-      return ['open_sidebar'];
-    } else if (canCreateSidebarFromMessage) {
-      return ['create_sidebar'];
+    if (item.threadCreatedFromMessage || canCreateSidebarFromMessage) {
+      return ['sidebar'];
     }
     return [];
   }, [item.threadCreatedFromMessage, canCreateSidebarFromMessage]);
 
   const openRobotextTooltipModal = React.useCallback(
     (x, y, width, height, pageX, pageY) => {
       invariant(
         verticalBounds,
         'verticalBounds should be present in openRobotextTooltipModal',
       );
       const coordinates = { x: pageX, y: pageY, width, height };
 
       const messageTop = pageY;
       const messageBottom = pageY + height;
       const boundsTop = verticalBounds.y;
       const boundsBottom = verticalBounds.y + verticalBounds.height;
 
       const belowMargin = 20;
       const belowSpace = fixedTooltipHeight + belowMargin;
       const { isViewer } = item.messageInfo.creator;
       const aboveMargin = isViewer ? 30 : 50;
       const aboveSpace = fixedTooltipHeight + aboveMargin;
 
       let margin = 0;
       if (
         messageBottom + belowSpace > boundsBottom &&
         messageTop - aboveSpace > boundsTop
       ) {
         margin = aboveMargin;
       }
 
       props.navigation.navigate<'RobotextMessageTooltipModal'>({
         name: RobotextMessageTooltipModalRouteName,
         params: {
           presentedFrom: props.route.key,
           initialCoordinates: coordinates,
           verticalBounds,
           visibleEntryIDs,
           location: 'fixed',
           margin,
           item,
         },
         key: getMessageTooltipKey(item),
       });
     },
     [item, props.navigation, props.route.key, verticalBounds, visibleEntryIDs],
   );
 
   const onLongPress = React.useCallback(() => {
     if (keyboardState && keyboardState.dismissKeyboardIfShowing()) {
       return;
     }
 
     if (visibleEntryIDs.length === 0) {
       return;
     }
 
     if (!viewRef.current || !verticalBounds) {
       return;
     }
 
     if (!focused) {
       toggleFocus(messageKey(item.messageInfo));
     }
 
     invariant(overlayContext, 'RobotextMessage should have OverlayContext');
     overlayContext.setScrollBlockingModalStatus('open');
     viewRef.current?.measure(openRobotextTooltipModal);
   }, [
     focused,
     item,
     keyboardState,
     overlayContext,
     toggleFocus,
     verticalBounds,
     viewRef,
     visibleEntryIDs,
     openRobotextTooltipModal,
   ]);
 
   const onLayout = React.useCallback(() => {}, []);
 
   const contentAndHeaderOpacity = useContentAndHeaderOpacity(item);
 
   return (
     <View {...viewProps}>
       <AnimatedView style={{ opacity: contentAndHeaderOpacity }}>
         {timestamp}
       </AnimatedView>
       <View onLayout={onLayout} ref={viewRef}>
         <AnimatedView style={{ opacity: contentAndHeaderOpacity }}>
           <InnerRobotextMessage
             item={item}
             onPress={onPress}
             onLongPress={onLongPress}
           />
         </AnimatedView>
       </View>
       {inlineSidebar}
     </View>
   );
 }
 
 const unboundStyles = {
   sidebar: {
     marginTop: inlineSidebarCenterStyle.topOffset,
     marginBottom: -inlineSidebarCenterStyle.topOffset,
     alignSelf: 'center',
   },
 };
 
 export { RobotextMessage };
diff --git a/native/chat/text-message-tooltip-modal.react.js b/native/chat/text-message-tooltip-modal.react.js
index 6af4953b4..fe3ec8065 100644
--- a/native/chat/text-message-tooltip-modal.react.js
+++ b/native/chat/text-message-tooltip-modal.react.js
@@ -1,73 +1,68 @@
 // @flow
 
 import Clipboard from '@react-native-clipboard/clipboard';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { createMessageReply } from 'lib/shared/message-utils';
 import type { DispatchFunctions, BindServerCall } from 'lib/utils/action-utils';
 
 import type { InputState } from '../input/input-state';
 import { displayActionResultModal } from '../navigation/action-result-modal';
 import {
   createTooltip,
   type TooltipParams,
   type TooltipRoute,
   type BaseTooltipProps,
 } from '../navigation/tooltip.react';
 import type { ChatTextMessageInfoItemWithHeight } from '../types/chat-types';
 import { onPressReport } from './message-report-utils';
 import { navigateToSidebar } from './sidebar-navigation';
 import TextMessageTooltipButton from './text-message-tooltip-button.react';
 
 export type TextMessageTooltipModalParams = TooltipParams<{
   +item: ChatTextMessageInfoItemWithHeight,
 }>;
 
 const confirmCopy = () => displayActionResultModal('copied!');
 
 function onPressCopy(route: TooltipRoute<'TextMessageTooltipModal'>) {
   Clipboard.setString(route.params.item.messageInfo.text);
   setTimeout(confirmCopy);
 }
 
 function onPressReply(
   route: TooltipRoute<'TextMessageTooltipModal'>,
   dispatchFunctions: DispatchFunctions,
   bindServerCall: BindServerCall,
   inputState: ?InputState,
 ) {
   invariant(
     inputState,
     'inputState should be set in TextMessageTooltipModal.onPressReply',
   );
   inputState.addReply(createMessageReply(route.params.item.messageInfo.text));
 }
 
 const spec = {
   entries: [
     { id: 'copy', text: 'Copy', onPress: onPressCopy },
     { id: 'reply', text: 'Reply', onPress: onPressReply },
     {
       id: 'report',
       text: 'Report',
       onPress: onPressReport,
     },
     {
-      id: 'create_sidebar',
-      text: 'Thread',
-      onPress: navigateToSidebar,
-    },
-    {
-      id: 'open_sidebar',
+      id: 'sidebar',
       text: 'Thread',
       onPress: navigateToSidebar,
     },
   ],
 };
 
 const TextMessageTooltipModal: React.ComponentType<
   BaseTooltipProps<'TextMessageTooltipModal'>,
 > = createTooltip<'TextMessageTooltipModal'>(TextMessageTooltipButton, spec);
 
 export default TextMessageTooltipModal;
diff --git a/native/chat/text-message.react.js b/native/chat/text-message.react.js
index 66345d953..a200b5430 100644
--- a/native/chat/text-message.react.js
+++ b/native/chat/text-message.react.js
@@ -1,230 +1,231 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import { messageKey } from 'lib/shared/message-utils';
 import {
   threadHasPermission,
   useCanCreateSidebarFromMessage,
 } from 'lib/shared/thread-utils';
 import { threadPermissions } from 'lib/types/thread-types';
 
 import { MarkdownLinkContext } from '../markdown/markdown-link-context';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context';
 import type { NavigationRoute } from '../navigation/route-names';
 import { TextMessageTooltipModalRouteName } from '../navigation/route-names';
 import { fixedTooltipHeight } from '../navigation/tooltip.react';
 import type { ChatTextMessageInfoItemWithHeight } from '../types/chat-types';
 import type { VerticalBounds } from '../types/layout-types';
 import type { ChatNavigationProp } from './chat.react';
 import ComposedMessage from './composed-message.react';
 import { InnerTextMessage } from './inner-text-message.react';
 import textMessageSendFailed from './text-message-send-failed';
 import { getMessageTooltipKey } from './utils';
 
 type BaseProps = {
   ...React.ElementConfig<typeof View>,
   +item: ChatTextMessageInfoItemWithHeight,
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
   +focused: boolean,
   +toggleFocus: (messageKey: string) => void,
   +verticalBounds: ?VerticalBounds,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +canCreateSidebarFromMessage: boolean,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
   // MarkdownLinkContext
   +linkModalActive: boolean,
   +linkIsBlockingPresses: boolean,
 };
 class TextMessage extends React.PureComponent<Props> {
   message: ?React.ElementRef<typeof View>;
 
   render() {
     const {
       item,
       navigation,
       route,
       focused,
       toggleFocus,
       verticalBounds,
       overlayContext,
       linkModalActive,
       linkIsBlockingPresses,
       canCreateSidebarFromMessage,
       ...viewProps
     } = this.props;
 
     let swipeOptions = 'none';
     const canReply = this.canReply();
     const canNavigateToSidebar = this.canNavigateToSidebar();
     if (linkModalActive) {
       swipeOptions = 'none';
     } else if (canReply && canNavigateToSidebar) {
       swipeOptions = 'both';
     } else if (canReply) {
       swipeOptions = 'reply';
     } else if (canNavigateToSidebar) {
       swipeOptions = 'sidebar';
     }
 
     return (
       <ComposedMessage
         item={item}
         sendFailed={textMessageSendFailed(item)}
         focused={focused}
         swipeOptions={swipeOptions}
         {...viewProps}
       >
         <InnerTextMessage
           item={item}
           onPress={this.onPress}
           messageRef={this.messageRef}
         />
       </ComposedMessage>
     );
   }
 
   messageRef = (message: ?React.ElementRef<typeof View>) => {
     this.message = message;
   };
 
   canReply() {
     return threadHasPermission(
       this.props.item.threadInfo,
       threadPermissions.VOICED,
     );
   }
 
   canNavigateToSidebar() {
     return (
       this.props.item.threadCreatedFromMessage ||
       this.props.canCreateSidebarFromMessage
     );
   }
 
   visibleEntryIDs() {
     const result = ['copy'];
 
     if (this.canReply()) {
       result.push('reply');
     }
 
-    if (this.props.item.threadCreatedFromMessage) {
-      result.push('open_sidebar');
-    } else if (this.props.canCreateSidebarFromMessage) {
-      result.push('create_sidebar');
+    if (
+      this.props.item.threadCreatedFromMessage ||
+      this.props.canCreateSidebarFromMessage
+    ) {
+      result.push('sidebar');
     }
 
     if (!this.props.item.messageInfo.creator.isViewer) {
       result.push('report');
     }
 
     return result;
   }
 
   onPress = () => {
     const visibleEntryIDs = this.visibleEntryIDs();
     if (visibleEntryIDs.length === 0) {
       return;
     }
 
     const {
       message,
       props: { verticalBounds, linkIsBlockingPresses },
     } = this;
     if (!message || !verticalBounds || linkIsBlockingPresses) {
       return;
     }
 
     const { focused, toggleFocus, item } = this.props;
     if (!focused) {
       toggleFocus(messageKey(item.messageInfo));
     }
 
     const { overlayContext } = this.props;
     invariant(overlayContext, 'TextMessage should have OverlayContext');
     overlayContext.setScrollBlockingModalStatus('open');
 
     message.measure((x, y, width, height, pageX, pageY) => {
       const coordinates = { x: pageX, y: pageY, width, height };
 
       const messageTop = pageY;
       const messageBottom = pageY + height;
       const boundsTop = verticalBounds.y;
       const boundsBottom = verticalBounds.y + verticalBounds.height;
 
       const belowMargin = 20;
       const belowSpace = fixedTooltipHeight + belowMargin;
       const { isViewer } = item.messageInfo.creator;
       const aboveMargin = isViewer ? 30 : 50;
       const aboveSpace = fixedTooltipHeight + aboveMargin;
 
       let margin = belowMargin;
       if (
         messageBottom + belowSpace > boundsBottom &&
         messageTop - aboveSpace > boundsTop
       ) {
         margin = aboveMargin;
       }
 
       this.props.navigation.navigate<'TextMessageTooltipModal'>({
         name: TextMessageTooltipModalRouteName,
         params: {
           presentedFrom: this.props.route.key,
           initialCoordinates: coordinates,
           verticalBounds,
           visibleEntryIDs,
           location: 'fixed',
           margin,
           item,
         },
         key: getMessageTooltipKey(item),
       });
     });
   };
 }
 
 const ConnectedTextMessage: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedTextMessage(props: BaseProps) {
     const overlayContext = React.useContext(OverlayContext);
 
     const [linkModalActive, setLinkModalActive] = React.useState(false);
     const [linkPressActive, setLinkPressActive] = React.useState(false);
     const markdownLinkContext = React.useMemo(
       () => ({
         setLinkModalActive,
         setLinkPressActive,
       }),
       [setLinkModalActive, setLinkPressActive],
     );
     const canCreateSidebarFromMessage = useCanCreateSidebarFromMessage(
       props.item.threadInfo,
       props.item.messageInfo,
     );
 
     const linkIsBlockingPresses = linkModalActive || linkPressActive;
     return (
       <MarkdownLinkContext.Provider value={markdownLinkContext}>
         <TextMessage
           {...props}
           canCreateSidebarFromMessage={canCreateSidebarFromMessage}
           overlayContext={overlayContext}
           linkModalActive={linkModalActive}
           linkIsBlockingPresses={linkIsBlockingPresses}
         />
       </MarkdownLinkContext.Provider>
     );
   },
 );
 
 export { ConnectedTextMessage as TextMessage };
diff --git a/native/navigation/tooltip.react.js b/native/navigation/tooltip.react.js
index fddb3842d..76f7b6d11 100644
--- a/native/navigation/tooltip.react.js
+++ b/native/navigation/tooltip.react.js
@@ -1,624 +1,621 @@
 // @flow
 
 import type { RouteProp } from '@react-navigation/native';
 import * as Haptics from 'expo-haptics';
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   View,
   StyleSheet,
   TouchableWithoutFeedback,
   Platform,
   TouchableOpacity,
 } from 'react-native';
 import Animated from 'react-native-reanimated';
 import { useDispatch } from 'react-redux';
 
 import {
   type ServerCallState,
   serverCallStateSelector,
 } from 'lib/selectors/server-calls';
 import type { Dispatch } from 'lib/types/redux-types';
 import {
   createBoundServerCallsSelector,
   useDispatchActionPromise,
   type DispatchActionPromise,
   type ActionFunc,
   type BindServerCall,
   type DispatchFunctions,
 } from 'lib/utils/action-utils';
 
 import { ChatContext, type ChatContextType } from '../chat/chat-context';
 import CommIcon from '../components/comm-icon.react';
 import { SingleLine } from '../components/single-line.react';
 import SWMansionIcon from '../components/swmansion-icon.react';
 import { type InputState, InputStateContext } from '../input/input-state';
 import { type DimensionsInfo } from '../redux/dimensions-updater.react';
 import { useSelector } from '../redux/redux-utils';
 import {
   type VerticalBounds,
   type LayoutCoordinates,
 } from '../types/layout-types';
 import type { LayoutEvent } from '../types/react-native';
 import { AnimatedView, type ViewStyle, type TextStyle } from '../types/styles';
 import type { AppNavigationProp } from './app-navigator.react';
 import { OverlayContext, type OverlayContextType } from './overlay-context';
 import type { TooltipModalParamList } from './route-names';
 
 /* eslint-disable import/no-named-as-default-member */
 const { Value, Node, Extrapolate, add, multiply, interpolateNode } = Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 export type TooltipEntry<RouteName: $Keys<TooltipModalParamList>> = {
   +id: string,
   +text: string,
   +onPress: (
     route: TooltipRoute<RouteName>,
     dispatchFunctions: DispatchFunctions,
     bindServerCall: BindServerCall,
     inputState: ?InputState,
     navigation: AppNavigationProp<RouteName>,
     viewerID: ?string,
     chatContext: ?ChatContextType,
   ) => mixed,
 };
 type TooltipItemProps<RouteName> = {
   +spec: TooltipEntry<RouteName>,
   +onPress: (entry: TooltipEntry<RouteName>) => void,
   +containerStyle?: ViewStyle,
   +labelStyle?: TextStyle,
 };
 type TooltipSpec<RouteName> = {
   +entries: $ReadOnlyArray<TooltipEntry<RouteName>>,
   +labelStyle?: ViewStyle,
 };
 
 export type TooltipParams<CustomProps> = {
   ...CustomProps,
   +presentedFrom: string,
   +initialCoordinates: LayoutCoordinates,
   +verticalBounds: VerticalBounds,
   +location?: 'above' | 'below' | 'fixed',
   +margin?: number,
   +visibleEntryIDs?: $ReadOnlyArray<string>,
 };
 export type TooltipRoute<RouteName: $Keys<TooltipModalParamList>> = RouteProp<
   TooltipModalParamList,
   RouteName,
 >;
 
 export type BaseTooltipProps<RouteName> = {
   +navigation: AppNavigationProp<RouteName>,
   +route: TooltipRoute<RouteName>,
 };
 type ButtonProps<Base> = {
   ...Base,
   +progress: Node,
   +isOpeningSidebar: boolean,
 };
 type TooltipProps<Base> = {
   ...Base,
   // Redux state
   +dimensions: DimensionsInfo,
   +serverCallState: ServerCallState,
   +viewerID: ?string,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
   // withInputState
   +inputState: ?InputState,
   +chatContext: ?ChatContextType,
 };
 function createTooltip<
   RouteName: $Keys<TooltipModalParamList>,
   BaseTooltipPropsType: BaseTooltipProps<RouteName> = BaseTooltipProps<RouteName>,
 >(
   ButtonComponent: React.ComponentType<ButtonProps<BaseTooltipPropsType>>,
   tooltipSpec: TooltipSpec<RouteName>,
 ): React.ComponentType<BaseTooltipPropsType> {
   class TooltipItem extends React.PureComponent<TooltipItemProps<RouteName>> {
     render() {
       let icon;
       if (this.props.spec.id === 'copy') {
         icon = <SWMansionIcon name="copy" style={styles.icon} size={16} />;
       } else if (this.props.spec.id === 'reply') {
         icon = <CommIcon name="reply" style={styles.icon} size={12} />;
       } else if (this.props.spec.id === 'report') {
         icon = (
           <SWMansionIcon name="warning-circle" style={styles.icon} size={16} />
         );
-      } else if (
-        this.props.spec.id === 'create_sidebar' ||
-        this.props.spec.id === 'open_sidebar'
-      ) {
+      } else if (this.props.spec.id === 'sidebar') {
         icon = (
           <SWMansionIcon
             name="message-circle-lines"
             style={styles.icon}
             size={16}
           />
         );
       }
 
       return (
         <TouchableOpacity
           onPress={this.onPress}
           style={this.props.containerStyle}
         >
           {icon}
           <SingleLine style={[styles.label, this.props.labelStyle]}>
             {this.props.spec.text}
           </SingleLine>
         </TouchableOpacity>
       );
     }
 
     onPress = () => {
       this.props.onPress(this.props.spec);
     };
   }
   class Tooltip extends React.PureComponent<
     TooltipProps<BaseTooltipPropsType>,
   > {
     backdropOpacity: Node;
     tooltipContainerOpacity: Node;
     tooltipVerticalAbove: Node;
     tooltipVerticalBelow: Node;
     tooltipHorizontalOffset: Value = new Value(0);
     tooltipHorizontal: Node;
     tooltipScale: Node;
 
     constructor(props: TooltipProps<BaseTooltipPropsType>) {
       super(props);
 
       const { overlayContext } = props;
       invariant(overlayContext, 'Tooltip should have OverlayContext');
       const { position } = overlayContext;
 
       this.backdropOpacity = interpolateNode(position, {
         inputRange: [0, 1],
         outputRange: [0, 0.7],
         extrapolate: Extrapolate.CLAMP,
       });
       this.tooltipContainerOpacity = interpolateNode(position, {
         inputRange: [0, 0.1],
         outputRange: [0, 1],
         extrapolate: Extrapolate.CLAMP,
       });
 
       const { margin } = this;
       this.tooltipVerticalAbove = interpolateNode(position, {
         inputRange: [0, 1],
         outputRange: [margin + this.tooltipHeight / 2, 0],
         extrapolate: Extrapolate.CLAMP,
       });
       this.tooltipVerticalBelow = interpolateNode(position, {
         inputRange: [0, 1],
         outputRange: [-margin - this.tooltipHeight / 2, 0],
         extrapolate: Extrapolate.CLAMP,
       });
 
       this.tooltipHorizontal = multiply(
         add(1, multiply(-1, position)),
         this.tooltipHorizontalOffset,
       );
 
       this.tooltipScale = interpolateNode(position, {
         inputRange: [0, 0.2, 0.8, 1],
         outputRange: [0, 0, 1, 1],
         extrapolate: Extrapolate.CLAMP,
       });
     }
 
     componentDidMount() {
       Haptics.impactAsync();
     }
 
     get entries(): $ReadOnlyArray<TooltipEntry<RouteName>> {
       const { entries } = tooltipSpec;
       const { visibleEntryIDs } = this.props.route.params;
       if (!visibleEntryIDs) {
         return entries;
       }
       const visibleSet = new Set(visibleEntryIDs);
       return entries.filter(entry => visibleSet.has(entry.id));
     }
 
     get tooltipHeight(): number {
       if (this.props.route.params.location === 'fixed') {
         return fixedTooltipHeight;
       } else {
         return tooltipHeight(this.entries.length);
       }
     }
 
     get location(): 'above' | 'below' | 'fixed' {
       const { params } = this.props.route;
       const { location } = params;
       if (location) {
         return location;
       }
 
       const { initialCoordinates, verticalBounds } = params;
       const { y, height } = initialCoordinates;
       const contentTop = y;
       const contentBottom = y + height;
       const boundsTop = verticalBounds.y;
       const boundsBottom = verticalBounds.y + verticalBounds.height;
 
       const { margin, tooltipHeight: curTooltipHeight } = this;
       const fullHeight = curTooltipHeight + margin;
       if (
         contentBottom + fullHeight > boundsBottom &&
         contentTop - fullHeight > boundsTop
       ) {
         return 'above';
       }
 
       return 'below';
     }
 
     get opacityStyle() {
       return {
         ...styles.backdrop,
         opacity: this.backdropOpacity,
       };
     }
 
     get contentContainerStyle() {
       const { verticalBounds } = this.props.route.params;
       const fullScreenHeight = this.props.dimensions.height;
       const top = verticalBounds.y;
       const bottom =
         fullScreenHeight - verticalBounds.y - verticalBounds.height;
       return {
         ...styles.contentContainer,
         marginTop: top,
         marginBottom: bottom,
       };
     }
 
     get buttonStyle() {
       const { params } = this.props.route;
       const { initialCoordinates, verticalBounds } = params;
       const { x, y, width, height } = initialCoordinates;
       return {
         width: Math.ceil(width),
         height: Math.ceil(height),
         marginTop: y - verticalBounds.y,
         marginLeft: x,
       };
     }
 
     get margin() {
       const customMargin = this.props.route.params.margin;
       return customMargin !== null && customMargin !== undefined
         ? customMargin
         : 20;
     }
 
     get tooltipContainerStyle() {
       const { dimensions, route } = this.props;
       const { initialCoordinates, verticalBounds } = route.params;
       const { x, y, width, height } = initialCoordinates;
       const { margin, location } = this;
 
       const style = {};
       style.position = 'absolute';
       (style.alignItems = 'center'),
         (style.opacity = this.tooltipContainerOpacity);
       style.transform = [{ translateX: this.tooltipHorizontal }];
 
       const extraLeftSpace = x;
       const extraRightSpace = dimensions.width - width - x;
       if (extraLeftSpace < extraRightSpace) {
         style.left = 0;
         style.minWidth = width + 2 * extraLeftSpace;
       } else {
         style.right = 0;
         style.minWidth = width + 2 * extraRightSpace;
       }
 
       if (location === 'fixed') {
         style.minWidth = dimensions.width - 16;
         style.left = 8;
         style.right = 8;
       }
 
       if (location === 'above') {
         const fullScreenHeight = dimensions.height;
         style.bottom =
           fullScreenHeight - Math.max(y, verticalBounds.y) + margin;
         style.transform.push({ translateY: this.tooltipVerticalAbove });
       } else {
         style.top =
           Math.min(y + height, verticalBounds.y + verticalBounds.height) +
           margin;
         style.transform.push({ translateY: this.tooltipVerticalBelow });
       }
 
       style.transform.push({ scale: this.tooltipScale });
 
       return style;
     }
 
     render() {
       const {
         dimensions,
         serverCallState,
         viewerID,
         dispatch,
         dispatchActionPromise,
         overlayContext,
         inputState,
         chatContext,
         ...navAndRouteForFlow
       } = this.props;
 
       const tooltipContainerStyle = [styles.itemContainer];
 
       if (this.location === 'fixed') {
         tooltipContainerStyle.push(styles.itemContainerFixed);
       }
 
       const { entries } = this;
       const items = entries.map((entry, index) => {
         let style;
         if (this.location === 'fixed') {
           style = index !== entries.length - 1 ? styles.itemMarginFixed : null;
         } else {
           style = index !== entries.length - 1 ? styles.itemMargin : null;
         }
         return (
           <TooltipItem
             key={index}
             spec={entry}
             onPress={this.onPressEntry}
             containerStyle={[...tooltipContainerStyle, style]}
             labelStyle={tooltipSpec.labelStyle}
           />
         );
       });
 
       let triangleStyle;
       const { route } = this.props;
       const { initialCoordinates } = route.params;
       const { x, width } = initialCoordinates;
       const extraLeftSpace = x;
       const extraRightSpace = dimensions.width - width - x;
       if (extraLeftSpace < extraRightSpace) {
         triangleStyle = {
           alignSelf: 'flex-start',
           left: extraLeftSpace + (width - 20) / 2,
         };
       } else {
         triangleStyle = {
           alignSelf: 'flex-end',
           right: extraRightSpace + (width - 20) / 2,
         };
       }
 
       let triangleDown = null;
       let triangleUp = null;
       const { location } = this;
       if (location === 'above') {
         triangleDown = <View style={[styles.triangleDown, triangleStyle]} />;
       } else if (location === 'below') {
         triangleUp = <View style={[styles.triangleUp, triangleStyle]} />;
       }
 
       invariant(overlayContext, 'Tooltip should have OverlayContext');
       const { position } = overlayContext;
       const isOpeningSidebar = !!chatContext?.currentTransitionSidebarSourceID;
 
       const buttonProps: ButtonProps<BaseTooltipPropsType> = {
         ...navAndRouteForFlow,
         progress: position,
         isOpeningSidebar,
       };
 
       const itemsStyle = [styles.items];
 
       if (this.location === 'fixed') {
         itemsStyle.push(styles.itemsFixed);
       }
 
       return (
         <TouchableWithoutFeedback onPress={this.onPressBackdrop}>
           <View style={styles.container}>
             <AnimatedView style={this.opacityStyle} />
             <View style={this.contentContainerStyle}>
               <View style={this.buttonStyle}>
                 <ButtonComponent {...buttonProps} />
               </View>
             </View>
             <AnimatedView
               style={this.tooltipContainerStyle}
               onLayout={this.onTooltipContainerLayout}
             >
               {triangleUp}
               <View style={itemsStyle}>{items}</View>
               {triangleDown}
             </AnimatedView>
           </View>
         </TouchableWithoutFeedback>
       );
     }
 
     onPressBackdrop = () => {
       this.props.navigation.goBackOnce();
     };
 
     onPressEntry = (entry: TooltipEntry<RouteName>) => {
       this.props.navigation.goBackOnce();
       const dispatchFunctions = {
         dispatch: this.props.dispatch,
         dispatchActionPromise: this.props.dispatchActionPromise,
       };
       entry.onPress(
         this.props.route,
         dispatchFunctions,
         this.bindServerCall,
         this.props.inputState,
         this.props.navigation,
         this.props.viewerID,
         this.props.chatContext,
       );
     };
 
     bindServerCall = <F>(serverCall: ActionFunc<F>): F => {
       const {
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
       } = this.props.serverCallState;
       return createBoundServerCallsSelector(serverCall)({
         dispatch: this.props.dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
       });
     };
 
     onTooltipContainerLayout = (event: LayoutEvent) => {
       const { route, dimensions } = this.props;
       const { x, width } = route.params.initialCoordinates;
 
       const extraLeftSpace = x;
       const extraRightSpace = dimensions.width - width - x;
 
       const actualWidth = event.nativeEvent.layout.width;
       if (extraLeftSpace < extraRightSpace) {
         const minWidth = width + 2 * extraLeftSpace;
         this.tooltipHorizontalOffset.setValue((minWidth - actualWidth) / 2);
       } else {
         const minWidth = width + 2 * extraRightSpace;
         this.tooltipHorizontalOffset.setValue((actualWidth - minWidth) / 2);
       }
     };
   }
   return React.memo<BaseTooltipPropsType>(function ConnectedTooltip(
     props: BaseTooltipPropsType,
   ) {
     const dimensions = useSelector(state => state.dimensions);
     const serverCallState = useSelector(serverCallStateSelector);
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const overlayContext = React.useContext(OverlayContext);
     const inputState = React.useContext(InputStateContext);
     const chatContext = React.useContext(ChatContext);
     return (
       <Tooltip
         {...props}
         dimensions={dimensions}
         serverCallState={serverCallState}
         viewerID={viewerID}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         overlayContext={overlayContext}
         inputState={inputState}
         chatContext={chatContext}
       />
     );
   });
 }
 
 const styles = StyleSheet.create({
   backdrop: {
     backgroundColor: 'black',
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   container: {
     flex: 1,
   },
   contentContainer: {
     flex: 1,
     overflow: 'hidden',
   },
   icon: {
     marginRight: 4,
   },
   itemContainer: {
     alignItems: 'center',
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'center',
     padding: 10,
   },
   itemContainerFixed: {
     flexDirection: 'column',
   },
   itemMargin: {
     borderBottomColor: '#E1E1E1',
     borderBottomWidth: 1,
   },
   itemMarginFixed: {
     borderRightColor: '#E1E1E1',
     borderRightWidth: 1,
   },
   items: {
     backgroundColor: 'white',
     borderRadius: 5,
     overflow: 'hidden',
   },
   itemsFixed: {
     flex: 1,
     flexDirection: 'row',
   },
   label: {
     color: '#444',
     fontSize: 14,
     lineHeight: 17,
     textAlign: 'center',
   },
   triangleDown: {
     borderBottomColor: 'transparent',
     borderBottomWidth: 0,
     borderLeftColor: 'transparent',
     borderLeftWidth: 10,
     borderRightColor: 'transparent',
     borderRightWidth: 10,
     borderStyle: 'solid',
     borderTopColor: 'white',
     borderTopWidth: 10,
     height: 10,
     top: Platform.OS === 'android' ? -1 : 0,
     width: 10,
   },
   triangleUp: {
     borderBottomColor: 'white',
     borderBottomWidth: 10,
     borderLeftColor: 'transparent',
     borderLeftWidth: 10,
     borderRightColor: 'transparent',
     borderRightWidth: 10,
     borderStyle: 'solid',
     borderTopColor: 'transparent',
     borderTopWidth: 0,
     bottom: Platform.OS === 'android' ? -1 : 0,
     height: 10,
     width: 10,
   },
 });
 
 function tooltipHeight(numEntries: number): number {
   // 10 (triangle) + 37 * numEntries (entries) + numEntries - 1 (padding)
   return 9 + 38 * numEntries;
 }
 
 const fixedTooltipHeight: number = 53;
 
 export { createTooltip, fixedTooltipHeight };