fix(invitations): tell an existing member their standing is unchanged

The join preview reported the same no-join shape for two different outcomes: an
external collaborator, and an invitee who already belongs to the organization
acceptance lands in. `buildMembershipNotice` rendered both as "you'll join as an
external collaborator ... everything you own stays yours", which is wrong for an
existing member — they stay an internal member and simply gain the granted
workspaces.

The preview now reports `alreadyMemberOfOrganization` for that case (a
membership in a DIFFERENCE organization is still the external path, since
acceptance downgrades), and the notice states that standing is unchanged. This is
the same conflation behind the accept loop fixed in 4eb7725, now removed from
the shape itself rather than worked around per consumer.

Also re-verify the removal-impact disclosure at the moment of confirmation.
`isFetching` only holds the confirm button while a request is in flight, so an
identity-bound credential the member gained after the fetch settled would break
on removal without ever being disclosed. Confirm now refetches and, if the set
changed, keeps the dialog open on the refreshed warning instead of proceeding.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/settings/components/team-management/team-management.tsx

@@ -87,10 +87,15 @@ export function TeamManagement({
     data: removalImpactCredentials,
     isFetching: isRemovalImpactFetching,
     isError: isRemovalImpactError,
+    refetch: refetchRemovalImpact,
   } = useMemberRemovalImpact(organizationId, removeMemberDialog.memberId, {
     enabled: removeMemberDialog.open,
   })
 
+  const disclosedBreakingCredentials = [
+    ...new Set(removalImpactCredentials?.map((credential) => credential.displayName) ?? []),
+  ]
+
   const totalSeats = organizationBillingData?.data?.totalSeats ?? 0
   const usedSeats = organizationBillingData?.data?.members?.length ?? 0
   const reservedSeats = organizationBillingData?.data?.usedSeats ?? 0
@@ -174,6 +179,25 @@ export function TeamManagement({
     if (!session?.user || !memberId) return
 
     try {
+      /**
+       * Re-verify the disclosure at the moment of confirmation. `isFetching`
+       * holds the button only while a request is in flight; a credential the
+       * member gained after the fetch settled would otherwise be removed
+       * without ever having been disclosed. On a change the dialog stays open
+       * showing the refreshed warning, so the admin confirms against what is
+       * actually true — the same consent contract the invite flow uses.
+       */
+      const refreshed = await refetchRemovalImpact()
+      if (refreshed.data) {
+        const current = [...new Set(refreshed.data.map((credential) => credential.displayName))]
+        if (
+          current.length !== disclosedBreakingCredentials.length ||
+          current.some((name) => !disclosedBreakingCredentials.includes(name))
+        ) {
+          return
+        }
+      }
+
       await removeMemberMutation.mutateAsync({
         memberId,
         orgId: organizationId,
@@ -195,6 +219,7 @@ export function TeamManagement({
   }, [
     removeMemberDialog.memberId,
     removeMemberDialog.isSelfRemoval,
+    disclosedBreakingCredentials,
     session?.user?.id,
     organizationId,
     removeMemberMutation,
@@ -368,9 +393,7 @@ export function TeamManagement({
         memberName={removeMemberDialog.memberName}
         isSelfRemoval={removeMemberDialog.isSelfRemoval}
         isExternalRemoval={removeMemberDialog.isExternalRemoval}
-        breakingCredentials={[
-          ...new Set(removalImpactCredentials?.map((c) => c.displayName) ?? []),
-        ]}
+        breakingCredentials={disclosedBreakingCredentials}
         credentialImpactPending={isRemovalImpactFetching}
         credentialImpactFailed={isRemovalImpactError}
         isSubmitting={removeMemberMutation.isPending}

apps/sim/lib/api/contracts/invitations.ts

@@ -140,6 +140,13 @@ export const invitationDetailsSchema = z.object({
 
 export const invitationJoinPreviewSchema = z.object({
   willJoinOrganization: z.boolean(),
+  /**
+   * The invitee is already a member of the organization acceptance lands in, so
+   * only workspace access changes. Reported separately because it shares
+   * `willJoinOrganization: false` with the external case, which means something
+   * different to the person accepting.
+   */
+  alreadyMemberOfOrganization: z.boolean(),
   /** Name of the organization acceptance will actually join. */
   organizationName: z.string().nullable(),
   workspacesToMove: z.array(z.string()).max(DISCLOSED_WORKSPACE_ID_LIMIT),

apps/sim/lib/invitations/core.ts

@@ -218,6 +218,15 @@ async function hasLiveGrantInStampedOrganization(
 
 export interface InvitationJoinPreviewResult {
   willJoinOrganization: boolean
+  /**
+   * True when the invitee is ALREADY a member of the organization acceptance
+   * lands in, so nothing about their standing changes — they simply gain the
+   * granted workspaces. Distinct from the external case, which also reports
+   * `willJoinOrganization: false` but means "no seat, and never a member".
+   * Without this the accept screen cannot tell the two apart and would tell an
+   * existing member they are joining as an external collaborator.
+   */
+  alreadyMemberOfOrganization: boolean
   /**
    * Name of the organization acceptance will actually join. For a workspace
    * invite this is the granted workspace's LIVE organization, which can differ
@@ -247,6 +256,7 @@ export async function getInvitationJoinPreview(
 ): Promise<InvitationJoinPreviewResult> {
   const noJoin: InvitationJoinPreviewResult = {
     willJoinOrganization: false,
+    alreadyMemberOfOrganization: false,
     organizationName: null,
     workspacesToMove: [],
     workspaceIdsToMove: [],
@@ -277,7 +287,16 @@ export async function getInvitationJoinPreview(
    * one (acceptance downgrades to external or rejects).
    */
   const existingMembership = await getUserOrganization(inviteeUserId)
-  if (existingMembership) return noJoin
+  if (existingMembership) {
+    /**
+     * Already in the organization acceptance lands in: nothing about their
+     * standing changes. A membership in a DIFFERENT organization is the
+     * external case — acceptance downgrades — so it keeps the plain shape.
+     */
+    const inTargetOrganization =
+      !!workspaceOrganizationId && existingMembership.organizationId === workspaceOrganizationId
+    return inTargetOrganization ? { ...noJoin, alreadyMemberOfOrganization: true } : noJoin
+  }
 
   if (!(await stampedOrganizationAllowsEscalation(inv, workspaceOrganizationId))) return noJoin
 
@@ -324,6 +343,7 @@ export async function getInvitationJoinPreview(
 
   return {
     willJoinOrganization: true,
+    alreadyMemberOfOrganization: false,
     organizationName: targetOrganizationName,
     workspacesToMove: ownedWorkspaces.map((row) => row.name),
     workspaceIdsToMove: ownedWorkspaces.map((row) => row.id),

apps/sim/lib/invitations/disclosure-copy.test.ts

@@ -10,6 +10,7 @@ import {
 const preview = (over: Partial<Parameters<typeof buildMembershipNotice>[0]['joinPreview']> = {}) =>
   ({
     willJoinOrganization: true,
+    alreadyMemberOfOrganization: false,
     organizationName: 'Acme',
     workspacesToMove: [],
     workspaceIdsToMove: [],
@@ -61,6 +62,24 @@ describe('buildMembershipNotice', () => {
     expect(notice).not.toContain('uses one of their seats')
   })
 
+  /**
+   * An existing member shares `willJoinOrganization: false` with the external
+   * case but means something different — their standing is unchanged.
+   */
+  it('discloses unchanged standing for an existing member, not external', () => {
+    const notice = buildMembershipNotice({
+      joinPreview: preview({ willJoinOrganization: false, alreadyMemberOfOrganization: true }),
+      membershipIntent: 'internal',
+      isOrganizationAdminRole: false,
+      organizationLabel: 'Acme',
+      isOrganizationScoped: true,
+    })
+
+    expect(notice).toContain('already a member of Acme')
+    expect(notice).not.toContain('external collaborator')
+    expect(notice).not.toContain('uses one of their seats')
+  })
+
   it('falls back to the sent intent when no preview could be computed', () => {
     expect(
       buildMembershipNotice({

apps/sim/lib/invitations/disclosure-copy.ts

@@ -74,6 +74,15 @@ export function buildMembershipNotice({
 }): string {
   if (!isOrganizationScoped || !membershipIntent) return ''
 
+  /**
+   * Already a member of the organization acceptance lands in: their standing is
+   * unchanged, so neither the join copy nor the external copy is true. Checked
+   * first because this case also reports `willJoinOrganization: false`.
+   */
+  if (joinPreview?.alreadyMemberOfOrganization) {
+    return ` You're already a member of ${organizationLabel}, so accepting only adds the workspaces above — your membership and seat don't change.`
+  }
+
   const willJoinOrganization = joinPreview
     ? joinPreview.willJoinOrganization
     : membershipIntent !== 'external'