diff --git a/lib/shared/messages/add-members-message-spec.js b/lib/shared/messages/add-members-message-spec.js
index 4c1cff39b..5a1dfa738 100644
--- a/lib/shared/messages/add-members-message-spec.js
+++ b/lib/shared/messages/add-members-message-spec.js
@@ -1,163 +1,159 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   AddMembersMessageData,
   AddMembersMessageInfo,
   RawAddMembersMessageInfo,
 } from '../../types/messages/add-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  NotificationTextsParams,
-} from './message-spec';
+import { notifRobotextForMessageInfo } from '../notif-utils';
+import type { CreateMessageInfoParams, MessageSpec } from './message-spec';
 import { joinResult } from './utils';
 
 export const addMembersMessageSpec: MessageSpec<
   AddMembersMessageData,
   RawAddMembersMessageInfo,
   AddMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: AddMembersMessageData | RawAddMembersMessageInfo,
   ): string {
     return JSON.stringify(data.addedUserIDs);
   },
 
   messageContentForClientDB(data: RawAddMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawAddMembersMessageInfo {
     return {
       type: messageTypes.ADD_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       addedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawAddMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawAddMembersMessageInfo: RawAddMembersMessageInfo = {
       type: messageTypes.ADD_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       addedUserIDs: JSON.parse(content),
     };
     return rawAddMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawAddMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): AddMembersMessageInfo {
     const addedMembers = params.createRelativeUserInfos(
       rawMessageInfo.addedUserIDs,
     );
     return {
       type: messageTypes.ADD_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       addedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: AddMembersMessageData,
     id: ?string,
   ): RawAddMembersMessageInfo {
     invariant(id, 'RawAddMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: AddMembersMessageInfo): EntityText {
     const users = messageInfo.addedMembers;
     invariant(users.length !== 0, 'added who??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const addedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     return ET`${creator} added ${addedUsers}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const addedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.ADD_MEMBERS,
         'messageInfo should be messageTypes.ADD_MEMBERS!',
       );
       for (const member of messageInfo.addedMembers) {
         addedMembersObject[member.id] = member;
       }
     }
     const addedMembers = values(addedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.ADD_MEMBERS,
       'messageInfo should be messageTypes.ADD_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, addedMembers };
 
-    const robotext = params.strippedRobotextForMessageInfo(
-      mergedMessageInfo,
+    const robotext = notifRobotextForMessageInfo(mergedMessageInfo, threadInfo);
+    const merged = ET`${robotext} to ${ET.thread({
+      display: 'shortName',
       threadInfo,
-    );
-    const merged = `${robotext} to ${params.notifThreadName(threadInfo)}`;
+    })}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawAddMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
   generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawAddMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.addedUserIDs;
   },
 });
diff --git a/lib/shared/messages/change-role-message-spec.js b/lib/shared/messages/change-role-message-spec.js
index b8cd25994..e3f33c9fc 100644
--- a/lib/shared/messages/change-role-message-spec.js
+++ b/lib/shared/messages/change-role-message-spec.js
@@ -1,178 +1,177 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeRoleMessageData,
   ChangeRoleMessageInfo,
   RawChangeRoleMessageInfo,
 } from '../../types/messages/change-role';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
+import { notifRobotextForMessageInfo } from '../notif-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
-  type NotificationTextsParams,
   type RobotextParams,
 } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeRoleMessageSpec: MessageSpec<
   ChangeRoleMessageData,
   RawChangeRoleMessageInfo,
   ChangeRoleMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeRoleMessageData | RawChangeRoleMessageInfo,
   ): string {
     return JSON.stringify({
       userIDs: data.userIDs,
       newRole: data.newRole,
     });
   },
 
   messageContentForClientDB(data: RawChangeRoleMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeRoleMessageInfo {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeRoleMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const rawChangeRoleMessageInfo: RawChangeRoleMessageInfo = {
       type: messageTypes.CHANGE_ROLE,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       userIDs: content.userIDs,
       newRole: content.newRole,
     };
     return rawChangeRoleMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeRoleMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ChangeRoleMessageInfo {
     const members = params.createRelativeUserInfos(rawMessageInfo.userIDs);
     return {
       type: messageTypes.CHANGE_ROLE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       members,
       newRole: rawMessageInfo.newRole,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeRoleMessageData,
     id: ?string,
   ): RawChangeRoleMessageInfo {
     invariant(id, 'RawChangeRoleMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(
     messageInfo: ChangeRoleMessageInfo,
     params: RobotextParams,
   ): EntityText {
     const users = messageInfo.members;
     invariant(users.length !== 0, 'changed whose role??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const affectedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     const { threadInfo } = params;
     invariant(threadInfo, 'ThreadInfo should be set for CHANGE_ROLE message');
     const verb = threadInfo.roles[messageInfo.newRole].isDefault
       ? 'removed'
       : 'added';
     const noun = users.length === 1 ? 'an admin' : 'admins';
 
     return ET`${creator} ${verb} ${affectedUsers} as ${noun}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const membersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.CHANGE_ROLE,
         'messageInfo should be messageTypes.CHANGE_ROLE!',
       );
       for (const member of messageInfo.members) {
         membersObject[member.id] = member;
       }
     }
     const members = values(membersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_ROLE,
       'messageInfo should be messageTypes.CHANGE_ROLE!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, members };
 
-    const robotext = params.strippedRobotextForMessageInfo(
-      mergedMessageInfo,
+    const robotext = notifRobotextForMessageInfo(mergedMessageInfo, threadInfo);
+    const merged = ET`${robotext} of ${ET.thread({
+      display: 'shortName',
       threadInfo,
-    );
-    const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
+    })}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawChangeRoleMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.newRole,
     );
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/change-settings-message-spec.js b/lib/shared/messages/change-settings-message-spec.js
index f47325b90..fd1182e19 100644
--- a/lib/shared/messages/change-settings-message-spec.js
+++ b/lib/shared/messages/change-settings-message-spec.js
@@ -1,173 +1,166 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   ChangeSettingsMessageData,
   ChangeSettingsMessageInfo,
   RawChangeSettingsMessageInfo,
 } from '../../types/messages/change-settings';
 import type { NotifTexts } from '../../types/notif-types';
 import { assertThreadType } from '../../types/thread-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import { ET, type EntityText } from '../../utils/entity-text';
 import { validHexColorRegex } from '../account-utils';
+import { notifRobotextForMessageInfo } from '../notif-utils';
 import { threadLabel } from '../thread-utils';
-import {
-  pushTypes,
-  type MessageSpec,
-  type NotificationTextsParams,
-} from './message-spec';
+import { pushTypes, type MessageSpec } from './message-spec';
 import { joinResult } from './utils';
 
 export const changeSettingsMessageSpec: MessageSpec<
   ChangeSettingsMessageData,
   RawChangeSettingsMessageInfo,
   ChangeSettingsMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: ChangeSettingsMessageData | RawChangeSettingsMessageInfo,
   ): string {
     return JSON.stringify({
       [data.field]: data.value,
     });
   },
 
   messageContentForClientDB(data: RawChangeSettingsMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawChangeSettingsMessageInfo {
     const content = JSON.parse(row.content);
     const field = Object.keys(content)[0];
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       field,
       value: content[field],
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawChangeSettingsMessageInfo {
     invariant(
       clientDBMessageInfo.content !== undefined &&
         clientDBMessageInfo.content !== null,
       'content must be defined',
     );
     const content = JSON.parse(clientDBMessageInfo.content);
     const field = Object.keys(content)[0];
     const rawChangeSettingsMessageInfo: RawChangeSettingsMessageInfo = {
       type: messageTypes.CHANGE_SETTINGS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       field,
       value: content[field],
     };
     return rawChangeSettingsMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawChangeSettingsMessageInfo,
     creator: RelativeUserInfo,
   ): ChangeSettingsMessageInfo {
     return {
       type: messageTypes.CHANGE_SETTINGS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       field: rawMessageInfo.field,
       value: rawMessageInfo.value,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: ChangeSettingsMessageData,
     id: ?string,
   ): RawChangeSettingsMessageInfo {
     invariant(id, 'RawChangeSettingsMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: ChangeSettingsMessageInfo): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     if (
       (messageInfo.field === 'name' || messageInfo.field === 'description') &&
       messageInfo.value.toString() === ''
     ) {
       return ET`${creator} cleared ${ET.thread({
         display: 'alwaysDisplayShortName',
         threadID: messageInfo.threadID,
         possessive: true,
       })} ${messageInfo.field}`;
     }
     let value;
     if (
       messageInfo.field === 'color' &&
       messageInfo.value.toString().match(validHexColorRegex)
     ) {
       value = ET.color({ hex: `#${messageInfo.value}` });
     } else if (messageInfo.field === 'type') {
       invariant(
         typeof messageInfo.value === 'number',
         'messageInfo.value should be number for thread type change ',
       );
       const newThreadType = assertThreadType(messageInfo.value);
       value = threadLabel(newThreadType);
     } else {
       value = messageInfo.value.toString();
     }
     return ET`${creator} updated ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
       possessive: true,
     })} ${messageInfo.field} to "${value}"`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_SETTINGS,
       'messageInfo should be messageTypes.CHANGE_SETTINGS!',
     );
-    const body = params.strippedRobotextForMessageInfo(
-      mostRecentMessageInfo,
-      threadInfo,
-    );
+    const body = notifRobotextForMessageInfo(mostRecentMessageInfo, threadInfo);
     return {
       merged: body,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawChangeSettingsMessageInfo,
   ): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
       rawMessageInfo.field,
     );
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 });
diff --git a/lib/shared/messages/message-spec.js b/lib/shared/messages/message-spec.js
index dd9b2d6b6..b6aee639a 100644
--- a/lib/shared/messages/message-spec.js
+++ b/lib/shared/messages/message-spec.js
@@ -1,118 +1,113 @@
 // @flow
 
 import type { PlatformDetails } from '../../types/device-types';
 import type { Media } from '../../types/media-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
   RawComposableMessageInfo,
   RawMessageInfo,
   RawRobotextMessageInfo,
-  RobotextMessageInfo,
 } from '../../types/message-types';
 import type { RawUnsupportedMessageInfo } from '../../types/messages/unsupported';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import type { EntityText } from '../../utils/entity-text';
 import { type ParserRules } from '../markdown';
 
 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 = {
   +notifThreadName: (threadInfo: ThreadInfo) => string,
   +notifTextForSubthreadCreation: (
     creator: RelativeUserInfo,
     threadType: ThreadType,
     parentThreadInfo: ThreadInfo,
     childThreadName: ?string,
     childThreadUIName: string,
   ) => NotifTexts,
-  +strippedRobotextForMessageInfo: (
-    messageInfo: RobotextMessageInfo,
-    threadInfo: ThreadInfo,
-  ) => string,
   +notificationTexts: (
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ) => Promise<NotifTexts>,
 };
 
 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 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) => string,
   +generatesNotifs: (
     rawMessageInfo: RawInfo,
     params: GeneratesNotifsParams,
   ) => Promise<?PushType>,
   +userIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +startsThread?: boolean,
   +threadIDs?: (rawMessageInfo: RawInfo) => $ReadOnlyArray<string>,
   +includedInRepliesCount?: boolean,
 };
diff --git a/lib/shared/messages/remove-members-message-spec.js b/lib/shared/messages/remove-members-message-spec.js
index f48f9e10e..c97504176 100644
--- a/lib/shared/messages/remove-members-message-spec.js
+++ b/lib/shared/messages/remove-members-message-spec.js
@@ -1,163 +1,159 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageData,
   RemoveMembersMessageInfo,
 } from '../../types/messages/remove-members';
 import type { NotifTexts } from '../../types/notif-types';
 import type { ThreadInfo } from '../../types/thread-types';
 import type { RelativeUserInfo } from '../../types/user-types';
 import {
   ET,
   type EntityText,
   pluralizeEntityText,
 } from '../../utils/entity-text';
 import { values } from '../../utils/objects';
-import type {
-  CreateMessageInfoParams,
-  MessageSpec,
-  NotificationTextsParams,
-} from './message-spec';
+import { notifRobotextForMessageInfo } from '../notif-utils';
+import type { CreateMessageInfoParams, MessageSpec } from './message-spec';
 import { joinResult } from './utils';
 
 export const removeMembersMessageSpec: MessageSpec<
   RemoveMembersMessageData,
   RawRemoveMembersMessageInfo,
   RemoveMembersMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: RemoveMembersMessageData | RawRemoveMembersMessageInfo,
   ): string {
     return JSON.stringify(data.removedUserIDs);
   },
 
   messageContentForClientDB(data: RawRemoveMembersMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawRemoveMembersMessageInfo {
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       removedUserIDs: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawRemoveMembersMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawRemoveMembersMessageInfo: RawRemoveMembersMessageInfo = {
       type: messageTypes.REMOVE_MEMBERS,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       removedUserIDs: JSON.parse(content),
     };
     return rawRemoveMembersMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawRemoveMembersMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): RemoveMembersMessageInfo {
     const removedMembers = params.createRelativeUserInfos(
       rawMessageInfo.removedUserIDs,
     );
     return {
       type: messageTypes.REMOVE_MEMBERS,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       removedMembers,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: RemoveMembersMessageData,
     id: ?string,
   ): RawRemoveMembersMessageInfo {
     invariant(id, 'RawRemoveMembersMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: RemoveMembersMessageInfo): EntityText {
     const users = messageInfo.removedMembers;
     invariant(users.length !== 0, 'added who??');
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     const removedUsers = pluralizeEntityText(
       users.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     return ET`${creator} removed ${removedUsers}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const removedMembersObject = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.REMOVE_MEMBERS,
         'messageInfo should be messageTypes.REMOVE_MEMBERS!',
       );
       for (const member of messageInfo.removedMembers) {
         removedMembersObject[member.id] = member;
       }
     }
     const removedMembers = values(removedMembersObject);
 
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.REMOVE_MEMBERS,
       'messageInfo should be messageTypes.REMOVE_MEMBERS!',
     );
     const mergedMessageInfo = { ...mostRecentMessageInfo, removedMembers };
 
-    const robotext = params.strippedRobotextForMessageInfo(
-      mergedMessageInfo,
+    const robotext = notifRobotextForMessageInfo(mergedMessageInfo, threadInfo);
+    const merged = ET`${robotext} from ${ET.thread({
+      display: 'shortName',
       threadInfo,
-    );
-    const merged = `${robotext} from ${params.notifThreadName(threadInfo)}`;
+    })}`;
     return {
       merged,
       title: threadInfo.uiName,
       body: robotext,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawRemoveMembersMessageInfo): string {
     return joinResult(
       rawMessageInfo.type,
       rawMessageInfo.threadID,
       rawMessageInfo.creatorID,
     );
   },
 
   generatesNotifs: async () => undefined,
 
   userIDs(rawMessageInfo: RawRemoveMembersMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.removedUserIDs;
   },
 });
diff --git a/lib/shared/notif-utils.js b/lib/shared/notif-utils.js
index d7236e9bf..a25371cb4 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,194 +1,196 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type MessageType,
 } from '../types/message-types';
 import type { ResolvedNotifTexts } from '../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../types/thread-types';
 import type { RelativeUserInfo } from '../types/user-types';
 import type { GetENSNames } from '../utils/ens-helpers';
 import {
+  ET,
   getEntityTextAsString,
-  entityTextToRawString,
   type EntityText,
 } from '../utils/entity-text';
 import { promiseAll } from '../utils/promises';
 import { trimText } from '../utils/text-utils';
 import { robotextForMessageInfo } from './message-utils';
 import { messageSpecs } from './messages/message-specs';
 import { threadNoun } from './thread-utils';
 import { stringForUser } from './user-utils';
 
 async function notifTextsForMessageInfo(
   messageInfos: MessageInfo[],
   threadInfo: ThreadInfo,
   getENSNames: ?GetENSNames,
 ): Promise<ResolvedNotifTexts> {
   const fullNotifTexts = await fullNotifTextsForMessageInfo(
     messageInfos,
     threadInfo,
     getENSNames,
   );
   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 };
 }
 
 const notifTextForSubthreadCreation = (
   creator: RelativeUserInfo,
   threadType: ThreadType,
   parentThreadInfo: ThreadInfo,
   childThreadName: ?string,
   childThreadUIName: string,
 ) => {
   const prefix = stringForUser(creator);
   let body = `created a new ${threadNoun(threadType)}`;
   if (parentThreadInfo.name) {
     body += ` in ${parentThreadInfo.name}`;
   }
   let merged = `${prefix} ${body}`;
   if (childThreadName) {
     merged += ` called "${childThreadName}"`;
   }
   return {
     merged,
     body,
     title: childThreadUIName,
     prefix,
   };
 };
 
 function notifThreadName(threadInfo: ThreadInfo): string {
   if (threadInfo.name) {
     return threadInfo.name;
   } else {
     return 'your chat';
   }
 }
 
 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,
   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,
       getENSNames,
     );
   const unresolvedNotifTexts = await messageSpec.notificationTexts(
     messageInfos,
     threadInfo,
     {
       notifThreadName,
       notifTextForSubthreadCreation,
-      strippedRobotextForMessageInfo,
       notificationTexts: innerNotificationTexts,
     },
   );
 
   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(unresolvedNotifTexts.title),
   };
   if (unresolvedNotifTexts.prefix) {
     promises = {
       ...promises,
       prefix: resolveToString(unresolvedNotifTexts.prefix),
     };
   }
   return await promiseAll(promises);
 }
 
-function strippedRobotextForMessageInfo(
+function notifRobotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ThreadInfo,
-): string {
+): EntityText {
   const robotext = robotextForMessageInfo(messageInfo, threadInfo);
-  const threadName = notifThreadName(threadInfo);
-  const threadMadeExplicit = robotext.map(entity => {
+  return robotext.map(entity => {
     if (
       typeof entity !== 'string' &&
       entity.type === 'thread' &&
       entity.id === threadInfo.id
     ) {
-      return threadName;
+      return ET.thread({
+        display: 'shortName',
+        threadInfo,
+        possessive: entity.possessive,
+      });
     }
     return entity;
   });
-  return entityTextToRawString(threadMadeExplicit);
 }
 
 function notifCollapseKeyForRawMessageInfo(
   rawMessageInfo: RawMessageInfo,
 ): ?string {
   const messageSpec = messageSpecs[rawMessageInfo.type];
   return messageSpec.notificationCollapseKey?.(rawMessageInfo) ?? 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,
   notifCollapseKeyForRawMessageInfo,
   mergePrefixIntoBody,
 };