diff --git a/web/chat/chat-message-list.css b/web/chat/chat-message-list.css
index b655e91e6..454fac7dc 100644
--- a/web/chat/chat-message-list.css
+++ b/web/chat/chat-message-list.css
@@ -1,224 +1,224 @@
 div.container {
   margin-left: 400px;
   height: 100%;
   background-color: var(--bg);
   display: flex;
   flex-direction: column;
   box-sizing: border-box;
 }
 div.activeContainer {
   border: 2px solid #5989d6;
   margin-left: 402px;
 }
 div.outerMessageContainer {
   position: relative;
   height: calc(100vh - 128px);
   min-height: 0;
   display: flex;
   flex-direction: column;
 }
 div.messageContainer {
   height: 100%;
   overflow-y: auto;
   display: flex;
   flex-direction: column-reverse;
 }
 div.mirroredMessageContainer {
   flex-direction: column !important;
   transform: scaleY(-1);
 }
 div.mirroredMessageContainer > div {
   transform: scaleY(-1);
 }
 
 div.message {
   display: flex;
   flex-direction: column;
   flex-shrink: 0;
 }
 
 div.loading {
   text-align: center;
   padding: 12px;
 }
 
 div.conversationHeader {
   color: var(--chat-timestamp-color);
   font-size: var(--xs-font-12);
   line-height: var(--line-height-text);
   text-align: center;
 }
 div.conversationHeader:last-child {
   padding-top: 6px;
 }
 
-div.messageActionActiveArea {
+div.messageTooltipActiveArea {
   position: absolute;
   display: flex;
   top: 0;
   bottom: 0;
   align-items: center;
   padding: 0 12px;
 }
 
-div.viewerMessageActionActiveArea {
+div.viewerMessageTooltipActiveArea {
   right: 100%;
 }
 div.nonViewerMessageActiveArea {
   left: 100%;
 }
-div.messageActionActiveArea > div + div {
+div.messageTooltipActiveArea > div + div {
   margin-left: 4px;
 }
 
-div.messageActionLinkIcon:hover {
+div.messageTooltipLinkIcon:hover {
   cursor: pointer;
 }
 
 div.textMessage {
   padding: 6px 12px;
   white-space: pre-wrap;
   word-wrap: break-word;
   width: 100%;
   box-sizing: border-box;
 }
 div.textMessageDefaultBackground {
   background-color: var(--text-message-default-background);
 }
 div.normalTextMessage {
   font-size: 16px;
 }
 div.emojiOnlyTextMessage {
   font-size: 32px;
   font-family: emoji;
 }
 span.authorName {
   color: #777777;
   font-size: 14px;
   padding: 4px 24px;
 }
 div.darkTextMessage {
   color: white;
 }
 div.lightTextMessage {
   color: black;
 }
 
 div.content {
   display: flex;
   flex-shrink: 0;
   align-items: center;
   margin-bottom: 5px;
   box-sizing: border-box;
   width: 100%;
 }
 div.nonViewerContent {
   align-self: flex-start;
   justify-content: flex-start;
   padding-right: 8px;
 }
 div.viewerContent {
   align-self: flex-end;
   justify-content: flex-end;
   padding-right: 4px;
 }
 div.iconContainer {
   margin-right: 1px;
 }
 div.iconContainer > svg {
   height: 16px;
 }
 
 div.messageBoxContainer {
   position: relative;
   display: flex;
   max-width: calc(min(68%, 1000px));
   margin: 0 4px 0 12px;
 }
 div.fixedWidthMessageBoxContainer {
   width: 68%;
 }
 
 div.messageBox {
   overflow: hidden;
   display: flex;
   flex-wrap: wrap;
   justify-content: space-between;
   flex-shrink: 0;
   max-width: 100%;
 }
 div.fixedWidthMessageBox {
   width: 100%;
 }
 
 div.failedSend {
   text-transform: uppercase;
   display: flex;
   justify-content: flex-end;
   flex-shrink: 0;
   font-size: 14px;
   margin-right: 30px;
   padding-bottom: 6px;
 }
 span.deliveryFailed {
   padding: 0 3px;
   color: #555555;
 }
 a.retrySend {
   padding: 0 3px;
   cursor: pointer;
 }
 
 div.messageBox > div.imageGrid {
   display: grid;
   width: 100%;
   grid-template-columns: repeat(6, 1fr);
   grid-gap: 5px;
 }
 div.messageBox span.multimedia > span.multimediaImage {
   min-height: initial;
   min-width: initial;
 }
 div.messageBox span.multimedia > span.multimediaImage > img {
   max-height: 600px;
 }
 
 div.imageGrid > span.multimedia {
   grid-column-end: span 3;
 }
 div.imageGrid > span.multimedia:first-child {
   margin-top: 0;
 }
 div.imageGrid > span.multimedia > span.multimediaImage {
   flex: 1;
 }
 div.imageGrid > span.multimedia > span.multimediaImage:after {
   content: '';
   display: block;
   padding-bottom: calc(min(600px, 100%));
 }
 div.imageGrid > span.multimedia > span.multimediaImage > img {
   position: absolute;
   width: 100%;
   height: 100%;
   object-fit: cover;
 }
 
 div.imageGrid > span.multimedia:nth-last-child(n + 3):first-child,
 div.imageGrid > span.multimedia:nth-last-child(n + 3):first-child ~ * {
   grid-column-end: span 2;
 }
 div.imageGrid > span.multimedia:nth-last-child(n + 4):first-child,
 div.imageGrid > span.multimedia:nth-last-child(n + 4):first-child ~ * {
   grid-column-end: span 3;
 }
 div.imageGrid > span.multimedia:nth-last-child(n + 5):first-child,
 div.imageGrid > span.multimedia:nth-last-child(n + 5):first-child ~ * {
   grid-column-end: span 2;
 }
 div.sidebarMarginBottom {
   margin-bottom: 8px;
 }
 svg.inlineSidebarIcon {
   color: #666666;
 }
diff --git a/web/chat/composed-message.react.js b/web/chat/composed-message.react.js
index a31cd31a9..786e8387b 100644
--- a/web/chat/composed-message.react.js
+++ b/web/chat/composed-message.react.js
@@ -1,235 +1,235 @@
 // @flow
 
 import classNames from 'classnames';
 import * as React from 'react';
 import {
   Circle as CircleIcon,
   CheckCircle as CheckCircleIcon,
   XCircle as XCircleIcon,
 } from 'react-feather';
 
 import { type ChatMessageInfoItem } from 'lib/selectors/chat-selectors';
 import { useSidebarExistsOrCanBeCreated } from 'lib/shared/thread-utils';
 import { stringForUser } from 'lib/shared/user-utils';
 import { assertComposableMessageType } from 'lib/types/message-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
 
 import { type InputState, InputStateContext } from '../input/input-state';
 import css from './chat-message-list.css';
 import FailedSend from './failed-send.react';
 import { InlineSidebar } from './inline-sidebar.react';
-import MessageActionButtons from './message-action-buttons';
+import MessageTooltip from './message-tooltip.react';
 import {
   type OnMessagePositionWithContainerInfo,
   type MessagePositionInfo,
 } from './position-types';
 import { tooltipPositions } from './tooltip-utils';
 
 const availableTooltipPositionsForViewerMessage = [
   tooltipPositions.TOP_RIGHT,
   tooltipPositions.LEFT,
 ];
 const availableTooltipPositionsForNonViewerMessage = [
   tooltipPositions.TOP_LEFT,
   tooltipPositions.RIGHT,
 ];
 
 type BaseProps = {
   +item: ChatMessageInfoItem,
   +threadInfo: ThreadInfo,
   +sendFailed: boolean,
   +setMouseOverMessagePosition: (
     messagePositionInfo: MessagePositionInfo,
   ) => void,
   +mouseOverMessagePosition?: ?OnMessagePositionWithContainerInfo,
   +canReply: boolean,
   +children: React.Node,
   +fixedWidth?: boolean,
   +borderRadius: number,
 };
 type BaseConfig = React.Config<BaseProps, typeof ComposedMessage.defaultProps>;
 type Props = {
   ...BaseProps,
   // Redux state
   +sidebarExistsOrCanBeCreated: boolean,
   // withInputState
   +inputState: ?InputState,
 };
 class ComposedMessage extends React.PureComponent<Props> {
   static defaultProps: { +borderRadius: number } = {
     borderRadius: 8,
   };
 
   render(): React.Node {
     assertComposableMessageType(this.props.item.messageInfo.type);
     const { borderRadius, item, threadInfo } = this.props;
     const { id, creator } = item.messageInfo;
     const threadColor = threadInfo.color;
 
     const { isViewer } = creator;
     const contentClassName = classNames({
       [css.content]: true,
       [css.viewerContent]: isViewer,
       [css.nonViewerContent]: !isViewer,
     });
     const messageBoxContainerClassName = classNames({
       [css.messageBoxContainer]: true,
       [css.fixedWidthMessageBoxContainer]: this.props.fixedWidth,
     });
     const messageBoxClassName = classNames({
       [css.messageBox]: true,
       [css.fixedWidthMessageBox]: this.props.fixedWidth,
     });
     const messageBoxStyle = {
       borderTopRightRadius: isViewer && !item.startsCluster ? 0 : borderRadius,
       borderBottomRightRadius: isViewer && !item.endsCluster ? 0 : borderRadius,
       borderTopLeftRadius: !isViewer && !item.startsCluster ? 0 : borderRadius,
       borderBottomLeftRadius: !isViewer && !item.endsCluster ? 0 : borderRadius,
     };
 
     let authorName = null;
     if (!isViewer && item.startsCluster) {
       authorName = (
         <span className={css.authorName}>{stringForUser(creator)}</span>
       );
     }
 
     let deliveryIcon = null;
     let failedSendInfo = null;
     if (isViewer) {
       let deliveryIconSpan;
       let deliveryIconColor = threadColor;
       if (id !== null && id !== undefined) {
         deliveryIconSpan = <CheckCircleIcon />;
       } else if (this.props.sendFailed) {
         deliveryIconSpan = <XCircleIcon />;
         deliveryIconColor = 'FF0000';
         failedSendInfo = <FailedSend item={item} threadInfo={threadInfo} />;
       } else {
         deliveryIconSpan = <CircleIcon />;
       }
       deliveryIcon = (
         <div
           className={css.iconContainer}
           style={{ color: `#${deliveryIconColor}` }}
         >
           {deliveryIconSpan}
         </div>
       );
     }
 
-    let messageActionButtons;
+    let messageTooltip;
     if (
       this.props.mouseOverMessagePosition &&
       this.props.mouseOverMessagePosition.item.messageInfo.id === id &&
       (this.props.sidebarExistsOrCanBeCreated || this.props.canReply)
     ) {
       const availableTooltipPositions = isViewer
         ? availableTooltipPositionsForViewerMessage
         : availableTooltipPositionsForNonViewerMessage;
 
-      messageActionButtons = (
-        <MessageActionButtons
+      messageTooltip = (
+        <MessageTooltip
           threadInfo={threadInfo}
           item={item}
           availableTooltipPositions={availableTooltipPositions}
           setMouseOverMessagePosition={this.props.setMouseOverMessagePosition}
           mouseOverMessagePosition={this.props.mouseOverMessagePosition}
           canReply={this.props.canReply}
           inputState={this.props.inputState}
         />
       );
     }
 
-    let messageActionLinks;
-    if (messageActionButtons) {
-      const actionLinksClassName = classNames({
-        [css.messageActionActiveArea]: true,
-        [css.viewerMessageActionActiveArea]: isViewer,
+    let messageTooltipLinks;
+    if (messageTooltip) {
+      const tooltipLinksClassName = classNames({
+        [css.messageTooltipActiveArea]: true,
+        [css.viewerMessageTooltipActiveArea]: isViewer,
         [css.nonViewerMessageActiveArea]: !isViewer,
       });
 
-      messageActionLinks = (
-        <div className={actionLinksClassName}>{messageActionButtons}</div>
+      messageTooltipLinks = (
+        <div className={tooltipLinksClassName}>{messageTooltip}</div>
       );
     }
 
-    const viewerActionLinks = isViewer ? messageActionLinks : null;
-    const nonViewerActionLinks = !isViewer ? messageActionLinks : null;
+    const viewerTooltipLinks = isViewer ? messageTooltipLinks : null;
+    const nonViewerTooltipLinks = !isViewer ? messageTooltipLinks : null;
 
     let inlineSidebar = null;
     if (item.threadCreatedFromMessage) {
       const positioning = isViewer ? 'right' : 'left';
       inlineSidebar = (
         <div className={css.sidebarMarginBottom}>
           <InlineSidebar
             threadInfo={item.threadCreatedFromMessage}
             positioning={positioning}
           />
         </div>
       );
     }
 
     return (
       <React.Fragment>
         {authorName}
         <div className={contentClassName}>
           <div
             className={messageBoxContainerClassName}
             onMouseEnter={this.onMouseEnter}
             onMouseLeave={this.onMouseLeave}
           >
-            {viewerActionLinks}
+            {viewerTooltipLinks}
             <div className={messageBoxClassName} style={messageBoxStyle}>
               {this.props.children}
             </div>
-            {nonViewerActionLinks}
+            {nonViewerTooltipLinks}
           </div>
           {deliveryIcon}
         </div>
         {failedSendInfo}
         {inlineSidebar}
       </React.Fragment>
     );
   }
 
   onMouseEnter: (event: SyntheticEvent<HTMLDivElement>) => void = event => {
     const { item } = this.props;
     const rect = event.currentTarget.getBoundingClientRect();
     const { top, bottom, left, right, height, width } = rect;
     const messagePosition = { top, bottom, left, right, height, width };
     this.props.setMouseOverMessagePosition({
       type: 'on',
       item,
       messagePosition,
     });
   };
 
   onMouseLeave: () => void = () => {
     const { item } = this.props;
     this.props.setMouseOverMessagePosition({ type: 'off', item });
   };
 }
 
 type ConnectedConfig = React.Config<
   BaseProps,
   typeof ComposedMessage.defaultProps,
 >;
 const ConnectedComposedMessage: React.ComponentType<ConnectedConfig> = React.memo<BaseConfig>(
   function ConnectedComposedMessage(props) {
     const sidebarExistsOrCanBeCreated = useSidebarExistsOrCanBeCreated(
       props.threadInfo,
       props.item,
     );
     const inputState = React.useContext(InputStateContext);
     return (
       <ComposedMessage
         {...props}
         sidebarExistsOrCanBeCreated={sidebarExistsOrCanBeCreated}
         inputState={inputState}
       />
     );
   },
 );
 
 export default ConnectedComposedMessage;
diff --git a/web/chat/message-action-buttons.css b/web/chat/message-tooltip.css
similarity index 100%
rename from web/chat/message-action-buttons.css
rename to web/chat/message-tooltip.css
diff --git a/web/chat/message-action-buttons.js b/web/chat/message-tooltip.react.js
similarity index 97%
rename from web/chat/message-action-buttons.js
rename to web/chat/message-tooltip.react.js
index 97188bd04..bc2cc62d2 100644
--- a/web/chat/message-action-buttons.js
+++ b/web/chat/message-tooltip.react.js
@@ -1,275 +1,275 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import type { ChatMessageInfoItem } from 'lib/selectors/chat-selectors';
 import { useSidebarExistsOrCanBeCreated } from 'lib/shared/thread-utils';
 import type { ThreadInfo } from 'lib/types/thread-types';
 import { longAbsoluteDate } from 'lib/utils/date-utils';
 
 import type { InputState } from '../input/input-state';
 import { useSelector } from '../redux/redux-utils';
 import {
   useOnClickThread,
   useOnClickPendingSidebar,
 } from '../selectors/nav-selectors';
 import SWMansionIcon from '../SWMansionIcon.react';
-import css from './message-action-buttons.css';
 import MessageReplyButton from './message-reply-button.react';
+import css from './message-tooltip.css';
 import type {
   ItemAndContainerPositionInfo,
   MessagePositionInfo,
   OnMessagePositionWithContainerInfo,
   PositionInfo,
 } from './position-types';
 import { tooltipPositions, type TooltipPosition } from './tooltip-utils';
 import {
   TooltipMenu,
   type TooltipStyle,
   TooltipTextItem,
 } from './tooltip.react';
 
 const messageActionIconExcessVerticalWhitespace = 10;
 
 const openSidebarText = 'Go to sidebar';
 const createSidebarText = 'Create sidebar';
 
 type TooltipType = 'sidebar' | 'reply';
 
-type MessageActionButtonsProps = {
+type MessageTooltipProps = {
   +threadInfo: ThreadInfo,
   +item: ChatMessageInfoItem,
   +availableTooltipPositions: $ReadOnlyArray<TooltipPosition>,
   +setMouseOverMessagePosition?: (
     messagePositionInfo: MessagePositionInfo,
   ) => void,
   +mouseOverMessagePosition: OnMessagePositionWithContainerInfo,
   +canReply?: boolean,
   +inputState?: ?InputState,
 };
-function MessageActionButtons(props: MessageActionButtonsProps): React.Node {
+function MessageTooltip(props: MessageTooltipProps): React.Node {
   const {
     threadInfo,
     item,
     availableTooltipPositions,
     setMouseOverMessagePosition,
     mouseOverMessagePosition,
     canReply,
     inputState,
   } = props;
 
   const { containerPosition } = mouseOverMessagePosition;
 
   const [activeTooltip, setActiveTooltip] = React.useState<?TooltipType>();
   const [pointingTo, setPointingTo] = React.useState();
 
   const showTooltip = React.useCallback(
     (tooltipType: TooltipType, iconPosition: ItemAndContainerPositionInfo) => {
       if (activeTooltip) {
         return;
       }
       setActiveTooltip(tooltipType);
       setPointingTo(iconPosition);
     },
     [activeTooltip],
   );
 
   const hideTooltip = React.useCallback(() => {
     setActiveTooltip(null);
   }, []);
 
   const showSidebarTooltip = React.useCallback(
     (event: SyntheticEvent<HTMLDivElement>) => {
       const rect = event.currentTarget.getBoundingClientRect();
       const iconPosition = getIconPosition(rect, containerPosition);
       showTooltip('sidebar', iconPosition);
     },
     [containerPosition, showTooltip],
   );
 
   const showReplyTooltip = React.useCallback(
     (event: SyntheticEvent<HTMLDivElement>) => {
       const rect = event.currentTarget.getBoundingClientRect();
       const iconPosition = getIconPosition(rect, containerPosition);
       showTooltip('reply', iconPosition);
     },
     [containerPosition, showTooltip],
   );
 
   const { threadCreatedFromMessage, messageInfo } = item;
 
   const onThreadOpen = useOnClickThread(threadCreatedFromMessage);
   const onPendingSidebarOpen = useOnClickPendingSidebar(
     messageInfo,
     threadInfo,
   );
   const onSidebarButtonClick = React.useCallback(
     (event: SyntheticEvent<HTMLButtonElement>) => {
       if (threadCreatedFromMessage) {
         onThreadOpen(event);
       } else {
         onPendingSidebarOpen(event);
       }
     },
     [onPendingSidebarOpen, onThreadOpen, threadCreatedFromMessage],
   );
 
   const onReplyButtonClick = React.useCallback(() => {
     invariant(
       setMouseOverMessagePosition,
       'setMouseOverMessagePosition should be set if replyButton exists',
     );
     setMouseOverMessagePosition({ type: 'off', item: item });
   }, [item, setMouseOverMessagePosition]);
 
   let tooltipText = '';
   if (activeTooltip === 'reply') {
     tooltipText = 'Reply';
   } else if (activeTooltip === 'sidebar') {
     tooltipText = threadCreatedFromMessage
       ? openSidebarText
       : createSidebarText;
   }
 
   let tooltipMenu = null;
   if (pointingTo && activeTooltip) {
     tooltipMenu = (
       <TooltipMenu
         availableTooltipPositions={availableTooltipPositions}
         targetPositionInfo={pointingTo}
         layoutPosition="relative"
         getStyle={getMessageActionTooltipStyle}
       >
         <TooltipTextItem text={tooltipText} />
       </TooltipMenu>
     );
   }
 
   let replyButton;
   if (canReply) {
     invariant(inputState, 'inputState must be set if replyButton exists');
     invariant(
       mouseOverMessagePosition,
       'mouseOverMessagePosition must be set if replyButton exists',
     );
     replyButton = (
       <div
         className={css.messageActionLinkIcon}
         onMouseEnter={showReplyTooltip}
         onMouseLeave={hideTooltip}
       >
         <MessageReplyButton
           messagePositionInfo={mouseOverMessagePosition}
           onReplyClick={onReplyButtonClick}
           inputState={inputState}
         />
         {activeTooltip === 'reply' ? tooltipMenu : null}
       </div>
     );
   }
 
   const sidebarExistsOrCanBeCreated = useSidebarExistsOrCanBeCreated(
     threadInfo,
     item,
   );
 
   let sidebarButton;
   if (sidebarExistsOrCanBeCreated) {
     sidebarButton = (
       <div
         className={css.messageActionLinkIcon}
         onMouseEnter={showSidebarTooltip}
         onMouseLeave={hideTooltip}
         onClick={onSidebarButtonClick}
       >
         <SWMansionIcon icon="message-circle-lines" size={18} />
         {activeTooltip === 'sidebar' ? tooltipMenu : null}
       </div>
     );
   }
 
   const timezone = useSelector(state => state.timeZone);
   const timestampText = React.useMemo(
     () => longAbsoluteDate(messageInfo.time, timezone),
     [messageInfo.time, timezone],
   );
 
   const { isViewer } = messageInfo.creator;
   const messageActionButtonsContainerClassName = classNames({
     [css.messageActionContainer]: true,
     [css.messageActionButtons]: true,
     [css.messageActionButtonsViewer]: isViewer,
     [css.messageActionButtonsNonViewer]: !isViewer,
   });
   return (
     <div>
       <div className={messageActionButtonsContainerClassName}>
         {sidebarButton}
         {replyButton}
       </div>
       <div className={css.timestampContainer}>
         <p>{timestampText}</p>
       </div>
     </div>
   );
 }
 
 function getIconPosition(
   rect: ClientRect,
   containerPosition: PositionInfo,
 ): ItemAndContainerPositionInfo {
   const { top, bottom, left, right, width, height } = rect;
   return {
     containerPosition,
     itemPosition: {
       top:
         top - containerPosition.top + messageActionIconExcessVerticalWhitespace,
       bottom:
         bottom -
         containerPosition.top -
         messageActionIconExcessVerticalWhitespace,
       left: left - containerPosition.left,
       right: right - containerPosition.left,
       width,
       height: height - messageActionIconExcessVerticalWhitespace * 2,
     },
   };
 }
 
 function getMessageActionTooltipStyle(
   tooltipPosition: TooltipPosition,
 ): TooltipStyle {
   let className;
   if (tooltipPosition === tooltipPositions.TOP_RIGHT) {
     className = classNames(
       css.messageActionTopRightTooltip,
       css.messageActionExtraAreaTop,
       css.messageActionExtraAreaTopRight,
     );
   } else if (tooltipPosition === tooltipPositions.TOP_LEFT) {
     className = classNames(
       css.messageActionTopLeftTooltip,
       css.messageActionExtraAreaTop,
       css.messageActionExtraAreaTopLeft,
     );
   } else if (tooltipPosition === tooltipPositions.RIGHT) {
     className = classNames(
       css.messageActionRightTooltip,
       css.messageActionExtraArea,
       css.messageActionExtraAreaRight,
     );
   } else if (tooltipPosition === tooltipPositions.LEFT) {
     className = classNames(
       css.messageActionLeftTooltip,
       css.messageActionExtraArea,
       css.messageActionExtraAreaLeft,
     );
   }
 
   invariant(className, `${tooltipPosition} is not valid for message tooltip`);
   return { className };
 }
 
-export default MessageActionButtons;
+export default MessageTooltip;
diff --git a/web/chat/robotext-message.css b/web/chat/robotext-message.css
index 710700cdf..0abe9004a 100644
--- a/web/chat/robotext-message.css
+++ b/web/chat/robotext-message.css
@@ -1,35 +1,35 @@
 div.robotextContainer {
   text-align: center;
   color: var(--fg);
   padding: 6px 0;
   margin: 0 40px 5px 40px;
   font-size: var(--s-font-14);
   line-height: var(--line-height-text);
 }
 div.innerRobotextContainer {
   display: inline-flex;
   position: relative;
   word-break: break-word;
 }
 div.sidebarMarginTop {
   margin-top: 4px;
   margin-bottom: -8px;
 }
-div.messageActionLinks {
+div.messageTooltipLinks {
   position: absolute;
   display: flex;
   top: 0;
   bottom: 0;
   align-items: center;
   color: gray;
   padding: 0 6px;
 }
-div.viewerMessageActionLinks {
+div.viewerMessageTooltipLinks {
   right: 100%;
 }
-div.nonViewerMessageActionLinks {
+div.nonViewerMessageTooltipLinks {
   left: 100%;
 }
-div.messageActionLinks > div + div {
+div.messageTooltipLinks > div + div {
   margin-left: 4px;
 }
diff --git a/web/chat/robotext-message.react.js b/web/chat/robotext-message.react.js
index a978790af..1544a4b2e 100644
--- a/web/chat/robotext-message.react.js
+++ b/web/chat/robotext-message.react.js
@@ -1,220 +1,220 @@
 // @flow
 
 import classNames from 'classnames';
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 
 import { type RobotextChatMessageInfoItem } from 'lib/selectors/chat-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { splitRobotext, parseRobotextEntity } from 'lib/shared/message-utils';
 import { useSidebarExistsOrCanBeCreated } from 'lib/shared/thread-utils';
 import type { Dispatch } from 'lib/types/redux-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
 
 import Markdown from '../markdown/markdown.react';
 import { linkRules } from '../markdown/rules.react';
 import { useSelector } from '../redux/redux-utils';
 import { updateNavInfoActionType } from '../types/nav-types';
 import { InlineSidebar } from './inline-sidebar.react';
-import MessageActionButtons from './message-action-buttons';
+import MessageTooltip from './message-tooltip.react';
 import type {
   MessagePositionInfo,
   OnMessagePositionWithContainerInfo,
 } from './position-types';
 import css from './robotext-message.css';
 import { tooltipPositions } from './tooltip-utils';
 
 const availableTooltipPositionsForRobotext = [
   tooltipPositions.TOP_RIGHT,
   tooltipPositions.RIGHT,
   tooltipPositions.LEFT,
 ];
 
 type BaseProps = {
   +item: RobotextChatMessageInfoItem,
   +threadInfo: ThreadInfo,
   +setMouseOverMessagePosition: (
     messagePositionInfo: MessagePositionInfo,
   ) => void,
   +mouseOverMessagePosition: ?OnMessagePositionWithContainerInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +sidebarExistsOrCanBeCreated: boolean,
 };
 class RobotextMessage extends React.PureComponent<Props> {
   render() {
     let inlineSidebar;
     if (this.props.item.threadCreatedFromMessage) {
       inlineSidebar = (
         <div className={css.sidebarMarginTop}>
           <InlineSidebar
             threadInfo={this.props.item.threadCreatedFromMessage}
             positioning="center"
           />
         </div>
       );
     }
 
     const { item, threadInfo, sidebarExistsOrCanBeCreated } = this.props;
     const { id } = item.messageInfo;
-    let messageActionTooltip;
+    let messageTooltip;
     if (
       this.props.mouseOverMessagePosition &&
       this.props.mouseOverMessagePosition.item.messageInfo.id === id &&
       sidebarExistsOrCanBeCreated
     ) {
-      messageActionTooltip = (
-        <MessageActionButtons
+      messageTooltip = (
+        <MessageTooltip
           threadInfo={threadInfo}
           item={item}
           mouseOverMessagePosition={this.props.mouseOverMessagePosition}
           availableTooltipPositions={availableTooltipPositionsForRobotext}
         />
       );
     }
 
-    let messageActionLinks;
-    if (messageActionTooltip) {
-      messageActionLinks = (
+    let messageTooltipLinks;
+    if (messageTooltip) {
+      messageTooltipLinks = (
         <div
           className={classNames(
-            css.messageActionLinks,
-            css.nonViewerMessageActionLinks,
+            css.messageTooltipLinks,
+            css.nonViewerMessageTooltipLinks,
           )}
         >
-          {messageActionTooltip}
+          {messageTooltip}
         </div>
       );
     }
 
     return (
       <div className={css.robotextContainer}>
         <div
           className={css.innerRobotextContainer}
           onMouseEnter={this.onMouseEnter}
           onMouseLeave={this.onMouseLeave}
         >
           <span>{this.linkedRobotext()}</span>
-          {messageActionLinks}
+          {messageTooltipLinks}
         </div>
         {inlineSidebar}
       </div>
     );
   }
 
   linkedRobotext() {
     const { item } = this.props;
     const { robotext } = item;
     const robotextParts = splitRobotext(robotext);
     const textParts = [];
     let keyIndex = 0;
     for (const splitPart of robotextParts) {
       if (splitPart === '') {
         continue;
       }
       if (splitPart.charAt(0) !== '<') {
         const key = `text${keyIndex++}`;
         textParts.push(
           <Markdown key={key} rules={linkRules(false)}>
             {decodeURI(splitPart)}
           </Markdown>,
         );
         continue;
       }
 
       const { rawText, entityType, id } = parseRobotextEntity(splitPart);
 
       if (entityType === 't' && id !== item.messageInfo.threadID) {
         textParts.push(<ThreadEntity key={id} id={id} name={rawText} />);
       } else if (entityType === 'c') {
         textParts.push(<ColorEntity key={id} color={rawText} />);
       } else {
         textParts.push(rawText);
       }
     }
 
     return textParts;
   }
 
   onMouseEnter = (event: SyntheticEvent<HTMLDivElement>) => {
     const { item } = this.props;
     const rect = event.currentTarget.getBoundingClientRect();
     const { top, bottom, left, right, height, width } = rect;
     const messagePosition = { top, bottom, left, right, height, width };
     this.props.setMouseOverMessagePosition({
       type: 'on',
       item,
       messagePosition,
     });
   };
 
   onMouseLeave = () => {
     const { item } = this.props;
     this.props.setMouseOverMessagePosition({ type: 'off', item });
   };
 }
 
 type BaseInnerThreadEntityProps = {
   +id: string,
   +name: string,
 };
 type InnerThreadEntityProps = {
   ...BaseInnerThreadEntityProps,
   +threadInfo: ThreadInfo,
   +dispatch: Dispatch,
 };
 class InnerThreadEntity extends React.PureComponent<InnerThreadEntityProps> {
   render() {
     return <a onClick={this.onClickThread}>{this.props.name}</a>;
   }
 
   onClickThread = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const id = this.props.id;
     this.props.dispatch({
       type: updateNavInfoActionType,
       payload: {
         activeChatThreadID: id,
       },
     });
   };
 }
 const ThreadEntity = React.memo<BaseInnerThreadEntityProps>(
   function ConnectedInnerThreadEntity(props: BaseInnerThreadEntityProps) {
     const { id } = props;
     const threadInfo = useSelector(state => threadInfoSelector(state)[id]);
     const dispatch = useDispatch();
 
     return (
       <InnerThreadEntity
         {...props}
         threadInfo={threadInfo}
         dispatch={dispatch}
       />
     );
   },
 );
 
 function ColorEntity(props: { color: string }) {
   const colorStyle = { color: props.color };
   return <span style={colorStyle}>{props.color}</span>;
 }
 
 const ConnectedRobotextMessage: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedRobotextMessage(props) {
     const sidebarExistsOrCanBeCreated = useSidebarExistsOrCanBeCreated(
       props.threadInfo,
       props.item,
     );
     return (
       <RobotextMessage
         {...props}
         sidebarExistsOrCanBeCreated={sidebarExistsOrCanBeCreated}
       />
     );
   },
 );
 
 export default ConnectedRobotextMessage;