diff --git a/lib/shared/dm-ops/add-members-spec.js b/lib/shared/dm-ops/add-members-spec.js
index 2ec1a8236..10769ddec 100644
--- a/lib/shared/dm-ops/add-members-spec.js
+++ b/lib/shared/dm-ops/add-members-spec.js
@@ -1,128 +1,155 @@
 // @flow
 
 import invariant from 'invariant';
 import uuid from 'uuid';
 
 import { createRoleAndPermissionForThickThreads } from './create-thread-spec.js';
 import type {
   DMOperationSpec,
   ProcessDMOperationUtilities,
 } from './dm-op-spec.js';
 import type { DMAddMembersOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import { type RawMessageInfo } from '../../types/message-types.js';
 import type { AddMembersMessageData } from '../../types/messages/add-members.js';
 import {
   minimallyEncodeMemberInfo,
   type ThickRawThreadInfo,
 } from '../../types/minimally-encoded-thread-permissions-types.js';
 import { joinThreadSubscription } from '../../types/subscription-types.js';
 import type { ThickMemberInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type { ClientUpdateInfo } from '../../types/update-types.js';
 import { values } from '../../utils/objects.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
 import { roleIsDefaultRole, userIsMember } from '../thread-utils.js';
 
 export type AddMembersResult = {
   rawMessageInfos: Array<RawMessageInfo>,
   updateInfos: Array<ClientUpdateInfo>,
   threadInfo: ?ThickRawThreadInfo,
 };
 
 function createAddNewMembersMessageDataFromDMOperation(
   dmOperation: DMAddMembersOperation,
 ): AddMembersMessageData {
   const { editorID, time, addedUserIDs, threadID } = dmOperation;
   return {
     type: messageTypes.ADD_MEMBERS,
     threadID,
     creatorID: editorID,
     time,
     addedUserIDs: [...addedUserIDs],
   };
 }
 
 const addMembersSpec: DMOperationSpec<DMAddMembersOperation> = Object.freeze({
   notificationsCreationData: async (dmOperation: DMAddMembersOperation) => {
     const messageData =
       createAddNewMembersMessageDataFromDMOperation(dmOperation);
     return { messageDatas: [messageData] };
   },
   processDMOperation: async (
     dmOperation: DMAddMembersOperation,
     viewerID: string,
     utilities: ProcessDMOperationUtilities,
   ) => {
     const { editorID, time, messageID, addedUserIDs, threadID } = dmOperation;
     const messageData =
       createAddNewMembersMessageDataFromDMOperation(dmOperation);
     const rawMessageInfos = [
       rawMessageInfoFromMessageData(messageData, messageID),
     ];
     const currentThreadInfo = utilities.threadInfos[threadID];
     if (!currentThreadInfo.thick) {
       return {
         rawMessageInfos: [],
         updateInfos: [],
       };
     }
     const defaultRoleID = values(currentThreadInfo.roles).find(role =>
       roleIsDefaultRole(role),
     )?.id;
     invariant(defaultRoleID, 'Default role ID must exist');
     const { membershipPermissions } = createRoleAndPermissionForThickThreads(
       currentThreadInfo.type,
       currentThreadInfo.id,
       defaultRoleID,
     );
-    const newMembers = addedUserIDs
-      .filter(userID => !userIsMember(currentThreadInfo, userID))
-      .map(userID =>
+
+    const memberTimestamps = { ...currentThreadInfo.timestamps.members };
+    const newMembers = [];
+    for (const userID of addedUserIDs) {
+      if (!memberTimestamps[userID]) {
+        memberTimestamps[userID] = {
+          isMember: time,
+          subscription: currentThreadInfo.creationTime,
+        };
+      }
+
+      if (memberTimestamps[userID].isMember > time) {
+        continue;
+      }
+
+      memberTimestamps[userID] = {
+        ...memberTimestamps[userID],
+        isMember: time,
+      };
+
+      if (userIsMember(currentThreadInfo, userID)) {
+        continue;
+      }
+
+      newMembers.push(
         minimallyEncodeMemberInfo<ThickMemberInfo>({
           id: userID,
           role: defaultRoleID,
           permissions: membershipPermissions,
           isSender: editorID === viewerID,
           subscription: joinThreadSubscription,
         }),
       );
+    }
 
     const resultThreadInfo = {
       ...currentThreadInfo,
       members: [...currentThreadInfo.members, ...newMembers],
+      timestamps: {
+        ...currentThreadInfo.timestamps,
+        members: memberTimestamps,
+      },
     };
     const updateInfos = [
       {
         type: updateTypes.UPDATE_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: resultThreadInfo,
       },
     ];
 
     return {
       rawMessageInfos,
       updateInfos,
     };
   },
   canBeProcessed(
     dmOperation: DMAddMembersOperation,
     viewerID: string,
     utilities: ProcessDMOperationUtilities,
   ) {
     if (utilities.threadInfos[dmOperation.threadID]) {
       return { isProcessingPossible: true };
     }
     return {
       isProcessingPossible: false,
       reason: {
         type: 'missing_thread',
         threadID: dmOperation.threadID,
       },
     };
   },
   supportsAutoRetry: true,
 });
 
 export { addMembersSpec, createAddNewMembersMessageDataFromDMOperation };