diff --git a/lib/shared/reaction-utils.js b/lib/shared/reaction-utils.js
index bfdc5fb02..9c016882c 100644
--- a/lib/shared/reaction-utils.js
+++ b/lib/shared/reaction-utils.js
@@ -1,111 +1,113 @@
 // @flow
 
 import _sortBy from 'lodash/fp/sortBy.js';
 import * as React from 'react';
 
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import { useThreadHasPermission } from './thread-utils.js';
 import { stringForUserExplicit } from './user-utils.js';
 import { useENSNames } from '../hooks/ens-cache.js';
 import type { ReactionInfo } from '../selectors/chat-selectors.js';
 import type {
   ComposableMessageInfo,
   RobotextMessageInfo,
 } from '../types/message-types.js';
 import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
+import { threadTypeIsThick } from '../types/thread-types-enum.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function useViewerAlreadySelectedMessageReactions(
   reactions: ReactionInfo,
 ): $ReadOnlyArray<string> {
   return React.useMemo(() => {
     const alreadySelectedEmojis = [];
 
     for (const reaction in reactions) {
       const reactionInfo = reactions[reaction];
 
       if (reactionInfo.viewerReacted) {
         alreadySelectedEmojis.push(reaction);
       }
     }
 
     return alreadySelectedEmojis;
   }, [reactions]);
 }
 
 export type MessageReactionListInfo = {
   +id: string,
   +isViewer: boolean,
   +reaction: string,
   +username: string,
 };
 
 function useMessageReactionsList(
   reactions: ReactionInfo,
 ): $ReadOnlyArray<MessageReactionListInfo> {
   const withoutENSNames = React.useMemo(() => {
     const result = [];
 
     for (const reaction in reactions) {
       const reactionInfo = reactions[reaction];
 
       reactionInfo.users.forEach(user => {
         result.push({
           ...user,
           username: stringForUserExplicit(user),
           reaction,
         });
       });
     }
 
     const sortByNumReactions = (reactionInfo: MessageReactionListInfo) => {
       const numOfReactions = reactions[reactionInfo.reaction].users.length;
       return numOfReactions ? -numOfReactions : 0;
     };
 
     return _sortBy(
       ([sortByNumReactions, 'username']: $ReadOnlyArray<
         ((reactionInfo: MessageReactionListInfo) => mixed) | string,
       >),
     )(result);
   }, [reactions]);
   return useENSNames<MessageReactionListInfo>(withoutENSNames);
 }
 
 function useCanCreateReactionFromMessage(
   threadInfo: ThreadInfo,
   targetMessageInfo: ComposableMessageInfo | RobotextMessageInfo,
 ): boolean {
   const targetMessageCreatorRelationship = useSelector(
     state =>
       state.userStore.userInfos[targetMessageInfo.creator.id]
         ?.relationshipStatus,
   );
 
   const userHasReactionPermission = useThreadHasPermission(
     threadInfo,
     threadPermissions.REACT_TO_MESSAGE,
   );
   if (!userHasReactionPermission) {
     return false;
   }
 
   if (
-    !targetMessageInfo.id ||
-    threadInfo.sourceMessageID === targetMessageInfo.id
+    (!targetMessageInfo.id && !threadTypeIsThick(threadInfo.type)) ||
+    (threadInfo.sourceMessageID &&
+      threadInfo.sourceMessageID === targetMessageInfo.id)
   ) {
     return false;
   }
 
   return (
     !targetMessageCreatorRelationship ||
     !relationshipBlockedInEitherDirection(targetMessageCreatorRelationship)
   );
 }
 
 export {
   useViewerAlreadySelectedMessageReactions,
   useMessageReactionsList,
   useCanCreateReactionFromMessage,
 };
diff --git a/lib/shared/sidebar-utils.js b/lib/shared/sidebar-utils.js
index 413d57a89..d6cefdfba 100644
--- a/lib/shared/sidebar-utils.js
+++ b/lib/shared/sidebar-utils.js
@@ -1,243 +1,244 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { ParserRules } from './markdown.js';
 import { getMessageTitle, isInvalidSidebarSource } from './message-utils.js';
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import {
   createPendingThread,
   getSingleOtherUser,
   extractMentionedMembers,
   useThreadHasPermission,
   userIsMember,
 } from './thread-utils.js';
 import type { ChatMessageInfoItem } from '../selectors/chat-selectors.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import type {
   RobotextMessageInfo,
   ComposableMessageInfo,
 } from '../types/message-types.js';
 import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { threadTypes, threadTypeIsThick } from '../types/thread-types-enum.js';
 import type { LoggedInUserInfo } from '../types/user-types.js';
 import type { GetENSNames } from '../utils/ens-helpers.js';
 import {
   entityTextToRawString,
   getEntityTextAsString,
 } from '../utils/entity-text.js';
 import type { GetFCNames } from '../utils/farcaster-helpers.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { trimText } from '../utils/text-utils.js';
 
 type SharedCreatePendingSidebarInput = {
   +sourceMessageInfo: ComposableMessageInfo | RobotextMessageInfo,
   +parentThreadInfo: ThreadInfo,
   +loggedInUserInfo: LoggedInUserInfo,
 };
 
 type BaseCreatePendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +messageTitle: string,
 };
 
 type UserIDAndUsername = {
   +id: string,
   +username: ?string,
   ...
 };
 
 function baseCreatePendingSidebar(
   input: BaseCreatePendingSidebarInput,
 ): ThreadInfo {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     messageTitle,
   } = input;
   const { color, type: parentThreadType } = parentThreadInfo;
   const threadName = trimText(messageTitle, 30);
 
   const initialMembers = new Map<string, UserIDAndUsername>();
 
   const { id: viewerID, username: viewerUsername } = loggedInUserInfo;
   initialMembers.set(viewerID, { id: viewerID, username: viewerUsername });
 
   if (userIsMember(parentThreadInfo, sourceMessageInfo.creator.id)) {
     const { id: sourceAuthorID, username: sourceAuthorUsername } =
       sourceMessageInfo.creator;
     const initialMemberUserInfo = {
       id: sourceAuthorID,
       username: sourceAuthorUsername,
     };
     initialMembers.set(sourceAuthorID, initialMemberUserInfo);
   }
 
   const singleOtherUser = getSingleOtherUser(parentThreadInfo, viewerID);
   if (
     (parentThreadType === threadTypes.GENESIS_PERSONAL ||
       parentThreadType === threadTypes.PERSONAL) &&
     singleOtherUser
   ) {
     const singleOtherUsername = parentThreadInfo.members.find(
       member => member.id === singleOtherUser,
     )?.username;
     const singleOtherUserInfo = {
       id: singleOtherUser,
       username: singleOtherUsername,
     };
     initialMembers.set(singleOtherUser, singleOtherUserInfo);
   }
 
   if (sourceMessageInfo.type === messageTypes.TEXT) {
     const mentionedMembersOfParent = extractMentionedMembers(
       sourceMessageInfo.text,
       parentThreadInfo,
     );
     for (const [memberID, member] of mentionedMembersOfParent) {
       initialMembers.set(memberID, member);
     }
   }
 
   return createPendingThread({
     viewerID,
     threadType: threadTypeIsThick(parentThreadInfo.type)
       ? threadTypes.THICK_SIDEBAR
       : threadTypes.SIDEBAR,
     members: [...initialMembers.values()],
     parentThreadInfo,
     threadColor: color,
     name: threadName,
     sourceMessageID: sourceMessageInfo.id,
   });
 }
 
 // The message title here may have ETH addresses that aren't resolved to ENS
 // names. This function should only be used in cases where we're sure that we
 // don't care about the thread title. We should prefer createPendingSidebar
 // wherever possible
 type CreateUnresolvedPendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +markdownRules: ParserRules,
 };
 
 function createUnresolvedPendingSidebar(
   input: CreateUnresolvedPendingSidebarInput,
 ): ThreadInfo {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     markdownRules,
   } = input;
 
   const messageTitleEntityText = getMessageTitle(
     sourceMessageInfo,
     parentThreadInfo,
     parentThreadInfo,
     markdownRules,
   );
   const messageTitle = entityTextToRawString(messageTitleEntityText, {
     ignoreViewer: true,
   });
 
   return baseCreatePendingSidebar({
     sourceMessageInfo,
     parentThreadInfo,
     messageTitle,
     loggedInUserInfo,
   });
 }
 
 type CreatePendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +markdownRules: ParserRules,
   +getENSNames: ?GetENSNames,
   +getFCNames: ?GetFCNames,
 };
 
 async function createPendingSidebar(
   input: CreatePendingSidebarInput,
 ): Promise<ThreadInfo> {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     markdownRules,
     getENSNames,
     getFCNames,
   } = input;
 
   const messageTitleEntityText = getMessageTitle(
     sourceMessageInfo,
     parentThreadInfo,
     parentThreadInfo,
     markdownRules,
   );
   const messageTitle = await getEntityTextAsString(
     messageTitleEntityText,
     { getENSNames, getFCNames },
     { ignoreViewer: true },
   );
   invariant(
     messageTitle !== null && messageTitle !== undefined,
     'getEntityTextAsString only returns falsey when passed falsey',
   );
 
   return baseCreatePendingSidebar({
     sourceMessageInfo,
     parentThreadInfo,
     messageTitle,
     loggedInUserInfo,
   });
 }
 
 function useCanCreateSidebarFromMessage(
   threadInfo: ThreadInfo,
   messageInfo: ComposableMessageInfo | RobotextMessageInfo,
 ): boolean {
   const messageCreatorUserInfo = useSelector(
     state => state.userStore.userInfos[messageInfo.creator.id],
   );
   const hasCreateSidebarsPermission = useThreadHasPermission(
     threadInfo,
     threadPermissions.CREATE_SIDEBARS,
   );
   if (!hasCreateSidebarsPermission) {
     return false;
   }
 
   if (
-    !messageInfo.id ||
-    threadInfo.sourceMessageID === messageInfo.id ||
+    (!messageInfo.id && !threadTypeIsThick(threadInfo.type)) ||
+    (threadInfo.sourceMessageID &&
+      threadInfo.sourceMessageID === messageInfo.id) ||
     isInvalidSidebarSource(messageInfo)
   ) {
     return false;
   }
 
   const messageCreatorRelationship = messageCreatorUserInfo?.relationshipStatus;
   return (
     !messageCreatorRelationship ||
     !relationshipBlockedInEitherDirection(messageCreatorRelationship)
   );
 }
 
 function useSidebarExistsOrCanBeCreated(
   threadInfo: ThreadInfo,
   messageItem: ChatMessageInfoItem,
 ): boolean {
   const canCreateSidebarFromMessage = useCanCreateSidebarFromMessage(
     threadInfo,
     messageItem.messageInfo,
   );
   return !!messageItem.threadCreatedFromMessage || canCreateSidebarFromMessage;
 }
 
 export {
   createUnresolvedPendingSidebar,
   createPendingSidebar,
   useCanCreateSidebarFromMessage,
   useSidebarExistsOrCanBeCreated,
 };