diff --git a/lib/socket/socket.react.js b/lib/socket/socket.react.js
index 4005960a4..497596d39 100644
--- a/lib/socket/socket.react.js
+++ b/lib/socket/socket.react.js
@@ -1,746 +1,772 @@
 // @flow
 
 import invariant from 'invariant';
 import _throttle from 'lodash/throttle';
 import * as React from 'react';
 
 import { updateActivityActionTypes } from '../actions/activity-actions';
 import { logOutActionTypes } from '../actions/user-actions';
 import { unsupervisedBackgroundActionType } from '../reducers/lifecycle-state-reducer';
 import {
   pingFrequency,
   serverRequestSocketTimeout,
   clientRequestVisualTimeout,
   clientRequestSocketTimeout,
 } from '../shared/timeouts';
 import { logInActionSources, type LogOutResult } from '../types/account-types';
 import type { CalendarQuery } from '../types/entry-types';
 import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
 import type { Dispatch } from '../types/redux-types';
 import {
   serverRequestTypes,
   type ClientClientResponse,
   type ClientServerRequest,
 } from '../types/request-types';
 import {
   type SessionState,
   type SessionIdentification,
   type PreRequestUserState,
 } from '../types/session-types';
 import {
   clientSocketMessageTypes,
   type ClientClientSocketMessage,
   serverSocketMessageTypes,
   type ClientServerSocketMessage,
   stateSyncPayloadTypes,
   fullStateSyncActionType,
   incrementalStateSyncActionType,
   updateConnectionStatusActionType,
   type ConnectionInfo,
   type ClientInitialClientSocketMessage,
   type ClientResponsesClientSocketMessage,
   type PingClientSocketMessage,
   type AckUpdatesClientSocketMessage,
   type APIRequestClientSocketMessage,
   type ClientSocketMessageWithoutID,
   type SocketListener,
   type ConnectionStatus,
   setLateResponseActionType,
 } from '../types/socket-types';
 import type { CommTransportLayer } from '../types/socket-types';
 import { actionLogger } from '../utils/action-logger';
 import type { DispatchActionPromise } from '../utils/action-utils';
 import {
   setNewSessionActionType,
   fetchNewCookieFromNativeCredentials,
 } from '../utils/action-utils';
 import { getConfig } from '../utils/config';
 import { ServerError } from '../utils/errors';
 import { promiseAll } from '../utils/promises';
 import sleep from '../utils/sleep';
 import ActivityHandler from './activity-handler.react';
 import APIRequestHandler from './api-request-handler.react';
 import CalendarQueryHandler from './calendar-query-handler.react';
 import {
   InflightRequests,
   SocketTimeout,
   SocketOffline,
 } from './inflight-requests';
 import MessageHandler from './message-handler.react';
 import ReportHandler from './report-handler.react';
 import RequestResponseHandler from './request-response-handler.react';
 import UpdateHandler from './update-handler.react';
 
 const remainingTimeAfterVisualTimeout =
   clientRequestSocketTimeout - clientRequestVisualTimeout;
 
 export type BaseSocketProps = {
   +detectUnsupervisedBackgroundRef?: (
     detectUnsupervisedBackground: (alreadyClosed: boolean) => boolean,
   ) => void,
 };
 type Props = {
   ...BaseSocketProps,
   // Redux state
   +active: boolean,
   +openSocket: () => CommTransportLayer,
   +getClientResponses: (
     activeServerRequests: $ReadOnlyArray<ClientServerRequest>,
   ) => $ReadOnlyArray<ClientClientResponse>,
   +activeThread: ?string,
   +sessionStateFunc: () => SessionState,
   +sessionIdentification: SessionIdentification,
   +cookie: ?string,
   +urlPrefix: string,
   +connection: ConnectionInfo,
   +currentCalendarQuery: () => CalendarQuery,
   +canSendReports: boolean,
   +frozen: boolean,
   +preRequestUserState: PreRequestUserState,
+  +noDataAfterPolicyAcknowledgment?: boolean,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +logOut: (preRequestUserState: PreRequestUserState) => Promise<LogOutResult>,
+  +socketCrashLoopRecovery?: () => Promise<void>,
 };
 type State = {
   +inflightRequests: ?InflightRequests,
 };
 class Socket extends React.PureComponent<Props, State> {
   state: State = {
     inflightRequests: null,
   };
   socket: ?CommTransportLayer;
   nextClientMessageID: number = 0;
   listeners: Set<SocketListener> = new Set();
   pingTimeoutID: ?TimeoutID;
   messageLastReceived: ?number;
   initialPlatformDetailsSent: boolean =
     getConfig().platformDetails.platform === 'web';
   reopenConnectionAfterClosing: boolean = false;
   invalidationRecoveryInProgress: boolean = false;
   initializedWithUserState: ?PreRequestUserState;
+  failuresAfterPolicyAcknowledgment: number = 0;
 
   openSocket(newStatus: ConnectionStatus) {
     if (
       this.props.frozen ||
       (getConfig().platformDetails.platform !== 'web' &&
         (!this.props.cookie || !this.props.cookie.startsWith('user=')))
     ) {
       return;
     }
     if (this.socket) {
       const { status } = this.props.connection;
       if (status === 'forcedDisconnecting') {
         this.reopenConnectionAfterClosing = true;
         return;
       } else if (status === 'disconnecting' && this.socket.readyState === 1) {
         this.markSocketInitialized();
         return;
       } else if (
         status === 'connected' ||
         status === 'connecting' ||
         status === 'reconnecting'
       ) {
         return;
       }
       if (this.socket.readyState < 2) {
         this.socket.close();
         console.log(`this.socket seems open, but Redux thinks it's ${status}`);
       }
     }
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: newStatus },
     });
 
     const socket = this.props.openSocket();
     const openObject = {};
     socket.onopen = () => {
       if (this.socket === socket) {
         this.initializeSocket();
         openObject.initializeMessageSent = true;
       }
     };
     socket.onmessage = this.receiveMessage;
     socket.onclose = () => {
       if (this.socket === socket) {
         this.onClose();
       }
     };
     this.socket = socket;
 
     (async () => {
       await sleep(clientRequestVisualTimeout);
       if (this.socket !== socket || openObject.initializeMessageSent) {
         return;
       }
       this.setLateResponse(-1, true);
       await sleep(remainingTimeAfterVisualTimeout);
       if (this.socket !== socket || openObject.initializeMessageSent) {
         return;
       }
       this.finishClosingSocket();
     })();
 
     this.setState({
       inflightRequests: new InflightRequests({
         timeout: () => {
           if (this.socket === socket) {
             this.finishClosingSocket();
           }
         },
         setLateResponse: (messageID: number, isLate: boolean) => {
           if (this.socket === socket) {
             this.setLateResponse(messageID, isLate);
           }
         },
       }),
     });
   }
 
   markSocketInitialized() {
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: 'connected' },
     });
     this.resetPing();
   }
 
   closeSocket(
     // This param is a hack. When closing a socket there is a race between this
     // function and the one to propagate the activity update. We make sure that
     // the activity update wins the race by passing in this param.
     activityUpdatePending: boolean,
   ) {
     const { status } = this.props.connection;
     if (status === 'disconnected') {
       return;
     } else if (status === 'disconnecting' || status === 'forcedDisconnecting') {
       this.reopenConnectionAfterClosing = false;
       return;
     }
     this.stopPing();
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: 'disconnecting' },
     });
     if (!activityUpdatePending) {
       this.finishClosingSocket();
     }
   }
 
   forceCloseSocket() {
     this.stopPing();
     const { status } = this.props.connection;
     if (status !== 'forcedDisconnecting' && status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: { status: 'forcedDisconnecting' },
       });
     }
     this.finishClosingSocket();
   }
 
   finishClosingSocket(receivedResponseTo?: ?number) {
     const { inflightRequests } = this.state;
     if (
       inflightRequests &&
       !inflightRequests.allRequestsResolvedExcept(receivedResponseTo)
     ) {
       return;
     }
     if (this.socket && this.socket.readyState < 2) {
       // If it's not closing already, close it
       this.socket.close();
     }
     this.socket = null;
     this.stopPing();
     this.setState({ inflightRequests: null });
     if (this.props.connection.status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: { status: 'disconnected' },
       });
     }
     if (this.reopenConnectionAfterClosing) {
       this.reopenConnectionAfterClosing = false;
       if (this.props.active) {
         this.openSocket('connecting');
       }
     }
   }
 
   reconnect: $Call<typeof _throttle, () => void, number> = _throttle(
     () => this.openSocket('reconnecting'),
     2000,
   );
 
   componentDidMount() {
     if (this.props.detectUnsupervisedBackgroundRef) {
       this.props.detectUnsupervisedBackgroundRef(
         this.detectUnsupervisedBackground,
       );
     }
     if (this.props.active) {
       this.openSocket('connecting');
     }
   }
 
   componentWillUnmount() {
     this.closeSocket(false);
     this.reconnect.cancel();
   }
 
   componentDidUpdate(prevProps: Props) {
     if (this.props.active && !prevProps.active) {
       this.openSocket('connecting');
     } else if (!this.props.active && prevProps.active) {
       this.closeSocket(!!prevProps.activeThread);
     } else if (
       this.props.active &&
       prevProps.openSocket !== this.props.openSocket
     ) {
       // This case happens when the baseURL/urlPrefix is changed
       this.reopenConnectionAfterClosing = true;
       this.forceCloseSocket();
     } else if (
       this.props.active &&
       this.props.connection.status === 'disconnected' &&
       prevProps.connection.status !== 'disconnected' &&
       !this.invalidationRecoveryInProgress
     ) {
       this.reconnect();
     }
   }
 
   render(): React.Node {
     // It's important that APIRequestHandler get rendered first here. This is so
     // that it is registered with Redux first, so that its componentDidUpdate
     // processes before the other Handlers. This allows APIRequestHandler to
     // register itself with action-utils before other Handlers call
     // dispatchActionPromise in response to the componentDidUpdate triggered by
     // the same Redux change (state.connection.status).
     return (
       <React.Fragment>
         <APIRequestHandler
           inflightRequests={this.state.inflightRequests}
           sendMessage={this.sendMessageWithoutID}
         />
         <ActivityHandler
           activeThread={this.props.activeThread}
           frozen={this.props.frozen}
         />
         <RequestResponseHandler
           inflightRequests={this.state.inflightRequests}
           sendMessage={this.sendMessageWithoutID}
           addListener={this.addListener}
           removeListener={this.removeListener}
           getClientResponses={this.props.getClientResponses}
           currentCalendarQuery={this.props.currentCalendarQuery}
         />
         <UpdateHandler
           sendMessage={this.sendMessageWithoutID}
           addListener={this.addListener}
           removeListener={this.removeListener}
         />
         <MessageHandler
           addListener={this.addListener}
           removeListener={this.removeListener}
         />
         <CalendarQueryHandler
           currentCalendarQuery={this.props.currentCalendarQuery}
           frozen={this.props.frozen}
         />
         <ReportHandler canSendReports={this.props.canSendReports} />
       </React.Fragment>
     );
   }
 
   sendMessageWithoutID: (
     message: ClientSocketMessageWithoutID,
   ) => number = message => {
     const id = this.nextClientMessageID++;
     // These conditions all do the same thing and the runtime checks are only
     // necessary for Flow
     if (message.type === clientSocketMessageTypes.INITIAL) {
       this.sendMessage(({ ...message, id }: ClientInitialClientSocketMessage));
     } else if (message.type === clientSocketMessageTypes.RESPONSES) {
       this.sendMessage(
         ({ ...message, id }: ClientResponsesClientSocketMessage),
       );
     } else if (message.type === clientSocketMessageTypes.PING) {
       this.sendMessage(({ ...message, id }: PingClientSocketMessage));
     } else if (message.type === clientSocketMessageTypes.ACK_UPDATES) {
       this.sendMessage(({ ...message, id }: AckUpdatesClientSocketMessage));
     } else if (message.type === clientSocketMessageTypes.API_REQUEST) {
       this.sendMessage(({ ...message, id }: APIRequestClientSocketMessage));
     }
     return id;
   };
 
   sendMessage(message: ClientClientSocketMessage) {
     const socket = this.socket;
     invariant(socket, 'should be set');
     socket.send(JSON.stringify(message));
   }
 
   static messageFromEvent(event: MessageEvent): ?ClientServerSocketMessage {
     if (typeof event.data !== 'string') {
       console.log('socket received a non-string message');
       return null;
     }
     try {
       return JSON.parse(event.data);
     } catch (e) {
       console.log(e);
       return null;
     }
   }
 
   receiveMessage: (event: MessageEvent) => Promise<void> = async event => {
     const message = Socket.messageFromEvent(event);
     if (!message) {
       return;
     }
+    this.failuresAfterPolicyAcknowledgment = 0;
 
     const { inflightRequests } = this.state;
     if (!inflightRequests) {
       // inflightRequests can be falsey here if we receive a message after we've
       // begun shutting down the socket. It's possible for a React Native
       // WebSocket to deliver a message even after close() is called on it. In
       // this case the message is probably a PONG, which we can safely ignore.
       // If it's not a PONG, it has to be something server-initiated (like
       // UPDATES or MESSAGES), since InflightRequests.allRequestsResolvedExcept
       // will wait for all responses to client-initiated requests to be
       // delivered before closing a socket. UPDATES and MESSAGES are both
       // checkpointed on the client, so should be okay to just ignore here and
       // redownload them later, probably in an incremental STATE_SYNC.
       return;
     }
 
     // If we receive any message, that indicates that our connection is healthy,
     // so we can reset the ping timeout.
     this.resetPing();
 
     inflightRequests.resolveRequestsForMessage(message);
     const { status } = this.props.connection;
     if (status === 'disconnecting' || status === 'forcedDisconnecting') {
       this.finishClosingSocket(
         // We do this for Flow
         message.responseTo !== undefined ? message.responseTo : null,
       );
     }
 
     for (const listener of this.listeners) {
       listener(message);
     }
 
     if (message.type === serverSocketMessageTypes.ERROR) {
       const { message: errorMessage, payload } = message;
       if (payload) {
         console.log(`socket sent error ${errorMessage} with payload`, payload);
       } else {
         console.log(`socket sent error ${errorMessage}`);
       }
       if (errorMessage === 'policies_not_accepted') {
         this.props.dispatch({
           type: forcePolicyAcknowledgmentActionType,
           payload,
         });
       }
     } else if (message.type === serverSocketMessageTypes.AUTH_ERROR) {
       const { sessionChange } = message;
       const cookie = sessionChange ? sessionChange.cookie : this.props.cookie;
       this.invalidationRecoveryInProgress = true;
 
       const recoverySessionChange = await fetchNewCookieFromNativeCredentials(
         this.props.dispatch,
         cookie,
         this.props.urlPrefix,
         logInActionSources.socketAuthErrorResolutionAttempt,
       );
 
       if (!recoverySessionChange && sessionChange) {
         // This should only happen in the cookieSources.BODY (native) case when
         // the resolution attempt failed
         const { cookie: newerCookie, currentUserInfo } = sessionChange;
         this.props.dispatch({
           type: setNewSessionActionType,
           payload: {
             sessionChange: {
               cookieInvalidated: true,
               currentUserInfo,
               cookie: newerCookie,
             },
             preRequestUserState: this.initializedWithUserState,
             error: null,
             logInActionSource:
               logInActionSources.socketAuthErrorResolutionAttempt,
           },
         });
       } else if (!recoverySessionChange) {
         this.props.dispatchActionPromise(
           logOutActionTypes,
           this.props.logOut(this.props.preRequestUserState),
         );
       }
       this.invalidationRecoveryInProgress = false;
     }
   };
 
   addListener: (listener: SocketListener) => void = listener => {
     this.listeners.add(listener);
   };
 
   removeListener: (listener: SocketListener) => void = listener => {
     this.listeners.delete(listener);
   };
 
   onClose: () => void = () => {
     const { status } = this.props.connection;
     this.socket = null;
     this.stopPing();
     if (this.state.inflightRequests) {
       this.state.inflightRequests.rejectAll(new Error('socket closed'));
       this.setState({ inflightRequests: null });
     }
     const handled = this.detectUnsupervisedBackground(true);
     if (!handled && status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: { status: 'disconnected' },
       });
     }
   };
 
   async sendInitialMessage() {
     const { inflightRequests } = this.state;
     invariant(
       inflightRequests,
       'inflightRequests falsey inside sendInitialMessage',
     );
     const messageID = this.nextClientMessageID++;
     const promises = {};
 
     const clientResponses = [];
     if (!this.initialPlatformDetailsSent) {
       this.initialPlatformDetailsSent = true;
       clientResponses.push({
         type: serverRequestTypes.PLATFORM_DETAILS,
         platformDetails: getConfig().platformDetails,
       });
     }
 
     const { queuedActivityUpdates } = this.props.connection;
     if (queuedActivityUpdates.length > 0) {
       clientResponses.push({
         type: serverRequestTypes.INITIAL_ACTIVITY_UPDATES,
         activityUpdates: queuedActivityUpdates,
       });
       promises.activityUpdateMessage = inflightRequests.fetchResponse(
         messageID,
         serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE,
       );
     }
 
     const sessionState = this.props.sessionStateFunc();
     const { sessionIdentification } = this.props;
     const initialMessage = {
       type: clientSocketMessageTypes.INITIAL,
       id: messageID,
       payload: {
         clientResponses,
         sessionState,
         sessionIdentification,
       },
     };
     this.initializedWithUserState = this.props.preRequestUserState;
     this.sendMessage(initialMessage);
 
     promises.stateSyncMessage = inflightRequests.fetchResponse(
       messageID,
       serverSocketMessageTypes.STATE_SYNC,
     );
 
     const { stateSyncMessage, activityUpdateMessage } = await promiseAll(
       promises,
     );
 
     if (activityUpdateMessage) {
       this.props.dispatch({
         type: updateActivityActionTypes.success,
         payload: {
           activityUpdates: queuedActivityUpdates,
           result: activityUpdateMessage.payload,
         },
       });
     }
 
     if (stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL) {
       const { sessionID, type, ...actionPayload } = stateSyncMessage.payload;
       this.props.dispatch({
         type: fullStateSyncActionType,
         payload: {
           ...actionPayload,
           calendarQuery: sessionState.calendarQuery,
         },
       });
       if (sessionID !== null && sessionID !== undefined) {
         invariant(
           this.initializedWithUserState,
           'initializedWithUserState should be set when state sync received',
         );
         this.props.dispatch({
           type: setNewSessionActionType,
           payload: {
             sessionChange: { cookieInvalidated: false, sessionID },
             preRequestUserState: this.initializedWithUserState,
             error: null,
             logInActionSource: undefined,
           },
         });
       }
     } else {
       const { type, ...actionPayload } = stateSyncMessage.payload;
       this.props.dispatch({
         type: incrementalStateSyncActionType,
         payload: {
           ...actionPayload,
           calendarQuery: sessionState.calendarQuery,
         },
       });
     }
 
     const currentAsOf =
       stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL
         ? stateSyncMessage.payload.updatesCurrentAsOf
         : stateSyncMessage.payload.updatesResult.currentAsOf;
     this.sendMessageWithoutID({
       type: clientSocketMessageTypes.ACK_UPDATES,
       payload: { currentAsOf },
     });
 
     this.markSocketInitialized();
   }
 
   initializeSocket: (retriesLeft?: number) => Promise<void> = async (
     retriesLeft = 1,
   ) => {
     try {
       await this.sendInitialMessage();
     } catch (e) {
+      if (this.props.noDataAfterPolicyAcknowledgment) {
+        this.failuresAfterPolicyAcknowledgment++;
+      } else {
+        this.failuresAfterPolicyAcknowledgment = 0;
+      }
+      if (
+        this.failuresAfterPolicyAcknowledgment >= 2 &&
+        this.props.socketCrashLoopRecovery
+      ) {
+        this.failuresAfterPolicyAcknowledgment = 0;
+        try {
+          await this.props.socketCrashLoopRecovery();
+        } catch (error) {
+          console.log(error);
+          this.props.dispatchActionPromise(
+            logOutActionTypes,
+            this.props.logOut(this.props.preRequestUserState),
+          );
+        }
+        return;
+      }
+
       console.log(e);
       const { status } = this.props.connection;
       if (
         e instanceof SocketTimeout ||
         e instanceof SocketOffline ||
         (status !== 'connecting' && status !== 'reconnecting')
       ) {
         // This indicates that the socket will be closed. Do nothing, since the
         // connection status update will trigger a reconnect.
       } else if (
         retriesLeft === 0 ||
         (e instanceof ServerError && e.message !== 'unknown_error')
       ) {
         if (e.message === 'not_logged_in') {
           this.props.dispatchActionPromise(
             logOutActionTypes,
             this.props.logOut(this.props.preRequestUserState),
           );
         } else if (this.socket) {
           this.socket.close();
         }
       } else {
         await this.initializeSocket(retriesLeft - 1);
       }
     }
   };
 
   stopPing() {
     if (this.pingTimeoutID) {
       clearTimeout(this.pingTimeoutID);
       this.pingTimeoutID = null;
     }
   }
 
   resetPing() {
     this.stopPing();
     const socket = this.socket;
     this.messageLastReceived = Date.now();
     this.pingTimeoutID = setTimeout(() => {
       if (this.socket === socket) {
         this.sendPing();
       }
     }, pingFrequency);
   }
 
   async sendPing() {
     if (this.props.connection.status !== 'connected') {
       // This generally shouldn't happen because anything that changes the
       // connection status should call stopPing(), but it's good to make sure
       return;
     }
     const messageID = this.sendMessageWithoutID({
       type: clientSocketMessageTypes.PING,
     });
     try {
       invariant(
         this.state.inflightRequests,
         'inflightRequests falsey inside sendPing',
       );
       await this.state.inflightRequests.fetchResponse(
         messageID,
         serverSocketMessageTypes.PONG,
       );
     } catch (e) {}
   }
 
   setLateResponse: (messageID: number, isLate: boolean) => void = (
     messageID,
     isLate,
   ) => {
     this.props.dispatch({
       type: setLateResponseActionType,
       payload: { messageID, isLate },
     });
   };
 
   cleanUpServerTerminatedSocket() {
     if (this.socket && this.socket.readyState < 2) {
       this.socket.close();
     } else {
       this.onClose();
     }
   }
 
   detectUnsupervisedBackground: (
     alreadyClosed: boolean,
   ) => boolean = alreadyClosed => {
     // On native, sometimes the app is backgrounded without the proper callbacks
     // getting triggered. This leaves us in an incorrect state for two reasons:
     // (1) The connection is still considered to be active, causing API requests
     //     to be processed via socket and failing.
     // (2) We rely on flipping foreground state in Redux to detect activity
     //     changes, and thus won't think we need to update activity.
     if (
       this.props.connection.status !== 'connected' ||
       !this.messageLastReceived ||
       this.messageLastReceived + serverRequestSocketTimeout >= Date.now() ||
       (actionLogger.mostRecentActionTime &&
         actionLogger.mostRecentActionTime + 3000 < Date.now())
     ) {
       return false;
     }
     if (!alreadyClosed) {
       this.cleanUpServerTerminatedSocket();
     }
     this.props.dispatch({
       type: unsupervisedBackgroundActionType,
       payload: null,
     });
     return true;
   };
 }
 
 export default Socket;
diff --git a/lib/types/account-types.js b/lib/types/account-types.js
index 8663e6285..3e98c6d9d 100644
--- a/lib/types/account-types.js
+++ b/lib/types/account-types.js
@@ -1,186 +1,187 @@
 // @flow
 
 import type { PolicyType } from '../facts/policies.js';
 import { values } from '../utils/objects';
 import type { PlatformDetails } from './device-types';
 import type {
   CalendarQuery,
   CalendarResult,
   RawEntryInfo,
 } from './entry-types';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
   GenericMessagesResult,
 } from './message-types';
 import type { PreRequestUserState } from './session-types';
 import type { RawThreadInfo } from './thread-types';
 import type {
   UserInfo,
   LoggedOutUserInfo,
   LoggedInUserInfo,
   OldLoggedInUserInfo,
 } from './user-types';
 
 export type ResetPasswordRequest = {
   +usernameOrEmail: string,
 };
 
 export type LogOutResult = {
   +currentUserInfo: ?LoggedOutUserInfo,
   +preRequestUserState: PreRequestUserState,
 };
 
 export type LogOutResponse = {
   +currentUserInfo: LoggedOutUserInfo,
 };
 
 export type RegisterInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
 };
 
 type DeviceTokenUpdateRequest = {
   +deviceToken: string,
 };
 
 export type RegisterRequest = {
   +username: string,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
 };
 
 export type RegisterResponse = {
   id: string,
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   currentUserInfo: OldLoggedInUserInfo | LoggedInUserInfo,
   cookieChange: {
     threadInfos: { +[id: string]: RawThreadInfo },
     userInfos: $ReadOnlyArray<UserInfo>,
   },
 };
 
 export type RegisterResult = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadInfos: { +[id: string]: RawThreadInfo },
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarQuery: CalendarQuery,
 };
 
 export type DeleteAccountRequest = {
   +password: ?string,
 };
 
 export const logInActionSources = Object.freeze({
   cookieInvalidationResolutionAttempt: 'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT',
   appStartCookieLoggedInButInvalidRedux:
     'APP_START_COOKIE_LOGGED_IN_BUT_INVALID_REDUX',
   appStartReduxLoggedInButInvalidCookie:
     'APP_START_REDUX_LOGGED_IN_BUT_INVALID_COOKIE',
   socketAuthErrorResolutionAttempt: 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT',
   sqliteOpFailure: 'SQLITE_OP_FAILURE',
   sqliteLoadFailure: 'SQLITE_LOAD_FAILURE',
   logInFromWebForm: 'LOG_IN_FROM_WEB_FORM',
   logInFromNativeForm: 'LOG_IN_FROM_NATIVE_FORM',
   logInFromNativeSIWE: 'LOG_IN_FROM_NATIVE_SIWE',
+  refetchUserDataAfterAcknowledgment: 'REFETCH_USER_DATA_AFTER_ACKNOWLEDGMENT',
 });
 
 export type LogInActionSource = $Values<typeof logInActionSources>;
 
 export type LogInStartingPayload = {
   +calendarQuery: CalendarQuery,
   +logInActionSource?: LogInActionSource,
 };
 
 export type LogInExtraInfo = {
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
 };
 
 export type LogInInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
   +logInActionSource: LogInActionSource,
 };
 
 export type LogInRequest = {
   +usernameOrEmail?: ?string,
   +username?: ?string,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +watchedIDs: $ReadOnlyArray<string>,
   +source?: LogInActionSource,
 };
 
 export type LogInResponse = {
   +currentUserInfo: LoggedInUserInfo | OldLoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +rawEntryInfos?: ?$ReadOnlyArray<RawEntryInfo>,
   +serverTime: number,
   +cookieChange: {
     +threadInfos: { +[id: string]: RawThreadInfo },
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type LogInResult = {
   +threadInfos: { +[id: string]: RawThreadInfo },
   +currentUserInfo: LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: number,
   +logInActionSource: LogInActionSource,
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type UpdatePasswordRequest = {
   code: string,
   password: string,
   calendarQuery?: ?CalendarQuery,
   deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   platformDetails: PlatformDetails,
   watchedIDs: $ReadOnlyArray<string>,
 };
 
 export type PolicyAcknowledgmentRequest = {
   +policy: PolicyType,
 };
 
 export type EmailSubscriptionRequest = {
   +email: string,
 };
 export type UpdateUserSettingsRequest = {
   +name: 'default_user_notifications',
   +data: NotificationTypes,
 };
 
 export const userSettingsTypes = Object.freeze({
   DEFAULT_NOTIFICATIONS: 'default_user_notifications',
 });
 
 export type DefaultNotificationPayload = {
   +default_user_notifications: ?NotificationTypes,
 };
 
 export const notificationTypes = Object.freeze({
   FOCUSED: 'focused',
   BADGE_ONLY: 'badge_only',
   BACKGROUND: 'background',
 });
 
 export type NotificationTypes = $Values<typeof notificationTypes>;
 
 export const notificationTypeValues: $ReadOnlyArray<NotificationTypes> = values(
   notificationTypes,
 );
diff --git a/native/selectors/account-selectors.js b/native/selectors/account-selectors.js
index 10a761427..5dadcd32e 100644
--- a/native/selectors/account-selectors.js
+++ b/native/selectors/account-selectors.js
@@ -1,22 +1,45 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import { logInExtraInfoSelector } from 'lib/selectors/account-selectors';
 import type { LogInExtraInfo } from 'lib/types/account-types';
+import type { UserPolicies } from 'lib/types/policy-types';
+import { values } from 'lib/utils/objects';
 
 import { calendarActiveSelector } from '../navigation/nav-selectors';
+import type { AppState } from '../redux/state-types';
+import type { ConnectivityInfo } from '../types/connectivity';
 import type { NavPlusRedux } from '../types/selector-types';
 
 const nativeLogInExtraInfoSelector: (
   input: NavPlusRedux,
 ) => () => LogInExtraInfo = createSelector(
   (input: NavPlusRedux) => logInExtraInfoSelector(input.redux),
   (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
   (
     logInExtraInfoFunc: (calendarActive: boolean) => LogInExtraInfo,
     calendarActive: boolean,
   ) => () => logInExtraInfoFunc(calendarActive),
 );
 
-export { nativeLogInExtraInfoSelector };
+const noDataAfterPolicyAcknowledgmentSelector: (
+  state: AppState,
+) => boolean = createSelector(
+  (state: AppState) => state.connectivity,
+  (state: AppState) => state.messageStore.currentAsOf,
+  (state: AppState) => state.userPolicies,
+  (
+    connectivity: ConnectivityInfo,
+    currentAsOf: number,
+    userPolicies: UserPolicies,
+  ) =>
+    connectivity.connected &&
+    currentAsOf === 0 &&
+    values(userPolicies).every(policy => policy.isAcknowledged),
+);
+
+export {
+  nativeLogInExtraInfoSelector,
+  noDataAfterPolicyAcknowledgmentSelector,
+};
diff --git a/native/socket.react.js b/native/socket.react.js
index 827675a6f..c97a70cf9 100644
--- a/native/socket.react.js
+++ b/native/socket.react.js
@@ -1,107 +1,148 @@
 // @flow
 
 import * as React from 'react';
+import Alert from 'react-native/Libraries/Alert/Alert';
 import { useDispatch } from 'react-redux';
 
-import { logOut } from 'lib/actions/user-actions';
+import { logOut, logOutActionTypes } from 'lib/actions/user-actions';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors';
 import { isLoggedIn } from 'lib/selectors/user-selectors';
+import { accountHasPassword } from 'lib/shared/account-utils';
 import Socket, { type BaseSocketProps } from 'lib/socket/socket.react';
+import { logInActionSources } from 'lib/types/account-types';
 import {
   useServerCall,
   useDispatchActionPromise,
+  fetchNewCookieFromNativeCredentials,
 } from 'lib/utils/action-utils';
 
 import { InputStateContext } from './input/input-state';
 import {
   activeMessageListSelector,
   nativeCalendarQuery,
 } from './navigation/nav-selectors';
 import { NavContext } from './navigation/navigation-context';
 import { useSelector } from './redux/redux-utils';
+import { noDataAfterPolicyAcknowledgmentSelector } from './selectors/account-selectors';
 import {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 } from './selectors/socket-selectors';
 
 const NativeSocket: React.ComponentType<BaseSocketProps> = React.memo<BaseSocketProps>(
   function NativeSocket(props: BaseSocketProps) {
     const inputState = React.useContext(InputStateContext);
     const navContext = React.useContext(NavContext);
 
     const cookie = useSelector(state => state.cookie);
     const urlPrefix = useSelector(state => state.urlPrefix);
     const connection = useSelector(state => state.connection);
     const frozen = useSelector(state => state.frozen);
     const active = useSelector(
       state => isLoggedIn(state) && state.lifecycleState !== 'background',
     );
+    const noDataAfterPolicyAcknowledgment = useSelector(
+      noDataAfterPolicyAcknowledgmentSelector,
+    );
+    const currentUserInfo = useSelector(state => state.currentUserInfo);
 
     const openSocket = useSelector(openSocketSelector);
     const sessionIdentification = useSelector(sessionIdentificationSelector);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
 
     const getClientResponses = useSelector(state =>
       nativeGetClientResponsesSelector({
         redux: state,
         navContext,
       }),
     );
     const sessionStateFunc = useSelector(state =>
       nativeSessionStateFuncSelector({
         redux: state,
         navContext,
       }),
     );
     const currentCalendarQuery = useSelector(state =>
       nativeCalendarQuery({
         redux: state,
         navContext,
       }),
     );
 
     const canSendReports = useSelector(
       state =>
         !state.frozen &&
         state.connectivity.hasWiFi &&
         (!inputState || !inputState.uploadInProgress()),
     );
 
     const activeThread = React.useMemo(() => {
       if (!active) {
         return null;
       }
       return activeMessageListSelector(navContext);
     }, [active, navContext]);
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useServerCall(logOut);
 
+    const socketCrashLoopRecovery = React.useCallback(async () => {
+      if (!accountHasPassword(currentUserInfo)) {
+        dispatchActionPromise(
+          logOutActionTypes,
+          callLogOut(preRequestUserState),
+        );
+        Alert.alert(
+          'Log in needed',
+          'After acknowledging the policies, we need you to log in to your account again',
+          [{ text: 'OK' }],
+        );
+        return;
+      }
+
+      await fetchNewCookieFromNativeCredentials(
+        dispatch,
+        cookie,
+        urlPrefix,
+        logInActionSources.refetchUserDataAfterAcknowledgment,
+      );
+    }, [
+      callLogOut,
+      cookie,
+      currentUserInfo,
+      dispatch,
+      dispatchActionPromise,
+      preRequestUserState,
+      urlPrefix,
+    ]);
+
     return (
       <Socket
         {...props}
         active={active}
         openSocket={openSocket}
         getClientResponses={getClientResponses}
         activeThread={activeThread}
         sessionStateFunc={sessionStateFunc}
         sessionIdentification={sessionIdentification}
         cookie={cookie}
         urlPrefix={urlPrefix}
         connection={connection}
         currentCalendarQuery={currentCalendarQuery}
         canSendReports={canSendReports}
         frozen={frozen}
         preRequestUserState={preRequestUserState}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
+        noDataAfterPolicyAcknowledgment={noDataAfterPolicyAcknowledgment}
+        socketCrashLoopRecovery={socketCrashLoopRecovery}
       />
     );
   },
 );
 
 export default NativeSocket;