diff --git a/web/database/utils/store.js b/web/database/utils/store.js
index 14c496eca..1ce06eaca 100644
--- a/web/database/utils/store.js
+++ b/web/database/utils/store.js
@@ -1,38 +1,49 @@
 // @flow
 
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
+import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import type { ClientStore } from 'lib/types/store-ops-types.js';
 
 import { workerRequestMessageTypes } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../database-module-provider.js';
 
 async function getClientStore(): Promise<ClientStore> {
   const databaseModule = await getDatabaseModule();
   let result: ClientStore = {
     currentUserID: null,
     drafts: [],
     messages: null,
     threadStore: null,
     messageStoreThreads: null,
     reports: null,
     users: null,
   };
   const data = await databaseModule.schedule({
     type: workerRequestMessageTypes.GET_CLIENT_STORE,
   });
   if (data?.store?.drafts) {
     result = {
       ...result,
       drafts: data.store.drafts,
     };
   }
   if (data?.store?.reports) {
     result = {
       ...result,
       reports: reportStoreOpsHandlers.translateClientDBData(data.store.reports),
     };
   }
+  if (data?.store?.threads && data.store.threads.length > 0) {
+    result = {
+      ...result,
+      threadStore: {
+        threadInfos: threadStoreOpsHandlers.translateClientDBData(
+          data.store.threads,
+        ),
+      },
+    };
+  }
   return result;
 }
 
 export { getClientStore };
diff --git a/web/database/worker/process-operations.js b/web/database/worker/process-operations.js
index d5bfade2e..231f287c6 100644
--- a/web/database/worker/process-operations.js
+++ b/web/database/worker/process-operations.js
@@ -1,80 +1,111 @@
 // @flow
 
 import type { ClientDBReportStoreOperation } from 'lib/ops/report-store-ops.js';
+import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import type {
   ClientDBDraftStoreOperation,
   DraftStoreOperation,
 } from 'lib/types/draft-types.js';
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types.js';
 
+import {
+  clientDBThreadInfoToWebThread,
+  webThreadToClientDBThreadInfo,
+} from '../types/entities.js';
 import type { SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 
 function processDraftStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   operations: $ReadOnlyArray<ClientDBDraftStoreOperation>,
 ) {
   for (const operation: DraftStoreOperation of operations) {
     if (operation.type === 'remove_all') {
       sqliteQueryExecutor.removeAllDrafts();
     } else if (operation.type === 'update') {
       const { key, text } = operation.payload;
       sqliteQueryExecutor.updateDraft(key, text);
     } else if (operation.type === 'move') {
       const { oldKey, newKey } = operation.payload;
       sqliteQueryExecutor.moveDraft(oldKey, newKey);
     } else {
       throw new Error('Unsupported draft operation');
     }
   }
 }
 
 function processReportStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
 ) {
   for (const operation: ClientDBReportStoreOperation of operations) {
     if (operation.type === 'remove_all_reports') {
       sqliteQueryExecutor.removeAllReports();
     } else if (operation.type === 'remove_reports') {
       const { ids } = operation.payload;
       sqliteQueryExecutor.removeReports(ids);
     } else if (operation.type === 'replace_report') {
       const { id, report } = operation.payload;
       sqliteQueryExecutor.replaceReport({ id, report });
     } else {
       throw new Error('Unsupported report operation');
     }
   }
 }
 
+function processThreadStoreOperations(
+  sqliteQueryExecutor: SQLiteQueryExecutor,
+  operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
+) {
+  for (const operation: ClientDBThreadStoreOperation of operations) {
+    if (operation.type === 'remove_all') {
+      sqliteQueryExecutor.removeAllThreads();
+    } else if (operation.type === 'remove') {
+      const { ids } = operation.payload;
+      sqliteQueryExecutor.removeThreads(ids);
+    } else if (operation.type === 'replace') {
+      sqliteQueryExecutor.replaceThreadWeb(
+        clientDBThreadInfoToWebThread(operation.payload),
+      );
+    } else {
+      throw new Error('Unsupported thread operation');
+    }
+  }
+}
+
 function processDBStoreOperations(
   sqliteQueryExecutor: SQLiteQueryExecutor,
   storeOperations: ClientDBStoreOperations,
 ) {
-  const { draftStoreOperations, reportStoreOperations } = storeOperations;
+  const { draftStoreOperations, reportStoreOperations, threadStoreOperations } =
+    storeOperations;
 
   if (draftStoreOperations) {
     processDraftStoreOperations(sqliteQueryExecutor, draftStoreOperations);
   }
   if (reportStoreOperations) {
     processReportStoreOperations(sqliteQueryExecutor, reportStoreOperations);
   }
+  if (threadStoreOperations) {
+    processThreadStoreOperations(sqliteQueryExecutor, threadStoreOperations);
+  }
 }
 
 function getClientStore(
   sqliteQueryExecutor: SQLiteQueryExecutor,
 ): ClientDBStore {
   return {
     drafts: sqliteQueryExecutor.getAllDrafts(),
     messages: [],
-    threads: [],
+    threads: sqliteQueryExecutor
+      .getAllThreadsWeb()
+      .map(t => webThreadToClientDBThreadInfo(t)),
     messageStoreThreads: [],
     reports: sqliteQueryExecutor.getAllReports(),
     users: [],
   };
 }
 
 export { processDBStoreOperations, getClientStore };
diff --git a/web/redux/redux-setup.js b/web/redux/redux-setup.js
index 1f35ee8b1..32a753c15 100644
--- a/web/redux/redux-setup.js
+++ b/web/redux/redux-setup.js
@@ -1,330 +1,347 @@
 // @flow
 
 import invariant from 'invariant';
 import type { PersistState } from 'redux-persist/es/types.js';
 
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
+import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import { mostRecentlyReadThreadSelector } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { invalidSessionDowngrade } from 'lib/shared/session-utils.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type { Shape } from 'lib/types/core.js';
 import type { CryptoStore } from 'lib/types/crypto-types.js';
 import type { DraftStore } from 'lib/types/draft-types.js';
 import type { EnabledApps } from 'lib/types/enabled-apps.js';
 import type { EntryStore, CalendarQuery } from 'lib/types/entry-types.js';
 import { type CalendarFilter } from 'lib/types/filter-types.js';
 import type { IntegrityStore } from 'lib/types/integrity-types.js';
 import type { KeyserverStore } from 'lib/types/keyserver-types.js';
 import type { LifecycleState } from 'lib/types/lifecycle-state-types.js';
 import type { InviteLinksStore } from 'lib/types/link-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { MessageStore } from 'lib/types/message-types.js';
 import type { UserPolicies } from 'lib/types/policy-types.js';
 import type { BaseAction } from 'lib/types/redux-types.js';
 import type { ReportStore } from 'lib/types/report-types.js';
 import type { GlobalThemeInfo } from 'lib/types/theme-types.js';
 import type { ThreadActivityStore } from 'lib/types/thread-activity-types';
 import type { ThreadStore } from 'lib/types/thread-types.js';
 import type { CurrentUserInfo, UserStore } from 'lib/types/user-types.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import type { NotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateWindowActiveActionType,
   updateNavInfoActionType,
   updateWindowDimensionsActionType,
   setInitialReduxState,
 } from './action-types.js';
 import { reduceCommunityPickerStore } from './community-picker-reducer.js';
 import { reduceCryptoStore, setCryptoStore } from './crypto-store-reducer.js';
 import reduceNavInfo from './nav-reducer.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { getVisibility } from './visibility.js';
 import { getDatabaseModule } from '../database/database-module-provider.js';
 import { activeThreadSelector } from '../selectors/nav-selectors.js';
 import { type NavInfo } from '../types/nav-types.js';
 import type { InitialReduxState } from '../types/redux-types.js';
 import { workerRequestMessageTypes } from '../types/worker-types.js';
 
 export type WindowDimensions = { width: number, height: number };
 
 export type CommunityPickerStore = {
   +chat: ?string,
   +calendar: ?string,
 };
 
 export type AppState = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +communityPickerStore: CommunityPickerStore,
   +windowDimensions: WindowDimensions,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +windowActive: boolean,
   +userPolicies: UserPolicies,
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   +_persist: ?PersistState,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +initialStateLoaded: boolean,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
 };
 
 export type Action =
   | BaseAction
   | { type: 'UPDATE_NAV_INFO', payload: Shape<NavInfo> }
   | {
       type: 'UPDATE_WINDOW_DIMENSIONS',
       payload: WindowDimensions,
     }
   | {
       type: 'UPDATE_WINDOW_ACTIVE',
       payload: boolean,
     }
   | { +type: 'SET_CRYPTO_STORE', payload: CryptoStore }
   | { +type: 'SET_INITIAL_REDUX_STATE', payload: InitialReduxState };
 
 export function reducer(oldState: AppState | void, action: Action): AppState {
   invariant(oldState, 'should be set');
   let state = oldState;
 
   if (action.type === setInitialReduxState) {
     const { userInfos, keyserverInfos, ...rest } = action.payload;
     const newKeyserverInfos = { ...state.keyserverStore.keyserverInfos };
     for (const keyserverID in keyserverInfos) {
       const newUpdatesCurrentAsOf = canUseDatabaseOnWeb(rest.currentUserInfo.id)
         ? newKeyserverInfos[keyserverID].updatesCurrentAsOf
         : keyserverInfos[keyserverID].updatesCurrentAsOf;
       newKeyserverInfos[keyserverID] = {
         ...newKeyserverInfos[keyserverID],
         ...keyserverInfos[keyserverID],
         updatesCurrentAsOf: newUpdatesCurrentAsOf,
       };
     }
     return validateState(oldState, {
       ...state,
       ...rest,
       userStore: { userInfos },
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: newKeyserverInfos,
       },
       initialStateLoaded: true,
     });
   } else if (action.type === updateWindowDimensionsActionType) {
     return validateState(oldState, {
       ...state,
       windowDimensions: action.payload,
     });
   } else if (action.type === updateWindowActiveActionType) {
     return validateState(oldState, {
       ...state,
       windowActive: action.payload,
     });
   } else if (action.type === setNewSessionActionType) {
     if (
       invalidSessionDowngrade(
         oldState,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
       )
     ) {
       return oldState;
     }
 
     state = {
       ...state,
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: {
           ...state.keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...state.keyserverStore.keyserverInfos[ashoatKeyserverID],
             sessionID: action.payload.sessionChange.sessionID,
           },
         },
       },
     };
   } else if (
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
     (action.type === deleteAccountActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       ))
   ) {
     return oldState;
   }
 
   if (
     action.type !== updateNavInfoActionType &&
     action.type !== setCryptoStore
   ) {
     const baseReducerResult = baseReducer(state, action, onStateDifference);
     state = baseReducerResult.state;
 
     const {
-      storeOperations: { draftStoreOperations, reportStoreOperations },
+      storeOperations: {
+        draftStoreOperations,
+        reportStoreOperations,
+        threadStoreOperations,
+      },
     } = baseReducerResult;
-    if (draftStoreOperations.length > 0 || reportStoreOperations.length > 0) {
+    if (
+      draftStoreOperations.length > 0 ||
+      reportStoreOperations.length > 0 ||
+      threadStoreOperations.length > 0
+    ) {
       (async () => {
         const databaseModule = await getDatabaseModule();
         const isSupported = await databaseModule.isDatabaseSupported();
         if (!isSupported) {
           return;
         }
         const convertedReportStoreOperations =
           reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
+        const convertedThreadStoreOperations = canUseDatabaseOnWeb(
+          state.currentUserInfo?.id,
+        )
+          ? threadStoreOpsHandlers.convertOpsToClientDBOps(
+              threadStoreOperations,
+            )
+          : [];
         await databaseModule.schedule({
           type: workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
           storeOperations: {
             draftStoreOperations,
             reportStoreOperations: convertedReportStoreOperations,
+            threadStoreOperations: convertedThreadStoreOperations,
           },
         });
       })();
     }
   }
 
   const communityPickerStore = reduceCommunityPickerStore(
     state.communityPickerStore,
     action,
   );
 
   state = {
     ...state,
     navInfo: reduceNavInfo(
       state.navInfo,
       action,
       state.threadStore.threadInfos,
     ),
     cryptoStore: reduceCryptoStore(state.cryptoStore, action),
     communityPickerStore,
   };
 
   return validateState(oldState, state);
 }
 
 function validateState(oldState: AppState, state: AppState): AppState {
   if (
     (state.navInfo.activeChatThreadID &&
       !state.navInfo.pendingThread &&
       !state.threadStore.threadInfos[state.navInfo.activeChatThreadID]) ||
     (!state.navInfo.activeChatThreadID && isLoggedIn(state))
   ) {
     // Makes sure the active thread always exists
     state = {
       ...state,
       navInfo: {
         ...state.navInfo,
         activeChatThreadID: mostRecentlyReadThreadSelector(state),
       },
     };
   }
 
   const activeThread = activeThreadSelector(state);
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     getVisibility().hidden()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but visibilityjs reports the window is not visible',
     );
   }
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     !document.hasFocus()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but document.hasFocus() is false',
     );
   }
   if (
     activeThread &&
     !getVisibility().hidden() &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     document.hasFocus() &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread
   ) {
     // Makes sure a currently focused thread is never unread
     state = {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos: {
           ...state.threadStore.threadInfos,
           [activeThread]: {
             ...state.threadStore.threadInfos[activeThread],
             currentUser: {
               ...state.threadStore.threadInfos[activeThread].currentUser,
               unread: false,
             },
           },
         },
       },
     };
   }
 
   const oldActiveThread = activeThreadSelector(oldState);
   if (
     activeThread &&
     oldActiveThread !== activeThread &&
     state.messageStore.threads[activeThread]
   ) {
     const now = Date.now();
     state = {
       ...state,
       threadActivityStore: {
         ...state.threadActivityStore,
         [activeThread]: {
           ...state.threadActivityStore[activeThread],
           lastNavigatedTo: now,
         },
       },
     };
   }
 
   return state;
 }