diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index 47b8a66c3..678011d36 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,242 +1,224 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type NotificationTextsParams,
 } from './message-spec.js';
 import { joinResult } from './utils.js';
 import type { PlatformDetails } from '../../types/device-types.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from '../../types/messages/create-sidebar.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 } from '../../types/user-types.js';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
 } from '../../utils/entity-text.js';
-import { isMentioned } from '../mention-utils.js';
+import { notifTextsForSidebarCreation } from '../notif-utils.js';
 import { hasMinCodeVersion } from '../version-utils.js';
 
 export const createSidebarMessageSpec: MessageSpec<
   CreateSidebarMessageData,
   RawCreateSidebarMessageInfo,
   CreateSidebarMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSidebarMessageData | RawCreateSidebarMessageInfo,
   ): string {
     return JSON.stringify({
       ...data.initialThreadState,
       sourceMessageAuthorID: data.sourceMessageAuthorID,
     });
   },
 
   messageContentForClientDB(data: RawCreateSidebarMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateSidebarMessageInfo {
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       row.content,
     );
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessageAuthorID,
       initialThreadState,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSidebarMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
 
     const { sourceMessageAuthorID, ...initialThreadState } = JSON.parse(
       clientDBMessageInfo.content,
     );
     const rawCreateSidebarMessageInfo: RawCreateSidebarMessageInfo = {
       type: messageTypes.CREATE_SIDEBAR,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessageAuthorID: sourceMessageAuthorID,
       initialThreadState: initialThreadState,
     };
     return rawCreateSidebarMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSidebarMessageInfo {
     const { threadInfos } = params;
     const parentThreadInfo =
       threadInfos[rawMessageInfo.initialThreadState.parentThreadID];
 
     const sourceMessageAuthor = params.createRelativeUserInfos([
       rawMessageInfo.sourceMessageAuthorID,
     ])[0];
     if (!sourceMessageAuthor) {
       return null;
     }
 
     return {
       type: messageTypes.CREATE_SIDEBAR,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessageAuthor,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSidebarMessageData,
     id: ?string,
   ): RawCreateSidebarMessageInfo {
     invariant(id, 'RawCreateSidebarMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateSidebarMessageInfo): EntityText {
     let text = ET`started ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
     const users = messageInfo.initialThreadState.otherMembers.filter(
       member => member.id !== messageInfo.sourceMessageAuthor.id,
     );
     if (users.length !== 0) {
       const initialUsers = pluralizeEntityText(
         users.map(user => ET`${ET.user({ userInfo: user })}`),
       );
       text = ET`${text} and added ${initialUsers}`;
     }
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${text}`;
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawCreateSidebarMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawCreateSidebarMessageInfo | RawUnsupportedMessageInfo {
     if (hasMinCodeVersion(platformDetails, 75)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'created a thread',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawCreateSidebarMessageInfo,
   ): RawCreateSidebarMessageInfo {
     return unwrapped;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): Promise<NotifTexts> {
-    const firstMessageInfo = messageInfos[0];
+    const createSidebarMessageInfo = messageInfos[0];
     invariant(
-      firstMessageInfo.type === messageTypes.CREATE_SIDEBAR,
-      'firstMessageInfo should be messageTypes.CREATE_SIDEBAR!',
+      createSidebarMessageInfo.type === messageTypes.CREATE_SIDEBAR,
+      'first MessageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
 
-    const creator = ET.user({ userInfo: firstMessageInfo.creator });
-    const prefix = ET`${creator}`;
-
-    const initialName = firstMessageInfo.initialThreadState.name;
-    const sourceMessageAuthorPossessive = ET.user({
-      userInfo: firstMessageInfo.sourceMessageAuthor,
-      possessive: true,
-    });
-
-    let body = `started a thread in response to `;
-    body = ET`${body} ${sourceMessageAuthorPossessive} message`;
-
-    const { username } = params.notifTargetUserInfo;
-
+    let sidebarSourceMessageInfo;
     const secondMessageInfo = messageInfos[1];
     if (
-      username &&
       secondMessageInfo &&
-      secondMessageInfo.type === messageTypes.SIDEBAR_SOURCE &&
-      secondMessageInfo.sourceMessage.type === messageTypes.TEXT &&
-      isMentioned(username, secondMessageInfo.sourceMessage.text)
+      secondMessageInfo.type === messageTypes.SIDEBAR_SOURCE
     ) {
-      body = ET`${body} that tagged you`;
-    } else if (initialName) {
-      body = ET`${body} "${initialName}"`;
+      sidebarSourceMessageInfo = secondMessageInfo;
     }
 
-    return {
-      merged: ET`${prefix} ${body}`,
-      body,
-      title: threadInfo.uiName,
-      prefix,
-    };
+    return notifTextsForSidebarCreation({
+      createSidebarMessageInfo,
+      sidebarSourceMessageInfo,
+      threadInfo,
+      params,
+    });
   },
 
   notificationCollapseKey(rawMessageInfo: RawCreateSidebarMessageInfo): string {
     return joinResult(messageTypes.CREATE_SIDEBAR, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateSidebarMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSidebarMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return [parentThreadID];
   },
 });
diff --git a/lib/shared/notif-utils.js b/lib/shared/notif-utils.js
index dfa765bea..afaa89e3c 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,262 +1,316 @@
 // @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 { 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,
+  +threadInfo: ThreadInfo,
+  +params: NotificationTextsParams,
+};
+function notifTextsForSidebarCreation(
+  input: NotifTextsForSidebarCreationInput,
+): NotifTexts {
+  const {
+    sidebarSourceMessageInfo,
+    createSidebarMessageInfo,
+    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 (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,
 };