diff --git a/keyserver/src/deleters/thread-deleters.js b/keyserver/src/deleters/thread-deleters.js
index 59af378f9..8c80ce0f0 100644
--- a/keyserver/src/deleters/thread-deleters.js
+++ b/keyserver/src/deleters/thread-deleters.js
@@ -1,156 +1,158 @@
 // @flow
 
 import { permissionLookup } from 'lib/permissions/thread-permissions.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import {
   type ThreadDeletionRequest,
   type LeaveThreadResult,
 } from 'lib/types/thread-types.js';
 import { updateTypes } from 'lib/types/update-types-enum.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import { createUpdates } from '../creators/update-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import {
   fetchThreadInfos,
   fetchServerThreadInfos,
+  fetchContainedThreadIDs,
 } from '../fetchers/thread-fetchers.js';
 import { fetchThreadPermissionsBlob } from '../fetchers/thread-permission-fetchers.js';
 import { fetchUpdateInfoForThreadDeletion } from '../fetchers/update-fetchers.js';
 import { rescindPushNotifs } from '../push/rescind.js';
 import type { Viewer } from '../session/viewer.js';
 
 async function deleteThread(
   viewer: Viewer,
   threadDeletionRequest: ThreadDeletionRequest,
 ): Promise<LeaveThreadResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
   const { threadID } = threadDeletionRequest;
 
-  const [permissionsBlob, { threadInfos: serverThreadInfos }] =
-    await Promise.all([
-      fetchThreadPermissionsBlob(viewer, threadID),
-      fetchServerThreadInfos(SQL`t.id = ${threadID}`),
-    ]);
+  const permissionsBlob = await fetchThreadPermissionsBlob(viewer, threadID);
 
   if (!permissionsBlob) {
     // This should only occur if the first request goes through but the client
     // never receives the response
     const [{ updateInfos }, fetchThreadInfoResult] = await Promise.all([
       fetchUpdateInfoForThreadDeletion(viewer, threadID),
       hasMinCodeVersion(viewer.platformDetails, { native: 62 })
         ? undefined
         : fetchThreadInfos(viewer),
     ]);
     if (fetchThreadInfoResult) {
       const { threadInfos } = fetchThreadInfoResult;
       return { threadInfos, updatesResult: { newUpdates: updateInfos } };
     }
     return { updatesResult: { newUpdates: updateInfos } };
   }
 
   const hasPermission = permissionLookup(
     permissionsBlob,
     threadPermissions.DELETE_THREAD,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_credentials');
   }
 
-  await rescindPushNotifs(
-    SQL`n.thread = ${threadID}`,
-    SQL`IF(m.thread = ${threadID}, NULL, m.thread)`,
-  );
-
-  // TODO: if org, delete all descendant threads as well. make sure to warn user
   // TODO: handle descendant thread permission update correctly.
   //       thread-permission-updaters should be used for descendant threads.
+  const threadIDs = await fetchContainedThreadIDs(threadID);
+
+  const [{ threadInfos: serverThreadInfos }] = await Promise.all([
+    fetchServerThreadInfos(SQL`t.id IN (${threadIDs})`),
+    rescindPushNotifs(
+      SQL`n.thread IN (${threadIDs})`,
+      SQL`IF(m.thread IN (${threadIDs}), NULL, m.thread)`,
+    ),
+  ]);
+
   const query = SQL`
     DELETE t, ic, d, id, e, ie, re, ire, mm, r, ir, ms, im, up, iu, f, n, ino
     FROM threads t
     LEFT JOIN ids ic ON ic.id = t.id
     LEFT JOIN days d ON d.thread = t.id
     LEFT JOIN ids id ON id.id = d.id
     LEFT JOIN entries e ON e.day = d.id
     LEFT JOIN ids ie ON ie.id = e.id
     LEFT JOIN revisions re ON re.entry = e.id
     LEFT JOIN ids ire ON ire.id = re.id
     LEFT JOIN memberships mm ON mm.thread = t.id
     LEFT JOIN roles r ON r.thread = t.id
     LEFT JOIN ids ir ON ir.id = r.id
     LEFT JOIN messages ms ON ms.thread = t.id
     LEFT JOIN ids im ON im.id = ms.id
     LEFT JOIN uploads up ON (up.container = ms.id OR up.container = t.id)
     LEFT JOIN ids iu ON iu.id = up.id
     LEFT JOIN focused f ON f.thread = t.id
     LEFT JOIN notifications n ON n.thread = t.id
     LEFT JOIN ids ino ON ino.id = n.id
-    WHERE t.id = ${threadID}
+    WHERE t.id IN (${threadIDs})
   `;
 
-  const serverThreadInfo = serverThreadInfos[threadID];
   const time = Date.now();
   const updateDatas = [];
-  for (const memberInfo of serverThreadInfo.members) {
-    updateDatas.push({
-      type: updateTypes.DELETE_THREAD,
-      userID: memberInfo.id,
-      time,
-      threadID,
-    });
+  for (const containedThreadID of threadIDs) {
+    for (const memberInfo of serverThreadInfos[containedThreadID].members) {
+      updateDatas.push({
+        type: updateTypes.DELETE_THREAD,
+        userID: memberInfo.id,
+        time,
+        threadID: containedThreadID,
+      });
+    }
   }
 
   const [{ viewerUpdates }] = await Promise.all([
     createUpdates(updateDatas, { viewer, updatesForCurrentSession: 'return' }),
     dbQuery(query),
   ]);
 
   if (hasMinCodeVersion(viewer.platformDetails, { native: 62 })) {
     return { updatesResult: { newUpdates: viewerUpdates } };
   }
 
   const { threadInfos } = await fetchThreadInfos(viewer);
   return {
     threadInfos,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
   };
 }
 
 async function deleteInaccessibleThreads(): Promise<void> {
   // A thread is considered "inaccessible" if it has no membership rows. Note
   // that membership rows exist whenever a user can see a thread, even if they
   // are not technically a member (in which case role=0). For now, we're also
   // excluding threads with children, since to properly delete those we would
   // need to update their parent_thread_id, and possibly change their type.
   await dbQuery(SQL`
     DELETE t, i, m2, d, id, e, ie, re, ire, r, ir, ms, im, up, iu, f, n, ino
     FROM threads t
     LEFT JOIN ids i ON i.id = t.id
     LEFT JOIN memberships m1 ON m1.thread = t.id AND m1.role > -1
     LEFT JOIN threads c ON c.parent_thread_id = t.id
     LEFT JOIN memberships m2 ON m2.thread = t.id
     LEFT JOIN days d ON d.thread = t.id
     LEFT JOIN ids id ON id.id = d.id
     LEFT JOIN entries e ON e.day = d.id
     LEFT JOIN ids ie ON ie.id = e.id
     LEFT JOIN revisions re ON re.entry = e.id
     LEFT JOIN ids ire ON ire.id = re.id
     LEFT JOIN roles r ON r.thread = t.id
     LEFT JOIN ids ir ON ir.id = r.id
     LEFT JOIN messages ms ON ms.thread = t.id
     LEFT JOIN ids im ON im.id = ms.id
     LEFT JOIN uploads up ON (up.container = ms.id OR up.container = t.id)
     LEFT JOIN ids iu ON iu.id = up.id
     LEFT JOIN focused f ON f.thread = t.id
     LEFT JOIN notifications n ON n.thread = t.id
     LEFT JOIN ids ino ON ino.id = n.id
     WHERE m1.thread IS NULL AND c.id IS NULL
   `);
 }
 
 export { deleteThread, deleteInaccessibleThreads };
diff --git a/keyserver/src/fetchers/thread-fetchers.js b/keyserver/src/fetchers/thread-fetchers.js
index 3cdcf3886..3c8edfa87 100644
--- a/keyserver/src/fetchers/thread-fetchers.js
+++ b/keyserver/src/fetchers/thread-fetchers.js
@@ -1,321 +1,341 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { getAllThreadPermissions } from 'lib/permissions/thread-permissions.js';
 import {
   rawThreadInfoFromServerThreadInfo,
   getContainingThreadID,
   getCommunity,
 } from 'lib/shared/thread-utils.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type { AvatarDBContent, ClientAvatar } from 'lib/types/avatar-types.js';
 import type { RawMessageInfo, MessageInfo } from 'lib/types/message-types.js';
 import { threadTypes, type ThreadType } from 'lib/types/thread-types-enum.js';
 import {
   type RawThreadInfo,
   type ServerThreadInfo,
 } from 'lib/types/thread-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import { getUploadURL } from './upload-fetchers.js';
 import { dbQuery, SQL } from '../database/database.js';
 import type { SQLStatementType } from '../database/types.js';
 import type { Viewer } from '../session/viewer.js';
 
 type FetchServerThreadInfosResult = {
   +threadInfos: { +[id: string]: ServerThreadInfo },
 };
 
 async function fetchServerThreadInfos(
   condition?: SQLStatementType,
 ): Promise<FetchServerThreadInfosResult> {
   const whereClause = condition ? SQL`WHERE `.append(condition) : '';
 
   const rolesQuery = SQL`
     SELECT t.id, t.default_role, r.id AS role, r.name, r.permissions
     FROM threads t
     LEFT JOIN roles r ON r.thread = t.id
   `.append(whereClause);
 
   const threadsQuery = SQL`
   SELECT t.id, t.name, t.parent_thread_id, t.containing_thread_id,
     t.community, t.depth, t.color, t.description, t.type, t.creation_time,
     t.source_message, t.replies_count, t.avatar, t.pinned_count, m.user, 
     m.role, m.permissions, m.subscription, 
     m.last_read_message < m.last_message AS unread, m.sender,
     up.id AS upload_id, up.secret AS upload_secret
   FROM threads t
   LEFT JOIN memberships m ON m.thread = t.id AND m.role >= 0
   LEFT JOIN uploads up ON up.container = t.id
   `
     .append(whereClause)
     .append(SQL` ORDER BY m.user ASC`);
   const [[threadsResult], [rolesResult]] = await Promise.all([
     dbQuery(threadsQuery),
     dbQuery(rolesQuery),
   ]);
 
   const threadInfos = {};
   for (const threadsRow of threadsResult) {
     const threadID = threadsRow.id.toString();
     if (!threadInfos[threadID]) {
       threadInfos[threadID] = {
         id: threadID,
         type: threadsRow.type,
         name: threadsRow.name ? threadsRow.name : '',
         description: threadsRow.description ? threadsRow.description : '',
         color: threadsRow.color,
         creationTime: threadsRow.creation_time,
         parentThreadID: threadsRow.parent_thread_id
           ? threadsRow.parent_thread_id.toString()
           : null,
         containingThreadID: threadsRow.containing_thread_id
           ? threadsRow.containing_thread_id.toString()
           : null,
         depth: threadsRow.depth,
         community: threadsRow.community
           ? threadsRow.community.toString()
           : null,
         members: [],
         roles: {},
         repliesCount: threadsRow.replies_count,
         pinnedCount: threadsRow.pinned_count,
       };
       if (threadsRow.avatar) {
         const avatar: AvatarDBContent = JSON.parse(threadsRow.avatar);
         let clientAvatar: ?ClientAvatar;
         if (avatar && avatar.type !== 'image') {
           clientAvatar = avatar;
         } else if (
           avatar &&
           avatar.type === 'image' &&
           threadsRow.upload_id &&
           threadsRow.upload_secret
         ) {
           const uploadID = threadsRow.upload_id.toString();
           invariant(
             uploadID === avatar.uploadID,
             `uploadID of upload should match uploadID of image avatar`,
           );
           clientAvatar = {
             type: 'image',
             uri: getUploadURL(uploadID, threadsRow.upload_secret),
           };
         }
 
         threadInfos[threadID] = {
           ...threadInfos[threadID],
           avatar: clientAvatar,
         };
       }
     }
     const sourceMessageID = threadsRow.source_message?.toString();
     if (sourceMessageID) {
       threadInfos[threadID].sourceMessageID = sourceMessageID;
     }
     if (threadsRow.user) {
       const userID = threadsRow.user.toString();
       const allPermissions = getAllThreadPermissions(
         JSON.parse(threadsRow.permissions),
         threadID,
       );
       threadInfos[threadID].members.push({
         id: userID,
         permissions: allPermissions,
         role: threadsRow.role ? threadsRow.role.toString() : null,
         subscription: JSON.parse(threadsRow.subscription),
         unread: threadsRow.role ? !!threadsRow.unread : null,
         isSender: !!threadsRow.sender,
       });
     }
   }
 
   for (const rolesRow of rolesResult) {
     const threadID = rolesRow.id.toString();
     if (!rolesRow.role) {
       continue;
     }
     const role = rolesRow.role.toString();
     if (!threadInfos[threadID].roles[role]) {
       threadInfos[threadID].roles[role] = {
         id: role,
         name: rolesRow.name,
         permissions: JSON.parse(rolesRow.permissions),
         isDefault: role === rolesRow.default_role.toString(),
       };
     }
   }
 
   return { threadInfos };
 }
 
 export type FetchThreadInfosResult = {
   +threadInfos: { +[id: string]: RawThreadInfo },
 };
 
 async function fetchThreadInfos(
   viewer: Viewer,
   condition?: SQLStatementType,
 ): Promise<FetchThreadInfosResult> {
   const serverResult = await fetchServerThreadInfos(condition);
   return rawThreadInfosFromServerThreadInfos(viewer, serverResult);
 }
 
 const shimCommunityRoot = {
   [threadTypes.COMMUNITY_ROOT]: threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT]:
     threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD]:
     threadTypes.COMMUNITY_OPEN_SUBTHREAD,
   [threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD]:
     threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.GENESIS]: threadTypes.COMMUNITY_SECRET_SUBTHREAD,
 };
 
 function rawThreadInfosFromServerThreadInfos(
   viewer: Viewer,
   serverResult: FetchServerThreadInfosResult,
 ): FetchThreadInfosResult {
   const viewerID = viewer.id;
   const codeVersionBelow70 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 70,
   });
   const codeVersionBelow87 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 87,
   });
   const codeVersionBelow102 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 102,
   });
   const codeVersionBelow104 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 104,
   });
   const codeVersionBelow209 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 209,
   });
   const codeVersionBelow213 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 213,
   });
   const codeVersionBelow221 = !hasMinCodeVersion(viewer.platformDetails, {
     native: 221,
   });
 
   const threadInfos = {};
   for (const threadID in serverResult.threadInfos) {
     const serverThreadInfo = serverResult.threadInfos[threadID];
     const threadInfo = rawThreadInfoFromServerThreadInfo(
       serverThreadInfo,
       viewerID,
       {
         includeVisibilityRules: codeVersionBelow70,
         filterMemberList: codeVersionBelow70,
         shimThreadTypes: codeVersionBelow87 ? shimCommunityRoot : null,
         hideThreadStructure: codeVersionBelow102,
         filterDetailedThreadEditPermissions: codeVersionBelow104,
         filterThreadEditAvatarPermission: codeVersionBelow213,
         excludePinInfo: codeVersionBelow209,
         filterManageInviteLinksPermission: codeVersionBelow221,
       },
     );
     if (threadInfo) {
       threadInfos[threadID] = threadInfo;
     }
   }
   return { threadInfos };
 }
 
 async function verifyThreadIDs(
   threadIDs: $ReadOnlyArray<string>,
 ): Promise<$ReadOnlyArray<string>> {
   if (threadIDs.length === 0) {
     return [];
   }
 
   const query = SQL`SELECT id FROM threads WHERE id IN (${threadIDs})`;
   const [result] = await dbQuery(query);
 
   const verified = [];
   for (const row of result) {
     verified.push(row.id.toString());
   }
   return verified;
 }
 
 async function verifyThreadID(threadID: string): Promise<boolean> {
   const result = await verifyThreadIDs([threadID]);
   return result.length !== 0;
 }
 
 type ThreadAncestry = {
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
 };
 async function determineThreadAncestry(
   parentThreadID: ?string,
   threadType: ThreadType,
 ): Promise<ThreadAncestry> {
   if (!parentThreadID) {
     return { containingThreadID: null, community: null, depth: 0 };
   }
   const parentThreadInfos = await fetchServerThreadInfos(
     SQL`t.id = ${parentThreadID}`,
   );
   const parentThreadInfo = parentThreadInfos.threadInfos[parentThreadID];
   if (!parentThreadInfo) {
     throw new ServerError('invalid_parameters');
   }
   const containingThreadID = getContainingThreadID(
     parentThreadInfo,
     threadType,
   );
   const community = getCommunity(parentThreadInfo);
   const depth = parentThreadInfo.depth + 1;
   return { containingThreadID, community, depth };
 }
 
 function personalThreadQuery(
   firstMemberID: string,
   secondMemberID: string,
 ): SQLStatementType {
   return SQL`
     SELECT t.id 
     FROM threads t
     INNER JOIN memberships m1 
       ON m1.thread = t.id AND m1.user = ${firstMemberID}
     INNER JOIN memberships m2
       ON m2.thread = t.id AND m2.user = ${secondMemberID}
     WHERE t.type = ${threadTypes.PERSONAL}
       AND m1.role > 0
       AND m2.role > 0
   `;
 }
 
 async function fetchPersonalThreadID(
   viewerID: string,
   otherMemberID: string,
 ): Promise<?string> {
   const query = personalThreadQuery(viewerID, otherMemberID);
   const [threads] = await dbQuery(query);
   return threads[0]?.id.toString();
 }
 
 async function serverThreadInfoFromMessageInfo(
   message: RawMessageInfo | MessageInfo,
 ): Promise<?ServerThreadInfo> {
   const threadID = message.threadID;
   const threads = await fetchServerThreadInfos(SQL`t.id = ${threadID}`);
   return threads.threadInfos[threadID];
 }
 
+async function fetchContainedThreadIDs(
+  parentThreadID: string,
+): Promise<Array<string>> {
+  const query = SQL`
+    WITH RECURSIVE thread_tree AS (
+      SELECT id, containing_thread_id
+      FROM threads
+      WHERE id = ${parentThreadID}
+      UNION ALL
+      SELECT t.id, t.containing_thread_id
+      FROM threads t
+      JOIN thread_tree tt ON t.containing_thread_id = tt.id
+    )
+    SELECT id FROM thread_tree
+  `;
+  const [result] = await dbQuery(query);
+  return result.map(row => row.id.toString());
+}
+
 export {
   fetchServerThreadInfos,
   fetchThreadInfos,
   rawThreadInfosFromServerThreadInfos,
   verifyThreadIDs,
   verifyThreadID,
   determineThreadAncestry,
   personalThreadQuery,
   fetchPersonalThreadID,
   serverThreadInfoFromMessageInfo,
+  fetchContainedThreadIDs,
 };