diff --git a/lib/shared/messages/create-sidebar-message-spec.js b/lib/shared/messages/create-sidebar-message-spec.js
index ca2b567b6..5ce9a9ce6 100644
--- a/lib/shared/messages/create-sidebar-message-spec.js
+++ b/lib/shared/messages/create-sidebar-message-spec.js
@@ -1,146 +1,150 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   CreateSidebarMessageData,
   CreateSidebarMessageInfo,
   RawCreateSidebarMessageInfo,
 } from '../../types/message/create-sidebar';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
 import type { MessageSpec } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const createSidebarMessageSpec: MessageSpec<
   CreateSidebarMessageData,
   RawCreateSidebarMessageInfo,
   CreateSidebarMessageInfo,
 > = Object.freeze({
   messageContent(data) {
     return JSON.stringify({
       ...data.initialThreadState,
       sourceMessageAuthorID: data.sourceMessageAuthorID,
     });
   },
 
   rawMessageInfoFromRow(row) {
     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,
     };
   },
 
   createMessageInfo(rawMessageInfo, creator, params) {
     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, id) {
     return { ...messageData, id };
   },
 
   robotext(messageInfo, creator, params) {
     let text = `started ${params.encodedThreadEntity(
       messageInfo.threadID,
       `this sidebar`,
     )}`;
     const users = messageInfo.initialThreadState.otherMembers.filter(
       (member) => member.id !== messageInfo.sourceMessageAuthor.id,
     );
     if (users.length !== 0) {
       const initialUsersString = params.robotextForUsers(users);
       text += ` and added ${initialUsersString}`;
     }
     return `${creator} ${text}`;
   },
 
   shimUnsupportedMessageInfo(rawMessageInfo, platformDetails) {
     // TODO determine min code version
     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 sidebar',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
+  unshimMessageInfo(unwrapped) {
+    return unwrapped;
+  },
+
   notificationTexts(messageInfos, threadInfo) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.CREATE_SIDEBAR,
       'messageInfo should be messageTypes.CREATE_SIDEBAR!',
     );
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const sourceMessageAuthorPossessive = messageInfo.sourceMessageAuthor
       .isViewer
       ? 'your'
       : `${stringForUser(messageInfo.sourceMessageAuthor)}'s`;
     const body =
       `started a sidebar in response to ${sourceMessageAuthorPossessive} ` +
       `message "${messageInfo.initialThreadState.name ?? ''}"`;
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
   generatesNotifs: true,
 
   userIDs(rawMessageInfo) {
     return rawMessageInfo.initialThreadState.memberIDs;
   },
 
   threadIDs(rawMessageInfo) {
     const { parentThreadID } = rawMessageInfo.initialThreadState;
     return [parentThreadID];
   },
 });
diff --git a/lib/shared/messages/sidebar-source-message-spec.js b/lib/shared/messages/sidebar-source-message-spec.js
index d0ae9de21..404ad0d78 100644
--- a/lib/shared/messages/sidebar-source-message-spec.js
+++ b/lib/shared/messages/sidebar-source-message-spec.js
@@ -1,111 +1,115 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type {
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageData,
   SidebarSourceMessageInfo,
 } from '../../types/message-types';
 import { messageTypes } from '../../types/message-types';
 import { hasMinCodeVersion } from '../version-utils';
 import type { MessageSpec } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const sidebarSourceMessageSpec: MessageSpec<
   SidebarSourceMessageData,
   RawSidebarSourceMessageInfo,
   SidebarSourceMessageInfo,
 > = Object.freeze({
   messageContent(data) {
     const sourceMessageID = data.sourceMessage?.id;
     invariant(sourceMessageID, 'Source message id should be set');
     return JSON.stringify({
       sourceMessageID,
     });
   },
 
   rawMessageInfoFromRow(row, params) {
     const { derivedMessages } = params;
     invariant(derivedMessages, 'Derived messages should be provided');
 
     const content = JSON.parse(row.content);
     const sourceMessage = derivedMessages.get(content.sourceMessageID);
     if (!sourceMessage) {
       console.warn(
         `Message with id ${row.id} has a derived message ` +
           `${content.sourceMessageID} which is not present in the database`,
       );
     }
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       sourceMessage,
     };
   },
 
   createMessageInfo(rawMessageInfo, creator, params) {
     if (!rawMessageInfo.sourceMessage) {
       return null;
     }
     const sourceMessage = params.createMessageInfoFromRaw(
       rawMessageInfo.sourceMessage,
     );
     invariant(
       sourceMessage && sourceMessage.type !== messageTypes.SIDEBAR_SOURCE,
       'Sidebars can not be created from SIDEBAR SOURCE',
     );
 
     return {
       type: messageTypes.SIDEBAR_SOURCE,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       sourceMessage,
     };
   },
 
   rawMessageInfoFromMessageData(messageData, id) {
     return { ...messageData, id };
   },
 
   shimUnsupportedMessageInfo(rawMessageInfo, platformDetails) {
     // TODO determine min code version
     if (
       hasMinCodeVersion(platformDetails, 75) &&
       rawMessageInfo.sourceMessage
     ) {
       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: 'first message in sidebar',
       dontPrefixCreator: true,
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
+  unshimMessageInfo(unwrapped) {
+    return unwrapped;
+  },
+
   notificationTexts(messageInfos, threadInfo, params) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.SIDEBAR_SOURCE,
       'messageInfo should be messageTypes.SIDEBAR_SOURCE!',
     );
     const sourceMessageInfo = messageInfo.sourceMessage;
     return params.notificationTexts([sourceMessageInfo], threadInfo);
   },
 
   generatesNotifs: false,
 
   startsThread: true,
 });
diff --git a/lib/shared/unshim-utils.js b/lib/shared/unshim-utils.js
index 080703cc7..29223f444 100644
--- a/lib/shared/unshim-utils.js
+++ b/lib/shared/unshim-utils.js
@@ -1,53 +1,55 @@
 // @flow
 
 import _mapValues from 'lodash/fp/mapValues';
 
 import {
   type MessageStore,
   type RawMessageInfo,
   type MessageType,
   messageTypes,
 } from '../types/message-types';
 import { messageSpecs } from './messages/message-specs';
 
 function unshimFunc(
   messageInfo: RawMessageInfo,
   unshimTypes: Set<MessageType>,
 ): RawMessageInfo {
   if (messageInfo.type !== messageTypes.UNSUPPORTED) {
     return messageInfo;
   }
   if (!unshimTypes.has(messageInfo.unsupportedMessageInfo.type)) {
     return messageInfo;
   }
   const unwrapped = messageInfo.unsupportedMessageInfo;
   const { unshimMessageInfo } = messageSpecs[unwrapped.type];
   const unshimmed = unshimMessageInfo?.(unwrapped, messageInfo);
   return unshimmed ?? unwrapped;
 }
 
 function unshimMessageStore(
   messageStore: MessageStore,
   unshimTypes: $ReadOnlyArray<MessageType>,
 ): MessageStore {
   const set = new Set(unshimTypes);
   const messages = _mapValues((messageInfo: RawMessageInfo) =>
     unshimFunc(messageInfo, set),
   )(messageStore.messages);
   return { ...messageStore, messages };
 }
 
 const localUnshimTypes = new Set([
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
   messageTypes.UPDATE_RELATIONSHIP,
+  messageTypes.CREATE_SIDEBAR,
+  messageTypes.SIDEBAR_SOURCE,
 ]);
 function unshimMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): RawMessageInfo[] {
   return messageInfos.map((messageInfo: RawMessageInfo) =>
     unshimFunc(messageInfo, localUnshimTypes),
   );
 }
 
 export { unshimMessageStore, unshimMessageInfos };
diff --git a/native/redux/persist.js b/native/redux/persist.js
index 866224603..ad66e35b2 100644
--- a/native/redux/persist.js
+++ b/native/redux/persist.js
@@ -1,227 +1,234 @@
 // @flow
 
 import AsyncStorage from '@react-native-community/async-storage';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 import { createMigrate } from 'redux-persist';
 
 import { highestLocalIDSelector } from 'lib/selectors/local-id-selectors';
 import { inconsistencyResponsesToReports } from 'lib/shared/report-utils';
 import { unshimMessageStore } from 'lib/shared/unshim-utils';
 import { defaultCalendarFilters } from 'lib/types/filter-types';
 import { messageTypes } from 'lib/types/message-types';
 import { defaultConnectionInfo } from 'lib/types/socket-types';
 
 import { defaultNotifPermissionAlertInfo } from '../push/alerts';
 import { defaultDeviceCameraInfo } from '../types/camera';
 import { defaultGlobalThemeInfo } from '../types/themes';
 import type { AppState } from './redux-setup';
 
 const migrations = {
   [1]: (state: AppState) => ({
     ...state,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   }),
   [2]: (state: AppState) => ({
     ...state,
     messageSentFromRoute: [],
   }),
   [3]: (state) => ({
     currentUserInfo: state.currentUserInfo,
     entryStore: state.entryStore,
     threadInfos: state.threadInfos,
     userInfos: state.userInfos,
     messageStore: {
       ...state.messageStore,
       currentAsOf: state.currentAsOf,
     },
     drafts: state.drafts,
     updatesCurrentAsOf: state.currentAsOf,
     cookie: state.cookie,
     deviceToken: state.deviceToken,
     urlPrefix: state.urlPrefix,
     customServer: state.customServer,
     threadIDsToNotifIDs: state.threadIDsToNotifIDs,
     notifPermissionAlertInfo: state.notifPermissionAlertInfo,
     messageSentFromRoute: state.messageSentFromRoute,
     _persist: state._persist,
   }),
   [4]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
   }),
   [5]: (state: AppState) => ({
     ...state,
     calendarFilters: defaultCalendarFilters,
   }),
   [6]: (state) => ({
     ...state,
     threadInfos: undefined,
     threadStore: {
       threadInfos: state.threadInfos,
       inconsistencyResponses: [],
     },
   }),
   [7]: (state) => ({
     ...state,
     lastUserInteraction: undefined,
     sessionID: undefined,
     entryStore: {
       ...state.entryStore,
       inconsistencyResponses: [],
     },
   }),
   [8]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
     connection: defaultConnectionInfo(Platform.OS),
     watchedThreadIDs: [],
     foreground: true,
     entryStore: {
       ...state.entryStore,
       actualizedCalendarQuery: undefined,
     },
   }),
   [9]: (state: AppState) => ({
     ...state,
     connection: {
       ...state.connection,
       lateResponses: [],
     },
   }),
   [10]: (state: AppState) => ({
     ...state,
     nextLocalID: highestLocalIDSelector(state) + 1,
     connection: {
       ...state.connection,
       showDisconnectedBar: false,
     },
     messageStore: {
       ...state.messageStore,
       local: {},
     },
   }),
   [11]: (state: AppState) => ({
     ...state,
     messageStore: unshimMessageStore(state.messageStore, [messageTypes.IMAGES]),
   }),
   [12]: (state: AppState) => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [13]: (state: AppState) => ({
     ...state,
     deviceCameraInfo: defaultDeviceCameraInfo,
     deviceOrientation: Orientation.getInitialOrientation(),
   }),
   [14]: (state: AppState) => ({
     ...state,
     messageStore: unshimMessageStore(state.messageStore, [
       messageTypes.MULTIMEDIA,
     ]),
   }),
   [15]: (state) => ({
     ...state,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.threadStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.entryStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     queuedReports: [],
   }),
   [16]: (state) => {
     const result = {
       ...state,
       messageSentFromRoute: undefined,
       dataLoaded: !!state.currentUserInfo && !state.currentUserInfo.anonymous,
     };
     if (state.navInfo) {
       result.navInfo = {
         ...state.navInfo,
         navigationState: undefined,
       };
     }
     return result;
   },
   [17]: (state) => ({
     ...state,
     userInfos: undefined,
     userStore: {
       userInfos: state.userInfos,
       inconsistencyResponses: [],
     },
   }),
   [18]: (state) => ({
     ...state,
     userStore: {
       userInfos: state.userStore.userInfos,
       inconsistencyReports: [],
     },
   }),
   [19]: (state) => {
     const threadInfos = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const { visibilityRules, ...rest } = threadInfo;
       threadInfos[threadID] = rest;
     }
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos,
       },
     };
   },
   [20]: (state: AppState) => ({
     ...state,
     messageStore: unshimMessageStore(state.messageStore, [
       messageTypes.UPDATE_RELATIONSHIP,
     ]),
   }),
+  [21]: (state: AppState) => ({
+    ...state,
+    messageStore: unshimMessageStore(state.messageStore, [
+      messageTypes.CREATE_SIDEBAR,
+      messageTypes.SIDEBAR_SOURCE,
+    ]),
+  }),
 };
 
 const persistConfig = {
   key: 'root',
   storage: AsyncStorage,
   blacklist: [
     'loadingStatuses',
     'foreground',
     'dimensions',
     'connectivity',
     'deviceOrientation',
     'frozen',
   ],
   debug: __DEV__,
-  version: 20,
+  version: 21,
   migrate: createMigrate(migrations, { debug: __DEV__ }),
   timeout: __DEV__ ? 0 : undefined,
 };
 
 const codeVersion = 74;
 
 // This local exists to avoid a circular dependency where redux-setup needs to
 // import all the navigation and screen stuff, but some of those screens want to
 // access the persistor to purge its state.
 let storedPersistor = null;
 function setPersistor(persistor: *) {
   storedPersistor = persistor;
 }
 function getPersistor() {
   invariant(storedPersistor, 'should be set');
   return storedPersistor;
 }
 
 export { persistConfig, codeVersion, setPersistor, getPersistor };