diff --git a/lib/selectors/nav-selectors.js b/lib/selectors/nav-selectors.js
index f59790430..0a10e97cd 100644
--- a/lib/selectors/nav-selectors.js
+++ b/lib/selectors/nav-selectors.js
@@ -1,206 +1,210 @@
 // @flow
 
 import * as React from 'react';
 import { createSelector } from 'reselect';
 
 import { useENSNames } from '../hooks/ens-cache.js';
 import SearchIndex from '../shared/search-index.js';
 import type { Platform } from '../types/device-types.js';
 import {
   type CalendarQuery,
   defaultCalendarQuery,
 } from '../types/entry-types.js';
 import type { CalendarFilter } from '../types/filter-types.js';
 import type {
   ThreadInfo,
   RelativeMemberInfo,
   RawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseNavInfo } from '../types/nav-types.js';
 import type { BaseAppState } from '../types/redux-types.js';
+import { threadTypeIsPrivate } from '../types/thread-types-enum.js';
 import type { UserInfo } from '../types/user-types.js';
 import { getConfig } from '../utils/config.js';
 import { values } from '../utils/objects.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function timeUntilCalendarRangeExpiration(
   lastUserInteractionCalendar: number,
 ): ?number {
   const inactivityLimit = getConfig().calendarRangeInactivityLimit;
   if (inactivityLimit === null || inactivityLimit === undefined) {
     return null;
   }
   return lastUserInteractionCalendar + inactivityLimit - Date.now();
 }
 
 function calendarRangeExpired(lastUserInteractionCalendar: number): boolean {
   const timeUntil = timeUntilCalendarRangeExpiration(
     lastUserInteractionCalendar,
   );
   if (timeUntil === null || timeUntil === undefined) {
     return false;
   }
   return timeUntil <= 0;
 }
 
 const currentCalendarQuery: (
   state: BaseAppState<>,
 ) => (calendarActive: boolean) => CalendarQuery = createSelector(
   (state: BaseAppState<>) => state.entryStore.lastUserInteractionCalendar,
   (state: BaseAppState<>) => state.navInfo,
   (state: BaseAppState<>) => state.calendarFilters,
   (
     lastUserInteractionCalendar: number,
     navInfo: BaseNavInfo,
     calendarFilters: $ReadOnlyArray<CalendarFilter>,
   ) => {
     // Return a function since we depend on the time of evaluation
     return (calendarActive: boolean, platform: ?Platform): CalendarQuery => {
       if (calendarActive) {
         return {
           startDate: navInfo.startDate,
           endDate: navInfo.endDate,
           filters: calendarFilters,
         };
       }
       if (calendarRangeExpired(lastUserInteractionCalendar)) {
         return defaultCalendarQuery(platform);
       }
       return {
         startDate: navInfo.startDate,
         endDate: navInfo.endDate,
         filters: calendarFilters,
       };
     };
   },
 );
 
 // Without allAtOnce, useThreadSearchIndex and useUserSearchIndex are very
 // expensive. useENSNames would trigger their recalculation for each ENS name
 // as it streams in, but we would prefer to trigger their recaculation just
 // once for every update of the underlying Redux data.
 const useENSNamesOptions = { allAtOnce: true };
 
 function useUserSearchIndex(
   userInfos: $ReadOnlyArray<UserInfo | RelativeMemberInfo>,
 ): SearchIndex {
   const membersWithENSNames = useENSNames(userInfos, useENSNamesOptions);
 
   const memberMap = React.useMemo(() => {
     const result = new Map<string, UserInfo | RelativeMemberInfo>();
     for (const userInfo of membersWithENSNames) {
       result.set(userInfo.id, userInfo);
     }
     return result;
   }, [membersWithENSNames]);
 
   return React.useMemo(() => {
     const searchIndex = new SearchIndex();
 
     for (const userInfo of userInfos) {
       const searchTextArray = [];
 
       const rawUsername = userInfo.username;
       if (rawUsername) {
         searchTextArray.push(rawUsername);
       }
 
       const resolvedUserInfo = memberMap.get(userInfo.id);
       const resolvedUsername = resolvedUserInfo?.username;
       if (resolvedUsername && resolvedUsername !== rawUsername) {
         searchTextArray.push(resolvedUsername);
       }
 
       searchIndex.addEntry(userInfo.id, searchTextArray.join(' '));
     }
 
     return searchIndex;
   }, [userInfos, memberMap]);
 }
 
 function useThreadSearchIndex(
   threadInfos: $ReadOnlyArray<RawThreadInfo | ThreadInfo>,
 ): SearchIndex {
   const userInfos = useSelector(state => state.userStore.userInfos);
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const nonViewerMembers = React.useMemo(() => {
     const allMembersOfAllThreads = new Map<string, UserInfo>();
     for (const threadInfo of threadInfos) {
       for (const member of threadInfo.members) {
         if (!member.role || member.id === viewerID) {
           continue;
         }
         if (!allMembersOfAllThreads.has(member.id)) {
           const userInfo = userInfos[member.id];
           if (userInfo?.username) {
             allMembersOfAllThreads.set(member.id, userInfo);
           }
         }
       }
     }
     return [...allMembersOfAllThreads.values()];
   }, [threadInfos, userInfos, viewerID]);
 
   const nonViewerMembersWithENSNames = useENSNames(
     nonViewerMembers,
     useENSNamesOptions,
   );
 
   const memberMap = React.useMemo(() => {
     const result = new Map<string, UserInfo>();
     for (const userInfo of nonViewerMembersWithENSNames) {
       result.set(userInfo.id, userInfo);
     }
     return result;
   }, [nonViewerMembersWithENSNames]);
 
   return React.useMemo(() => {
     const searchIndex = new SearchIndex();
     for (const threadInfo of threadInfos) {
       const searchTextArray = [];
       if (threadInfo.name) {
         searchTextArray.push(threadInfo.name);
       }
       if (threadInfo.description) {
         searchTextArray.push(threadInfo.description);
       }
       for (const member of threadInfo.members) {
-        if (!member.role || member.id === viewerID) {
+        if (
+          !member.role ||
+          (member.id === viewerID && !threadTypeIsPrivate(threadInfo.type))
+        ) {
           continue;
         }
         const userInfo = userInfos[member.id];
         const rawUsername = userInfo?.username;
         if (rawUsername) {
           searchTextArray.push(rawUsername);
         }
         const resolvedUserInfo = memberMap.get(member.id);
         const username = resolvedUserInfo?.username;
         if (username && username !== rawUsername) {
           searchTextArray.push(username);
         }
       }
       searchIndex.addEntry(threadInfo.id, searchTextArray.join(' '));
     }
     return searchIndex;
   }, [threadInfos, viewerID, userInfos, memberMap]);
 }
 
 function useGlobalThreadSearchIndex(): SearchIndex {
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
   const threadInfosArray = React.useMemo(
     () => values(threadInfos),
     [threadInfos],
   );
   return useThreadSearchIndex(threadInfosArray);
 }
 
 export {
   timeUntilCalendarRangeExpiration,
   currentCalendarQuery,
   useUserSearchIndex,
   useThreadSearchIndex,
   useGlobalThreadSearchIndex,
 };
diff --git a/lib/types/thread-types-enum.js b/lib/types/thread-types-enum.js
index c1e9cd97e..30555afb4 100644
--- a/lib/types/thread-types-enum.js
+++ b/lib/types/thread-types-enum.js
@@ -1,185 +1,194 @@
 // @flow
 
 import invariant from 'invariant';
 import type { TRefinement } from 'tcomb';
 
 import { values } from '../utils/objects.js';
 import { tNumEnum } from '../utils/validation-utils.js';
 
 // Should be in sync with native/cpp/CommonCpp/NativeModules/\
 // PersistentStorageUtilities/ThreadOperationsUtilities/ThreadTypeEnum.h
 export const thinThreadTypes = Object.freeze({
   //OPEN: 0,   (DEPRECATED)
   //CLOSED: 1, (DEPRECATED)
   //SECRET: 2, (DEPRECATED)
   // has parent, not top-level (appears under parent in inbox), and visible to
   // all members of parent
   SIDEBAR: 5,
   // canonical thread for each pair of users. represents the friendship
   // created under GENESIS. being deprecated in favor of PERSONAL
   GENESIS_PERSONAL: 6,
   // canonical thread for each single user
   // created under GENESIS. being deprecated in favor of PRIVATE
   GENESIS_PRIVATE: 7,
   // aka "org". no parent, top-level, has admin
   COMMUNITY_ROOT: 8,
   // like COMMUNITY_ROOT, but members aren't voiced
   COMMUNITY_ANNOUNCEMENT_ROOT: 9,
   // an open subthread. has parent, top-level (not sidebar), and visible to all
   // members of parent. root ancestor is a COMMUNITY_ROOT
   COMMUNITY_OPEN_SUBTHREAD: 3,
   // like COMMUNITY_SECRET_SUBTHREAD, but members aren't voiced
   COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD: 10,
   // a secret subthread. optional parent, top-level (not sidebar), visible only
   // to its members. root ancestor is a COMMUNITY_ROOT
   COMMUNITY_SECRET_SUBTHREAD: 4,
   // like COMMUNITY_SECRET_SUBTHREAD, but members aren't voiced
   COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD: 11,
   // like COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD, but you can't leave
   GENESIS: 12,
 });
 export type ThinThreadType = $Values<typeof thinThreadTypes>;
 
 export const nonSidebarThickThreadTypes = Object.freeze({
   // local "thick" thread (outside of community). no parent, can only have
   // sidebar children
   LOCAL: 13,
   // canonical thread for each pair of users. represents the friendship
   PERSONAL: 14,
   // canonical thread for each single user
   PRIVATE: 15,
 });
 export type NonSidebarThickThreadType = $Values<
   typeof nonSidebarThickThreadTypes,
 >;
 
 export const sidebarThickThreadTypes = Object.freeze({
   // has parent, not top-level (appears under parent in inbox), and visible to
   // all members of parent
   THICK_SIDEBAR: 16,
 });
 export type SidebarThickThreadType = $Values<typeof sidebarThickThreadTypes>;
 
 export const thickThreadTypes = Object.freeze({
   ...nonSidebarThickThreadTypes,
   ...sidebarThickThreadTypes,
 });
 export type ThickThreadType =
   | NonSidebarThickThreadType
   | SidebarThickThreadType;
 
 export type ThreadType = ThinThreadType | ThickThreadType;
 
 export const threadTypes = Object.freeze({
   ...thinThreadTypes,
   ...thickThreadTypes,
 });
 
 const thickThreadTypesSet = new Set(Object.values(thickThreadTypes));
 export function threadTypeIsThick(threadType: ThreadType): boolean {
   return thickThreadTypesSet.has(threadType);
 }
 
 export function assertThinThreadType(threadType: number): ThinThreadType {
   invariant(
     threadType === 3 ||
       threadType === 4 ||
       threadType === 5 ||
       threadType === 6 ||
       threadType === 7 ||
       threadType === 8 ||
       threadType === 9 ||
       threadType === 10 ||
       threadType === 11 ||
       threadType === 12,
     'number is not ThinThreadType enum',
   );
   return threadType;
 }
 
 export function assertThickThreadType(threadType: number): ThickThreadType {
   invariant(
     threadType === 13 ||
       threadType === 14 ||
       threadType === 15 ||
       threadType === 16,
     'number is not ThickThreadType enum',
   );
   return threadType;
 }
 export const thickThreadTypeValidator: TRefinement<number> = tNumEnum(
   values(thickThreadTypes),
 );
 
 export function assertThreadType(threadType: number): ThreadType {
   invariant(
     threadType === 3 ||
       threadType === 4 ||
       threadType === 5 ||
       threadType === 6 ||
       threadType === 7 ||
       threadType === 8 ||
       threadType === 9 ||
       threadType === 10 ||
       threadType === 11 ||
       threadType === 12 ||
       threadType === 13 ||
       threadType === 14 ||
       threadType === 15 ||
       threadType === 16,
     'number is not ThreadType enum',
   );
   return threadType;
 }
 
 export const threadTypeValidator: TRefinement<number> = tNumEnum(
   values(threadTypes),
 );
 
 export const communityThreadTypes: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.COMMUNITY_ROOT,
   threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT,
   threadTypes.GENESIS,
 ]);
 
 export const announcementThreadTypes: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.GENESIS,
   threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT,
   threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD,
   threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD,
 ]);
 
 export const communitySubthreads: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.COMMUNITY_OPEN_SUBTHREAD,
   threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD,
   threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD,
 ]);
 
 export const sidebarThreadTypes: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.SIDEBAR,
   threadTypes.THICK_SIDEBAR,
 ]);
 
 export const personalThreadTypes: $ReadOnlyArray<number> = Object.freeze([
   threadTypes.PERSONAL,
   threadTypes.GENESIS_PERSONAL,
 ]);
 
+export const privateThreadTypes: $ReadOnlyArray<number> = Object.freeze([
+  threadTypes.PRIVATE,
+  threadTypes.GENESIS_PRIVATE,
+]);
+
 export function threadTypeIsCommunityRoot(threadType: ThreadType): boolean {
   return communityThreadTypes.includes(threadType);
 }
 
 export function threadTypeIsAnnouncementThread(
   threadType: ThreadType,
 ): boolean {
   return announcementThreadTypes.includes(threadType);
 }
 
 export function threadTypeIsSidebar(threadType: ThreadType): boolean {
   return sidebarThreadTypes.includes(threadType);
 }
 
 export function threadTypeIsPersonal(threadType: ThreadType): boolean {
   return personalThreadTypes.includes(threadType);
 }
+
+export function threadTypeIsPrivate(threadType: ThreadType): boolean {
+  return privateThreadTypes.includes(threadType);
+}