diff --git a/lib/reducers/master-reducer.js b/lib/reducers/master-reducer.js
index 22ec94a42..bf456d698 100644
--- a/lib/reducers/master-reducer.js
+++ b/lib/reducers/master-reducer.js
@@ -1,168 +1,174 @@
 // @flow
 
 import reduceCalendarFilters from './calendar-filters-reducer.js';
 import { reduceCalendarQuery } from './calendar-query-reducer.js';
 import reduceDataLoaded from './data-loaded-reducer.js';
 import { reduceDeviceToken } from './device-token-reducer.js';
 import { reduceDraftStore } from './draft-reducer.js';
 import reduceEnabledApps from './enabled-apps-reducer.js';
 import { reduceEntryInfos } from './entry-reducer.js';
 import { reduceIntegrityStore } from './integrity-reducer.js';
 import reduceInviteLinks from './invite-links-reducer.js';
 import reduceKeyserverStore from './keyserver-reducer.js';
 import reduceLifecycleState from './lifecycle-state-reducer.js';
 import { reduceLoadingStatuses } from './loading-reducer.js';
 import reduceNextLocalID from './local-id-reducer.js';
 import { reduceMessageStore } from './message-reducer.js';
 import reduceBaseNavInfo from './nav-reducer.js';
 import { reduceNotifPermissionAlertInfo } from './notif-permission-alert-info-reducer.js';
 import policiesReducer from './policies-reducer.js';
 import reduceReportStore from './report-store-reducer.js';
 import reduceServicesAccessToken from './services-access-token-reducer.js';
 import { reduceThreadActivity } from './thread-activity-reducer.js';
 import { reduceThreadInfos } from './thread-reducer.js';
 import { reduceCurrentUserInfo, reduceUserInfos } from './user-reducer.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   registerActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import type { BaseNavInfo } from '../types/nav-types.js';
 import type { BaseAppState, BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 export default function baseReducer<N: BaseNavInfo, T: BaseAppState<N>>(
   state: T,
   action: BaseAction,
 ): { state: T, storeOperations: StoreOperations } {
   const { threadStore, newThreadInconsistencies, threadStoreOperations } =
     reduceThreadInfos(state.threadStore, action);
   const { threadInfos } = threadStore;
 
   const [entryStore, newEntryInconsistencies] = reduceEntryInfos(
     state.entryStore,
     action,
     threadInfos,
   );
 
+  const [userStore, newUserInconsistencies] = reduceUserInfos(
+    state.userStore,
+    action,
+  );
+
   const newInconsistencies = [
     ...newEntryInconsistencies,
     ...newThreadInconsistencies,
+    ...newUserInconsistencies,
   ];
   // Only allow checkpoints to increase if we are connected
   // or if the action is a STATE_SYNC
   const { messageStoreOperations, messageStore: reducedMessageStore } =
     reduceMessageStore(state.messageStore, action, threadInfos);
   let messageStore = reducedMessageStore;
 
   let keyserverStore = reduceKeyserverStore(state.keyserverStore, action);
 
   if (
     keyserverStore.keyserverInfos[ashoatKeyserverID].connection.status !==
       'connected' &&
     action.type !== incrementalStateSyncActionType &&
     action.type !== fullStateSyncActionType &&
     action.type !== registerActionTypes.success &&
     action.type !== logInActionTypes.success &&
     action.type !== siweAuthActionTypes.success
   ) {
     if (
       messageStore.currentAsOf[ashoatKeyserverID] !==
       state.messageStore.currentAsOf[ashoatKeyserverID]
     ) {
       messageStore = {
         ...messageStore,
         currentAsOf: {
           ...messageStore.currentAsOf,
           [ashoatKeyserverID]:
             state.messageStore.currentAsOf[ashoatKeyserverID],
         },
       };
     }
     if (
       keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf !==
       state.keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf
     ) {
       const keyserverInfos = { ...keyserverStore.keyserverInfos };
       keyserverInfos[ashoatKeyserverID] = {
         ...keyserverInfos[ashoatKeyserverID],
         updatesCurrentAsOf:
           state.keyserverStore.keyserverInfos[ashoatKeyserverID]
             .updatesCurrentAsOf,
       };
       keyserverStore = { ...keyserverStore, keyserverInfos };
     }
   }
 
   const { draftStore, draftStoreOperations } = reduceDraftStore(
     state.draftStore,
     action,
   );
 
   const { reportStore, reportStoreOperations } = reduceReportStore(
     state.reportStore,
     action,
     newInconsistencies,
   );
 
   return {
     state: {
       ...state,
       navInfo: reduceBaseNavInfo(state.navInfo, action),
       draftStore,
       entryStore,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
       currentUserInfo: reduceCurrentUserInfo(state.currentUserInfo, action),
       threadStore,
-      userStore: reduceUserInfos(state.userStore, action),
+      userStore,
       messageStore,
       calendarFilters: reduceCalendarFilters(
         state.calendarFilters,
         action,
         threadStore,
       ),
       notifPermissionAlertInfo: reduceNotifPermissionAlertInfo(
         state.notifPermissionAlertInfo,
         action,
       ),
       actualizedCalendarQuery: reduceCalendarQuery(
         state.actualizedCalendarQuery,
         action,
       ),
       lifecycleState: reduceLifecycleState(state.lifecycleState, action),
       enabledApps: reduceEnabledApps(state.enabledApps, action),
       reportStore,
       nextLocalID: reduceNextLocalID(state.nextLocalID, action),
       dataLoaded: reduceDataLoaded(state.dataLoaded, action),
       userPolicies: policiesReducer(state.userPolicies, action),
       deviceToken: reduceDeviceToken(state.deviceToken, action),
       commServicesAccessToken: reduceServicesAccessToken(
         state.commServicesAccessToken,
         action,
       ),
       inviteLinksStore: reduceInviteLinks(state.inviteLinksStore, action),
       keyserverStore,
       threadActivityStore: reduceThreadActivity(
         state.threadActivityStore,
         action,
       ),
       integrityStore: reduceIntegrityStore(
         state.integrityStore,
         action,
         threadStore.threadInfos,
         threadStoreOperations,
       ),
     },
     storeOperations: {
       draftStoreOperations,
       threadStoreOperations,
       messageStoreOperations,
       reportStoreOperations,
     },
   };
 }
diff --git a/lib/reducers/user-reducer.js b/lib/reducers/user-reducer.js
index b573f402c..24bb12b9c 100644
--- a/lib/reducers/user-reducer.js
+++ b/lib/reducers/user-reducer.js
@@ -1,240 +1,257 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   joinThreadActionTypes,
   newThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   setUserSettingsActionTypes,
   updateUserAvatarActionTypes,
   resetUserStateActionType,
 } from '../actions/user-actions.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { BaseAction } from '../types/redux-types.js';
+import type { UserInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import type { CurrentUserInfo, UserStore } from '../types/user-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 function reduceCurrentUserInfo(
   state: ?CurrentUserInfo,
   action: BaseAction,
 ): ?CurrentUserInfo {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success
   ) {
     if (!_isEqual(action.payload.currentUserInfo)(state)) {
       return action.payload.currentUserInfo;
     }
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo
   ) {
     const { sessionChange } = action.payload;
     if (!_isEqual(sessionChange.currentUserInfo)(state)) {
       return sessionChange.currentUserInfo;
     }
   } else if (action.type === fullStateSyncActionType) {
     const { currentUserInfo } = action.payload;
     if (!_isEqual(currentUserInfo)(state)) {
       return currentUserInfo;
     }
   } else if (
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType
   ) {
     return action.payload.updatesResult.newUpdates.reduce(
       (reducedState, update) => {
         const { reduceCurrentUser } = updateSpecs[update.type];
         return reduceCurrentUser
           ? reduceCurrentUser(reducedState, update)
           : reducedState;
       },
       state,
     );
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (
       checkStateRequest &&
       checkStateRequest.stateChanges &&
       checkStateRequest.stateChanges.currentUserInfo &&
       !_isEqual(checkStateRequest.stateChanges.currentUserInfo)(state)
     ) {
       return checkStateRequest.stateChanges.currentUserInfo;
     }
   } else if (
     action.type === updateUserAvatarActionTypes.success &&
     state &&
     !state.anonymous
   ) {
     const { viewerUpdates } = action.payload.updates;
     for (const update of viewerUpdates) {
       if (
         update.type === updateTypes.UPDATE_CURRENT_USER &&
         !_isEqual(update.currentUserInfo.avatar)(state.avatar)
       ) {
         return {
           ...state,
           avatar: update.currentUserInfo.avatar,
         };
       }
     }
     return state;
   } else if (action.type === setUserSettingsActionTypes.success) {
     if (state?.settings) {
       return {
         ...state,
         settings: {
           ...state.settings,
           ...action.payload,
         },
       };
     }
   } else if (action.type === resetUserStateActionType) {
     state = state && state.anonymous ? state : null;
   }
   return state;
 }
 
-function reduceUserInfos(state: UserStore, action: BaseAction): UserStore {
+function reduceUserInfos(
+  state: UserStore,
+  action: BaseAction,
+): [UserStore, $ReadOnlyArray<UserInconsistencyReportCreationRequest>] {
   if (
     action.type === joinThreadActionTypes.success ||
     action.type === newThreadActionTypes.success
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const updated = { ...state.userInfos, ...newUserInfos };
     if (!_isEqual(state.userInfos)(updated)) {
-      return {
-        ...state,
-        userInfos: updated,
-      };
+      return [
+        {
+          ...state,
+          userInfos: updated,
+        },
+        [],
+      ];
     }
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     if (Object.keys(state.userInfos).length === 0) {
-      return state;
+      return [state, []];
     }
-    return {
-      userInfos: {},
-      inconsistencyReports: state.inconsistencyReports,
-    };
+    return [
+      {
+        userInfos: {},
+        inconsistencyReports: state.inconsistencyReports,
+      },
+      [],
+    ];
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === fullStateSyncActionType
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     if (!_isEqual(state.userInfos)(newUserInfos)) {
-      return {
-        userInfos: newUserInfos,
-        inconsistencyReports: state.inconsistencyReports,
-      };
+      return [
+        {
+          userInfos: newUserInfos,
+          inconsistencyReports: state.inconsistencyReports,
+        },
+        [],
+      ];
     }
   } else if (
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const updated = action.payload.updatesResult.newUpdates.reduce(
       (reducedState, update) => {
         const { reduceUserInfos: reduceUserInfosUpdate } =
           updateSpecs[update.type];
         return reduceUserInfosUpdate
           ? reduceUserInfosUpdate(reducedState, update)
           : reducedState;
       },
       { ...state.userInfos, ...newUserInfos },
     );
     if (!_isEqual(state.userInfos)(updated)) {
-      return {
-        ...state,
-        userInfos: updated,
-      };
+      return [
+        {
+          ...state,
+          userInfos: updated,
+        },
+        [],
+      ];
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
-      return state;
+      return [state, []];
     }
     const { userInfos, deleteUserInfoIDs } = checkStateRequest.stateChanges;
     if (!userInfos && !deleteUserInfoIDs) {
-      return state;
+      return [state, []];
     }
 
     const newUserInfos = { ...state.userInfos };
     if (userInfos) {
       for (const userInfo of userInfos) {
         newUserInfos[userInfo.id] = userInfo;
       }
     }
     if (deleteUserInfoIDs) {
       for (const deleteUserInfoID of deleteUserInfoIDs) {
         delete newUserInfos[deleteUserInfoID];
       }
     }
 
     const newInconsistencies = stateSyncSpecs.users.findStoreInconsistencies(
       action,
       state.userInfos,
       newUserInfos,
     );
-    return {
-      userInfos: newUserInfos,
-      inconsistencyReports: [
-        ...state.inconsistencyReports,
-        ...newInconsistencies,
-      ],
-    };
+    return [
+      {
+        userInfos: newUserInfos,
+        inconsistencyReports: state.inconsistencyReports,
+      },
+      newInconsistencies,
+    ];
   } else if (action.type === updateUserAvatarActionTypes.success) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.updates.userInfos,
     );
     const updated = { ...state.userInfos, ...newUserInfos };
-    return !_isEqual(state.userInfos)(updated)
+    const newState = !_isEqual(state.userInfos)(updated)
       ? {
           ...state,
           userInfos: updated,
         }
       : state;
+    return [newState, []];
   }
 
-  return state;
+  return [state, []];
 }
 
 export { reduceCurrentUserInfo, reduceUserInfos };
diff --git a/lib/utils/report-utils.js b/lib/utils/report-utils.js
index 6c70d4c56..bcd4ecca0 100644
--- a/lib/utils/report-utils.js
+++ b/lib/utils/report-utils.js
@@ -1,45 +1,46 @@
 // @flow
 
 import { useSelector } from './redux-utils.js';
 import { getUUID } from './uuid.js';
 import {
   type SupportedReports,
   type EnabledReports,
   type ClientReportCreationRequest,
   reportTypes,
 } from '../types/report-types.js';
 
 function useIsReportEnabled(reportType: SupportedReports): boolean {
   return useSelector(state => state.reportStore.enabledReports[reportType]);
 }
 
 // maximum size of reports without std::string overhead
 const MAX_REPORT_LENGTH = 200_000_000 - 90000;
 function isReportSizeValid(report: ClientReportCreationRequest): boolean {
   try {
     return JSON.stringify(report).length < MAX_REPORT_LENGTH;
   } catch (e) {
     return false;
   }
 }
 
 function isReportEnabled(
   report: ClientReportCreationRequest,
   enabledReports: EnabledReports,
 ): boolean {
   const isReportTypeEnabled =
     (report.type === reportTypes.MEDIA_MISSION &&
       enabledReports.mediaReports) ||
     (report.type === reportTypes.ERROR && enabledReports.crashReports) ||
     ((report.type === reportTypes.ENTRY_INCONSISTENCY ||
-      report.type === reportTypes.THREAD_INCONSISTENCY) &&
+      report.type === reportTypes.THREAD_INCONSISTENCY ||
+      report.type === reportTypes.USER_INCONSISTENCY) &&
       enabledReports.inconsistencyReports);
 
   return isReportTypeEnabled && isReportSizeValid(report);
 }
 
 function generateReportID(): string {
   return getUUID();
 }
 
 export { useIsReportEnabled, isReportEnabled, generateReportID };