diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index 12b039e64..b70110129 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,222 +1,227 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
 } 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 { 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,
   ): Promise<NotifTexts> {
     const firstMessageInfo = messageInfos[0];
     invariant(
       firstMessageInfo.type === messageTypes.CREATE_SIDEBAR,
       'firstMessageInfo 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`;
     if (initialName) {
       body = ET`${body} "${initialName}"`;
     }
 
     return {
       merged: ET`${prefix} ${body}`,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   },
 
+  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/messages/sidebar-source-message-spec.js b/lib/shared/messages/sidebar-source-message-spec.js
index 3a097d43d..93ca96450 100644
--- a/lib/shared/messages/sidebar-source-message-spec.js
+++ b/lib/shared/messages/sidebar-source-message-spec.js
@@ -1,183 +1,188 @@
 // @flow
 
 import invariant from 'invariant';
 
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  NotificationTextsParams,
-  RawMessageInfoFromServerDBRowParams,
+import {
+  pushTypes,
+  type CreateMessageInfoParams,
+  type MessageSpec,
+  type NotificationTextsParams,
+  type RawMessageInfoFromServerDBRowParams,
 } from './message-spec.js';
-import { assertSingleMessageInfo } from './utils.js';
+import { assertSingleMessageInfo, joinResult } from './utils.js';
 import type { PlatformDetails } from '../../types/device-types.js';
 import type {
   MessageInfo,
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageData,
   SidebarSourceMessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import { messageTypes } 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 } from '../../types/user-types.js';
 import { hasMinCodeVersion } from '../version-utils.js';
 
 export const sidebarSourceMessageSpec: MessageSpec<
   SidebarSourceMessageData,
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: SidebarSourceMessageData | RawSidebarSourceMessageInfo,
   ): string {
     const sourceMessageID = data.sourceMessage?.id;
     invariant(sourceMessageID, 'Source message id should be set');
     return JSON.stringify({
       sourceMessageID,
     });
   },
 
   messageContentForClientDB(data: RawSidebarSourceMessageInfo): string {
     invariant(
       data.sourceMessage && data.sourceMessage.id,
       'sourceMessage and sourceMessage.id should be defined',
     );
     return JSON.stringify(data.sourceMessage);
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawSidebarSourceMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const sourceMessage = JSON.parse(clientDBMessageInfo.content);
     const rawSidebarSourceMessageInfo: RawSidebarSourceMessageInfo = {
       type: messageTypes.SIDEBAR_SOURCE,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       sourceMessage,
     };
     return rawSidebarSourceMessageInfo;
   },
 
   messageTitle() {
     invariant(false, 'Cannot call messageTitle on sidebarSourceMessageSpec');
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawSidebarSourceMessageInfo {
     const { derivedMessages } = params;
     invariant(derivedMessages, 'Derived messages should be provided');
 
     const content = JSON.parse(row.content);
     const sourceMessage = derivedMessages.get(content.sourceMessageID);
     if (!sourceMessage) {
       console.warn(
         `Message with id ${row.id} has a derived message ` +
           `${content.sourceMessageID} which is not present in the database`,
       );
     }
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessage,
     };
   },
 
   createMessageInfo(
     rawMessageInfo: RawSidebarSourceMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?SidebarSourceMessageInfo {
     if (!rawMessageInfo.sourceMessage) {
       return null;
     }
     const sourceMessage = params.createMessageInfoFromRaw(
       rawMessageInfo.sourceMessage,
     );
     invariant(
       sourceMessage &&
         sourceMessage.type !== messageTypes.SIDEBAR_SOURCE &&
         sourceMessage.type !== messageTypes.REACTION,
       'Sidebars can not be created from SIDEBAR SOURCE OR REACTION',
     );
 
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessage,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: SidebarSourceMessageData,
     id: ?string,
   ): RawSidebarSourceMessageInfo {
     invariant(id, 'RawSidebarSourceMessageInfo needs id');
     return { ...messageData, id };
   },
 
   shimUnsupportedMessageInfo(
     rawMessageInfo: RawSidebarSourceMessageInfo,
     platformDetails: ?PlatformDetails,
   ): RawSidebarSourceMessageInfo | RawUnsupportedMessageInfo {
     // TODO determine min code version
     if (
       hasMinCodeVersion(platformDetails, 75) &&
       rawMessageInfo.sourceMessage
     ) {
       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: 'first message in thread',
       dontPrefixCreator: true,
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
   unshimMessageInfo(
     unwrapped: RawSidebarSourceMessageInfo,
   ): RawSidebarSourceMessageInfo {
     return unwrapped;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.SIDEBAR_SOURCE,
       'messageInfo should be messageTypes.SIDEBAR_SOURCE!',
     );
     const sourceMessageInfo = messageInfo.sourceMessage;
     return await params.notificationTexts([sourceMessageInfo], threadInfo);
   },
 
-  generatesNotifs: async () => undefined,
+  notificationCollapseKey(rawMessageInfo: RawSidebarSourceMessageInfo): string {
+    return joinResult(messageTypes.CREATE_SIDEBAR, rawMessageInfo.threadID);
+  },
+
+  generatesNotifs: async () => pushTypes.NOTIF,
 
   startsThread: true,
 });