diff --git a/lib/shared/messages/message-spec.js b/lib/shared/messages/message-spec.js
index 4a53d313d..0373dbc0b 100644
--- a/lib/shared/messages/message-spec.js
+++ b/lib/shared/messages/message-spec.js
@@ -1,117 +1,117 @@
 // @flow
 
 import type { PlatformDetails } from '../../types/device-types.js';
 import type { Media } from '../../types/media-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
   RawComposableMessageInfo,
   RawMessageInfo,
   RawRobotextMessageInfo,
 } from '../../types/message-types.js';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo, UserInfo } from '../../types/user-types.js';
 import type { EntityText } from '../../utils/entity-text.js';
 import { type ParserRules } from '../markdown.js';
 
 export type MessageTitleParam<Info> = {
   +messageInfo: Info,
   +threadInfo: ThreadInfo,
   +markdownRules: ParserRules,
 };
 
 export type RawMessageInfoFromServerDBRowParams = {
   +localID: ?string,
   +media?: $ReadOnlyArray<Media>,
   +derivedMessages: $ReadOnlyMap<
     string,
     RawComposableMessageInfo | RawRobotextMessageInfo,
   >,
 };
 
 export type CreateMessageInfoParams = {
   +threadInfos: { +[id: string]: ThreadInfo },
   +createMessageInfoFromRaw: (rawInfo: RawMessageInfo) => ?MessageInfo,
   +createRelativeUserInfos: (
     userIDs: $ReadOnlyArray<string>,
   ) => RelativeUserInfo[],
 };
 
 export type RobotextParams = {
   +threadInfo: ?ThreadInfo,
 };
 
 export type NotificationTextsParams = {
   +notificationTexts: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ) => Promise<?NotifTexts>,
   +notifTargetUserInfo: UserInfo,
 };
 
 export type GeneratesNotifsParams = {
   +notifTargetUserID: string,
   +userNotMemberOfSubthreads: Set<string>,
   +fetchMessageInfoByID: (messageID: string) => Promise<?RawMessageInfo>,
 };
 
 export const pushTypes = Object.freeze({
   NOTIF: 'notif',
   RESCIND: 'rescind',
 });
 export type PushType = $Values<typeof pushTypes>;
 
 export type CreationSideEffectsFunc<RawInfo> = (
   messageInfo: RawInfo,
   threadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
 ) => Promise<mixed>;
 
 export type MessageSpec<Data, RawInfo, Info> = {
   +messageContentForServerDB?: (data: Data | RawInfo) => string,
   +messageContentForClientDB?: (data: RawInfo) => string,
   +messageTitle?: (param: MessageTitleParam<Info>) => EntityText,
   +rawMessageInfoFromServerDBRow?: (
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ) => ?RawInfo,
   +rawMessageInfoFromClientDB: (
     clientDBMessageInfo: ClientDBMessageInfo,
   ) => RawInfo,
   +createMessageInfo: (
     rawMessageInfo: RawInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ) => ?Info,
   +rawMessageInfoFromMessageData?: (messageData: Data, id: ?string) => RawInfo,
   +robotext?: (messageInfo: Info, params: RobotextParams) => EntityText,
   +shimUnsupportedMessageInfo?: (
     rawMessageInfo: RawInfo,
     platformDetails: ?PlatformDetails,
   ) => RawInfo | RawUnsupportedMessageInfo,
   +unshimMessageInfo?: (
     unwrapped: RawInfo,
     messageInfo: RawMessageInfo,
   ) => ?RawMessageInfo,
   +notificationTexts?: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ) => Promise<?NotifTexts>,
   +notificationCollapseKey?: (
     rawMessageInfo: RawInfo,
     messageData: Data,
-  ) => string,
+  ) => ?string,
   +generatesNotifs: (
     rawMessageInfo: RawInfo,
     messageData: Data,
     params: GeneratesNotifsParams,
   ) => Promise<?PushType>,
   +userIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +startsThread?: boolean,
   +threadIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +includedInRepliesCount?: boolean,
   +useCreationSideEffectsFunc?: () => CreationSideEffectsFunc<RawInfo>,
 };
diff --git a/lib/shared/messages/text-message-spec.js b/lib/shared/messages/text-message-spec.js
index a4fdf69a4..02a712261 100644
--- a/lib/shared/messages/text-message-spec.js
+++ b/lib/shared/messages/text-message-spec.js
@@ -1,257 +1,315 @@
 // @flow
 
 import invariant from 'invariant';
 import * as SimpleMarkdown from 'simple-markdown';
 
 import {
   pushTypes,
   type MessageSpec,
   type RawMessageInfoFromServerDBRowParams,
+  type NotificationTextsParams,
 } from './message-spec.js';
-import { assertSingleMessageInfo } from './utils.js';
+import { assertSingleMessageInfo, joinResult } from './utils.js';
 import {
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } from '../../actions/thread-actions.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   RawTextMessageInfo,
   TextMessageData,
   TextMessageInfo,
 } from '../../types/messages/text.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import { threadTypes } from '../../types/thread-types.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from '../../utils/action-utils.js';
 import { ET } from '../../utils/entity-text.js';
 import {
   type ASTNode,
   type SingleASTNode,
   stripSpoilersFromNotifications,
   stripSpoilersFromMarkdownAST,
 } from '../markdown.js';
+import { isMentioned } from '../mention-utils.js';
+import { notifTextsForSidebarCreation } from '../notif-utils.js';
 import {
   threadIsGroupChat,
   extractNewMentionedParentMembers,
 } from '../thread-utils.js';
 
 /**
  * most of the markdown leaves contain `content` field
  * (it is an array or a string) apart from lists,
  * which have `items` field (that holds an array)
  */
 const rawTextFromMarkdownAST = (node: ASTNode): string => {
   if (Array.isArray(node)) {
     return node.map(rawTextFromMarkdownAST).join('');
   }
   const { content, items } = node;
   if (content && typeof content === 'string') {
     return content;
   } else if (items) {
     return rawTextFromMarkdownAST(items);
   } else if (content) {
     return rawTextFromMarkdownAST(content);
   }
   return '';
 };
 
 const getFirstNonQuotedRawLine = (
   nodes: $ReadOnlyArray<SingleASTNode>,
 ): string => {
   let result = 'message';
   for (const node of nodes) {
     if (node.type === 'blockQuote') {
       result = 'quoted message';
     } else {
       const rawText = rawTextFromMarkdownAST(node);
       if (!rawText || !rawText.replace(/\s/g, '')) {
         // handles the case of an empty(or containing only white spaces)
         // new line that usually occurs between a quote and the rest
         // of the message(we don't want it as a title, thus continue)
         continue;
       }
       return rawText;
     }
   }
   return result;
 };
 
 export const textMessageSpec: MessageSpec<
   TextMessageData,
   RawTextMessageInfo,
   TextMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: TextMessageData | RawTextMessageInfo,
   ): string {
     return data.text;
   },
 
   messageContentForClientDB(data: RawTextMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   messageTitle({ messageInfo, markdownRules }) {
     const { text } = messageInfo;
     const parser = SimpleMarkdown.parserFor(markdownRules);
     const ast = stripSpoilersFromMarkdownAST(
       parser(text, { disableAutoBlockNewlines: true }),
     );
     return ET`${getFirstNonQuotedRawLine(ast).trim()}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       text: row.content,
     };
     if (params.localID) {
       rawTextMessageInfo = { ...rawTextMessageInfo, localID: params.localID };
     }
     return rawTextMessageInfo;
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       text: clientDBMessageInfo.content ?? '',
     };
     if (clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         localID: clientDBMessageInfo.local_id,
       };
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         id: clientDBMessageInfo.id,
       };
     }
     return rawTextMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawTextMessageInfo,
     creator: RelativeUserInfo,
   ): TextMessageInfo {
     let messageInfo: TextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       text: rawMessageInfo.text,
     };
     if (rawMessageInfo.id) {
       messageInfo = { ...messageInfo, id: rawMessageInfo.id };
     }
     if (rawMessageInfo.localID) {
       messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
     }
     return messageInfo;
   },
 
   rawMessageInfoFromMessageData(
     messageData: TextMessageData,
     id: ?string,
   ): RawTextMessageInfo {
     const { sidebarCreation, ...rest } = messageData;
     if (id) {
       return { ...rest, id };
     } else {
       return { ...rest };
     }
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-  ): Promise<NotifTexts> {
+    params: NotificationTextsParams,
+  ): Promise<?NotifTexts> {
+    // We special-case sidebarCreations. Usually we don't send any notifs in
+    // that case to avoid a double-notif, but we need to update the original
+    // notif if somebody was @-tagged in this message
+    if (
+      messageInfos.length === 3 &&
+      messageInfos[2].type === messageTypes.SIDEBAR_SOURCE &&
+      messageInfos[1].type === messageTypes.CREATE_SIDEBAR
+    ) {
+      const sidebarSourceMessageInfo = messageInfos[2];
+      const createSidebarMessageInfo = messageInfos[1];
+
+      const sourceMessage = messageInfos[2].sourceMessage;
+      const { username } = params.notifTargetUserInfo;
+      if (!username) {
+        // If we couldn't fetch the username for some reason, we won't be able
+        // to extract @-mentions anyways, so we'll give up on updating the notif
+        return null;
+      }
+
+      if (
+        sourceMessage.type === messageTypes.TEXT &&
+        isMentioned(username, sourceMessage.text)
+      ) {
+        // If the notif target was already mentioned in the source message,
+        // there's no need to update the notif
+        return null;
+      }
+
+      const messageInfo = messageInfos[0];
+      invariant(
+        messageInfo.type === messageTypes.TEXT,
+        'messageInfo should be messageTypes.TEXT!',
+      );
+      if (!isMentioned(username, messageInfo.text)) {
+        // We only need to update the notif if the notif target is mentioned
+        return null;
+      }
+
+      return notifTextsForSidebarCreation({
+        createSidebarMessageInfo,
+        sidebarSourceMessageInfo,
+        firstSidebarMessageInfo: messageInfo,
+        threadInfo,
+        params,
+      });
+    }
+
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     const notificationTextWithoutSpoilers = stripSpoilersFromNotifications(
       messageInfo.text,
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       const thread = ET.thread({ display: 'uiName', threadInfo });
       return {
         merged: ET`${thread}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
       };
     } else {
       const creator = ET.user({ userInfo: messageInfo.creator });
       const thread = ET.thread({ display: 'shortName', threadInfo });
       return {
         merged: ET`${creator} to ${thread}: ${notificationTextWithoutSpoilers}`,
         body: notificationTextWithoutSpoilers,
         title: threadInfo.uiName,
         prefix: ET`${creator}:`,
       };
     }
   },
 
-  generatesNotifs: async (
+  notificationCollapseKey(
     rawMessageInfo: RawTextMessageInfo,
     messageData: TextMessageData,
-  ) => (messageData.sidebarCreation ? undefined : pushTypes.NOTIF),
+  ): ?string {
+    if (!messageData.sidebarCreation) {
+      return null;
+    }
+    return joinResult(messageTypes.CREATE_SIDEBAR, rawMessageInfo.threadID);
+  },
+
+  generatesNotifs: async () => pushTypes.NOTIF,
 
   includedInRepliesCount: true,
 
   useCreationSideEffectsFunc: () => {
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useServerCall(changeThreadSettings);
     return async (
       messageInfo: RawTextMessageInfo,
       threadInfo: ThreadInfo,
       parentThreadInfo: ?ThreadInfo,
     ) => {
       if (threadInfo.type !== threadTypes.SIDEBAR) {
         return;
       }
       invariant(parentThreadInfo, 'all sidebars should have a parent thread');
 
       const mentionedNewMembers = extractNewMentionedParentMembers(
         messageInfo.text,
         threadInfo,
         parentThreadInfo,
       );
 
       if (mentionedNewMembers.length === 0) {
         return;
       }
 
       const newMemberIDs = mentionedNewMembers.map(({ id }) => id);
       const addMembersPromise = callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: { newMemberIDs },
       });
 
       dispatchActionPromise(changeThreadSettingsActionTypes, addMembersPromise);
       await addMembersPromise;
     };
   },
 });
diff --git a/lib/shared/notif-utils.js b/lib/shared/notif-utils.js
index afaa89e3c..fe4cd4a77 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,316 +1,325 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { isMentioned } from './mention-utils.js';
 import { robotextForMessageInfo } from './message-utils.js';
 import type { NotificationTextsParams } from './messages/message-spec.js';
 import { messageSpecs } from './messages/message-specs.js';
 import { threadNoun } from './thread-utils.js';
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type MessageType,
   type MessageData,
   type SidebarSourceMessageInfo,
   messageTypes,
 } from '../types/message-types.js';
 import type { CreateSidebarMessageInfo } from '../types/messages/create-sidebar.js';
+import type { TextMessageInfo } from '../types/messages/text.js';
 import type { NotifTexts, ResolvedNotifTexts } from '../types/notif-types.js';
 import type { ThreadInfo, ThreadType } from '../types/thread-types.js';
 import type { RelativeUserInfo, UserInfo } from '../types/user-types.js';
 import { prettyDate } from '../utils/date-utils.js';
 import type { GetENSNames } from '../utils/ens-helpers.js';
 import {
   ET,
   getEntityTextAsString,
   type EntityText,
   type ThreadEntity,
 } from '../utils/entity-text.js';
 import { promiseAll } from '../utils/promises.js';
 import { trimText } from '../utils/text-utils.js';
 
 async function notifTextsForMessageInfo(
   messageInfos: MessageInfo[],
   threadInfo: ThreadInfo,
   notifTargetUserInfo: UserInfo,
   getENSNames: ?GetENSNames,
 ): Promise<?ResolvedNotifTexts> {
   const fullNotifTexts = await fullNotifTextsForMessageInfo(
     messageInfos,
     threadInfo,
     notifTargetUserInfo,
     getENSNames,
   );
   if (!fullNotifTexts) {
     return fullNotifTexts;
   }
   const merged = trimText(fullNotifTexts.merged, 300);
   const body = trimText(fullNotifTexts.body, 300);
   const title = trimText(fullNotifTexts.title, 100);
   if (!fullNotifTexts.prefix) {
     return { merged, body, title };
   }
   const prefix = trimText(fullNotifTexts.prefix, 50);
   return { merged, body, title, prefix };
 }
 
 function notifTextsForEntryCreationOrEdit(
   messageInfos: $ReadOnlyArray<MessageInfo>,
   threadInfo: ThreadInfo,
 ): NotifTexts {
   const hasCreateEntry = messageInfos.some(
     messageInfo => messageInfo.type === messageTypes.CREATE_ENTRY,
   );
   const messageInfo = messageInfos[0];
 
   const thread = ET.thread({ display: 'shortName', threadInfo });
   const creator = ET.user({ userInfo: messageInfo.creator });
   const prefix = ET`${creator}`;
 
   if (!hasCreateEntry) {
     invariant(
       messageInfo.type === messageTypes.EDIT_ENTRY,
       'messageInfo should be messageTypes.EDIT_ENTRY!',
     );
     const date = prettyDate(messageInfo.date);
     let body = ET`updated the text of an event in ${thread}`;
     body = ET`${body} scheduled for ${date}: "${messageInfo.text}"`;
     const merged = ET`${prefix} ${body}`;
     return {
       merged,
       title: threadInfo.uiName,
       body,
       prefix,
     };
   }
   invariant(
     messageInfo.type === messageTypes.CREATE_ENTRY ||
       messageInfo.type === messageTypes.EDIT_ENTRY,
     'messageInfo should be messageTypes.CREATE_ENTRY/EDIT_ENTRY!',
   );
   const date = prettyDate(messageInfo.date);
   let body = ET`created an event in ${thread}`;
   body = ET`${body} scheduled for ${date}: "${messageInfo.text}"`;
   const merged = ET`${prefix} ${body}`;
   return {
     merged,
     title: threadInfo.uiName,
     body,
     prefix,
   };
 }
 
 type NotifTextsForSubthreadCreationInput = {
   +creator: RelativeUserInfo,
   +threadType: ThreadType,
   +parentThreadInfo: ThreadInfo,
   +childThreadName: ?string,
   +childThreadUIName: string | ThreadEntity,
 };
 function notifTextsForSubthreadCreation(
   input: NotifTextsForSubthreadCreationInput,
 ): NotifTexts {
   const {
     creator,
     threadType,
     parentThreadInfo,
     childThreadName,
     childThreadUIName,
   } = input;
 
   const prefix = ET`${ET.user({ userInfo: creator })}`;
 
   let body = `created a new ${threadNoun(threadType)}`;
   if (parentThreadInfo.name) {
     body = ET`${body} in ${parentThreadInfo.name}`;
   }
 
   let merged = ET`${prefix} ${body}`;
   if (childThreadName) {
     merged = ET`${merged} called "${childThreadName}"`;
   }
 
   return {
     merged,
     body,
     title: childThreadUIName,
     prefix,
   };
 }
 
 type NotifTextsForSidebarCreationInput = {
   +createSidebarMessageInfo: CreateSidebarMessageInfo,
   +sidebarSourceMessageInfo?: ?SidebarSourceMessageInfo,
+  +firstSidebarMessageInfo?: ?TextMessageInfo,
   +threadInfo: ThreadInfo,
   +params: NotificationTextsParams,
 };
 function notifTextsForSidebarCreation(
   input: NotifTextsForSidebarCreationInput,
 ): NotifTexts {
   const {
     sidebarSourceMessageInfo,
     createSidebarMessageInfo,
+    firstSidebarMessageInfo,
     threadInfo,
     params,
   } = input;
 
   const creator = ET.user({ userInfo: createSidebarMessageInfo.creator });
   const prefix = ET`${creator}`;
 
   const initialName = createSidebarMessageInfo.initialThreadState.name;
   const sourceMessageAuthorPossessive = ET.user({
     userInfo: createSidebarMessageInfo.sourceMessageAuthor,
     possessive: true,
   });
 
   let body = `started a thread in response to `;
   body = ET`${body} ${sourceMessageAuthorPossessive} message`;
 
   const { username } = params.notifTargetUserInfo;
 
   if (
     username &&
     sidebarSourceMessageInfo &&
     sidebarSourceMessageInfo.sourceMessage.type === messageTypes.TEXT &&
     isMentioned(username, sidebarSourceMessageInfo.sourceMessage.text)
   ) {
     body = ET`${body} that tagged you`;
+  } else if (
+    username &&
+    firstSidebarMessageInfo &&
+    isMentioned(username, firstSidebarMessageInfo.text)
+  ) {
+    body = ET`${body} and tagged you`;
   } else if (initialName) {
     body = ET`${body} "${initialName}"`;
   }
 
   return {
     merged: ET`${prefix} ${body}`,
     body,
     title: threadInfo.uiName,
     prefix,
   };
 }
 
 function mostRecentMessageInfoType(
   messageInfos: $ReadOnlyArray<MessageInfo>,
 ): MessageType {
   if (messageInfos.length === 0) {
     throw new Error('expected MessageInfo, but none present!');
   }
   return messageInfos[0].type;
 }
 
 async function fullNotifTextsForMessageInfo(
   messageInfos: $ReadOnlyArray<MessageInfo>,
   threadInfo: ThreadInfo,
   notifTargetUserInfo: UserInfo,
   getENSNames: ?GetENSNames,
 ): Promise<?ResolvedNotifTexts> {
   const mostRecentType = mostRecentMessageInfoType(messageInfos);
   const messageSpec = messageSpecs[mostRecentType];
   invariant(
     messageSpec.notificationTexts,
     `we're not aware of messageType ${mostRecentType}`,
   );
   const innerNotificationTexts = (
     innerMessageInfos: $ReadOnlyArray<MessageInfo>,
     innerThreadInfo: ThreadInfo,
   ) =>
     fullNotifTextsForMessageInfo(
       innerMessageInfos,
       innerThreadInfo,
       notifTargetUserInfo,
       getENSNames,
     );
   const unresolvedNotifTexts = await messageSpec.notificationTexts(
     messageInfos,
     threadInfo,
     { notifTargetUserInfo, notificationTexts: innerNotificationTexts },
   );
   if (!unresolvedNotifTexts) {
     return unresolvedNotifTexts;
   }
 
   const resolveToString = async (
     entityText: string | EntityText,
   ): Promise<string> => {
     if (typeof entityText === 'string') {
       return entityText;
     }
     const notifString = await getEntityTextAsString(entityText, getENSNames, {
       prefixThisThreadNounWith: 'your',
     });
     invariant(
       notifString !== null && notifString !== undefined,
       'getEntityTextAsString only returns falsey when passed falsey',
     );
     return notifString;
   };
   let promises = {
     merged: resolveToString(unresolvedNotifTexts.merged),
     body: resolveToString(unresolvedNotifTexts.body),
     title: resolveToString(ET`${unresolvedNotifTexts.title}`),
   };
   if (unresolvedNotifTexts.prefix) {
     promises = {
       ...promises,
       prefix: resolveToString(unresolvedNotifTexts.prefix),
     };
   }
   return await promiseAll(promises);
 }
 
 function notifRobotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ThreadInfo,
 ): EntityText {
   const robotext = robotextForMessageInfo(messageInfo, threadInfo);
   return robotext.map(entity => {
     if (
       typeof entity !== 'string' &&
       entity.type === 'thread' &&
       entity.id === threadInfo.id
     ) {
       return ET.thread({
         display: 'shortName',
         threadInfo,
         possessive: entity.possessive,
       });
     }
     return entity;
   });
 }
 
 function getNotifCollapseKey(
   rawMessageInfo: RawMessageInfo,
   messageData: MessageData,
 ): ?string {
   const messageSpec = messageSpecs[rawMessageInfo.type];
   return (
     messageSpec.notificationCollapseKey?.(rawMessageInfo, messageData) ?? null
   );
 }
 
 type Unmerged = $ReadOnly<{
   body: string,
   title: string,
   prefix?: string,
   ...
 }>;
 type Merged = {
   body: string,
   title: string,
 };
 function mergePrefixIntoBody(unmerged: Unmerged): Merged {
   const { body, title, prefix } = unmerged;
   const merged = prefix ? `${prefix} ${body}` : body;
   return { body: merged, title };
 }
 
 export {
   notifRobotextForMessageInfo,
   notifTextsForMessageInfo,
   notifTextsForEntryCreationOrEdit,
   notifTextsForSubthreadCreation,
   notifTextsForSidebarCreation,
   getNotifCollapseKey,
   mergePrefixIntoBody,
 };