diff --git a/lib/shared/messages/create-sub-thread-message-spec.js b/lib/shared/messages/create-sub-thread-message-spec.js
index 5f81e9a34..08dd269e2 100644
--- a/lib/shared/messages/create-sub-thread-message-spec.js
+++ b/lib/shared/messages/create-sub-thread-message-spec.js
@@ -1,163 +1,162 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { permissionLookup } from '../../permissions/thread-permissions';
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateSubthreadMessageData,
   CreateSubthreadMessageInfo,
   RawCreateSubthreadMessageInfo,
 } from '../../types/messages/create-subthread';
 import type { NotifTexts } from '../../types/notif-types';
 import { threadPermissions, threadTypes } 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 { notifTextsForSubthreadCreation } from '../notif-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
-  type NotificationTextsParams,
   type GeneratesNotifsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSubThreadMessageSpec: MessageSpec<
   CreateSubthreadMessageData,
   RawCreateSubthreadMessageInfo,
   CreateSubthreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateSubthreadMessageData | RawCreateSubthreadMessageInfo,
   ): string {
     return data.childThreadID;
   },
 
   messageContentForClientDB(data: RawCreateSubthreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): ?RawCreateSubthreadMessageInfo {
     const subthreadPermissions = row.subthread_permissions;
     if (!permissionLookup(subthreadPermissions, threadPermissions.KNOW_OF)) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       childThreadID: row.content,
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateSubthreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateSubthreadMessageInfo: RawCreateSubthreadMessageInfo = {
       type: messageTypes.CREATE_SUB_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       childThreadID: content,
     };
     return rawCreateSubthreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): ?CreateSubthreadMessageInfo {
     const { threadInfos } = params;
     const childThreadInfo = threadInfos[rawMessageInfo.childThreadID];
     if (!childThreadInfo) {
       return null;
     }
     return {
       type: messageTypes.CREATE_SUB_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       childThreadInfo,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateSubthreadMessageData,
     id: ?string,
   ): RawCreateSubthreadMessageInfo {
     invariant(id, 'RawCreateSubthreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateSubthreadMessageInfo): EntityText {
     const threadEntity = ET.thread({
       display: 'shortName',
       threadInfo: messageInfo.childThreadInfo,
       subchannel: true,
     });
 
     let text;
     if (messageInfo.childThreadInfo.name) {
       const childNoun =
         messageInfo.childThreadInfo.type === threadTypes.SIDEBAR
           ? 'thread'
           : 'subchannel';
       text = ET`created a ${childNoun} named "${threadEntity}"`;
     } else {
       text = ET`created a ${threadEntity}`;
     }
 
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} ${text}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SUB_THREAD,
       'messageInfo should be messageTypes.CREATE_SUB_THREAD!',
     );
-    return params.notifTextForSubthreadCreation(
-      messageInfo.creator,
-      messageInfo.childThreadInfo.type,
-      threadInfo,
-      messageInfo.childThreadInfo.name,
-      messageInfo.childThreadInfo.uiName,
-    );
+    return notifTextsForSubthreadCreation({
+      creator: messageInfo.creator,
+      threadType: messageInfo.childThreadInfo.type,
+      parentThreadInfo: threadInfo,
+      childThreadName: messageInfo.childThreadInfo.name,
+      childThreadUIName: messageInfo.childThreadInfo.uiName,
+    });
   },
 
   generatesNotifs: async (
     rawMessageInfo: RawCreateSubthreadMessageInfo,
     params: GeneratesNotifsParams,
   ) => {
     const { userNotMemberOfSubthreads } = params;
     return userNotMemberOfSubthreads.has(rawMessageInfo.childThreadID)
       ? pushTypes.NOTIF
       : undefined;
   },
 
   threadIDs(
     rawMessageInfo: RawCreateSubthreadMessageInfo,
   ): $ReadOnlyArray<string> {
     return [rawMessageInfo.childThreadID];
   },
 });
diff --git a/lib/shared/messages/create-thread-message-spec.js b/lib/shared/messages/create-thread-message-spec.js
index c34fd66f8..0bea351c9 100644
--- a/lib/shared/messages/create-thread-message-spec.js
+++ b/lib/shared/messages/create-thread-message-spec.js
@@ -1,190 +1,197 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from '../../types/messages/create-thread';
 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 { stringForUser } from '../user-utils';
+import { notifTextsForSubthreadCreation } from '../notif-utils';
+import { threadNoun } from '../thread-utils';
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
-  type NotificationTextsParams,
 } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createThreadMessageSpec: MessageSpec<
   CreateThreadMessageData,
   RawCreateThreadMessageInfo,
   CreateThreadMessageInfo,
 > = Object.freeze({
   messageContentForServerDB(
     data: CreateThreadMessageData | RawCreateThreadMessageInfo,
   ): string {
     return JSON.stringify(data.initialThreadState);
   },
 
   messageContentForClientDB(data: RawCreateThreadMessageInfo): string {
     return this.messageContentForServerDB(data);
   },
 
   rawMessageInfoFromServerDBRow(row: Object): RawCreateThreadMessageInfo {
     return {
       type: messageTypes.CREATE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       initialThreadState: JSON.parse(row.content),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawCreateThreadMessageInfo {
     const content = clientDBMessageInfo.content;
     invariant(
       content !== undefined && content !== null,
       'content must be defined',
     );
     const rawCreateThreadMessageInfo: RawCreateThreadMessageInfo = {
       type: messageTypes.CREATE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       initialThreadState: JSON.parse(content),
     };
     return rawCreateThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawCreateThreadMessageInfo,
     creator: RelativeUserInfo,
     params: CreateMessageInfoParams,
   ): CreateThreadMessageInfo {
     const initialParentThreadID =
       rawMessageInfo.initialThreadState.parentThreadID;
     const parentThreadInfo = initialParentThreadID
       ? params.threadInfos[initialParentThreadID]
       : null;
 
     return {
       type: messageTypes.CREATE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       initialThreadState: {
         name: rawMessageInfo.initialThreadState.name,
         parentThreadInfo,
         type: rawMessageInfo.initialThreadState.type,
         color: rawMessageInfo.initialThreadState.color,
         otherMembers: params.createRelativeUserInfos(
           rawMessageInfo.initialThreadState.memberIDs.filter(
             (userID: string) => userID !== rawMessageInfo.creatorID,
           ),
         ),
       },
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: CreateThreadMessageData,
     id: ?string,
   ): RawCreateThreadMessageInfo {
     invariant(id, 'RawCreateThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
   robotext(messageInfo: CreateThreadMessageInfo): EntityText {
     let text = ET`created ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
     })}`;
     const parentThread = messageInfo.initialThreadState.parentThreadInfo;
     if (parentThread) {
       text = ET`${text} as a child of ${ET.thread({
         display: 'uiName',
         threadInfo: parentThread,
       })}`;
     }
     if (messageInfo.initialThreadState.name) {
       text = ET`${text} with the name "${messageInfo.initialThreadState.name}"`;
     }
     const users = messageInfo.initialThreadState.otherMembers;
     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}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
-    params: NotificationTextsParams,
   ): Promise<NotifTexts> {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_THREAD,
       'messageInfo should be messageTypes.CREATE_THREAD!',
     );
+
+    const threadType = messageInfo.initialThreadState.type;
     const parentThreadInfo = messageInfo.initialThreadState.parentThreadInfo;
+    const threadName = messageInfo.initialThreadState.name;
+
     if (parentThreadInfo) {
-      return params.notifTextForSubthreadCreation(
-        messageInfo.creator,
-        messageInfo.initialThreadState.type,
+      return notifTextsForSubthreadCreation({
+        creator: messageInfo.creator,
+        threadType,
         parentThreadInfo,
-        messageInfo.initialThreadState.name,
-        threadInfo.uiName,
-      );
+        childThreadName: threadName,
+        childThreadUIName: threadInfo.uiName,
+      });
     }
-    const prefix = stringForUser(messageInfo.creator);
-    const body = 'created a new chat';
-    let merged = `${prefix} ${body}`;
-    if (messageInfo.initialThreadState.name) {
-      merged += ` called "${messageInfo.initialThreadState.name}"`;
+
+    const creator = ET.user({ userInfo: messageInfo.creator });
+    const prefix = ET`${creator}`;
+
+    const body = `created a new ${threadNoun(threadType)}`;
+    let merged = ET`${prefix} ${body}`;
+    if (threadName) {
+      merged = ET`${merged} called "${threadName}"`;
     }
+
     return {
       merged,
       body,
       title: threadInfo.uiName,
       prefix,
     };
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   userIDs(rawMessageInfo: RawCreateThreadMessageInfo): $ReadOnlyArray<string> {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   startsThread: true,
 
   threadIDs(
     rawMessageInfo: RawCreateThreadMessageInfo,
   ): $ReadOnlyArray<string> {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return parentThreadID ? [parentThreadID] : [];
   },
 });
diff --git a/lib/shared/messages/message-spec.js b/lib/shared/messages/message-spec.js
index b6aee639a..a46a65ee2 100644
--- a/lib/shared/messages/message-spec.js
+++ b/lib/shared/messages/message-spec.js
@@ -1,113 +1,106 @@
 // @flow
 
 import type { PlatformDetails } from '../../types/device-types';
 import type { Media } from '../../types/media-types';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
   RawComposableMessageInfo,
   RawMessageInfo,
   RawRobotextMessageInfo,
 } 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 { ThreadInfo } 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,
   +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/notif-utils.js b/lib/shared/notif-utils.js
index 2443837ca..69f353dfa 100644
--- a/lib/shared/notif-utils.js
+++ b/lib/shared/notif-utils.js
@@ -1,245 +1,258 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type MessageType,
   messageTypes,
 } from '../types/message-types';
 import type { NotifTexts, ResolvedNotifTexts } from '../types/notif-types';
 import type { ThreadInfo, ThreadType } from '../types/thread-types';
 import type { RelativeUserInfo } from '../types/user-types';
 import { prettyDate } from '../utils/date-utils';
 import type { GetENSNames } from '../utils/ens-helpers';
 import {
   ET,
   getEntityTextAsString,
   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 };
 }
 
 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,
   };
 }
 
-const notifTextForSubthreadCreation = (
-  creator: RelativeUserInfo,
-  threadType: ThreadType,
-  parentThreadInfo: ThreadInfo,
-  childThreadName: ?string,
-  childThreadUIName: string,
-) => {
-  const prefix = stringForUser(creator);
+type NotifTextsForSubthreadCreationInput = {
+  +creator: RelativeUserInfo,
+  +threadType: ThreadType,
+  +parentThreadInfo: ThreadInfo,
+  +childThreadName: ?string,
+  +childThreadUIName: EntityText | string,
+};
+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 += ` in ${parentThreadInfo.name}`;
+    body = ET`${body} in ${parentThreadInfo.name}`;
   }
-  let merged = `${prefix} ${body}`;
+
+  let merged = ET`${prefix} ${body}`;
   if (childThreadName) {
-    merged += ` called "${childThreadName}"`;
+    merged = ET`${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,
       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 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 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,
   notifTextsForEntryCreationOrEdit,
+  notifTextsForSubthreadCreation,
   notifCollapseKeyForRawMessageInfo,
   mergePrefixIntoBody,
 };