diff --git a/apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/chat/ChatStep.kt b/apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/chat/ChatStep.kt
index 0c505a1266..458dc3a238 100644
--- a/apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/chat/ChatStep.kt
+++ b/apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/chat/ChatStep.kt
@@ -151,6 +151,12 @@ enum class ProfileOrigin {
      */
     Mention,
 
+    /**
+     * A portrait in a public group's Chatting grid. Like [Mention], the person is not who the chat
+     * is with, so Mute would act on the wrong chat and opening a chat has somewhere new to go.
+     */
+    GroupMember,
+
     /** A `flipcash.com/...` link. The default for `AppRoute.Messaging.Profile`. Blocking pops back. */
     Link,
 
diff --git a/apps/flipcash/core/src/main/res/values/strings.xml b/apps/flipcash/core/src/main/res/values/strings.xml
index 8c8497f259..ff2f1f41f5 100644
--- a/apps/flipcash/core/src/main/res/values/strings.xml
+++ b/apps/flipcash/core/src/main/res/values/strings.xml
@@ -915,13 +915,19 @@
     <string name="subtitle_chatGate_speakerCreatorOnly">Only the creator can send messages</string>
     <string name="subtitle_chatGate_speakerUnsupported">Update Flipcash to send messages</string>
     <string name="action_buyMoreToken">Buy More %1$s</string>
+    <string name="action_join">Join</string>
     <string name="action_joinChat">Join Chat</string>
     <string name="title_leaveChat">Leave Chat</string>
-    <string name="action_leaveChat">Leave</string>
+    <string name="title_encryption">Encryption</string>
+    <string name="label_groupRequiredToJoin">%1$s Required to Join</string>
+    <string name="label_groupRequiredToChat">%1$s Required to Chat</string>
+    <string name="action_buyToJoin">Buy %1$s to Join</string>
+    <string name="action_buyToChat">Buy %1$s to Chat</string>
+    <string name="action_leaveChat">Leave Chat</string>
     <string name="prompt_title_leaveChat">Leave %1$s?</string>
-    <string name="prompt_description_leaveChat">You won’t receive new messages from this chat. You can join it again if it still lets you in</string>
+    <string name="prompt_description_leaveChat">You won’t receive messages from this group any more. You can join again with an invite link</string>
     <string name="error_title_failedToLeave">Something Went Wrong</string>
-    <string name="error_description_failedToLeave">We were unable to leave the chat. Please try again</string>
+    <string name="error_description_failedToLeave">We were unable to leave this group. Please try again</string>
 
     <!-- Muting a chat. The contract has two mute shapes, a deadline and forever, so the sheet
          offers durations plus an indefinite option; unmuting is its own request, which is why
@@ -953,9 +959,9 @@
     <string name="error_description_failedToMute">We were unable to mute the chat. Please try again</string>
     <string name="error_title_failedToUnmute">Something Went Wrong</string>
     <string name="error_description_failedToUnmute">We were unable to unmute the chat. Please try again</string>
-    <string name="error_title_failedToJoin">Couldn\'t Join</string>
-    <string name="error_description_failedToJoin">We were unable to join the chat. Please try again</string>
-    <string name="error_description_joinChat_rulesNotSatisfied">Your balance doesn\'t meet this chat\'s requirement yet</string>
+    <string name="error_title_failedToJoin">Couldn\'t Join Chat</string>
+    <string name="error_description_failedToJoin">Something went wrong. Please try again.</string>
+    <string name="error_description_joinChat_rulesNotSatisfied">You don\'t meet this chat\'s requirements yet.</string>
     <string name="error_description_joinChat_denied">This chat isn\'t open to you</string>
     <string name="error_description_joinChat_notFound">This chat no longer exists</string>
 
diff --git a/apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/chat/ProfileOriginTest.kt b/apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/chat/ProfileOriginTest.kt
index 1dcaa62e45..5530b30767 100644
--- a/apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/chat/ProfileOriginTest.kt
+++ b/apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/chat/ProfileOriginTest.kt
@@ -18,7 +18,7 @@ class ProfileOriginTest {
         val pops = ProfileOrigin.entries - setOf(ProfileOrigin.Scan, ProfileOrigin.UsernameLookup)
 
         assertEquals(
-            setOf(ProfileOrigin.Chat, ProfileOrigin.Mention, ProfileOrigin.Link, ProfileOrigin.Transaction),
+            setOf(ProfileOrigin.Chat, ProfileOrigin.Mention, ProfileOrigin.GroupMember, ProfileOrigin.Link, ProfileOrigin.Transaction),
             pops.toSet(),
         )
         pops.forEach { assertFalse(it.resetsToChatsAfterBlock, "$it") }
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt
index 550aa4ad65..b29c55f3a9 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt
@@ -248,14 +248,14 @@ private fun FlowGroupInviteSheet() {
     }
 
     GroupInviteSheet(
-        inviteUrl = state.groupInviteUrl,
+        inviteUrl = state.shareableGroupInviteUrl,
         subject = ShareToChatsSubject.Group(state.subject as? ChatSubject.Group),
         state = inviteState,
         onShare = { viewModel.dispatchEvent(ChatViewModel.Event.InviteLinkShared) },
         onCopy = { viewModel.dispatchEvent(ChatViewModel.Event.CopyInviteLink) },
         onToggle = inviteViewModel::toggle,
         onMessageChanged = inviteViewModel::onMessageChanged,
-        onInvite = { state.groupInviteUrl?.let(inviteViewModel::invite) },
+        onInvite = { state.shareableGroupInviteUrl?.let(inviteViewModel::invite) },
         onDismiss = dismissSheet,
     )
 }
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatSubject.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatSubject.kt
index 28bd1c5fad..4765c1a8b6 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatSubject.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatSubject.kt
@@ -86,6 +86,15 @@ sealed interface ChatSubject {
         val isMember: Boolean?,
         /** The group's creator (`ChatMetadata.creator`); null when the metadata did not carry one. */
         val creator: ID? = null,
+        /** The group's description (`ChatMetadata.description`); null when unset. */
+        val description: String? = null,
+        /**
+         * The banner above the group's profile. A feed row may carry none even when the group has
+         * one; the profile asks `GetChat` once when it opens on a group without one.
+         */
+        val coverPicture: MediaItem? = null,
+        /** A private group's roster is not sampled for the profile, which the server denies. */
+        val isPrivate: Boolean = false,
     ) : ChatSubject {
         override val title: String get() = groupTitle.orEmpty()
         override val subtitle: String? get() = null
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt
index 945a08cee1..058075562a 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt
@@ -57,6 +57,9 @@ import com.flipcash.features.messenger.R
 import com.flipcash.libs.coroutines.DispatcherProvider
 import com.flipcash.services.chat.E2eePolicy
 import com.flipcash.services.models.JoinChatError
+import com.flipcash.services.models.chat.SampledChatter
+import com.flipcash.app.messenger.internal.screens.profile.GroupBalanceRequirements
+import com.flipcash.app.messenger.internal.screens.profile.GroupProfileStanding
 import com.flipcash.services.models.TipAction
 import com.flipcash.services.models.TipOrigin
 import com.flipcash.services.models.UserProfile
@@ -183,6 +186,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.stateIn
@@ -398,6 +402,24 @@ internal class ChatViewModel @Inject constructor(
          * the whole round trip and read as dead — which is what it looked like before it had one.
          */
         val joinProgress: LoadingSuccessState = LoadingSuccessState(),
+        /** A leave is out, so the profile's Leave Chat shows a spinner and cannot be tapped again. */
+        val leaving: Boolean = false,
+        /**
+         * What the group's profile pins and states about the viewer's balance, decided with the
+         * live balance and rates. Null until they arrive, and for anything that is not a group.
+         */
+        val profileStanding: GroupProfileStanding? = null,
+        /**
+         * The name of each token a balance rule on the profile names, by the mint's bytes: the join
+         * and chat rows can name different ones, so the single [ruleCurrency] is not enough. A mint
+         * the cache has not resolved is absent.
+         */
+        val ruleTokens: Map<List<Byte>, RuleCurrency> = emptyMap(),
+        /**
+         * Who has been chatting in a public group, as of the last time its profile opened. Empty for
+         * a private group and when the sample could not be had.
+         */
+        val chatters: List<SampledChatter> = emptyList(),
         /**
          * The quick strip's entries for [selection], recomposed whenever the selected message
          * changes — empty while nothing is selected, while the selected message can't be reacted
@@ -580,6 +602,15 @@ internal class ChatViewModel @Inject constructor(
          */
         val offersGroupInvite: Boolean
             get() = groupInviteUrl != null
+
+        /**
+         * The same link without the membership check, for the profile's Share, which is offered to
+         * anyone looking at the group: the link is the chat's id and gives a recipient nothing the
+         * chat's own page would not. [groupInviteUrl] stays member-only, since it decides whether the
+         * transcript offers its own invite.
+         */
+        val shareableGroupInviteUrl: String?
+            get() = (subject as? ChatSubject.Group)?.let { Linkify.groupChatInvite(it.chatId) }
     }
 
     /**
@@ -650,6 +681,15 @@ internal class ChatViewModel @Inject constructor(
         /** The leave went through, so whatever is showing the group's profile should close. */
         data object LeftChat : Event
 
+        /** The leave did not go through; the profile stays up and the button comes back. */
+        data object LeaveFailed : Event
+
+        /** The group's profile came on screen: sample its chatters and fill in a missing cover. */
+        data object GroupProfileOpened : Event
+        data class OnChattersLoaded(val chatters: List<SampledChatter>) : Event
+        data class OnProfileStandingResolved(val standing: GroupProfileStanding?) : Event
+        data class OnRuleTokensResolved(val tokens: Map<List<Byte>, RuleCurrency>) : Event
+
         /** This chat's viewer state moved, from the stream or from the viewer's own request. */
         data class OnViewerStateResolved(val viewerState: ViewerState?) : Event
 
@@ -1704,6 +1744,98 @@ internal class ChatViewModel @Inject constructor(
             .onEach { dispatchEvent(Event.OnRuleCurrencyResolved(it)) }
             .launchIn(viewModelScope)
 
+        // The profile names the token behind both the join and the chat row, which may differ.
+        // Each is fetched like the gate's, and a mint that never resolves does not hold the others
+        // back: it simply stays unnamed.
+        stateFlow.map { state ->
+            GroupBalanceRequirements.from((state.subject as? ChatSubject.Group)?.rules)
+                ?.let { listOfNotNull(it.join, it.chat) }.orEmpty()
+                .mapNotNull { it.mints.firstOrNull()?.let { mint -> Mint(mint.bytes) } }
+                .distinct()
+        }
+            .distinctUntilChanged()
+            .flatMapLatest { mints ->
+                if (mints.isEmpty()) {
+                    flowOf(emptyMap())
+                } else {
+                    combine(
+                        mints.map { mint ->
+                            tokenCoordinator.observeRuleToken(mint)
+                                .map<Token, Pair<List<Byte>, RuleCurrency>?> {
+                                    mint.bytes to RuleCurrency(it.brandedName(resources), it.isReserve)
+                                }
+                                .onStart { emit(null) }
+                        }
+                    ) { named -> named.filterNotNull().toMap() }
+                }
+            }
+            .distinctUntilChanged()
+            .onEach { dispatchEvent(Event.OnRuleTokensResolved(it)) }
+            .launchIn(viewModelScope)
+
+        // What the profile's pinned button does and says, re-decided as the balance and rates move.
+        stateFlow.map { it.subject as? ChatSubject.Group }
+            .distinctUntilChanged()
+            .flatMapLatest { group ->
+                if (group == null) {
+                    flowOf(null)
+                } else {
+                    combine(
+                        tokenCoordinator.tokenBalances,
+                        userFlags.resolvedFlags.map { it.isStaff.effectiveValue },
+                        exchange.observeRates(),
+                    ) { balances, staff, rates ->
+                        GroupProfileStanding.of(
+                            isMember = group.isMember == true,
+                            rules = group.rules,
+                            balances = balances,
+                            isStaff = staff,
+                            rates = rates,
+                            viewerId = userManager.accountId,
+                            creatorId = group.creator,
+                        )
+                    }
+                }
+            }
+            .distinctUntilChanged()
+            .onEach { dispatchEvent(Event.OnProfileStandingResolved(it)) }
+            .launchIn(viewModelScope)
+
+        // Sampled as soon as a public group resolves, so the profile has its grid on the way in
+        // rather than popping it in after the push, and again each time the profile opens: this
+        // view model outlives the screen, and who is chatting is a thing that moves. The list on
+        // screen stays until the new one lands. A private group's sampling is denied, so it is
+        // not asked; a failure reads as nobody to show.
+        merge(
+            stateFlow.map { (it.subject as? ChatSubject.Group)?.takeUnless { group -> group.isPrivate }?.chatId }
+                .filterNotNull()
+                .distinctUntilChanged(),
+            eventFlow.filterIsInstance<Event.GroupProfileOpened>().mapNotNull { stateFlow.value.chatId },
+        ).onEach { chatId ->
+            val group = stateFlow.value.subject as? ChatSubject.Group ?: return@onEach
+            if (group.isPrivate) {
+                dispatchEvent(Event.OnChattersLoaded(emptyList()))
+                return@onEach
+            }
+            val chatters = chatCoordinator.sampleChatters(chatId)
+                .onFailure { trace("failed to sample chatters - ${it.localizedMessage}") }
+                .getOrNull()?.chatters
+            // A failed refresh keeps what is already showing; only a first failure hides the grid.
+            if (chatters != null || stateFlow.value.chatters.isEmpty()) {
+                dispatchEvent(Event.OnChattersLoaded(chatters.orEmpty()))
+            }
+        }.launchIn(viewModelScope)
+
+        // A row that came from the feed can lack the cover the profile shows; GetChat has it. The
+        // stored metadata updates and OnGroupResolved carries it into the subject.
+        eventFlow.filterIsInstance<Event.GroupProfileOpened>()
+            .onEach {
+                val chatId = stateFlow.value.chatId ?: return@onEach
+                val group = stateFlow.value.subject as? ChatSubject.Group ?: return@onEach
+                if (group.coverPicture == null) chatCoordinator.refreshCover(chatId)
+            }
+            .launchIn(viewModelScope)
+
         // Re-resolved whenever membership or the rules move, and internally whenever the balance
         // does. flatMapLatest rather than combine because the balance flow is the inner one: a new
         // subject must cancel the gate it was deciding, not race it.
@@ -2070,9 +2202,9 @@ internal class ChatViewModel @Inject constructor(
             .launchIn(viewModelScope)
 
         // Read off the state rather than carried on the event, so the row that copies the link and
-        // the row that shares it are handing out the one url [State.groupInviteUrl] builds.
+        // the row that shares it are handing out the one url [State.shareableGroupInviteUrl] builds.
         eventFlow.filterIsInstance<Event.CopyInviteLink>()
-            .mapNotNull { stateFlow.value.groupInviteUrl }
+            .mapNotNull { stateFlow.value.shareableGroupInviteUrl }
             .onEach { url ->
                 clipboardManager.setText(
                     text = url,
@@ -2211,7 +2343,7 @@ internal class ChatViewModel @Inject constructor(
         eventFlow.filterIsInstance<Event.LeaveChat>()
             .mapNotNull { stateFlow.value.subject as? ChatSubject.Group }
             .onEach { group ->
-                BottomBarManager.showAlert(
+                BottomBarManager.showInfo(
                     title = resources.getString(
                         R.string.prompt_title_leaveChat,
                         group.title,
@@ -2238,6 +2370,7 @@ internal class ChatViewModel @Inject constructor(
                     .onSuccess { dispatchEvent(Event.LeftChat) }
                     .onFailure {
                         trace("failed to leave chat - ${it.localizedMessage}")
+                        dispatchEvent(Event.LeaveFailed)
                         BottomBarManager.showError(
                             title = resources.getString(R.string.error_title_failedToLeave),
                             message = resources.getString(R.string.error_description_failedToLeave),
@@ -2834,6 +2967,9 @@ internal class ChatViewModel @Inject constructor(
                             rules = metadata.rules,
                             isMember = event.membership.isMember,
                             creator = metadata.creator,
+                            description = metadata.description,
+                            coverPicture = metadata.coverPicture,
+                            isPrivate = metadata.isPrivate,
                         ),
                         chatType = ChatType.GROUP,
                         resolveState = ResolveState.Resolved,
@@ -2868,9 +3004,12 @@ internal class ChatViewModel @Inject constructor(
                 is Event.GateFundingTapped,
                 Event.GroupInfoOpened,
                 Event.InviteCardFollowed,
-                Event.LeaveChat,
-                Event.LeaveConfirmed,
-                Event.LeftChat -> { state -> state }
+                Event.LeaveChat, Event.GroupProfileOpened -> { state -> state }
+                is Event.OnChattersLoaded -> { state -> state.copy(chatters = event.chatters) }
+                is Event.OnProfileStandingResolved -> { state -> state.copy(profileStanding = event.standing) }
+                is Event.OnRuleTokensResolved -> { state -> state.copy(ruleTokens = event.tokens) }
+                Event.LeaveConfirmed -> { state -> state.copy(leaving = true) }
+                Event.LeftChat, Event.LeaveFailed -> { state -> state.copy(leaving = false) }
                 is Event.OnTipUserResolved -> { state ->
                     // A device contact, once matched, wins over the server profile (it carries the
                     // phone number and the user's own naming). Otherwise this is a tip DM: adopt the
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/ChatProfileScreen.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/ChatProfileScreen.kt
index 97f40c3e2f..c2bc9c2dde 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/ChatProfileScreen.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/ChatProfileScreen.kt
@@ -160,11 +160,13 @@ internal fun PersonProfileScreen(
                     subtitle = state.participant?.handle?.takeIf { it != state.participant?.name },
                     // Until the whole profile is here a missing bio means nothing, so it is not shown.
                     body = person?.profile?.bio?.takeIf { state.isFullProfileLoaded },
-                    actions = {
-                        // As on iOS: "Muted until 5:56 PM" for a timed mute, and gone once it lapses.
+                    // On the cover's bottom edge beside the avatar: the cover is a fixed height, so
+                    // a mute state that arrives late never shifts the header, and Share keeps the row.
+                    onCover = {
+                        // "Muted until 5:56 PM" for a timed mute, and gone once it lapses.
                         val mutedLabel = rememberMutedLabel(state.viewerState)
-                        // iOS spaces the chips 8 apart and keeps the row's 12 before Share.
-                        if (state.isBlocked || mutedLabel != null) Row(
+                        Row(
+                            modifier = Modifier.weight(1f, fill = false),
                             horizontalArrangement = Arrangement.spacedBy(CodeTheme.dimens.staticGrid.x2),
                             verticalAlignment = Alignment.CenterVertically,
                         ) {
@@ -172,15 +174,21 @@ internal fun PersonProfileScreen(
                                 ProfileStatusChip(
                                     icon = Icons.Outlined.Block,
                                     text = stringResource(R.string.label_blocked),
+                                    overCover = true,
                                 )
                             }
                             if (mutedLabel != null) {
                                 ProfileStatusChip(
+                                    modifier = Modifier.weight(1f, fill = false),
                                     icon = Icons.Outlined.NotificationsOff,
                                     text = mutedLabel,
+                                    compactText = stringResource(R.string.label_muted),
+                                    overCover = true,
                                 )
                             }
                         }
+                    },
+                    actions = {
                         if (person != null) {
                             ProfileActionButton(
                                 icon = ImageVector.vectorResource(R.drawable.ic_share_os),
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileMenuItems.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileMenuItems.kt
index c53291ac3a..8e05d43951 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileMenuItems.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileMenuItems.kt
@@ -1,108 +1,49 @@
 package com.flipcash.app.messenger.internal.screens.profile
 
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.outlined.Logout
-import androidx.compose.material.icons.outlined.Edit
 import androidx.compose.material.icons.outlined.Feedback
-import androidx.compose.material.icons.outlined.PersonAdd
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.painter.Painter
-import androidx.compose.ui.graphics.vector.rememberVectorPainter
-import androidx.compose.ui.res.stringResource
-import com.flipcash.app.menu.FullMenuItem
-import com.flipcash.app.menu.MenuItem
+import androidx.compose.material.icons.outlined.LockOpen
+import androidx.compose.material.icons.outlined.NotificationsOff
+import androidx.compose.ui.graphics.vector.ImageVector
 import com.flipcash.features.messenger.R
 
 /**
- * What the group's profile can act on.
+ * What the group profile's top-right overflow can do, in the order it lists them.
  *
- * Its own type rather than [com.flipcash.app.messenger.internal.ChatViewModel.Event], because the
- * rows do different kinds of thing: leaving is a request to the conversation's view model, inviting
- * and muting are navigations. Naming them here lets one
- * [com.flipcash.app.menu.MenuList] carry them and the screen decide which is which.
+ * Kept apart from the composable that draws the menu so what each viewer is offered can be tested
+ * without a screen: Mute follows membership, and Report does not.
  */
-internal sealed interface GroupProfileAction {
-    data object Invite : GroupProfileAction
-    data object Mute : GroupProfileAction
-    data object Leave : GroupProfileAction
-    data object Report : GroupProfileAction
-
-    /** Opens node 10187:110373's list of what about the group can be changed. */
-    data object Edit : GroupProfileAction
-}
-
-/**
- * The same invite the empty transcript offers, for a group that already has messages in it.
- *
- * Shown only while there is a link to hand out, which is the same condition as being a member.
- *
- * A person-with-plus glyph, matching iOS' `person.badge.plus` on the same row. Not the `@` one:
- * `ic_at` belongs to the row *inside* the sheet this opens, where it stands for the username the
- * link is sent to (node 10127:118328). Not `ic_group_3` either, which names a group rather than the
- * act of adding to one — that is the New Chat row's job.
- */
-internal data object InviteToGroup : FullMenuItem<GroupProfileAction>() {
-    override val icon: Painter
-        @Composable get() = rememberVectorPainter(Icons.Outlined.PersonAdd)
-
-    override val name: String
-        @Composable get() = stringResource(R.string.action_invitePeopleToJoin)
-
-    override val action: GroupProfileAction = GroupProfileAction.Invite
-}
-
-internal data object ReportGroup : FullMenuItem<GroupProfileAction>() {
-    override val icon: Painter
-        @Composable get() = rememberVectorPainter(Icons.Outlined.Feedback)
-
-    override val name: String
-        @Composable get() = stringResource(R.string.title_report)
-
-    override val action: GroupProfileAction = GroupProfileAction.Report
+internal enum class GroupProfileMenuAction {
+    Encryption,
+    Mute,
+    Report;
+
+    /** Report is drawn in the destructive colour, after a divider. */
+    val isDestructive: Boolean get() = this == Report
+
+    @androidx.annotation.StringRes
+    fun labelRes(): Int = when (this) {
+        Encryption -> R.string.title_encryption
+        Mute -> R.string.title_muteChat
+        Report -> R.string.title_report
+    }
+
+    fun icon(): ImageVector = when (this) {
+        Encryption -> Icons.Outlined.LockOpen
+        Mute -> Icons.Outlined.NotificationsOff
+        Report -> Icons.Outlined.Feedback
+    }
 }
 
-internal data object LeaveChat : FullMenuItem<GroupProfileAction>() {
-    override val icon: Painter
-        @Composable get() = rememberVectorPainter(Icons.AutoMirrored.Outlined.Logout)
-
-    override val name: String
-        @Composable get() = stringResource(R.string.title_leaveChat)
-
-    override val action: GroupProfileAction = GroupProfileAction.Leave
-}
-
-/** The group's mute row. Shared definition; see [MuteChatItem]. */
-internal val MuteChat = MuteChatItem<GroupProfileAction>(GroupProfileAction.Mute)
-
 /**
- * The group's edit row, in the profile's top-right overflow rather than in the list below it.
- *
- * A pencil, the same glyph the message overflow uses for editing a message — one verb, one icon.
- * Not `ic_group_3`, which names a group rather than the act of changing one.
+ * The overflow's rows for a viewer.
  *
- * Node 10187:110373 is the screen this opens; the overflow it hangs from is the message
- * long-press menu's shape reused (see `ChatTopBar.MessageOverflow`).
+ * A non-member has no notification setting to change, so Mute is members only. Report is always
+ * there: a group you have already left is the one you are most likely to report. Invite, Edit and
+ * Leave are not here; they live on the profile's own buttons.
  */
-internal data object EditGroup : FullMenuItem<GroupProfileAction>() {
-    override val icon: Painter
-        @Composable get() = rememberVectorPainter(Icons.Outlined.Edit)
-
-    override val name: String
-        @Composable get() = stringResource(R.string.action_edit)
-
-    override val action: GroupProfileAction = GroupProfileAction.Edit
+internal fun groupProfileMenuActions(isMember: Boolean): List<GroupProfileMenuAction> = buildList {
+    add(GroupProfileMenuAction.Encryption)
+    if (isMember) add(GroupProfileMenuAction.Mute)
+    add(GroupProfileMenuAction.Report)
 }
-
-/**
- * What the profile's top-right overflow holds, for a viewer the server says may edit.
- *
- * [canEdit] comes from `ViewerState.Permissions` and is server-computed. It is passed in rather
- * than derived here on purpose: membership, being the creator, and the chat's kind all *look* like
- * they answer the question and none of them is the answer the server gives, so a local guess would
- * offer an Edit that `EditChat` then refuses with `DENIED`.
- *
- * Returns a list so the overflow has nothing to show — and so draws nothing — when the answer is
- * no. A single-item menu is still a menu; an empty one is not a button.
- */
-internal fun groupProfileOverflowItems(canEdit: Boolean): List<MenuItem<GroupProfileAction>> =
-    if (canEdit) listOf(EditGroup) else emptyList()
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileScreen.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileScreen.kt
index bcc0072a90..b6e2cc46d4 100644
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileScreen.kt
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileScreen.kt
@@ -1,17 +1,25 @@
 package com.flipcash.app.messenger.internal.screens.profile
 
 import android.os.Parcelable
-import androidx.annotation.VisibleForTesting
-import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.foundation.layout.statusBars
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.NotificationsOff
+import androidx.compose.material.icons.rounded.MoreVert
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -21,46 +29,61 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.unit.DpOffset
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.flipcash.analytics.GroupGateFunding
 import com.flipcash.analytics.GroupInviteSheetSource
+import com.flipcash.app.core.AppRoute
+import com.flipcash.app.core.chat.ChatParticipant
 import com.flipcash.app.core.chat.ChatStep
+import com.flipcash.app.core.chat.ProfileOrigin
 import com.flipcash.app.core.chat.ReportSubject
-import com.flipcash.app.core.AppRoute
-import com.flipcash.app.messenger.internal.screens.openGroupInvite
-import com.getcode.navigation.core.LocalCodeNavigator
-import com.flipcash.app.menu.MenuItem
-import com.flipcash.app.menu.MenuList
-import com.flipcash.app.messenger.internal.ChatMuteStatusChip
+import com.flipcash.app.core.tokens.TokenInfoEntry
 import com.flipcash.app.messenger.internal.ChatSubject
 import com.flipcash.app.messenger.internal.ChatViewModel
+import com.flipcash.app.messenger.internal.rememberMutedLabel
 import com.flipcash.app.messenger.internal.screens.components.ChatSubjectAvatar
+import com.flipcash.app.messenger.internal.screens.openGroupInvite
 import com.flipcash.features.messenger.R
+import com.flipcash.services.models.chat.BlobAccessContext
+import com.flipcash.services.models.chat.ChatRuleRequirement
 import com.flipcash.services.models.chat.ChatType
-import com.flipcash.services.models.chat.ViewerState
+import com.flipcash.shared.common.ui.profile.BalanceRequirementsCard
+import com.flipcash.shared.common.ui.profile.ChattingGridItem
+import com.flipcash.shared.common.ui.profile.GroupChattingGrid
+import com.flipcash.shared.common.ui.profile.ProfileActionButton
+import com.flipcash.shared.common.ui.profile.ProfileHeader
+import com.flipcash.shared.common.ui.profile.ProfilePinnedActionBar
+import com.flipcash.shared.common.ui.profile.ProfileStatusChip
+import com.flipcash.shared.common.ui.profile.chatterName
+import com.getcode.navigation.core.LocalCodeNavigator
 import com.getcode.navigation.flow.rememberFlowNavigator
+import com.getcode.opencode.model.financial.Fiat
+import com.getcode.solana.keys.Mint
 import com.getcode.theme.CodeTheme
 import com.getcode.theme.extraLarge
-import com.getcode.ui.components.AppBarDefaults
 import com.getcode.ui.components.AppBarWithTitle
+import com.getcode.ui.core.verticalScrollStateGradient
+import com.getcode.ui.components.CircularIconButton
 import com.getcode.ui.theme.CodeScaffold
+import dev.chrisbanes.haze.hazeSource
+import dev.chrisbanes.haze.rememberHazeState
 import kotlinx.coroutines.flow.filterIsInstance
 
 /**
  * The group's own profile, reached from the info card at the head of its transcript.
  *
- * Driven by the conversation's [ChatViewModel] rather than one of its own: everything on this
- * screen — the title, the picture, the member count, the membership the leave clears — is state the
- * transcript is already holding and keeping current from the roster. A second view model would
- * mean a second copy going stale behind this one.
+ * Driven by the conversation's [ChatViewModel] rather than one of its own: the title, picture,
+ * rules and membership are state the transcript already holds and keeps current. What is specific
+ * to this screen (who is chatting, the pinned action's standing, the names of the tokens the rules
+ * ask for) is loaded or derived there too, keyed off [ChatViewModel.Event.GroupProfileOpened].
  */
 @Composable
 internal fun GroupProfileScreen(viewModel: ChatViewModel) {
@@ -68,242 +91,317 @@ internal fun GroupProfileScreen(viewModel: ChatViewModel) {
     val navigator = LocalCodeNavigator.current
     val state by viewModel.stateFlow.collectAsStateWithLifecycle()
     val group = state.subject as? ChatSubject.Group
+    val isMember = group?.isMember == true
+
+    // Each time the screen is entered, not once per flow: the view model outlives this screen, and
+    // who is chatting moves between visits.
+    LaunchedEffect(viewModel, state.chatId) {
+        if (state.chatId != null) viewModel.dispatchEvent(ChatViewModel.Event.GroupProfileOpened)
+    }
 
     // Leaving exits the whole chat flow rather than popping this screen, landing back on the chat
     // list: a group you have left is not a conversation you are still in, and closing to the
     // transcript would leave you reading it from behind the gate you just put yourself outside of.
-    // Same exit the profile's block action takes, for the same reason — FlowHost.onExit pops the
-    // Chat route.
+    // FlowHost.onExit pops the Chat route.
     LaunchedEffect(viewModel) {
         viewModel.eventFlow
             .filterIsInstance<ChatViewModel.Event.LeftChat>()
             .collect { flowNavigator.exitCanceled() }
     }
 
-    CodeScaffold(
-        topBar = {
-            AppBarWithTitle(
-                onBackIconClicked = { flowNavigator.back() },
-                endContent = {
-                    GroupProfileOverflow(
-                        // Server-computed, and absent entirely for a non-member, so an
-                        // unresolved viewer state reads as "may not edit" rather than as a
-                        // permission to be re-derived here.
-                        canEdit = state.viewerState?.permissions?.canEdit == true,
-                        onAction = { action ->
-                            when (action) {
-                                GroupProfileAction.Edit ->
-                                    flowNavigator.navigateTo(ChatStep.EditGroup)
-                                // The overflow carries the edit row alone; the rest of
-                                // [GroupProfileAction] is the list's.
-                                else -> Unit
-                            }
-                        },
-                    )
-                },
-            )
-        },
-        bottomBar = {
-            E2eeFooter(
-                isEncrypted = false,
-                onLearnMore = { navigator.push(AppRoute.Messaging.E2eeGroupInfo) },
-            )
-        },
-    ) { innerPadding ->
-        MenuList(
+    // A join that went through lands on the chat, which is the screen underneath.
+    // The success flag is sticky on the view model, so only a join started from this screen counts:
+    // someone who joined from the gate and opens the profile afterwards must not be bounced.
+    var joinedHere by remember { mutableStateOf(false) }
+    LaunchedEffect(state.joinProgress.loading) {
+        if (state.joinProgress.loading) joinedHere = true
+    }
+    LaunchedEffect(state.joinProgress.success, joinedHere) {
+        if (state.joinProgress.success && joinedHere) flowNavigator.back()
+    }
+
+    val standing = state.profileStanding
+    val cta = standing?.cta ?: GroupProfileCta.None
+    val requirements = remember(group?.rules) { GroupBalanceRequirements.from(group?.rules) }
+    val tokens = state.ruleTokens
+
+    var menuOpen by remember { mutableStateOf(false) }
+    var pinnedHeight by remember { mutableStateOf(0.dp) }
+    val hasPinned = cta != GroupProfileCta.None || isMember
+    val clearance = if (hasPinned) pinnedHeight else 0.dp
+    val hazeState = rememberHazeState()
+
+    CodeScaffold { padding ->
+        Box(
             modifier = Modifier
                 .fillMaxSize()
-                .padding(innerPadding),
-            // Every other row is for members only: a non-member has no link to hand out, nothing
-            // to leave, and no viewer state on a chat they are not in. Membership comes from the
-            // roster rather than from the gate, so the rows go away the moment the leave itself
-            // lands, not when the balance rule next re-decides.
-            //
-            // Reporting is the exception, and deliberately so: a group you have already left is
-            // the one you are most likely to report.
-            items = buildList<MenuItem<GroupProfileAction>> {
-                if (state.groupInviteUrl != null) add(InviteToGroup)
-                if (group?.isMember == true) add(MuteChat)
-                add(ReportGroup)
-                if (group?.isMember == true) add(LeaveChat)
-            },
-            header = {
-                GroupProfileHeader(
-                    group = group,
-                    viewerState = state.viewerState,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        // The gap under the header is the header's own, because MenuList puts
-                        // nothing between its header slot and the first row. 40dp matches what
-                        // iOS spends here (its 16pt stack spacing plus the row block's 24pt top
-                        // inset); without it the mute chip sits against the first row and the
-                        // screen reads as one block rather than a title above a list.
-                        .padding(
-                            top = CodeTheme.dimens.grid.x7,
-                            bottom = CodeTheme.dimens.grid.x8,
-                        ),
-                )
-            },
-            onItemClick = { item ->
-                when (item.action) {
-                    // The same sheet the transcript's own invite CTA opens, pushed on this flow so
-                    // it sits over the profile the user asked from.
-                    GroupProfileAction.Invite -> {
-                        viewModel.dispatchEvent(
-                            ChatViewModel.Event.InviteSheetOpened(GroupInviteSheetSource.PROFILE)
+                .padding(padding),
+        ) {
+            val scrollState = rememberScrollState()
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    // The page fades out under the app bar and into the pinned bar, as on iOS.
+                    .verticalScrollStateGradient(
+                        scrollState = scrollState,
+                        showAtEnd = hasPinned,
+                        startInset = WindowInsets.statusBars.asPaddingValues().calculateTopPadding(),
+                        endInset = clearance,
+                    )
+                    .verticalScroll(scrollState)
+                    .padding(bottom = clearance),
+            ) {
+                ProfileHeader(
+                    modifier = Modifier.hazeSource(hazeState),
+                    cover = group?.coverPicture,
+                    access = group?.let { BlobAccessContext.ChatProfile(it.chatId) } ?: BlobAccessContext.Owned,
+                    avatar = { modifier ->
+                        ChatSubjectAvatar(subject = group, modifier = modifier)
+                    },
+                    title = group?.title.orEmpty(),
+                    // No member count under the name; the avatar row and body carry the group.
+                    subtitle = null,
+                    body = group?.description?.takeIf { it.isNotBlank() },
+                    onCover = {
+                        val mutedLabel = rememberMutedLabel(state.viewerState)
+                        if (isMember && mutedLabel != null) {
+                            // On the cover's bottom edge so a late mute state never shifts the
+                            // header, and the action row keeps its width for Edit Group and Share.
+                            ProfileStatusChip(
+                                modifier = Modifier.weight(1f, fill = false),
+                                overCover = true,
+                                icon = Icons.Outlined.NotificationsOff,
+                                text = mutedLabel,
+                                compactText = stringResource(R.string.label_muted),
+                            )
+                        }
+                    },
+                    actions = {
+                        // Server-computed, and absent for a non-member, so an unresolved viewer
+                        // state reads as "may not edit" rather than a permission re-derived here.
+                        if (state.viewerState?.permissions?.canEdit == true) {
+                            ProfileActionButton(
+                                text = stringResource(R.string.title_editGroup),
+                                onClick = { flowNavigator.navigateTo(ChatStep.EditGroup) },
+                            )
+                        }
+                        // Always offered: the link is the chat's id, so a non-member can hand it
+                        // out as well as a member can.
+                        ProfileActionButton(
+                            icon = ImageVector.vectorResource(R.drawable.ic_share_os),
+                            contentDescription = stringResource(R.string.action_share),
+                            onClick = {
+                                viewModel.dispatchEvent(
+                                    ChatViewModel.Event.InviteSheetOpened(GroupInviteSheetSource.PROFILE)
+                                )
+                                navigator.openGroupInvite()
+                            },
                         )
-                        navigator.openGroupInvite()
-                    }
-                    // Both muting and unmuting go through the picker, which is why this row
-                    // navigates either way rather than acting on one of them here. The outer
-                    // navigator, as with Report: the sheet is a top-level route shared with the
-                    // chat list, so it opens over the chat rather than inside it.
-                    GroupProfileAction.Mute -> state.chatId?.let { chatId ->
-                        navigator.push(AppRoute.Messaging.MuteChat(chatId, ChatType.GROUP))
-                    }
-                    GroupProfileAction.Leave ->
-                        viewModel.dispatchEvent(ChatViewModel.Event.LeaveChat)
-                    // The outer navigator, not this flow's: reporting is its own top-level
-                    // route, so it opens over the chat rather than inside it.
-                    GroupProfileAction.Report -> state.chatId?.let { chatId ->
-                        navigator.push(
-                            AppRoute.Messaging.Report(ReportSubject.Chat(chatId))
+                    },
+                )
+
+                val unknownName = stringResource(R.string.title_unnamedUser)
+                val chatters = remember(state.chatters, unknownName) {
+                    state.chatters.mapNotNull { chatter ->
+                        val profile = chatter.userProfile
+                        val userId = profile.userId ?: return@mapNotNull null
+                        ChattingGridItem(
+                            userId = userId,
+                            name = chatterName(profile.displayName, profile.username, unknownName),
+                            picture = profile.profilePicture,
+                            isHost = chatter.isCreator,
                         )
                     }
-                    // Edit is an overflow row, not a body row, so this arm is unreachable today.
-                    // It routes to the same step the overflow does so that "what Edit means" has
-                    // one definition, rather than going stale if the row ever moves into the body.
-                    GroupProfileAction.Edit -> flowNavigator.navigateTo(ChatStep.EditGroup)
                 }
-            },
-        )
-    }
-}
-
-/**
- * The overflow row's leading glyph, matching `ListItem`'s, so the one row inside the menu and the
- * rows on the screen behind it line their icons up at the same size.
- */
-private val OverflowIconSize = 24.dp
+                if (group != null && isChattingGridVisible(group.isPrivate, state.chatters)) {
+                    GroupChattingGrid(
+                        modifier = Modifier
+                            .padding(horizontal = CodeTheme.dimens.inset)
+                            .padding(top = CodeTheme.dimens.staticGrid.x6),
+                        chatters = chatters,
+                        onOpen = { item ->
+                            val chatter = state.chatters.firstOrNull { it.userProfile.userId == item.userId }
+                                ?: return@GroupChattingGrid
+                            // Straight to the person's profile: resolving a DM destination first
+                            // would send a tap on a portrait to a chat.
+                            flowNavigator.navigateTo(
+                                ChatStep.Profile(
+                                    contact = ChatParticipant.TipUser(item.userId, chatter.userProfile),
+                                    origin = ProfileOrigin.GroupMember,
+                                )
+                            )
+                        },
+                    )
+                }
 
-/**
- * The profile's top-right overflow — one row, Edit, and only for a viewer who may use it.
- *
- * Draws nothing at all when the list is empty rather than a disabled button: an overflow that
- * opens on nothing is worse than no overflow, and `canEdit` is stable for the life of the screen
- * in every case but a permission being revoked under it.
- *
- * Surface colour and corner are the message long-press menu's, from `ChatTopBar.MessageOverflow`,
- * so the two menus in this feature read as one control. The vertical placement is not: this one
- * opens *over* its button the way Chrome's toolbar overflow does, rather than below it. A menu
- * dropped clear of a top-right button pushes its first row toward the middle of the screen and
- * leaves the button stranded above it; covering the button puts the row where the thumb already
- * is. `ChatTopBar`'s menu still drops below, which is the remaining inconsistency.
- *
- * The row is icon-led for the same reason the rows below it are. `DropdownMenu` is laid out to a
- * 112dp minimum width, which a label as short as "Edit" leaves more than half empty; the glyph
- * fills the leading space the trailing space is measured against, so the menu reads as a row
- * rather than as a blank rounded rectangle with a word in the corner.
- */
-@Composable
-private fun GroupProfileOverflow(
-    canEdit: Boolean,
-    onAction: (GroupProfileAction) -> Unit,
-) {
-    val items = groupProfileOverflowItems(canEdit)
-    if (items.isEmpty()) return
+                if (requirements != null) {
+                    BalanceRequirementsCard(
+                        modifier = Modifier
+                            .padding(horizontal = CodeTheme.dimens.inset)
+                            .padding(top = CodeTheme.dimens.staticGrid.x6),
+                        join = requirements.join?.let { holdingLabel(it, tokens) },
+                        chat = requirements.chat?.let { holdingLabel(it, tokens) },
+                        yourBalance = (requirements.join ?: requirements.chat)?.let { rule ->
+                            standing?.yourBalance?.let { holdingLabel(it, rule.mints.firstOrNull()?.let { m -> Mint(m.bytes) }, tokens) }
+                        },
+                    )
+                }
+                Box(modifier = Modifier.padding(bottom = CodeTheme.dimens.staticGrid.x6))
+            }
 
-    var expanded by remember { mutableStateOf(false) }
-    // Measured rather than assumed: `AppBarDefaults.Overflow` sizes its own circle, so the pull-up
-    // that lands the menu's top edge on the button's top has to come from the anchor itself.
-    var anchorHeight by remember { mutableStateOf(0.dp) }
-    val density = LocalDensity.current
-    Box(modifier = Modifier.onSizeChanged { anchorHeight = with(density) { it.height.toDp() } }) {
-        AppBarDefaults.Overflow(
-            modifier = Modifier.testTag("action_group_profile_overflow"),
-            onClick = { expanded = true },
-        )
-        DropdownMenu(
-            expanded = expanded,
-            containerColor = CodeTheme.colors.brandLight,
-            shape = CodeTheme.shapes.extraLarge,
-            offset = DpOffset(x = 0.dp, y = -anchorHeight),
-            onDismissRequest = { expanded = false },
-        ) {
-            items.forEach { item ->
-                DropdownMenuItem(
-                    modifier = Modifier.testTag("action_edit_group"),
-                    leadingIcon = {
-                        Image(
-                            modifier = Modifier.size(OverflowIconSize),
-                            painter = item.icon,
-                            colorFilter = ColorFilter.tint(CodeTheme.colors.textMain),
-                            contentDescription = null,
-                        )
-                    },
-                    text = {
-                        Text(
-                            text = item.name,
-                            style = CodeTheme.typography.textSmall,
-                            color = CodeTheme.colors.textMain,
+            AppBarWithTitle(
+                onBackIconClicked = { flowNavigator.back() },
+                hazeState = hazeState,
+                endContent = {
+                    val density = LocalDensity.current
+                    var anchorHeight by remember { mutableStateOf(0.dp) }
+                    Box(modifier = Modifier.onSizeChanged { anchorHeight = with(density) { it.height.toDp() } }) {
+                        CircularIconButton(hazeState = hazeState, onClick = { menuOpen = true }) { size ->
+                            Icon(
+                                imageVector = Icons.Rounded.MoreVert,
+                                contentDescription = stringResource(R.string.action_moreProfileActions),
+                                tint = Color.White,
+                                modifier = Modifier.requiredSize(size),
+                            )
+                        }
+                        GroupProfileMenu(
+                            expanded = menuOpen,
+                            items = groupProfileMenuActions(isMember),
+                            anchorHeight = anchorHeight,
+                            onDismiss = { menuOpen = false },
+                            onItem = { item ->
+                                when (item) {
+                                    GroupProfileMenuAction.Encryption ->
+                                        navigator.push(AppRoute.Messaging.E2eeGroupInfo)
+                                    // The picker handles muting and unmuting both; pushed on the
+                                    // outer navigator, as it is a top-level route.
+                                    GroupProfileMenuAction.Mute -> state.chatId?.let { chatId ->
+                                        navigator.push(AppRoute.Messaging.MuteChat(chatId, ChatType.GROUP))
+                                    }
+                                    GroupProfileMenuAction.Report -> state.chatId?.let { chatId ->
+                                        navigator.push(AppRoute.Messaging.Report(ReportSubject.Chat(chatId)))
+                                    }
+                                }
+                            },
                         )
+                    }
+                },
+            )
+
+            if (hasPinned) {
+                val bar = (cta as? GroupProfileCta.BuyToJoin)?.requirement
+                    ?: (cta as? GroupProfileCta.BuyToChat)?.requirement
+                val buyMint = bar?.mints?.firstOrNull()?.let { Mint(it.bytes) }?.takeUnless { it == Mint.usdf }
+                val shortfall = (standing?.shortfall ?: bar?.amount)?.formatted(Fiat.FormattingRule.Truncated)
+                val isJoin = cta is GroupProfileCta.BuyToJoin
+
+                ProfilePinnedActionBar(
+                    modifier = Modifier.align(Alignment.BottomCenter),
+                    text = when (cta) {
+                        GroupProfileCta.Join -> stringResource(R.string.action_join)
+                        GroupProfileCta.OpenChat, GroupProfileCta.None -> stringResource(R.string.action_openChat)
+                        is GroupProfileCta.BuyToJoin -> stringResource(R.string.action_buyToJoin, shortfall.orEmpty())
+                        is GroupProfileCta.BuyToChat -> stringResource(R.string.action_buyToChat, shortfall.orEmpty())
                     },
+                    // A member whose standing has not arrived has nothing to open yet.
+                    enabled = cta != GroupProfileCta.None && !state.joinProgress.loading,
+                    isLoading = state.joinProgress.loading,
                     onClick = {
-                        expanded = false
-                        onAction(item.action)
+                        when (cta) {
+                            GroupProfileCta.Join -> viewModel.dispatchEvent(ChatViewModel.Event.JoinChat)
+                            GroupProfileCta.OpenChat -> flowNavigator.back()
+                            is GroupProfileCta.BuyToJoin, is GroupProfileCta.BuyToChat -> {
+                                if (buyMint == null) {
+                                    viewModel.dispatchEvent(ChatViewModel.Event.GateFundingTapped(GroupGateFunding.ADD_CASH))
+                                    viewModel.dispatchEvent(ChatViewModel.Event.PresentDepositOptions)
+                                } else {
+                                    viewModel.dispatchEvent(ChatViewModel.Event.GateFundingTapped(GroupGateFunding.BUY_TOKEN))
+                                    navigator.push(AppRoute.Token.Info(buyMint, TokenInfoEntry.ChatGate))
+                                }
+                            }
+                            GroupProfileCta.None -> Unit
+                        }
                     },
+                    above = if (bar != null) {
+                        {
+                            Text(
+                                modifier = Modifier.padding(bottom = CodeTheme.dimens.staticGrid.x2),
+                                text = stringResource(
+                                    if (isJoin) R.string.label_groupRequiredToJoin else R.string.label_groupRequiredToChat,
+                                    holdingLabel(bar, tokens),
+                                ),
+                                style = CodeTheme.typography.textSmall,
+                                color = CodeTheme.colors.textSecondary,
+                            )
+                        }
+                    } else null,
+                    secondaryText = if (isMember) stringResource(R.string.action_leaveChat) else null,
+                    onSecondaryClick = { viewModel.dispatchEvent(ChatViewModel.Event.LeaveChat) },
+                    isSecondaryLoading = state.leaving,
+                    onHeightChanged = { pinnedHeight = it },
                 )
             }
         }
     }
 }
 
-@VisibleForTesting
+/**
+ * A rule's amount as the profile writes it: "$10", "$2.50", and "$10 of NYC" for a token other
+ * than USDF whose name is known. A rule naming no mint, or the reserve, states the amount alone.
+ */
 @Composable
-internal fun GroupProfileHeader(
-    group: ChatSubject.Group?,
-    modifier: Modifier = Modifier,
-    viewerState: ViewerState? = null,
+private fun holdingLabel(
+    rule: ChatRuleRequirement.MinimumBalance,
+    tokens: Map<List<Byte>, com.flipcash.app.messenger.internal.RuleCurrency>,
+): String = holdingLabel(rule.amount, rule.mints.firstOrNull()?.let { Mint(it.bytes) }, tokens)
+
+@Composable
+private fun holdingLabel(
+    amount: Fiat,
+    mint: Mint?,
+    tokens: Map<List<Byte>, com.flipcash.app.messenger.internal.RuleCurrency>,
+): String {
+    val formatted = amount.formatted(Fiat.FormattingRule.Truncated)
+    val name = mint?.takeUnless { it == Mint.usdf }?.let { tokens[it.bytes] }?.name
+        ?: return formatted
+    return stringResource(R.string.label_chat_preview_cash_suffix, formatted, name)
+}
+
+/** The ⋯ button's menu: Encryption and Mute, then a divider and the red Report. */
+@Composable
+private fun GroupProfileMenu(
+    expanded: Boolean,
+    items: List<GroupProfileMenuAction>,
+    anchorHeight: androidx.compose.ui.unit.Dp,
+    onDismiss: () -> Unit,
+    onItem: (GroupProfileMenuAction) -> Unit,
 ) {
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally,
+    DropdownMenu(
+        expanded = expanded,
+        onDismissRequest = onDismiss,
+        containerColor = CodeTheme.colors.brandLight,
+        shape = CodeTheme.shapes.extraLarge,
+        offset = DpOffset(x = 0.dp, y = -anchorHeight),
     ) {
-        ChatSubjectAvatar(
-            subject = group,
-            modifier = Modifier
-                .size(CodeTheme.dimens.staticGrid.x17)
-                .clip(CircleShape),
-        )
-        Text(
-            // Wider than the 5dp that binds the identity lines below it, so the name reads as the
-            // start of that block rather than as another line of the picture.
-            modifier = Modifier.padding(top = CodeTheme.dimens.grid.x3),
-            text = group?.title.orEmpty(),
-            style = CodeTheme.typography.textLarge,
-            color = CodeTheme.colors.textMain,
-            maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
-        )
-        // The size stands where a person's handle does: it is the one thing a group is identified
-        // by beyond its name, and it is what a join or a leave changes.
-        if (group != null) {
-            Text(
-                modifier = Modifier.padding(top = CodeTheme.dimens.grid.x1),
-                text = pluralStringResource(
-                    R.plurals.subtitle_chatMemberCount,
-                    group.memberCount.toInt(),
-                    group.memberCount.toString(),
-                ),
-                style = CodeTheme.typography.textSmall,
-                color = CodeTheme.colors.textSecondary,
+        items.forEachIndexed { index, item ->
+            if (index > 0 && items[index - 1].isDestructive != item.isDestructive) {
+                HorizontalDivider(color = CodeTheme.colors.divider)
+            }
+            val tint = if (item.isDestructive) CodeTheme.colors.errorText else CodeTheme.colors.textMain
+            DropdownMenuItem(
+                leadingIcon = { Icon(imageVector = item.icon(), contentDescription = null, tint = tint) },
+                text = {
+                    Text(
+                        text = stringResource(item.labelRes()),
+                        style = CodeTheme.typography.textSmall,
+                        color = tint,
+                    )
+                },
+                onClick = {
+                    onDismiss()
+                    onItem(item)
+                },
             )
         }
-        // Last, because it is the only line here that is the viewer's setting rather than a fact
-        // about the group, and the only one that can stop being true while the screen is open.
-        ChatMuteStatusChip(
-            viewerState = viewerState,
-            modifier = Modifier.padding(top = CodeTheme.dimens.grid.x2),
-        )
     }
 }
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileState.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileState.kt
new file mode 100644
index 0000000000..2a26104fd5
--- /dev/null
+++ b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileState.kt
@@ -0,0 +1,190 @@
+package com.flipcash.app.messenger.internal.screens.profile
+
+import com.flipcash.services.models.chat.ChatRuleRequirement
+import com.flipcash.services.models.chat.ChatRules
+import com.flipcash.services.models.chat.SampledChatter
+import com.flipcash.shared.chat.GroupAccess
+import com.flipcash.shared.chat.heldAgainst
+import com.flipcash.shared.chat.unmetRequirements
+import com.flipcash.shared.chat.usdValue
+import com.getcode.opencode.model.core.ID
+import com.getcode.opencode.internal.extensions.fractionDigits
+import com.getcode.opencode.model.financial.CurrencyCode
+import com.getcode.opencode.model.financial.Fiat
+import com.getcode.opencode.model.financial.Rate
+import com.getcode.opencode.model.financial.TokenWithBalance
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+/**
+ * The one action pinned to the bottom of a group's profile.
+ *
+ * Mirrors iOS's `GroupProfileCTA`. Resolved from membership and the unmet rules rather than from
+ * the transcript's gate, because the two answer different questions: the gate decides what the
+ * transcript may show, this decides what the viewer can do next from here.
+ */
+internal sealed interface GroupProfileCta {
+    /** Nothing to offer: the answer is not known yet, or the bar is not one a viewer can clear. */
+    data object None : GroupProfileCta
+    data object Join : GroupProfileCta
+    data object OpenChat : GroupProfileCta
+
+    /** Not a member, and short of the join minimum. */
+    data class BuyToJoin(val requirement: ChatRuleRequirement.MinimumBalance) : GroupProfileCta
+
+    /** A member, and short of the minimum that lets them speak. */
+    data class BuyToChat(val requirement: ChatRuleRequirement.MinimumBalance) : GroupProfileCta
+
+    companion object {
+        /**
+         * @param access what the listener gate says; [GroupAccess.Undetermined] is iOS's
+         * `isProvisional`, a guess that offers nothing until a rate arrives.
+         * @param unmet every unmet rule in the order [unmetRequirements] lists them: listener rules
+         * first, then speaker rules.
+         */
+        fun resolve(
+            isMember: Boolean,
+            access: GroupAccess,
+            unmet: List<ChatRuleRequirement>,
+        ): GroupProfileCta {
+            if (isMember) {
+                // The last minimum, not the first: the speaker rules come after the listener ones,
+                // so it is the chat minimum, and it is the larger bar when both are unmet. A
+                // member under only the join minimum is told to buy to chat, as on iOS. A chat
+                // that is read-only, staff-only or creator-only has nothing to buy, so it opens.
+                val minimum = unmet.filterIsInstance<ChatRuleRequirement.MinimumBalance>().lastOrNull()
+                return if (minimum != null) BuyToChat(minimum) else OpenChat
+            }
+            return when (access) {
+                GroupAccess.Undetermined -> None
+                GroupAccess.Eligible, GroupAccess.Membered -> Join
+                is GroupAccess.Blocked -> {
+                    val minimum = access.unmet as? ChatRuleRequirement.MinimumBalance
+                    if (minimum != null) BuyToJoin(minimum) else None
+                }
+            }
+        }
+    }
+}
+
+/**
+ * The balance a group asks for, as the two rows the profile shows. Null when there is no minimum
+ * to show on either row.
+ *
+ * Only the first minimum of each list counts; staff, never and creator rules have no amount.
+ * [chat] falls back to [join] when no speaker minimum is set, because the server treats the
+ * listener rules as the speaker rules then. A chat-only minimum leaves [join] null.
+ */
+internal data class GroupBalanceRequirements(
+    val join: ChatRuleRequirement.MinimumBalance?,
+    val chat: ChatRuleRequirement.MinimumBalance?,
+) {
+    companion object {
+        fun from(rules: ChatRules?): GroupBalanceRequirements? {
+            val join = rules?.listener.orEmpty()
+                .filterIsInstance<ChatRuleRequirement.MinimumBalance>().firstOrNull()
+            val speaker = rules?.speaker.orEmpty()
+                .filterIsInstance<ChatRuleRequirement.MinimumBalance>().firstOrNull()
+            if (join == null && speaker == null) return null
+            return GroupBalanceRequirements(join = join, chat = speaker ?: join)
+        }
+    }
+}
+
+/**
+ * What the viewer still needs to buy to meet [requirement], in the requirement's own currency, or
+ * null when they already meet it or when the requirement cannot be restated (no rate for its
+ * currency). A null falls back to showing the full requirement.
+ *
+ * Compared in USD at display precision, as the gate does: the held side is rounded half-up to
+ * cents. A holding of the named mint counts alone; a requirement naming no mint is measured
+ * against everything held. The result is rounded up to the currency's smallest unit, so a buy of
+ * exactly this much clears the bar.
+ */
+internal fun balanceShortfall(
+    requirement: ChatRuleRequirement.MinimumBalance,
+    balances: List<TokenWithBalance>,
+    rates: Map<CurrencyCode, Rate>,
+): Fiat? {
+    val required = requirement.amount.usdValue(rates) ?: return null
+    val held = heldAgainst(requirement.mints, balances)?.toDouble() ?: 0.0
+    if (held >= required) return null
+    val shortUsd = BigDecimal.valueOf(required).subtract(BigDecimal.valueOf(held))
+        .setScale(MICRO_SCALE, RoundingMode.HALF_UP)
+    val currency = requirement.amount.currencyCode
+    val short = if (currency == CurrencyCode.USD) {
+        shortUsd
+    } else {
+        val fx = rates[currency]?.takeIf { it.isUsable() }?.fx?.takeIf { it > 0.0 } ?: return null
+        shortUsd.multiply(BigDecimal.valueOf(fx)).setScale(MICRO_SCALE, RoundingMode.HALF_UP)
+    }
+    return Fiat(fiat = short.setScale(currency.fractionDigits, RoundingMode.CEILING).toDouble(), currencyCode = currency)
+}
+
+/**
+ * The "Your Balance" line: what the viewer holds toward the join minimum (the chat minimum when
+ * there is none), in that requirement's currency. Null when it cannot be stated, which is a
+ * requirement in a currency with no rate.
+ *
+ * Measured by [heldAgainst], the same measurement the gate uses.
+ */
+internal fun yourBalance(
+    requirements: GroupBalanceRequirements,
+    balances: List<TokenWithBalance>,
+    rates: Map<CurrencyCode, Rate>,
+): Fiat? {
+    val rule = requirements.join ?: requirements.chat ?: return null
+    val heldUsd = (heldAgainst(rule.mints, balances) ?: Fiat.Zero).toDouble()
+    val currency = rule.amount.currencyCode
+    val value = if (currency == CurrencyCode.USD) {
+        heldUsd
+    } else {
+        val fx = rates[currency]?.takeIf { it.isUsable() }?.fx?.takeIf { it > 0.0 } ?: return null
+        heldUsd * fx
+    }
+    return Fiat(fiat = value, currencyCode = currency).rounded(currency.fractionDigits)
+}
+
+/** The Chatting section: only for a public group with someone to show. */
+internal fun isChattingGridVisible(isPrivate: Boolean, chatters: List<SampledChatter>): Boolean =
+    !isPrivate && chatters.isNotEmpty()
+
+/**
+ * The profile's pinned action and the figures behind it, decided together so they are re-decided
+ * together when a balance or rate moves.
+ */
+internal data class GroupProfileStanding(
+    val cta: GroupProfileCta,
+    /** The shortfall a buy CTA names; null falls back to the requirement's full amount. */
+    val shortfall: Fiat?,
+    /** The "Your Balance" line, when it can be stated. */
+    val yourBalance: Fiat?,
+) {
+    companion object {
+        fun of(
+            isMember: Boolean,
+            rules: ChatRules?,
+            balances: List<TokenWithBalance>,
+            isStaff: Boolean,
+            rates: Map<CurrencyCode, Rate>,
+            viewerId: ID?,
+            creatorId: ID?,
+        ): GroupProfileStanding {
+            val access = GroupAccess.evaluate(isMember, rules, balances, isStaff, rates)
+            val unmet = unmetRequirements(rules, balances, isStaff, viewerId, creatorId, rates)
+            val cta = GroupProfileCta.resolve(isMember, access, unmet)
+            val bar = when (cta) {
+                is GroupProfileCta.BuyToJoin -> cta.requirement
+                is GroupProfileCta.BuyToChat -> cta.requirement
+                else -> null
+            }
+            return GroupProfileStanding(
+                cta = cta,
+                shortfall = bar?.let { balanceShortfall(it, balances, rates) },
+                yourBalance = GroupBalanceRequirements.from(rules)?.let { yourBalance(it, balances, rates) },
+            )
+        }
+    }
+}
+
+private const val MICRO_SCALE = 6
diff --git a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/MuteMenuItems.kt b/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/MuteMenuItems.kt
deleted file mode 100644
index c2a453a624..0000000000
--- a/apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/screens/profile/MuteMenuItems.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.flipcash.app.messenger.internal.screens.profile
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.NotificationsOff
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.painter.Painter
-import androidx.compose.ui.graphics.vector.rememberVectorPainter
-import androidx.compose.ui.res.stringResource
-import com.flipcash.app.menu.FullMenuItem
-import com.flipcash.features.messenger.R
-
-/**
- * The row that opens the duration picker.
- *
- * Generic over the action because the two profiles that offer it — a group's and a DM's — name
- * their own actions, and a [com.flipcash.app.menu.MenuItem] carries one action type. Muting is the
- * same thing on both, so it is one row definition rather than two that can drift apart; what
- * differs is only what the screen does with the tap.
- *
- * One row, reading the same either way, whether or not the chat is currently muted: the picker it
- * opens is where unmuting lives too. A row that became "Unmute Notifications" under the tap that
- * muted the chat read as a missed tap — the words under the finger had turned into the opposite of
- * what was just chosen — and it left the row with nowhere to say *until when*. What the mute
- * currently is belongs to [com.flipcash.app.messenger.internal.ChatMuteStatusChip], under the
- * profile's title.
- *
- * Declare instances as top-level `val`s, naming the action type explicitly. [FullMenuItem] mints an
- * id per instance, so one built inside a composition would get a new one on every recomposition;
- * and inference off a `data object` argument picks that object's own type rather than the sealed
- * interface the menu is typed on.
- */
-internal class MuteChatItem<T>(override val action: T) : FullMenuItem<T>() {
-    override val icon: Painter
-        @Composable get() = rememberVectorPainter(Icons.Outlined.NotificationsOff)
-
-    override val name: String
-        @Composable get() = stringResource(R.string.title_muteChat)
-}
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupAnalyticsTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupAnalyticsTest.kt
index b8bc35f42c..ab4a7cfaf2 100644
--- a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupAnalyticsTest.kt
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupAnalyticsTest.kt
@@ -79,6 +79,7 @@ class ChatGroupAnalyticsTest {
     var mainCoroutineRule = MainCoroutineRule(UnconfinedTestDispatcher())
 
     private val chatCoordinator = mockk<ChatCoordinator>(relaxed = true) {
+        coEvery { sampleChatters(any()) } returns Result.failure(IllegalStateException("not sampled"))
         every { observeMediaSendProgress() } returns kotlinx.coroutines.flow.emptyFlow()
     }
     private val contactCoordinator = mockk<ContactCoordinator>(relaxed = true)
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupCashLinkTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupCashLinkTest.kt
index eb87f30dac..6f28e9d224 100644
--- a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupCashLinkTest.kt
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatGroupCashLinkTest.kt
@@ -76,6 +76,7 @@ class ChatGroupCashLinkTest {
     var mainCoroutineRule = MainCoroutineRule(UnconfinedTestDispatcher())
 
     private val chatCoordinator = mockk<ChatCoordinator>(relaxed = true) {
+        coEvery { sampleChatters(any()) } returns Result.failure(IllegalStateException("not sampled"))
         every { observeMediaSendProgress() } returns kotlinx.coroutines.flow.emptyFlow()
     }
     private val contactCoordinator = mockk<ContactCoordinator>(relaxed = true)
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatMentionPickerTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatMentionPickerTest.kt
index 5c65accd49..7daa38ca81 100644
--- a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatMentionPickerTest.kt
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatMentionPickerTest.kt
@@ -58,6 +58,7 @@ class ChatMentionPickerTest {
     var mainCoroutineRule = MainCoroutineRule(UnconfinedTestDispatcher())
 
     private val chatCoordinator = mockk<ChatCoordinator>(relaxed = true) {
+        coEvery { sampleChatters(any()) } returns Result.failure(IllegalStateException("not sampled"))
         every { observeMediaSendProgress() } returns kotlinx.coroutines.flow.emptyFlow()
     }
     private val userManager = mockk<UserManager>(relaxed = true)
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/E2eeScreenshotTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/E2eeScreenshotTest.kt
index 718746f8d3..89a7c2a7f4 100644
--- a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/E2eeScreenshotTest.kt
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/E2eeScreenshotTest.kt
@@ -4,31 +4,17 @@ import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.view.View
 import androidx.activity.ComponentActivity
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Icon
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import com.flipcash.app.core.chat.ChatParticipant
-import com.flipcash.app.menu.MenuList
 import com.flipcash.app.messenger.internal.screens.E2eeLearnMoreSheet
 import com.flipcash.app.messenger.internal.screens.E2eeSheetKind
-import com.flipcash.app.messenger.internal.screens.profile.E2eeFooter
-import com.flipcash.app.messenger.internal.screens.profile.GroupProfileHeader
-import com.flipcash.app.messenger.internal.screens.profile.InviteToGroup
-import com.flipcash.app.messenger.internal.screens.profile.LeaveChat
-import com.flipcash.app.messenger.internal.screens.profile.MuteChat
-import com.flipcash.app.messenger.internal.screens.profile.ReportGroup
 import com.flipcash.app.theme.FlipcashPreview
 import com.flipcash.features.messenger.R
 import com.flipcash.services.models.UserProfile
-import com.flipcash.services.models.chat.ChatId
-import com.getcode.theme.CodeTheme
-import com.getcode.ui.components.AppBarWithTitle
-import com.getcode.ui.theme.CodeScaffold
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -39,7 +25,7 @@ import java.io.File
 
 /**
  * Renders the end-to-end encryption surfaces to PNGs for comparison with the design: the DM
- * profile with its footer on, Group Info, and both learn-more sheets. Not an assertion test — it
+ * profile with its footer on and both learn-more sheets. Not an assertion test — it
  * writes to `build/screenshots/`, with the same mechanics as `ChatIdentityScreenshotTest`.
  *
  * The profiles are assembled from the screens' own pieces rather than the screens themselves,
@@ -53,36 +39,6 @@ class E2eeScreenshotTest {
     @get:Rule
     val composeRule = createAndroidComposeRule<ComponentActivity>()
 
-    @Test
-    fun rendersGroupInfo() = render("e2ee_group_info.png") {
-        val group = ChatSubject.Group(
-            chatId = ChatId(listOf(1.toByte())),
-            groupTitle = "Ballers",
-            picture = null,
-            memberCount = 3,
-            rules = null,
-            isMember = true,
-        )
-        CodeScaffold(
-            topBar = { AppBarWithTitle(onBackIconClicked = {}) },
-            bottomBar = { E2eeFooter(isEncrypted = false, onLearnMore = {}) },
-        ) { innerPadding ->
-            MenuList(
-                modifier = Modifier.fillMaxSize().padding(innerPadding),
-                items = listOf(InviteToGroup, MuteChat, ReportGroup, LeaveChat),
-                header = {
-                    GroupProfileHeader(
-                        group = group,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(top = CodeTheme.dimens.grid.x7, bottom = CodeTheme.dimens.grid.x8),
-                    )
-                },
-                onItemClick = {},
-            )
-        }
-    }
-
     @Test
     fun rendersDmSheet() = render("e2ee_sheet_dm.png") {
         E2eeLearnMoreSheet(kind = E2eeSheetKind.Dm, onDismiss = {})
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileOverflowTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileOverflowTest.kt
index fb497c7152..adcd9e06ca 100644
--- a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileOverflowTest.kt
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileOverflowTest.kt
@@ -5,28 +5,36 @@ import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 /**
- * Who is offered the group's Edit row.
+ * What the group profile's overflow offers, and to whom.
  *
- * `canEdit` is computed by the server and arrives on `ViewerState.Permissions`. The reason this is
- * worth a test of its own is that several local signals — being a member, having created the chat,
- * the chat being a group at all — look like they answer the question and none of them is the
- * answer. Offering Edit on a local guess produces a row that opens a screen whose Save then comes
- * back `DENIED`, which reads to the user as the app being broken rather than as a permission.
+ * Edit moved out to its own button (shown from the server's `canEdit`, which is not a local guess
+ * about membership or creatorship), so the menu is Encryption, Mute for members, and Report.
  */
 class GroupProfileOverflowTest {
 
     @Test
-    fun `a viewer who may edit is offered exactly the Edit row`() {
-        val items = groupProfileOverflowItems(canEdit = true)
+    fun `a member is offered encryption, mute and report in that order`() {
+        assertEquals(
+            listOf(
+                GroupProfileMenuAction.Encryption,
+                GroupProfileMenuAction.Mute,
+                GroupProfileMenuAction.Report,
+            ),
+            groupProfileMenuActions(isMember = true),
+        )
+    }
 
-        assertEquals(1, items.size)
-        assertEquals(GroupProfileAction.Edit, items.single().action)
+    @Test
+    fun `a non-member is not offered mute but is offered report`() {
+        assertEquals(
+            listOf(GroupProfileMenuAction.Encryption, GroupProfileMenuAction.Report),
+            groupProfileMenuActions(isMember = false),
+        )
     }
 
     @Test
-    fun `a viewer who may not edit is offered nothing`() {
-        // Empty rather than disabled: the overflow button itself is drawn only when this has
-        // something in it, so no-permission means no button, not a button that opens an empty menu.
-        assertTrue(groupProfileOverflowItems(canEdit = false).isEmpty())
+    fun `only report is destructive`() {
+        assertTrue(GroupProfileMenuAction.Report.isDestructive)
+        assertTrue(GroupProfileMenuAction.entries.filter { it.isDestructive } == listOf(GroupProfileMenuAction.Report))
     }
 }
diff --git a/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileStateTest.kt b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileStateTest.kt
new file mode 100644
index 0000000000..2fb266d23b
--- /dev/null
+++ b/apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/screens/profile/GroupProfileStateTest.kt
@@ -0,0 +1,297 @@
+package com.flipcash.app.messenger.internal.screens.profile
+
+import com.flipcash.services.models.UserProfile
+import com.flipcash.services.models.chat.ChatRuleRequirement
+import com.flipcash.services.models.chat.ChatRules
+import com.flipcash.services.models.chat.SampledChatter
+import com.getcode.opencode.model.financial.CurrencyCode
+import com.getcode.opencode.model.financial.Fiat
+import com.getcode.opencode.model.financial.HolderMetrics
+import com.getcode.opencode.model.financial.MintMetadata
+import com.getcode.opencode.model.financial.Rate
+import com.getcode.opencode.model.financial.TokenWithBalance
+import com.getcode.opencode.model.financial.VmMetadata
+import com.getcode.solana.keys.Mint
+import com.getcode.solana.keys.PublicKey
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/** Port of iOS's `GroupProfileStateTests`. */
+class GroupProfileStateTest {
+
+    private fun mint(seed: Byte) = Mint(ByteArray(32) { seed }.toList())
+
+    private fun token(seed: Byte) = MintMetadata(
+        address = mint(seed),
+        decimals = 6,
+        name = "T$seed",
+        symbol = "T$seed",
+        createdAt = null,
+        description = "",
+        imageUrl = "",
+        vmMetadata = VmMetadata(
+            vm = PublicKey.fromBase58("11111111111111111111111111111111"),
+            authority = PublicKey.fromBase58("11111111111111111111111111111111"),
+            lockDurationInDays = 21,
+        ),
+        launchpadMetadata = null,
+        billCustomizations = null,
+        socialLinks = emptyList(),
+        holderMetrics = HolderMetrics.None,
+    )
+
+    private fun held(seed: Byte, dollars: Double) =
+        TokenWithBalance(token = token(seed), balance = Fiat(dollars))
+
+    private fun minimum(amount: Fiat, mints: List<PublicKey> = emptyList()) =
+        ChatRuleRequirement.MinimumBalance(amount, mints)
+
+    private fun minimum(dollars: Double, mints: List<PublicKey> = emptyList()) =
+        minimum(Fiat(dollars), mints)
+
+    private fun rules(
+        listener: List<ChatRuleRequirement> = emptyList(),
+        speaker: List<ChatRuleRequirement> = emptyList(),
+    ) = ChatRules(listener = listener, speaker = speaker)
+
+    private fun standing(
+        isMember: Boolean,
+        rules: ChatRules?,
+        balances: List<TokenWithBalance> = emptyList(),
+        rates: Map<CurrencyCode, Rate> = emptyMap(),
+    ) = GroupProfileStanding.of(
+        isMember = isMember,
+        rules = rules,
+        balances = balances,
+        isStaff = false,
+        rates = rates,
+        viewerId = null,
+        creatorId = null,
+    )
+
+    // CTA
+
+    @Test
+    fun `non-member short of the join minimum buys to join`() {
+        val join = minimum(10.0)
+        assertEquals(
+            GroupProfileCta.BuyToJoin(join),
+            standing(false, rules(listener = listOf(join))).cta,
+        )
+    }
+
+    @Test
+    fun `non-member who meets the join minimum joins`() {
+        assertEquals(
+            GroupProfileCta.Join,
+            standing(false, rules(listener = listOf(minimum(10.0))), listOf(held(1, 20.0))).cta,
+        )
+    }
+
+    @Test
+    fun `non-member of a group with no rules joins`() {
+        assertEquals(GroupProfileCta.Join, standing(false, null).cta)
+        assertEquals(GroupProfileCta.Join, standing(false, rules()).cta)
+    }
+
+    @Test
+    fun `non-member of a staff-only group has nothing to do`() {
+        assertEquals(
+            GroupProfileCta.None,
+            standing(false, rules(listener = listOf(ChatRuleRequirement.Staff))).cta,
+        )
+    }
+
+    @Test
+    fun `non-member with a minimum in a currency with no rate has nothing to do yet`() {
+        assertEquals(
+            GroupProfileCta.None,
+            standing(false, rules(listener = listOf(minimum(Fiat(10.0, CurrencyCode.CAD))))).cta,
+        )
+    }
+
+    @Test
+    fun `member who may speak opens the chat`() {
+        assertEquals(
+            GroupProfileCta.OpenChat,
+            standing(
+                true,
+                rules(listener = listOf(minimum(10.0)), speaker = listOf(minimum(100.0))),
+                listOf(held(1, 500.0)),
+            ).cta,
+        )
+    }
+
+    @Test
+    fun `member short of the chat minimum only buys to chat`() {
+        val chat = minimum(100.0)
+        assertEquals(
+            GroupProfileCta.BuyToChat(chat),
+            standing(
+                true,
+                rules(listener = listOf(minimum(10.0)), speaker = listOf(chat)),
+                listOf(held(1, 12.0)),
+            ).cta,
+        )
+    }
+
+    @Test
+    fun `member short of both minimums buys to chat for the larger one`() {
+        val chat = minimum(100.0)
+        assertEquals(
+            GroupProfileCta.BuyToChat(chat),
+            standing(true, rules(listener = listOf(minimum(10.0)), speaker = listOf(chat))).cta,
+        )
+    }
+
+    @Test
+    fun `member under the join minimum alone buys to chat`() {
+        val join = minimum(10.0)
+        assertEquals(
+            GroupProfileCta.BuyToChat(join),
+            standing(true, rules(listener = listOf(join))).cta,
+        )
+    }
+
+    @Test
+    fun `member of a read-only group opens the chat`() {
+        assertEquals(
+            GroupProfileCta.OpenChat,
+            standing(true, rules(speaker = listOf(ChatRuleRequirement.Never))).cta,
+        )
+    }
+
+    // Requirements
+
+    @Test
+    fun `requirements carry a join and a chat minimum`() {
+        val join = minimum(10.0)
+        val chat = minimum(100.0)
+        assertEquals(
+            GroupBalanceRequirements(join, chat),
+            GroupBalanceRequirements.from(rules(listener = listOf(join), speaker = listOf(chat))),
+        )
+    }
+
+    @Test
+    fun `chat falls back to the join minimum`() {
+        val join = minimum(10.0)
+        assertEquals(
+            GroupBalanceRequirements(join, join),
+            GroupBalanceRequirements.from(
+                rules(listener = listOf(join), speaker = listOf(ChatRuleRequirement.Staff))
+            ),
+        )
+    }
+
+    @Test
+    fun `a chat-only minimum leaves join empty`() {
+        val chat = minimum(100.0)
+        assertEquals(
+            GroupBalanceRequirements(null, chat),
+            GroupBalanceRequirements.from(rules(speaker = listOf(chat))),
+        )
+    }
+
+    @Test
+    fun `requirements are hidden without a minimum`() {
+        assertNull(GroupBalanceRequirements.from(null))
+        assertNull(GroupBalanceRequirements.from(rules()))
+        assertNull(
+            GroupBalanceRequirements.from(
+                rules(
+                    listener = listOf(ChatRuleRequirement.Staff),
+                    speaker = listOf(ChatRuleRequirement.Never),
+                )
+            )
+        )
+    }
+
+    // Shortfall
+
+    @Test
+    fun `shortfall counts every holding when no mint is named`() {
+        assertEquals(
+            Fiat(3.67),
+            balanceShortfall(minimum(10.0), listOf(held(1, 3.0), held(2, 3.33)), emptyMap()),
+        )
+    }
+
+    @Test
+    fun `shortfall counts only the named mint`() {
+        assertEquals(
+            Fiat(6.0),
+            balanceShortfall(
+                minimum(10.0, listOf(mint(1))),
+                listOf(held(1, 4.0), held(2, 100.0)),
+                emptyMap(),
+            ),
+        )
+    }
+
+    @Test
+    fun `shortfall is restated in the requirement's currency and rounded up`() {
+        // 10 CAD at 1.25 per dollar is $8; holding $2.40 leaves $5.60, which is 7 CAD.
+        val rates = mapOf(CurrencyCode.CAD to Rate(1.25, CurrencyCode.CAD))
+        assertEquals(
+            Fiat(7.0, CurrencyCode.CAD),
+            balanceShortfall(minimum(Fiat(10.0, CurrencyCode.CAD)), listOf(held(1, 2.4)), rates),
+        )
+    }
+
+    @Test
+    fun `shortfall is null once the requirement is met`() {
+        assertNull(balanceShortfall(minimum(10.0), listOf(held(1, 10.0)), emptyMap()))
+    }
+
+    // Chatting grid
+
+    private fun chatter() = SampledChatter(
+        userProfile = UserProfile(
+            displayName = "Ted",
+            socialAccounts = emptyList(),
+            phoneNumber = null,
+            email = null,
+        ),
+        lastSentAt = null,
+        isCreator = false,
+    )
+
+    @Test
+    fun `a private group hides the grid even with chatters`() {
+        assertFalse(isChattingGridVisible(isPrivate = true, chatters = listOf(chatter())))
+    }
+
+    @Test
+    fun `no chatters hides the grid`() {
+        assertFalse(isChattingGridVisible(isPrivate = false, chatters = emptyList()))
+    }
+
+    @Test
+    fun `a public group with chatters shows the grid`() {
+        assertTrue(isChattingGridVisible(isPrivate = false, chatters = listOf(chatter())))
+    }
+
+    // Your Balance
+
+    @Test
+    fun `your balance reads the join minimum's mint`() {
+        val requirements = GroupBalanceRequirements(
+            join = minimum(10.0, listOf(mint(1))),
+            chat = minimum(100.0, listOf(mint(2))),
+        )
+        assertEquals(
+            Fiat(4.0),
+            yourBalance(requirements, listOf(held(1, 4.0), held(2, 50.0)), emptyMap()),
+        )
+    }
+
+    @Test
+    fun `your balance is hidden when its currency has no rate`() {
+        val requirements = GroupBalanceRequirements(minimum(Fiat(10.0, CurrencyCode.CAD)), null)
+        assertNull(yourBalance(requirements, listOf(held(1, 4.0)), emptyMap()))
+    }
+}
diff --git a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/ChatCoordinator.kt b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/ChatCoordinator.kt
index 326e5d2fa8..a5424d74fe 100644
--- a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/ChatCoordinator.kt
+++ b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/ChatCoordinator.kt
@@ -10,6 +10,7 @@ import com.flipcash.services.models.chat.ChatId
 import com.flipcash.services.models.chat.ChatMember
 import com.flipcash.services.models.chat.ChatMessage
 import com.flipcash.services.models.chat.ChatMetadata
+import com.flipcash.services.models.chat.ChatterSample
 import com.flipcash.services.models.chat.ChatType
 import com.flipcash.services.models.chat.EditChatParameters
 import com.flipcash.services.models.chat.IdempotencyKey
@@ -552,6 +553,22 @@ interface GroupOperations {
      * fails.
      */
     suspend fun leave(chatId: ChatId): Result<Unit>
+
+    /**
+     * A sample of [chatId]'s recent chatters, in the order the server returns them. Denied for a
+     * private group, which is the caller's to skip. Nothing is stored: the profile that asks
+     * reads it fresh each time it opens.
+     */
+    suspend fun sampleChatters(chatId: ChatId): Result<ChatterSample>
+
+    /**
+     * Stores the cover picture `GetChat` holds for [chatId], when it holds one.
+     *
+     * The feed RPCs may leave a cover unset even when one exists, so a row that arrived through
+     * them can lack the cover its profile shows. Writes only a cover that came back, so a failed
+     * or cover-less answer leaves whatever is stored alone.
+     */
+    suspend fun refreshCover(chatId: ChatId)
 }
 
 interface ChatCoordinator :
diff --git a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/GroupAccess.kt b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/GroupAccess.kt
index 891feb10a4..a2faae7d5e 100644
--- a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/GroupAccess.kt
+++ b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/GroupAccess.kt
@@ -10,6 +10,7 @@ import com.getcode.opencode.model.financial.Fiat
 import com.getcode.opencode.model.financial.Rate
 import com.getcode.opencode.model.financial.TokenWithBalance
 import com.getcode.opencode.model.financial.sum
+import com.getcode.solana.keys.PublicKey
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
@@ -246,12 +247,6 @@ private fun ChatRuleRequirement.isUnmet(
     viewerId: ID? = null,
     creatorId: ID? = null,
 ): Boolean {
-    // Keyed by bytes, not by the key object: `class Mint(bytes) : PublicKey(bytes)`
-    // (libs/encryption/keys/.../Mint.kt), so the `PublicKey`s in `mints` are not `Mint`s and
-    // a map keyed by `Mint` would miss every one of them.
-    val byMint: Map<List<Byte>, Fiat> =
-        balances.associate { it.token.address.bytes to it.balance }
-
     return when (this) {
         is ChatRuleRequirement.MinimumBalance -> {
             // Balances are held in USD; a requirement in another currency is restated through
@@ -261,11 +256,7 @@ private fun ChatRuleRequirement.isUnmet(
             // qualifies for as long as the rate table lacks that currency.
             // [GroupAccess.Undetermined] is how the listener gate admits it is guessing.
             val required = amount.usdValue(rates) ?: return false
-            val held = if (mints.isEmpty()) {
-                byMint.values.sum()
-            } else {
-                mints.mapNotNull { byMint[it.bytes] }.maxOrNull()
-            }
+            val held = heldAgainst(mints, balances)
             // Compared at display precision, the held side rounded half-up to cents
             // (`Fiat.toDouble`), and a total rounded once, after adding: a balance the wallet shows as $5.00 meets a $5 bar even
             // when its exact worth is $4.998, and $4.995 passes too. A launchpad
@@ -293,11 +284,53 @@ private fun ChatRuleRequirement.isUnmet(
     }
 }
 
+/**
+ * What the viewer holds toward a minimum balance naming [mints], in USD, or null when [mints] is
+ * non-empty and none of them is held.
+ *
+ * The largest single balance among the named mints, not their sum: the requirement is "hold $100 of
+ * this", and two unrelated $60 positions are not that. An empty [mints] names no token in
+ * particular and is measured against everything held, added up. This is the one measurement the
+ * gate ([isUnmet]) and a screen that shows the viewer's own balance both read.
+ */
+fun heldAgainst(mints: List<PublicKey>, balances: List<TokenWithBalance>): Fiat? {
+    // Keyed by bytes, not by the key object: `class Mint(bytes) : PublicKey(bytes)`
+    // (libs/encryption/keys/.../Mint.kt), so the `PublicKey`s in `mints` are not `Mint`s and
+    // a map keyed by `Mint` would miss every one of them.
+    val byMint: Map<List<Byte>, Fiat> =
+        balances.associate { it.token.address.bytes to it.balance }
+    return if (mints.isEmpty()) {
+        byMint.values.sum()
+    } else {
+        mints.mapNotNull { byMint[it.bytes] }.maxOrNull()
+    }
+}
+
+/**
+ * Every unmet rule in the order iOS's speaker verdict lists them: the listener rules first, then
+ * the speaker rules. Empty when the viewer may speak.
+ *
+ * [resolveSpeakerBlock] names the first minimum balance for the composer; a caller that needs the
+ * last one (the chat's own bar, which also covers the join bar) reads it from here.
+ */
+fun unmetRequirements(
+    rules: ChatRules?,
+    balances: List<TokenWithBalance>,
+    isStaff: Boolean,
+    viewerId: ID? = null,
+    creatorId: ID? = null,
+    rates: Map<CurrencyCode, Rate> = emptyMap(),
+): List<ChatRuleRequirement> {
+    val listenerUnmet = rules?.listener.orEmpty().filter { it.isUnmet(balances, isStaff, rates) }
+    val speakerUnmet = rules?.speaker.orEmpty().filter { it.isUnmet(balances, isStaff, rates, viewerId, creatorId) }
+    return listenerUnmet + speakerUnmet
+}
+
 /**
  * This amount in USD, or null when it is in another currency with no usable rate. A [Rate]'s `fx`
  * is units of its currency per US dollar, so the USD worth is the amount divided by it.
  */
-private fun Fiat.usdValue(rates: Map<CurrencyCode, Rate>): Double? {
+fun Fiat.usdValue(rates: Map<CurrencyCode, Rate>): Double? {
     if (currencyCode == CurrencyCode.USD) return decimalValue
     val fx = rates[currencyCode]?.takeIf { it.isUsable() }?.fx?.takeIf { it > 0.0 } ?: return null
     return decimalValue / fx
diff --git a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/internal/delegates/GroupFeedDelegate.kt b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/internal/delegates/GroupFeedDelegate.kt
index 4792e6c82b..1609bbff4c 100644
--- a/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/internal/delegates/GroupFeedDelegate.kt
+++ b/apps/flipcash/shared/chat/src/main/kotlin/com/flipcash/shared/chat/internal/delegates/GroupFeedDelegate.kt
@@ -8,6 +8,7 @@ import com.flipcash.app.persistence.sources.lastMessagesByChat
 import com.flipcash.services.controllers.ChatController
 import com.flipcash.services.models.chat.ChatId
 import com.flipcash.services.models.chat.ChatMetadata
+import com.flipcash.services.models.chat.ChatterSample
 import com.flipcash.services.models.chat.EditChatParameters
 import com.flipcash.services.models.chat.IdempotencyKey
 import com.flipcash.services.models.chat.RosterChange
@@ -203,6 +204,14 @@ class GroupFeedDelegate @Inject constructor(
             }
     }
 
+    override suspend fun sampleChatters(chatId: ChatId): Result<ChatterSample> =
+        chatController.sampleChatters(chatId)
+
+    override suspend fun refreshCover(chatId: ChatId) {
+        val cover = chatController.getChat(chatId).getOrNull()?.coverPicture ?: return
+        metadataDataSource.updateCoverPicture(chatId, cover)
+    }
+
     /**
      * Handles the list-level meaning of [changes], then hands them to [RosterStateHolder] for the
      * roster itself.
diff --git a/apps/flipcash/shared/chat/src/test/kotlin/com/flipcash/shared/chat/GroupAccessTest.kt b/apps/flipcash/shared/chat/src/test/kotlin/com/flipcash/shared/chat/GroupAccessTest.kt
index a2f43f10a9..f44e2bff51 100644
--- a/apps/flipcash/shared/chat/src/test/kotlin/com/flipcash/shared/chat/GroupAccessTest.kt
+++ b/apps/flipcash/shared/chat/src/test/kotlin/com/flipcash/shared/chat/GroupAccessTest.kt
@@ -362,6 +362,28 @@ class GroupAccessTest {
         )
     }
 
+    @Test
+    fun `unmet requirements list the listener rules before the speaker rules`() {
+        val listenerBar = ChatRuleRequirement.MinimumBalance(Fiat(100.0), listOf(badBoys))
+        val speakerBar = ChatRuleRequirement.MinimumBalance(Fiat(500.0), listOf(badBoys))
+        val both = ChatRules(listener = listOf(listenerBar), speaker = listOf(speakerBar))
+
+        assertEquals(listOf(listenerBar, speakerBar), unmetRequirements(both, emptyList(), isStaff = false))
+        assertEquals(listOf(speakerBar), unmetRequirements(both, listOf(held(1, "BadBoys", 200.0)), isStaff = false))
+        assertEquals(emptyList(), unmetRequirements(both, listOf(held(1, "BadBoys", 600.0)), isStaff = false))
+        // The composer still names the first one.
+        assertEquals(listenerBar, unmetSpeakerRequirement(both, emptyList(), isStaff = false))
+    }
+
+    @Test
+    fun `held against named mints is the largest, against none the total`() {
+        val balances = listOf(held(1, "BadBoys", 60.0), held(2, "Other", 60.0))
+
+        assertEquals(60.0, heldAgainst(listOf(badBoys), balances)?.toDouble())
+        assertEquals(120.0, heldAgainst(emptyList(), balances)?.toDouble())
+        assertEquals(null, heldAgainst(listOf(badBoys), emptyList()))
+    }
+
     @Test
     fun `with no speaker rules a met listener rule lets the viewer speak`() {
         val listenerOnly = rules(ChatRuleRequirement.MinimumBalance(Fiat(500.0), listOf(badBoys)))
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/BalanceRequirementsCard.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/BalanceRequirementsCard.kt
new file mode 100644
index 0000000000..649168af79
--- /dev/null
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/BalanceRequirementsCard.kt
@@ -0,0 +1,127 @@
+package com.flipcash.shared.common.ui.profile
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewWrapper
+import androidx.compose.ui.unit.dp
+import com.flipcash.app.theme.FlipcashThemeWrapper
+import com.flipcash.shared.common.ui.R
+import com.getcode.theme.CodeTheme
+import com.getcode.theme.White05
+
+private val RowHeight = 56.dp
+private val CardRadius = 12.dp
+private val RowInset = 16.dp
+
+/**
+ * The balance a group asks for, as a card of two rows, Join and Chat, with the viewer's own
+ * balance under it when [yourBalance] is known.
+ *
+ * Values arrive formatted, since the caller owns currency and token naming: "$10", "$10 of NYC".
+ * A null [join] or [chat] reads "None", so a group that only gates speaking still shows a Join row.
+ */
+@Composable
+fun BalanceRequirementsCard(
+    join: String?,
+    chat: String?,
+    yourBalance: String?,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = stringResource(R.string.title_balanceRequirements),
+            style = CodeTheme.typography.textLarge,
+            color = CodeTheme.colors.textMain,
+        )
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clip(RoundedCornerShape(CardRadius))
+                .background(White05),
+        ) {
+            RequirementRow(
+                label = stringResource(R.string.label_balanceRequirementJoin),
+                value = join ?: stringResource(R.string.label_balanceRequirementNone),
+            )
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(CodeTheme.dimens.border)
+                    .background(CodeTheme.colors.divider)
+            )
+            RequirementRow(
+                label = stringResource(R.string.label_balanceRequirementChat),
+                value = chat ?: stringResource(R.string.label_balanceRequirementNone),
+            )
+        }
+        if (yourBalance != null) {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = RowInset),
+                horizontalArrangement = Arrangement.SpaceBetween,
+            ) {
+                Text(
+                    text = stringResource(R.string.label_yourBalance),
+                    style = CodeTheme.typography.textSmall,
+                    color = CodeTheme.colors.textSecondary,
+                )
+                Text(
+                    text = yourBalance,
+                    style = CodeTheme.typography.textSmall,
+                    color = CodeTheme.colors.textSecondary,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun RequirementRow(label: String, value: String) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(RowHeight)
+            .padding(horizontal = RowInset),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.SpaceBetween,
+    ) {
+        Text(
+            text = label,
+            style = CodeTheme.typography.textSmall,
+            color = CodeTheme.colors.textSecondary,
+        )
+        Text(
+            text = value,
+            style = CodeTheme.typography.textMedium,
+            color = CodeTheme.colors.textMain,
+        )
+    }
+}
+
+@Preview
+@PreviewWrapper(FlipcashThemeWrapper::class)
+@Composable
+private fun Preview_BalanceRequirementsCard() {
+    Column(verticalArrangement = Arrangement.spacedBy(24.dp)) {
+        BalanceRequirementsCard(join = "$10 of NYC", chat = "$25 of NYC", yourBalance = "$4.50 of NYC")
+        BalanceRequirementsCard(join = null, chat = "$2.50", yourBalance = null)
+    }
+}
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/GroupChattingGrid.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/GroupChattingGrid.kt
new file mode 100644
index 0000000000..46eb7b0023
--- /dev/null
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/GroupChattingGrid.kt
@@ -0,0 +1,186 @@
+package com.flipcash.shared.common.ui.profile
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.WavingHand
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewWrapper
+import androidx.compose.ui.unit.dp
+import com.flipcash.app.theme.FlipcashThemeWrapper
+import com.flipcash.services.models.chat.BlobAccessContext
+import com.flipcash.services.models.chat.MediaItem
+import com.flipcash.shared.common.ui.ContactAvatar
+import com.flipcash.shared.common.ui.R
+import com.getcode.opencode.model.core.ID
+import com.getcode.theme.CodeTheme
+
+private const val Columns = 4
+private val SectionSpacing = 16.dp
+private val ColumnSpacing = 8.dp
+private val RowSpacing = 16.dp
+private val PortraitSize = 60.dp
+private val HostBadgeSize = 22.dp
+private val HostBadgeRing = 2.dp
+private val HostBadgeIconSize = 12.dp
+private val HostBadgeOffset = 2.dp
+
+/** One chatter as the grid draws it, already resolved to what is shown. */
+data class ChattingGridItem(
+    val userId: ID,
+    val name: String,
+    val picture: MediaItem?,
+    val isHost: Boolean,
+)
+
+/**
+ * What a chatter is called under their portrait: their display name, else their handle, else
+ * [fallback]. Blank counts as missing, since the server sends an empty display name for a profile
+ * that has none.
+ */
+fun chatterName(displayName: String?, username: String?, fallback: String): String =
+    displayName?.takeIf { it.isNotBlank() }
+        ?: username?.takeIf { it.isNotBlank() }?.let { "@$it" }
+        ?: fallback
+
+/**
+ * Who has been talking in a public group: a "Chatting" heading over portraits four to a row, the
+ * host badged. Draws nothing for an empty list, heading included.
+ *
+ * Rows are built by hand rather than as a lazy grid so it can sit inside the profile's own scroll.
+ * A short last row leaves its empty cells blank to keep the columns aligned. The order is the
+ * caller's; the grid does not sort.
+ */
+@Composable
+fun GroupChattingGrid(
+    chatters: List<ChattingGridItem>,
+    onOpen: (ChattingGridItem) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    if (chatters.isEmpty()) return
+
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(SectionSpacing),
+    ) {
+        Text(
+            text = stringResource(R.string.title_chatting),
+            style = CodeTheme.typography.textLarge,
+            color = CodeTheme.colors.textMain,
+        )
+        Column(verticalArrangement = Arrangement.spacedBy(RowSpacing)) {
+            chatters.chunked(Columns).forEach { row ->
+                Row(horizontalArrangement = Arrangement.spacedBy(ColumnSpacing)) {
+                    row.forEach { chatter ->
+                        ChatterCell(
+                            modifier = Modifier.weight(1f),
+                            chatter = chatter,
+                            onClick = { onOpen(chatter) },
+                        )
+                    }
+                    repeat(Columns - row.size) { Box(modifier = Modifier.weight(1f)) }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ChatterCell(
+    chatter: ChattingGridItem,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val hostLabel = stringResource(R.string.label_chatterHost, chatter.name)
+    Column(
+        modifier = modifier
+            .clickable(role = Role.Button, onClick = onClick)
+            .then(if (chatter.isHost) Modifier.semantics { contentDescription = hostLabel } else Modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(6.dp),
+    ) {
+        Box {
+            ContactAvatar(
+                image = chatter.picture,
+                displayName = chatter.name,
+                access = BlobAccessContext.profile(chatter.userId),
+                modifier = Modifier
+                    .size(PortraitSize)
+                    .clip(CircleShape),
+            )
+            if (chatter.isHost) {
+                HostBadge(
+                    modifier = Modifier
+                        .align(Alignment.BottomEnd)
+                        .offset(x = HostBadgeOffset, y = HostBadgeOffset),
+                )
+            }
+        }
+        Text(
+            modifier = Modifier.fillMaxWidth(),
+            text = chatter.name,
+            style = CodeTheme.typography.caption,
+            color = CodeTheme.colors.textMain,
+            textAlign = TextAlign.Center,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
+/** A white disc with a wave, ringed in the page's background so it reads as cut out of the portrait. */
+@Composable
+private fun HostBadge(modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
+            .size(HostBadgeSize)
+            .background(CodeTheme.colors.textMain, CircleShape)
+            .border(HostBadgeRing, CodeTheme.colors.background, CircleShape),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            modifier = Modifier.size(HostBadgeIconSize),
+            imageVector = Icons.Outlined.WavingHand,
+            contentDescription = null,
+            tint = CodeTheme.colors.background,
+        )
+    }
+}
+
+@Preview
+@PreviewWrapper(FlipcashThemeWrapper::class)
+@Composable
+private fun Preview_GroupChattingGrid() {
+    GroupChattingGrid(
+        chatters = List(6) { index ->
+            ChattingGridItem(
+                userId = listOf(index.toByte()),
+                name = if (index == 0) "Ada Lovelace" else "@user$index",
+                picture = null,
+                isHost = index == 0,
+            )
+        },
+        onOpen = {},
+    )
+}
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileActionButton.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileActionButton.kt
index 07b9ac798d..ece3d374cd 100644
--- a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileActionButton.kt
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileActionButton.kt
@@ -53,6 +53,8 @@ fun ProfileActionButton(
             text = text,
             style = CodeTheme.typography.textSmall,
             color = CodeTheme.colors.textMain,
+            maxLines = 1,
+            softWrap = false,
         )
     }
 }
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileHeader.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileHeader.kt
index 50d46b0750..2cc0e72c0e 100644
--- a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileHeader.kt
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileHeader.kt
@@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
@@ -39,7 +40,9 @@ private val AvatarOverlap = 42.dp
  * It renders a subject, not a user — a person today, a group next — so callers map their model to
  * these inputs. [avatar] receives the size, clip and ring to draw with, which keeps the avatar the
  * caller's (a user's picture, a group's) while the overlap stays the header's. [underSubtitle]
- * holds anything that belongs between the handle and the bio, such as a status chip.
+ * holds anything that belongs between the handle and the bio. [onCover] sits on the cover's
+ * bottom edge beside the avatar; the cover is a fixed height, so content there (a status chip that
+ * arrives late) never moves the rest of the header.
  *
  * [cover] is laid out edge to edge from the top of its parent and is not padded for the status
  * bar; the page gutter applies to everything below it.
@@ -55,10 +58,23 @@ fun ProfileHeader(
     actions: @Composable RowScope.() -> Unit,
     modifier: Modifier = Modifier,
     underSubtitle: @Composable () -> Unit = {},
+    onCover: @Composable RowScope.() -> Unit = {},
 ) {
     val inset = CodeTheme.dimens.inset
     Box(modifier = modifier.fillMaxWidth()) {
         ProfileCover(image = cover, access = access)
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(ProfileCoverHeight)
+                .padding(
+                    start = inset + AvatarSize + CodeTheme.dimens.staticGrid.x3,
+                    end = inset,
+                    bottom = CodeTheme.dimens.staticGrid.x2,
+                ),
+            verticalAlignment = Alignment.Bottom,
+            content = onCover,
+        )
         Column(modifier = Modifier.padding(top = ProfileCoverHeight - AvatarOverlap)) {
             Row(
                 modifier = Modifier
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfilePinnedActionBar.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfilePinnedActionBar.kt
index bd615fa944..00bd79ba98 100644
--- a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfilePinnedActionBar.kt
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfilePinnedActionBar.kt
@@ -44,6 +44,7 @@ fun ProfilePinnedActionBar(
     above: (@Composable () -> Unit)? = null,
     secondaryText: String? = null,
     onSecondaryClick: (() -> Unit)? = null,
+    isSecondaryLoading: Boolean = false,
     onHeightChanged: (Dp) -> Unit = {},
 ) {
     val density = LocalDensity.current
@@ -83,6 +84,8 @@ fun ProfilePinnedActionBar(
                     .padding(horizontal = CodeTheme.dimens.inset),
                 buttonState = ButtonState.Subtle,
                 text = secondaryText,
+                isLoading = isSecondaryLoading,
+                enabled = !isSecondaryLoading,
                 onClick = onSecondaryClick,
             )
         }
diff --git a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileStatusChip.kt b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileStatusChip.kt
index 0924d83365..fd19c26fc5 100644
--- a/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileStatusChip.kt
+++ b/apps/flipcash/shared/common-ui/src/main/kotlin/com/flipcash/shared/common/ui/profile/ProfileStatusChip.kt
@@ -12,9 +12,14 @@ import androidx.compose.material.icons.outlined.NotificationsOff
 import androidx.compose.material3.Icon
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.tooling.preview.PreviewWrapper
 import com.flipcash.app.theme.FlipcashThemeWrapper
@@ -30,9 +35,22 @@ fun ProfileStatusChip(
     icon: ImageVector,
     text: String,
     modifier: Modifier = Modifier,
+    // Shown instead of [text] when [text] doesn't fit on one line, e.g. "Muted" for "Muted until
+    // 12:15 PM" beside a profile's buttons. Without it, [text] ellipsizes.
+    compactText: String? = null,
+    overCover: Boolean = false,
 ) {
+    var compact by remember(text, compactText) { mutableStateOf(false) }
     Row(
         modifier = modifier
+            // Over a cover photo the 10% tint alone is unreadable; a dark backing sits under it.
+            .then(
+                if (overCover) {
+                    Modifier.background(CodeTheme.colors.background.copy(alpha = 0.7f), CircleShape)
+                } else {
+                    Modifier
+                }
+            )
             .background(
                 color = CodeTheme.colors.warning.copy(alpha = 0.1f),
                 shape = CircleShape,
@@ -51,9 +69,13 @@ fun ProfileStatusChip(
             tint = CodeTheme.colors.warning,
         )
         Text(
-            text = text,
+            modifier = Modifier.weight(1f, fill = false),
+            text = if (compact && compactText != null) compactText else text,
             style = CodeTheme.typography.textSmall,
             color = CodeTheme.colors.warning,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            onTextLayout = { if (it.hasVisualOverflow && compactText != null) compact = true },
         )
     }
 }
diff --git a/apps/flipcash/shared/common-ui/src/main/res/values/strings.xml b/apps/flipcash/shared/common-ui/src/main/res/values/strings.xml
index 51a0a846a3..e7825830b4 100644
--- a/apps/flipcash/shared/common-ui/src/main/res/values/strings.xml
+++ b/apps/flipcash/shared/common-ui/src/main/res/values/strings.xml
@@ -3,4 +3,11 @@
     <string name="title_profileMinimumToChat">Minimum to Chat</string>
     <string name="title_profileDateJoined">Date Joined</string>
     <string name="text_profileStatEmpty">—</string>
+    <string name="title_chatting">Chatting</string>
+    <string name="label_chatterHost">%1$s, host</string>
+    <string name="title_balanceRequirements">Balance Requirements</string>
+    <string name="label_balanceRequirementJoin">Join</string>
+    <string name="label_balanceRequirementChat">Chat</string>
+    <string name="label_balanceRequirementNone">None</string>
+    <string name="label_yourBalance">Your Balance</string>
 </resources>
diff --git a/ui/core/src/main/kotlin/com/getcode/ui/core/Modifier.kt b/ui/core/src/main/kotlin/com/getcode/ui/core/Modifier.kt
index 9ef7692e6d..b4f1e39ebe 100644
--- a/ui/core/src/main/kotlin/com/getcode/ui/core/Modifier.kt
+++ b/ui/core/src/main/kotlin/com/getcode/ui/core/Modifier.kt
@@ -362,6 +362,10 @@ fun Modifier.verticalScrollStateGradient(
         }
 }
 
+/**
+ * [startInset] and [endInset] move the fades in from the edges, for content that runs on under
+ * the status bar or an opaque pinned bar: the inset stays solid and the fade finishes where it starts.
+ */
 fun Modifier.verticalScrollStateGradient(
     scrollState: ScrollState,
     color: Color = Color.Unspecified,
@@ -370,22 +374,27 @@ fun Modifier.verticalScrollStateGradient(
     showAtEnd: Boolean = true,
     showAtEndAlways: Boolean = false,
     isLongGradient: Boolean = false,
+    startInset: Dp = 0.dp,
+    endInset: Dp = 0.dp,
 ): Modifier = composed {
     val backgroundColor = color.takeOrElse { CodeTheme.colors.background }
     val gradientSizePx =
         with(LocalDensity.current) { gradientSize.toPx() } * if (isLongGradient) 1.5f else 1f
+    val startInsetPx = with(LocalDensity.current) { startInset.toPx() }
+    val endInsetPx = with(LocalDensity.current) { endInset.toPx() }
     this
         .addIf((showAtStart && scrollState.value > 0) || showAtStartAlways) {
             Modifier.drawWithGradient(
                 color = backgroundColor,
-                startY = { gradientSizePx },
-                endY = { 0f },
+                startY = { startInsetPx + gradientSizePx },
+                endY = { startInsetPx },
             )
         }
         .addIf((showAtEnd && scrollState.value < scrollState.maxValue) || showAtEndAlways) {
             Modifier.drawWithGradient(
                 color = backgroundColor,
-                startY = { size.height - gradientSizePx },
+                startY = { size.height - endInsetPx - gradientSizePx },
+                endY = { size.height - endInsetPx },
             )
         }
 }