diff --git a/lib/shared/messages/change-settings-message-spec.js b/lib/shared/messages/change-settings-message-spec.js
index 67a3acba1..06c00a2ce 100644
--- a/lib/shared/messages/change-settings-message-spec.js
+++ b/lib/shared/messages/change-settings-message-spec.js
@@ -1,166 +1,172 @@
 // @flow
 
 import invariant from 'invariant';
 
-import { pushTypes, type MessageSpec } from './message-spec.js';
+import {
+  pushTypes,
+  type MessageSpec,
+  type RobotextParams,
+} from './message-spec.js';
 import { joinResult } from './utils.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   ChangeSettingsMessageData,
   ChangeSettingsMessageInfo,
   RawChangeSettingsMessageInfo,
 } from '../../types/messages/change-settings.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import { assertThreadType } from '../../types/thread-types.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import { ET, type EntityText } from '../../utils/entity-text.js';
 import { validHexColorRegex } from '../account-utils.js';
 import { notifRobotextForMessageInfo } from '../notif-utils.js';
 import { threadLabel } from '../thread-utils.js';
 
 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 for ChangeSettings',
     );
     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 {
+  robotext(
+    messageInfo: ChangeSettingsMessageInfo,
+    params: RobotextParams,
+  ): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
+    const thread = ET.thread({
+      display: 'alwaysDisplayShortName',
+      threadID: messageInfo.threadID,
+      threadType: params.threadInfo?.type,
+      parentThreadID: params.threadInfo?.parentThreadID,
+      possessive: true,
+    });
     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}`;
+      return ET`${creator} cleared ${thread} ${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}"`;
+    return ET`${creator} updated ${thread} ${messageInfo.field} to "${value}"`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): Promise<NotifTexts> {
     const mostRecentMessageInfo = messageInfos[0];
     invariant(
       mostRecentMessageInfo.type === messageTypes.CHANGE_SETTINGS,
       'messageInfo should be messageTypes.CHANGE_SETTINGS!',
     );
     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/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index 96a4a43c8..841b7b8e4 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,224 +1,230 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
   type NotificationTextsParams,
+  type RobotextParams,
 } 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 { 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 for CreateSidebar',
     );
 
     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 {
+  robotext(
+    messageInfo: CreateSidebarMessageInfo,
+    params: RobotextParams,
+  ): EntityText {
     let text = ET`started ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
+      threadType: params.threadInfo?.type,
+      parentThreadID: params.threadInfo?.parentThreadID,
     })}`;
     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 createSidebarMessageInfo = messageInfos[0];
     invariant(
       createSidebarMessageInfo.type === messageTypes.CREATE_SIDEBAR,
       'first MessageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
 
     let sidebarSourceMessageInfo;
     const secondMessageInfo = messageInfos[1];
     if (
       secondMessageInfo &&
       secondMessageInfo.type === messageTypes.SIDEBAR_SOURCE
     ) {
       sidebarSourceMessageInfo = secondMessageInfo;
     }
 
     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/messages/create-thread-message-spec.js b/lib/shared/messages/create-thread-message-spec.js
index 2bc68355d..1722d0e29 100644
--- a/lib/shared/messages/create-thread-message-spec.js
+++ b/lib/shared/messages/create-thread-message-spec.js
@@ -1,197 +1,203 @@
 // @flow
 
 import invariant from 'invariant';
 
 import {
   pushTypes,
   type CreateMessageInfoParams,
   type MessageSpec,
+  type RobotextParams,
 } from './message-spec.js';
 import { assertSingleMessageInfo } from './utils.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   CreateThreadMessageData,
   CreateThreadMessageInfo,
   RawCreateThreadMessageInfo,
 } from '../../types/messages/create-thread.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 { notifTextsForSubthreadCreation } from '../notif-utils.js';
 import { threadNoun } from '../thread-utils.js';
 
 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 for CreateThread',
     );
     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 {
+  robotext(
+    messageInfo: CreateThreadMessageInfo,
+    params: RobotextParams,
+  ): EntityText {
     let text = ET`created ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
+      threadType: params.threadInfo?.type,
+      parentThreadID: params.threadInfo?.parentThreadID,
     })}`;
     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,
   ): 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 notifTextsForSubthreadCreation({
         creator: messageInfo.creator,
         threadType,
         parentThreadInfo,
         childThreadName: threadName,
         childThreadUIName: threadInfo.uiName,
       });
     }
 
     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/join-thread-message-spec.js b/lib/shared/messages/join-thread-message-spec.js
index de87035f8..123b18334 100644
--- a/lib/shared/messages/join-thread-message-spec.js
+++ b/lib/shared/messages/join-thread-message-spec.js
@@ -1,117 +1,122 @@
 // @flow
 
 import invariant from 'invariant';
 
-import type { MessageSpec } from './message-spec.js';
+import type { MessageSpec, RobotextParams } from './message-spec.js';
 import { joinResult } from './utils.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   JoinThreadMessageData,
   JoinThreadMessageInfo,
   RawJoinThreadMessageInfo,
 } from '../../types/messages/join-thread.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 { values } from '../../utils/objects.js';
 
 export const joinThreadMessageSpec: MessageSpec<
   JoinThreadMessageData,
   RawJoinThreadMessageInfo,
   JoinThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawJoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawJoinThreadMessageInfo {
     const rawJoinThreadMessageInfo: RawJoinThreadMessageInfo = {
       type: messageTypes.JOIN_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawJoinThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawJoinThreadMessageInfo,
     creator: RelativeUserInfo,
   ): JoinThreadMessageInfo {
     return {
       type: messageTypes.JOIN_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: JoinThreadMessageData,
     id: ?string,
   ): RawJoinThreadMessageInfo {
     invariant(id, 'RawJoinThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
-  robotext(messageInfo: JoinThreadMessageInfo): EntityText {
+  robotext(
+    messageInfo: JoinThreadMessageInfo,
+    params: RobotextParams,
+  ): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} joined ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
+      threadType: params.threadInfo?.type,
+      parentThreadID: params.threadInfo?.parentThreadID,
     })}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): Promise<NotifTexts> {
     const joinerArray = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.JOIN_THREAD,
         'messageInfo should be messageTypes.JOIN_THREAD!',
       );
       joinerArray[messageInfo.creator.id] = messageInfo.creator;
     }
     const joiners = values(joinerArray);
     const joiningUsers = pluralizeEntityText(
       joiners.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     const body = ET`${joiningUsers} joined`;
     const thread = ET.thread({ display: 'shortName', threadInfo });
     const merged = ET`${body} ${thread}`;
 
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawJoinThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => undefined,
 });
diff --git a/lib/shared/messages/leave-thread-message-spec.js b/lib/shared/messages/leave-thread-message-spec.js
index 44f029db5..8274d31c3 100644
--- a/lib/shared/messages/leave-thread-message-spec.js
+++ b/lib/shared/messages/leave-thread-message-spec.js
@@ -1,117 +1,122 @@
 // @flow
 
 import invariant from 'invariant';
 
-import type { MessageSpec } from './message-spec.js';
+import type { MessageSpec, RobotextParams } from './message-spec.js';
 import { joinResult } from './utils.js';
 import { messageTypes } from '../../types/message-types.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import type {
   LeaveThreadMessageData,
   LeaveThreadMessageInfo,
   RawLeaveThreadMessageInfo,
 } from '../../types/messages/leave-thread.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 { values } from '../../utils/objects.js';
 
 export const leaveThreadMessageSpec: MessageSpec<
   LeaveThreadMessageData,
   RawLeaveThreadMessageInfo,
   LeaveThreadMessageInfo,
 > = Object.freeze({
   rawMessageInfoFromServerDBRow(row: Object): RawLeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
     };
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawLeaveThreadMessageInfo {
     const rawLeaveThreadMessageInfo: RawLeaveThreadMessageInfo = {
       type: messageTypes.LEAVE_THREAD,
       id: clientDBMessageInfo.id,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
     };
     return rawLeaveThreadMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawLeaveThreadMessageInfo,
     creator: RelativeUserInfo,
   ): LeaveThreadMessageInfo {
     return {
       type: messageTypes.LEAVE_THREAD,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
     };
   },
 
   rawMessageInfoFromMessageData(
     messageData: LeaveThreadMessageData,
     id: ?string,
   ): RawLeaveThreadMessageInfo {
     invariant(id, 'RawLeaveThreadMessageInfo needs id');
     return { ...messageData, id };
   },
 
-  robotext(messageInfo: LeaveThreadMessageInfo): EntityText {
+  robotext(
+    messageInfo: LeaveThreadMessageInfo,
+    params: RobotextParams,
+  ): EntityText {
     const creator = ET.user({ userInfo: messageInfo.creator });
     return ET`${creator} left ${ET.thread({
       display: 'alwaysDisplayShortName',
       threadID: messageInfo.threadID,
+      threadType: params.threadInfo?.type,
+      parentThreadID: params.threadInfo?.parentThreadID,
     })}`;
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
   ): Promise<NotifTexts> {
     const leaverBeavers = {};
     for (const messageInfo of messageInfos) {
       invariant(
         messageInfo.type === messageTypes.LEAVE_THREAD,
         'messageInfo should be messageTypes.LEAVE_THREAD!',
       );
       leaverBeavers[messageInfo.creator.id] = messageInfo.creator;
     }
     const leavers = values(leaverBeavers);
     const leavingUsers = pluralizeEntityText(
       leavers.map(user => ET`${ET.user({ userInfo: user })}`),
     );
 
     const body = ET`${leavingUsers} left`;
     const thread = ET.thread({ display: 'shortName', threadInfo });
     const merged = ET`${body} ${thread}`;
 
     return {
       merged,
       title: threadInfo.uiName,
       body,
     };
   },
 
   notificationCollapseKey(rawMessageInfo: RawLeaveThreadMessageInfo): string {
     return joinResult(rawMessageInfo.type, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => undefined,
 });
diff --git a/lib/utils/entity-text.js b/lib/utils/entity-text.js
index eaeb3a188..2b8f3924f 100644
--- a/lib/utils/entity-text.js
+++ b/lib/utils/entity-text.js
@@ -1,520 +1,526 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import type { GetENSNames } from './ens-helpers.js';
 import { useENSNames } from '../hooks/ens-cache.js';
 import { threadNoun } from '../shared/thread-utils.js';
 import { stringForUser } from '../shared/user-utils.js';
 import {
   threadTypes,
   type ThreadType,
   type RawThreadInfo,
   type ThreadInfo,
 } from '../types/thread-types.js';
 import { basePluralize } from '../utils/text-utils.js';
 
 type UserEntity = {
   +type: 'user',
   +id: string,
   +username?: ?string,
   +isViewer?: ?boolean,
   +possessive?: ?boolean, // eg. `user's` instead of `user`
 };
 
 // Comments explain how thread name will appear from user4's perspective
 export type ThreadEntity =
   | {
       +type: 'thread',
       +id: string,
       +name?: ?string,
       // displays threadInfo.name if set, or 'user1, user2, and user3'
       +display: 'uiName',
       // If uiName is EntityText, then at render time ThreadEntity will be
       // replaced with a pluralized list of uiName's UserEntities
       +uiName: $ReadOnlyArray<UserEntity> | string,
     }
   | {
       +type: 'thread',
       +id: string,
       +name?: ?string,
       // displays threadInfo.name if set, or eg. 'this thread' or 'this chat'
       +display: 'shortName',
       +threadType?: ?ThreadType,
+      +parentThreadID?: ?string,
       +alwaysDisplayShortName?: ?boolean, // don't default to name
       +subchannel?: ?boolean, // short name should be "subchannel"
       +possessive?: ?boolean, // eg. `this thread's` instead of `this thread`
     };
 
 type ColorEntity = {
   +type: 'color',
   +hex: string,
 };
 
 type EntityTextComponent = UserEntity | ThreadEntity | ColorEntity | string;
 
 export type EntityText = $ReadOnlyArray<EntityTextComponent>;
 
 const entityTextFunction = (
   strings: $ReadOnlyArray<string>,
   ...entities: $ReadOnlyArray<EntityTextComponent | EntityText>
 ) => {
   const result = [];
   for (let i = 0; i < strings.length; i++) {
     const str = strings[i];
     if (str) {
       result.push(str);
     }
     const entity = entities[i];
     if (!entity) {
       continue;
     }
 
     if (typeof entity === 'string') {
       const lastResult = result.length > 0 && result[result.length - 1];
       if (typeof lastResult === 'string') {
         result[result.length - 1] = lastResult + entity;
       } else {
         result.push(entity);
       }
     } else if (Array.isArray(entity)) {
       const [firstEntity, ...restOfEntity] = entity;
       const lastResult = result.length > 0 && result[result.length - 1];
       if (typeof lastResult === 'string' && typeof firstEntity === 'string') {
         result[result.length - 1] = lastResult + firstEntity;
       } else if (firstEntity) {
         result.push(firstEntity);
       }
       result.push(...restOfEntity);
     } else {
       result.push(entity);
     }
   }
   return result;
 };
 
 // defaults to shortName
 type EntityTextThreadInput =
   | {
       +display: 'uiName',
       +threadInfo: ThreadInfo,
     }
   | {
       +display?: 'shortName',
       +threadInfo: ThreadInfo | RawThreadInfo,
       +subchannel?: ?boolean,
       +possessive?: ?boolean,
     }
   | {
       +display: 'alwaysDisplayShortName',
       +threadInfo: ThreadInfo | RawThreadInfo,
       +possessive?: ?boolean,
     }
   | {
       +display: 'alwaysDisplayShortName',
       +threadID: string,
+      +parentThreadID?: ?string,
+      +threadType?: ?ThreadType,
       +possessive?: ?boolean,
     };
 entityTextFunction.thread = (input: EntityTextThreadInput) => {
   if (input.display === 'uiName') {
     const { threadInfo } = input;
     if (typeof threadInfo.uiName !== 'string') {
       return threadInfo.uiName;
     }
     return {
       type: 'thread',
       id: threadInfo.id,
       name: threadInfo.name,
       display: 'uiName',
       uiName: threadInfo.uiName,
     };
   }
   if (input.display === 'alwaysDisplayShortName' && input.threadID) {
-    const { threadID, possessive } = input;
+    const { threadID, threadType, parentThreadID, possessive } = input;
     return {
       type: 'thread',
       id: threadID,
       name: undefined,
       display: 'shortName',
-      threadType: undefined,
+      threadType,
+      parentThreadID,
       alwaysDisplayShortName: true,
       possessive,
     };
   } else if (input.display === 'alwaysDisplayShortName' && input.threadInfo) {
     const { threadInfo, possessive } = input;
     return {
       type: 'thread',
       id: threadInfo.id,
       name: threadInfo.name,
       display: 'shortName',
       threadType: threadInfo.type,
+      parentThreadID: threadInfo.parentThreadID,
       alwaysDisplayShortName: true,
       possessive,
     };
   } else if (input.display === 'shortName' || !input.display) {
     const { threadInfo, subchannel, possessive } = input;
     return {
       type: 'thread',
       id: threadInfo.id,
       name: threadInfo.name,
       display: 'shortName',
       threadType: threadInfo.type,
+      parentThreadID: threadInfo.parentThreadID,
       subchannel,
       possessive,
     };
   }
   invariant(
     false,
     `ET.thread passed unexpected display type: ${input.display}`,
   );
 };
 
 type EntityTextUserInput = {
   +userInfo: {
     +id: string,
     +username?: ?string,
     +isViewer?: ?boolean,
     ...
   },
   +possessive?: ?boolean,
 };
 entityTextFunction.user = (input: EntityTextUserInput) => ({
   type: 'user',
   id: input.userInfo.id,
   username: input.userInfo.username,
   isViewer: input.userInfo.isViewer,
   possessive: input.possessive,
 });
 
 type EntityTextColorInput = { +hex: string };
 entityTextFunction.color = (input: EntityTextColorInput) => ({
   type: 'color',
   hex: input.hex,
 });
 
 // ET is a JS tag function used in template literals, eg. ET`something`
 // It allows you to compose raw text and "entities" together
 type EntityTextFunction = ((
   strings: $ReadOnlyArray<string>,
   ...entities: $ReadOnlyArray<EntityTextComponent | EntityText>
 ) => EntityText) & {
   +thread: EntityTextThreadInput => ThreadEntity,
   +user: EntityTextUserInput => UserEntity,
   +color: EntityTextColorInput => ColorEntity,
   ...
 };
 const ET: EntityTextFunction = entityTextFunction;
 
 type MakePossessiveInput = { +str: string, +isViewer?: ?boolean };
 function makePossessive(input: MakePossessiveInput) {
   if (input.isViewer) {
     return 'your';
   }
   return `${input.str}’s`;
 }
 
 function getNameForThreadEntity(
   entity: ThreadEntity,
   params?: ?EntityTextToRawStringParams,
 ): string {
   const { name: userGeneratedName, display } = entity;
   if (entity.display === 'uiName') {
     if (userGeneratedName) {
       return userGeneratedName;
     }
     const { uiName } = entity;
     if (typeof uiName === 'string') {
       return uiName;
     }
     let userEntities = uiName;
     if (!params?.ignoreViewer) {
       userEntities = userEntities.filter(innerEntity => !innerEntity.isViewer);
     }
     if (userEntities.length === 0) {
       return 'just you';
     }
     const pluralized = pluralizeEntityText(
       userEntities.map(innerEntity => [innerEntity]),
     );
     return entityTextToRawString(pluralized, params);
   }
   invariant(
     entity.display === 'shortName',
     `getNameForThreadEntity can't handle thread entity display ${display}`,
   );
 
   let { name } = entity;
   if (!name || entity.alwaysDisplayShortName) {
     const threadType = entity.threadType ?? threadTypes.PERSONAL;
     const noun = entity.subchannel ? 'subchannel' : threadNoun(threadType);
     if (entity.id === params?.threadID) {
       const prefixThisThreadNounWith =
         params?.prefixThisThreadNounWith === 'your' ? 'your' : 'this';
       name = `${prefixThisThreadNounWith} ${noun}`;
     } else {
       name = `a ${noun}`;
     }
   }
   if (entity.possessive) {
     name = makePossessive({ str: name });
   }
   return name;
 }
 
 function getNameForUserEntity(
   entity: UserEntity,
   ignoreViewer: ?boolean,
 ): string {
   const isViewer = entity.isViewer && !ignoreViewer;
   const entityWithIsViewerIgnored = { ...entity, isViewer };
   const str = stringForUser(entityWithIsViewerIgnored);
   if (!entityWithIsViewerIgnored.possessive) {
     return str;
   }
   return makePossessive({ str, isViewer });
 }
 
 type EntityTextToRawStringParams = {
   +threadID?: ?string,
   +ignoreViewer?: ?boolean,
   +prefixThisThreadNounWith?: ?('this' | 'your'),
 };
 function entityTextToRawString(
   entityText: EntityText,
   params?: ?EntityTextToRawStringParams,
 ): string {
   const textParts = entityText.map(entity => {
     if (typeof entity === 'string') {
       return entity;
     } else if (entity.type === 'thread') {
       return getNameForThreadEntity(entity, params);
     } else if (entity.type === 'color') {
       return entity.hex;
     } else if (entity.type === 'user') {
       return getNameForUserEntity(entity, params?.ignoreViewer);
     } else {
       invariant(
         false,
         `entityTextToRawString can't handle entity type ${entity.type}`,
       );
     }
   });
   return textParts.join('');
 }
 
 type RenderFunctions = {
   +renderText: ({ +text: string }) => React.Node,
   +renderThread: ({ +id: string, +name: string }) => React.Node,
   +renderColor: ({ +hex: string }) => React.Node,
 };
 function entityTextToReact(
   entityText: EntityText,
   threadID: string,
   renderFuncs: RenderFunctions,
 ): React.Node {
   const { renderText, renderThread, renderColor } = renderFuncs;
   return entityText.map((entity, i) => {
     const key = `text${i}`;
     if (typeof entity === 'string') {
       return (
         <React.Fragment key={key}>
           {renderText({ text: entity })}
         </React.Fragment>
       );
     } else if (entity.type === 'thread') {
       const { id } = entity;
       const name = getNameForThreadEntity(entity, { threadID });
       if (id === threadID) {
         return name;
       } else {
         return (
           <React.Fragment key={key}>
             {renderThread({ id, name })}
           </React.Fragment>
         );
       }
     } else if (entity.type === 'color') {
       return (
         <React.Fragment key={key}>
           {renderColor({ hex: entity.hex })}
         </React.Fragment>
       );
     } else if (entity.type === 'user') {
       return getNameForUserEntity(entity);
     } else {
       invariant(
         false,
         `entityTextToReact can't handle entity type ${entity.type}`,
       );
     }
   });
 }
 
 function pluralizeEntityText(
   nouns: $ReadOnlyArray<EntityText>,
   maxNumberOfNouns: number = 3,
 ): EntityText {
   return basePluralize<EntityText>(
     nouns,
     maxNumberOfNouns,
     (a: EntityText | string, b: ?EntityText | string) =>
       b ? ET`${a}${b}` : ET`${a}`,
   );
 }
 
 type TextEntity = { +type: 'text', +text: string };
 type ShadowUserEntity = {
   +type: 'shadowUser',
   +username: string,
   +originalUsername: string,
 };
 type EntityTextComponentAsObject =
   | UserEntity
   | ThreadEntity
   | ColorEntity
   | TextEntity
   | ShadowUserEntity;
 function entityTextToObjects(
   entityText: EntityText,
 ): EntityTextComponentAsObject[] {
   const objs = [];
   for (const entity of entityText) {
     if (typeof entity === 'string') {
       objs.push({ type: 'text', text: entity });
       continue;
     }
     objs.push(entity);
     if (
       entity.type === 'thread' &&
       entity.display === 'uiName' &&
       typeof entity.uiName !== 'string'
     ) {
       for (const innerEntity of entity.uiName) {
         if (typeof innerEntity === 'string' || innerEntity.type !== 'user') {
           continue;
         }
         const { username } = innerEntity;
         if (username) {
           objs.push({
             type: 'shadowUser',
             originalUsername: username,
             username,
           });
         }
       }
     }
   }
   return objs;
 }
 function entityTextFromObjects(
   objects: $ReadOnlyArray<EntityTextComponentAsObject>,
 ): EntityText {
   const shadowUserMap = new Map<string, string>();
   for (const obj of objects) {
     if (obj.type === 'shadowUser' && obj.username !== obj.originalUsername) {
       shadowUserMap.set(obj.originalUsername, obj.username);
     }
   }
   return objects
     .map(entity => {
       if (entity.type === 'text') {
         return entity.text;
       } else if (entity.type === 'shadowUser') {
         return null;
       } else if (
         entity.type === 'thread' &&
         entity.display === 'uiName' &&
         typeof entity.uiName !== 'string'
       ) {
         const uiName = [];
         let changeOccurred = false;
         for (const innerEntity of entity.uiName) {
           if (typeof innerEntity === 'string' || innerEntity.type !== 'user') {
             uiName.push(innerEntity);
             continue;
           }
           const { username } = innerEntity;
           if (!username) {
             uiName.push(innerEntity);
             continue;
           }
           const ensName = shadowUserMap.get(username);
           if (!ensName) {
             uiName.push(innerEntity);
             continue;
           }
           changeOccurred = true;
           uiName.push({
             ...innerEntity,
             username: ensName,
           });
         }
         if (!changeOccurred) {
           return entity;
         }
         return {
           ...entity,
           uiName,
         };
       } else {
         return entity;
       }
     })
     .filter(Boolean);
 }
 
 function useENSNamesForEntityText(entityText: ?EntityText): ?EntityText {
   const allObjects = React.useMemo(
     () => (entityText ? entityTextToObjects(entityText) : []),
     [entityText],
   );
   const objectsWithENSNames = useENSNames(allObjects);
   return React.useMemo(
     () =>
       entityText ? entityTextFromObjects(objectsWithENSNames) : entityText,
     [entityText, objectsWithENSNames],
   );
 }
 
 function useEntityTextAsString(
   entityText: ?EntityText,
   params?: EntityTextToRawStringParams,
 ): ?string {
   const withENSNames = useENSNamesForEntityText(entityText);
   return React.useMemo(() => {
     if (!withENSNames) {
       return withENSNames;
     }
     return entityTextToRawString(withENSNames, params);
   }, [withENSNames, params]);
 }
 
 async function getEntityTextAsString(
   entityText: ?EntityText,
   getENSNames: ?GetENSNames,
   params?: EntityTextToRawStringParams,
 ): Promise<?string> {
   if (!entityText) {
     return entityText;
   }
 
   let resolvedEntityText = entityText;
   if (getENSNames) {
     const allObjects = entityTextToObjects(entityText);
     const objectsWithENSNames = await getENSNames(allObjects);
     resolvedEntityText = entityTextFromObjects(objectsWithENSNames);
   }
 
   return entityTextToRawString(resolvedEntityText, params);
 }
 
 export {
   ET,
   entityTextToRawString,
   entityTextToReact,
   pluralizeEntityText,
   useENSNamesForEntityText,
   useEntityTextAsString,
   getEntityTextAsString,
 };