diff --git a/lib/socket/socket.react.js b/lib/socket/socket.react.js
index 998a9f48d..4005960a4 100644
--- a/lib/socket/socket.react.js
+++ b/lib/socket/socket.react.js
@@ -1,739 +1,746 @@
 // @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,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +logOut: (preRequestUserState: PreRequestUserState) => Promise<LogOutResult>,
 };
 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;
 
   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;
     }
 
     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) {
       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/utils/action-utils.js b/lib/utils/action-utils.js
index 5350fc0ab..616c97061 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,440 +1,442 @@
 // @flow
 
 import _memoize from 'lodash/memoize';
 import * as React from 'react';
 import { useSelector, useDispatch } from 'react-redux';
 import { createSelector } from 'reselect';
 
 import { serverCallStateSelector } from '../selectors/server-calls';
 import {
   logInActionSources,
   type LogInActionSource,
   type LogInStartingPayload,
   type LogInResult,
 } from '../types/account-types';
 import type { Endpoint, SocketAPIHandler } from '../types/endpoints';
 import type { LoadingOptions, LoadingInfo } from '../types/loading-types';
 import type {
   ActionPayload,
   Dispatch,
   PromisedAction,
   BaseAction,
 } from '../types/redux-types';
 import type {
   ClientSessionChange,
   PreRequestUserState,
 } from '../types/session-types';
 import type { ConnectionStatus } from '../types/socket-types';
 import type { CurrentUserInfo } from '../types/user-types';
 import callServerEndpoint from './call-server-endpoint';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from './call-server-endpoint';
 import { getConfig } from './config';
 
 let nextPromiseIndex = 0;
 
 export type ActionTypes<
   STARTED_ACTION_TYPE: string,
   SUCCESS_ACTION_TYPE: string,
   FAILED_ACTION_TYPE: string,
 > = {
   started: STARTED_ACTION_TYPE,
   success: SUCCESS_ACTION_TYPE,
   failed: FAILED_ACTION_TYPE,
 };
 
 function wrapActionPromise<
   STARTED_ACTION_TYPE: string,
   STARTED_PAYLOAD: ActionPayload,
   SUCCESS_ACTION_TYPE: string,
   SUCCESS_PAYLOAD: ActionPayload,
   FAILED_ACTION_TYPE: string,
 >(
   actionTypes: ActionTypes<
     STARTED_ACTION_TYPE,
     SUCCESS_ACTION_TYPE,
     FAILED_ACTION_TYPE,
   >,
   promise: Promise<SUCCESS_PAYLOAD>,
   loadingOptions: ?LoadingOptions,
   startingPayload: ?STARTED_PAYLOAD,
 ): PromisedAction {
   const loadingInfo: LoadingInfo = {
     fetchIndex: nextPromiseIndex++,
     trackMultipleRequests: !!loadingOptions?.trackMultipleRequests,
     customKeyName: loadingOptions?.customKeyName || null,
   };
   return async (dispatch: Dispatch): Promise<void> => {
     const startAction = startingPayload
       ? {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
           payload: (startingPayload: STARTED_PAYLOAD),
         }
       : {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
         };
     dispatch(startAction);
     try {
       const result = await promise;
       dispatch({
         type: (actionTypes.success: SUCCESS_ACTION_TYPE),
         payload: (result: SUCCESS_PAYLOAD),
         loadingInfo,
       });
     } catch (e) {
       console.log(e);
       dispatch({
         type: (actionTypes.failed: FAILED_ACTION_TYPE),
         error: true,
         payload: (e: Error),
         loadingInfo,
       });
     }
   };
 }
 
 export type DispatchActionPromise = <
   STARTED: BaseAction,
   SUCCESS: BaseAction,
   FAILED: BaseAction,
 >(
   actionTypes: ActionTypes<
     $PropertyType<STARTED, 'type'>,
     $PropertyType<SUCCESS, 'type'>,
     $PropertyType<FAILED, 'type'>,
   >,
   promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
   loadingOptions?: LoadingOptions,
   startingPayload?: $PropertyType<STARTED, 'payload'>,
 ) => Promise<void>;
 
 function useDispatchActionPromise(): DispatchActionPromise {
   const dispatch = useDispatch();
   return React.useMemo(() => createDispatchActionPromise(dispatch), [dispatch]);
 }
 
 function createDispatchActionPromise(dispatch: Dispatch) {
   const dispatchActionPromise = function <
     STARTED: BaseAction,
     SUCCESS: BaseAction,
     FAILED: BaseAction,
   >(
     actionTypes: ActionTypes<
       $PropertyType<STARTED, 'type'>,
       $PropertyType<SUCCESS, 'type'>,
       $PropertyType<FAILED, 'type'>,
     >,
     promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
     loadingOptions?: LoadingOptions,
     startingPayload?: $PropertyType<STARTED, 'payload'>,
   ): Promise<void> {
     return dispatch(
       wrapActionPromise(actionTypes, promise, loadingOptions, startingPayload),
     );
   };
   return dispatchActionPromise;
 }
 
 export type DispatchFunctions = {
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
 };
 
 let currentlyWaitingForNewCookie = false;
 let serverEndpointCallsWaitingForNewCookie: ((
   callServerEndpoint: ?CallServerEndpoint,
 ) => void)[] = [];
 
 export type DispatchRecoveryAttempt = (
   actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
   promise: Promise<LogInResult>,
   startingPayload: LogInStartingPayload,
 ) => Promise<boolean>;
 
 const setNewSessionActionType = 'SET_NEW_SESSION';
 function setNewSession(
   dispatch: Dispatch,
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
 ) {
   dispatch({
     type: setNewSessionActionType,
     payload: { sessionChange, preRequestUserState, error, logInActionSource },
   });
 }
 
 // This function calls resolveInvalidatedCookie, which dispatchs a log in action
 // using the native credentials. Note that we never actually specify a sessionID
 // here, on the assumption that only native clients will call this. (Native
 // clients don't specify a sessionID, indicating to the server that it should
 // use the cookieID as the sessionID.)
 async function fetchNewCookieFromNativeCredentials(
   dispatch: Dispatch,
   cookie: ?string,
   urlPrefix: string,
   logInActionSource: LogInActionSource,
 ): Promise<?ClientSessionChange> {
   const resolveInvalidatedCookie = getConfig().resolveInvalidatedCookie;
   if (!resolveInvalidatedCookie) {
     return null;
   }
   let newSessionChange = null;
   let callServerEndpointCallback = null;
   const boundCallServerEndpoint = async (
     endpoint: Endpoint,
     data: { [key: string]: mixed },
     options?: ?CallServerEndpointOptions,
   ) => {
     const innerBoundSetNewSession = (
       sessionChange: ClientSessionChange,
       error: ?string,
     ) => {
       newSessionChange = sessionChange;
       setNewSession(dispatch, sessionChange, null, error, logInActionSource);
     };
     try {
       const result = await callServerEndpoint(
         cookie,
         innerBoundSetNewSession,
         () => new Promise(r => r(null)),
         () => new Promise(r => r(null)),
         urlPrefix,
         null,
         'disconnected',
         null,
         endpoint,
         data,
+        dispatch,
         options,
       );
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       return result;
     } catch (e) {
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       throw e;
     }
   };
   const dispatchRecoveryAttempt = (
     actionTypes: ActionTypes<
       'LOG_IN_STARTED',
       'LOG_IN_SUCCESS',
       'LOG_IN_FAILED',
     >,
     promise: Promise<LogInResult>,
     inputStartingPayload: LogInStartingPayload,
   ) => {
     const startingPayload = { ...inputStartingPayload, logInActionSource };
     dispatch(wrapActionPromise(actionTypes, promise, null, startingPayload));
     return new Promise(r => (callServerEndpointCallback = r));
   };
   await resolveInvalidatedCookie(
     boundCallServerEndpoint,
     dispatchRecoveryAttempt,
     logInActionSource,
   );
   return newSessionChange;
 }
 
 // Third param is optional and gets called with newCookie if we get a new cookie
 // Necessary to propagate cookie in cookieInvalidationRecovery below
 function bindCookieAndUtilsIntoCallServerEndpoint(
   params: BindServerCallsParams,
 ): CallServerEndpoint {
   const {
     dispatch,
     cookie,
     urlPrefix,
     sessionID,
     currentUserInfo,
     connectionStatus,
   } = params;
   const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
   const boundSetNewSession = (
     sessionChange: ClientSessionChange,
     error: ?string,
   ) =>
     setNewSession(
       dispatch,
       sessionChange,
       { currentUserInfo, cookie, sessionID },
       error,
       undefined,
     );
   // This function gets called before callServerEndpoint sends a request,
   // to make sure that we're not in the middle of trying to recover
   // an invalidated cookie
   const waitIfCookieInvalidated = () => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!currentlyWaitingForNewCookie) {
       // Our cookie seems to be valid
       return Promise.resolve(null);
     }
     // Wait to run until we get our new cookie
     return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
   };
   // This function is a helper for the next function defined below
   const attemptToResolveInvalidation = async (
     sessionChange: ClientSessionChange,
   ) => {
     const newAnonymousCookie = sessionChange.cookie;
     const newSessionChange = await fetchNewCookieFromNativeCredentials(
       dispatch,
       newAnonymousCookie,
       urlPrefix,
       logInActionSources.cookieInvalidationResolutionAttempt,
     );
 
     currentlyWaitingForNewCookie = false;
     const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
     serverEndpointCallsWaitingForNewCookie = [];
 
     const newCallServerEndpoint = newSessionChange
       ? bindCookieAndUtilsIntoCallServerEndpoint({
           ...params,
           cookie: newSessionChange.cookie,
           sessionID: newSessionChange.sessionID,
           currentUserInfo: newSessionChange.currentUserInfo,
         })
       : null;
     for (const func of currentWaitingCalls) {
       func(newCallServerEndpoint);
     }
     return newCallServerEndpoint;
   };
   // If this function is called, callServerEndpoint got a response invalidating
   // its cookie, and is wondering if it should just like... give up?
   // Or if there's a chance at redemption
   const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!loggedIn) {
       // We don't want to attempt any use native credentials of a logged out
       // user to log-in after a cookieInvalidation while logged out
       return Promise.resolve(null);
     }
     if (currentlyWaitingForNewCookie) {
       return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
     }
     currentlyWaitingForNewCookie = true;
     return attemptToResolveInvalidation(sessionChange);
   };
 
   return (
     endpoint: Endpoint,
     data: Object,
     options?: ?CallServerEndpointOptions,
   ) =>
     callServerEndpoint(
       cookie,
       boundSetNewSession,
       waitIfCookieInvalidated,
       cookieInvalidationRecovery,
       urlPrefix,
       sessionID,
       connectionStatus,
       socketAPIHandler,
       endpoint,
       data,
+      dispatch,
       options,
     );
 }
 
 export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F;
 export type BindServerCall = <F>(serverCall: ActionFunc<F>) => F;
 type BindServerCallsParams = {
   dispatch: Dispatch,
   cookie: ?string,
   urlPrefix: string,
   sessionID: ?string,
   currentUserInfo: ?CurrentUserInfo,
   connectionStatus: ConnectionStatus,
 };
 
 // All server calls needs to include some information from the Redux state
 // (namely, the cookie). This information is used deep in the server call,
 // at the point where callServerEndpoint is called. We don't want to bother
 // propagating the cookie (and any future config info that callServerEndpoint
 // needs) through to the server calls so they can pass it to callServerEndpoint.
 // Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
 // connect's mapStateToProps function, and then pass that "bound"
 // callServerEndpoint that no longer needs the cookie as a parameter on to
 // the server call.
 const baseCreateBoundServerCallsSelector = <F>(
   actionFunc: ActionFunc<F>,
 ): (BindServerCallsParams => F) =>
   createSelector(
     (state: BindServerCallsParams) => state.dispatch,
     (state: BindServerCallsParams) => state.cookie,
     (state: BindServerCallsParams) => state.urlPrefix,
     (state: BindServerCallsParams) => state.sessionID,
     (state: BindServerCallsParams) => state.currentUserInfo,
     (state: BindServerCallsParams) => state.connectionStatus,
     (
       dispatch: Dispatch,
       cookie: ?string,
       urlPrefix: string,
       sessionID: ?string,
       currentUserInfo: ?CurrentUserInfo,
       connectionStatus: ConnectionStatus,
     ) => {
       const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
         dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
       });
       return actionFunc(boundCallServerEndpoint);
     },
   );
 
 type CreateBoundServerCallsSelectorType = <F>(
   ActionFunc<F>,
 ) => BindServerCallsParams => F;
 const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType = (_memoize(
   baseCreateBoundServerCallsSelector,
 ): any);
 
 function useServerCall<F>(serverCall: ActionFunc<F>): F {
   const dispatch = useDispatch();
   const serverCallState = useSelector(serverCallStateSelector);
   return React.useMemo(
     () =>
       createBoundServerCallsSelector(serverCall)({
         ...serverCallState,
         dispatch,
       }),
     [serverCall, dispatch, serverCallState],
   );
 }
 
 let socketAPIHandler: ?SocketAPIHandler = null;
 function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
   socketAPIHandler = passedSocketAPIHandler;
 }
 
 export {
   useDispatchActionPromise,
   setNewSessionActionType,
   fetchNewCookieFromNativeCredentials,
   createBoundServerCallsSelector,
   registerActiveSocket,
   useServerCall,
 };
diff --git a/lib/utils/call-server-endpoint.js b/lib/utils/call-server-endpoint.js
index a3e4278b3..56f57f356 100644
--- a/lib/utils/call-server-endpoint.js
+++ b/lib/utils/call-server-endpoint.js
@@ -1,205 +1,214 @@
 // @flow
 
 import { callServerEndpointTimeout } from '../shared/timeouts';
 import { SocketOffline, SocketTimeout } from '../socket/inflight-requests';
 import type { Shape } from '../types/core';
 import {
   type Endpoint,
   type SocketAPIHandler,
   endpointIsSocketPreferred,
   endpointIsSocketOnly,
 } from '../types/endpoints';
+import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
+import type { Dispatch } from '../types/redux-types.js';
 import type {
   ServerSessionChange,
   ClientSessionChange,
 } from '../types/session-types';
 import type { ConnectionStatus } from '../types/socket-types';
 import type { CurrentUserInfo } from '../types/user-types';
 import { getConfig } from './config';
 import { ServerError, FetchTimeout } from './errors';
 import sleep from './sleep';
 import { uploadBlob, type UploadBlob } from './upload-blob';
 
 export type CallServerEndpointOptions = Shape<{
   // null timeout means no timeout, which is the default for uploadBlob
   +timeout: ?number, // in milliseconds
   // getResultInfo will be called right before callServerEndpoint successfully
   // resolves and includes additional information about the request
   +getResultInfo: (resultInfo: CallServerEndpointResultInfo) => mixed,
   +blobUpload: boolean | UploadBlob,
   // the rest (onProgress, abortHandler) only work with blobUpload
   +onProgress: (percent: number) => void,
   // abortHandler will receive an abort function once the upload starts
   +abortHandler: (abort: () => void) => void,
 }>;
 
 export type CallServerEndpointResultInfoInterface = 'socket' | 'REST';
 export type CallServerEndpointResultInfo = {
   +interface: CallServerEndpointResultInfoInterface,
 };
 
 export type CallServerEndpointResponse = Shape<{
   +cookieChange: ServerSessionChange,
   +currentUserInfo: CurrentUserInfo,
   +error: string,
   +payload: Object,
 }>;
 
 // You'll notice that this is not the type of the callServerEndpoint
 // function below. This is because the first several parameters to that
 // function get bound in by the helpers in lib/utils/action-utils.js.
 // This type represents the form of the callServerEndpoint function that
 // gets passed to the action function in lib/actions.
 export type CallServerEndpoint = (
   endpoint: Endpoint,
   input: Object,
   options?: ?CallServerEndpointOptions,
 ) => Promise<Object>;
 
 type RequestData = {
   input: { [key: string]: mixed },
   cookie?: ?string,
   sessionID?: ?string,
 };
 
 // If cookie is undefined, then we will defer to the underlying environment to
 // handle cookies, and we won't worry about them. We do this on the web since
 // our cookies are httponly to protect against XSS attacks. On the other hand,
 // on native we want to keep track of the cookies since we don't trust the
 // underlying implementations and prefer for things to be explicit, and XSS
 // isn't a thing on native. Note that for native, cookie might be null
 // (indicating we don't have one), and we will then set an empty Cookie header.
 async function callServerEndpoint(
   cookie: ?string,
   setNewSession: (sessionChange: ClientSessionChange, error: ?string) => void,
   waitIfCookieInvalidated: () => Promise<?CallServerEndpoint>,
   cookieInvalidationRecovery: (
     sessionChange: ClientSessionChange,
   ) => Promise<?CallServerEndpoint>,
   urlPrefix: string,
   sessionID: ?string,
   connectionStatus: ConnectionStatus,
   socketAPIHandler: ?SocketAPIHandler,
   endpoint: Endpoint,
   input: { [key: string]: mixed },
+  dispatch: Dispatch,
   options?: ?CallServerEndpointOptions,
 ): Promise<Object> {
   const possibleReplacement = await waitIfCookieInvalidated();
   if (possibleReplacement) {
     return await possibleReplacement(endpoint, input, options);
   }
 
   if (
     endpointIsSocketPreferred(endpoint) &&
     connectionStatus === 'connected' &&
     socketAPIHandler
   ) {
     try {
       const result = await socketAPIHandler({ endpoint, input });
       options?.getResultInfo?.({ interface: 'socket' });
       return result;
     } catch (e) {
       if (endpointIsSocketOnly(endpoint)) {
         throw e;
       } else if (e instanceof SocketOffline) {
         // nothing
       } else if (e instanceof SocketTimeout) {
         // nothing
       } else {
         throw e;
       }
     }
   }
   if (endpointIsSocketOnly(endpoint)) {
     throw new SocketOffline('socket_offline');
   }
 
   const url = urlPrefix ? `${urlPrefix}/${endpoint}` : endpoint;
 
   let json;
   if (options && options.blobUpload) {
     const uploadBlobCallback =
       typeof options.blobUpload === 'function'
         ? options.blobUpload
         : uploadBlob;
     json = await uploadBlobCallback(url, cookie, sessionID, input, options);
   } else {
     const mergedData: RequestData = { input };
     if (getConfig().setCookieOnRequest) {
       // We make sure that if setCookieOnRequest is true, we never set cookie to
       // undefined. null has a special meaning here: we don't currently have a
       // cookie, and we want the server to specify the new cookie it will
       // generate in the response body rather than the response header. See
       // session-types.js for more details on why we specify cookies in the body
       mergedData.cookie = cookie ? cookie : null;
     }
     if (getConfig().setSessionIDOnRequest) {
       // We make sure that if setSessionIDOnRequest is true, we never set
       // sessionID to undefined. null has a special meaning here: we cannot
       // consider the cookieID to be a unique session identifier, but we do not
       // have a sessionID to use either. This should only happen when the user
       // is not logged in on web.
       mergedData.sessionID = sessionID ? sessionID : null;
     }
     const callEndpointPromise = (async (): Promise<CallServerEndpointResponse> => {
       const response = await fetch(url, {
         method: 'POST',
         // This is necessary to allow cookie headers to get passed down to us
         credentials: 'same-origin',
         body: JSON.stringify(mergedData),
         headers: {
           'Accept': 'application/json',
           'Content-Type': 'application/json',
         },
       });
       const text = await response.text();
       try {
         return JSON.parse(text);
       } catch (e) {
         console.log(text);
         throw e;
       }
     })();
 
     const timeout =
       options && options.timeout ? options.timeout : callServerEndpointTimeout;
     if (!timeout) {
       json = await callEndpointPromise;
     } else {
       const rejectPromise = (async () => {
         await sleep(timeout);
         throw new FetchTimeout(
           `callServerEndpoint timed out call to ${endpoint}`,
           endpoint,
         );
       })();
       json = await Promise.race([callEndpointPromise, rejectPromise]);
     }
   }
 
   const { cookieChange, error, payload, currentUserInfo } = json;
   const sessionChange: ?ServerSessionChange = cookieChange;
   if (sessionChange) {
     const { threadInfos, userInfos, ...rest } = sessionChange;
     const clientSessionChange = rest.cookieInvalidated
       ? rest
       : { cookieInvalidated: false, currentUserInfo, ...rest };
     if (clientSessionChange.cookieInvalidated) {
       const maybeReplacement = await cookieInvalidationRecovery(
         clientSessionChange,
       );
       if (maybeReplacement) {
         return await maybeReplacement(endpoint, input, options);
       }
     }
     setNewSession(clientSessionChange, error);
   }
 
-  if (error) {
+  if (error === 'policies_not_accepted') {
+    dispatch({
+      type: forcePolicyAcknowledgmentActionType,
+      payload,
+    });
+    return;
+  } else if (error) {
     throw new ServerError(error, payload);
   }
   options?.getResultInfo?.({ interface: 'REST' });
   return json;
 }
 
 export default callServerEndpoint;