diff --git a/components/chat/ChatLobby.vue b/components/chat/ChatLobby.vue
index 7b1c06e3b..b0175e4bc 100644
--- a/components/chat/ChatLobby.vue
+++ b/components/chat/ChatLobby.vue
@@ -108,6 +108,8 @@ import Empty from "~/components/ui/empty/Empty.vue";
             :is-minimized="isMinimized"
             class="min-h-0 flex-1 overflow-y-auto"
             :last-read-count="lastReadMessageCount"
+            :message-room="messageRoom"
+            :can-moderate="canModerate"
             @bottom-state-change="handleBottomStateChange"
           />
           <Empty v-else class="flex-1 text-muted-foreground">
@@ -147,7 +149,7 @@ import Empty from "~/components/ui/empty/Empty.vue";
           </button>
         </div>
         <ChatInput
-          v-if="canSend"
+          v-if="composerEnabled"
           ref="chatInputRef"
           variant="global"
           :channels="chatChannels"
@@ -160,7 +162,7 @@ import Empty from "~/components/ui/empty/Empty.vue";
           </template>
         </ChatInput>
         <div v-else class="px-3 py-2 text-center text-xs text-muted-foreground">
-          {{ readonlyHint || $t("chat.readonly") }}
+          {{ readonlyText }}
         </div>
       </div>
     </div>
@@ -278,6 +280,8 @@ import Empty from "~/components/ui/empty/Empty.vue";
           variant="embedded"
           class="min-h-0 flex-1 overflow-y-auto"
           :last-read-count="tracksReadPosition ? lastReadMessageCount : 0"
+          :message-room="messageRoom"
+          :can-moderate="canModerate"
           @bottom-state-change="handleBottomStateChange"
         />
         <Empty v-else key="empty" class="min-h-0 flex-1 text-muted-foreground">
@@ -342,7 +346,7 @@ import Empty from "~/components/ui/empty/Empty.vue";
       <!-- Composer <-> readonly hint are different heights; measured swap. -->
       <HeightSwap>
         <ChatInput
-          v-if="canSend"
+          v-if="composerEnabled"
           key="composer"
           ref="chatInputRef"
           variant="embedded"
@@ -363,7 +367,7 @@ import Empty from "~/components/ui/empty/Empty.vue";
           key="hint"
           class="px-3 py-2 text-center text-xs text-muted-foreground"
         >
-          {{ readonlyHint || $t("chat.readonly") }}
+          {{ readonlyText }}
         </div>
       </HeightSwap>
     </div>
@@ -373,7 +377,13 @@ import Empty from "~/components/ui/empty/Empty.vue";
 <script lang="ts">
 import { markRaw, type PropType } from "vue";
 import socket, { chatMessageKey, chatMessageTime } from "~/web-sockets/Socket";
-import type { ChatType, Lobby, LobbyMessage } from "~/web-sockets/Socket";
+import type {
+  ChatType,
+  Lobby,
+  LobbyMessage,
+  LobbyMessageDeleted,
+} from "~/web-sockets/Socket";
+import { e_player_roles_enum } from "~/generated/zeus";
 
 import { useRightSidebar } from "~/composables/useRightSidebar";
 import { useSound } from "~/composables/useSound";
@@ -506,9 +516,13 @@ export default {
       // how a team callout ends up in front of the other side.
       sendTo: "everyone" as "everyone" | "team",
       viewFilter: "all" as "all" | "everyone" | "team",
-      // Counted per room, but only while the filter is hiding that room --
+      // Held per room, but only while the filter is hiding that room --
       // everything on screen has by definition been offered to the reader.
-      unseen: { everyone: 0, team: 0 } as Record<string, number>,
+      // Kept as message keys so a deleted line takes its mark with it.
+      unseen: { everyone: [], team: [] } as Record<
+        "everyone" | "team",
+        string[]
+      >,
     };
   },
   computed: {
@@ -562,6 +576,40 @@ export default {
         );
       });
     },
+    // A conversation between two people is theirs; the api refuses to moderate
+    // one, even for an administrator.
+    canModerate() {
+      return (
+        this.type !== "direct" &&
+        useAuthStore().isRoleAbove(e_player_roles_enum.moderator)
+      );
+    },
+    // One object per room, kept for as long as the rooms are, so handing it to
+    // every row costs no re-render.
+    messageRooms(): Record<
+      "everyone" | "team",
+      { type: ChatType; id: string } | null
+    > {
+      return {
+        everyone: this.channelTarget("everyone"),
+        team: this.teamLobbyId ? this.channelTarget("team") : null,
+      };
+    },
+    // A gag covers group chat only, and the api refuses the send either way --
+    // this just says so before the player has typed anything.
+    isGagged() {
+      return this.type !== "direct" && !!useAuthStore().me?.is_gagged;
+    },
+    composerEnabled() {
+      return this.canSend && !this.isGagged;
+    },
+    readonlyText() {
+      if (!this.canSend) {
+        return this.readonlyHint || this.$t("chat.readonly");
+      }
+
+      return this.$t("chat.gagged");
+    },
     // Only a single lineup's room is private; the match room admits both sides.
     isTeamContext() {
       return this.type === "match_team";
@@ -734,16 +782,71 @@ export default {
       }
 
       if (option === "all") {
-        return this.unseen.everyone + this.unseen.team;
+        return this.unseen.everyone.length + this.unseen.team.length;
       }
 
-      return this.unseen[option] ?? 0;
+      return this.unseen[option as "everyone" | "team"]?.length ?? 0;
     },
     channelTarget(channel: "everyone" | "team") {
       return channel === "team" && this.teamLobbyId
         ? { type: "match_team" as ChatType, id: this.teamLobbyId }
         : { type: this.type as ChatType, id: this.lobbyId };
     },
+    messageRoom(message: LobbyMessage) {
+      return this.messageRooms[message?.__channel ?? "everyone"] ?? null;
+    },
+    // Where the removed line sat in what this panel renders. `index` is its
+    // place in its own room; merged, the other room's earlier lines come first.
+    renderedIndex(
+      { message, index }: LobbyMessageDeleted,
+      channel: "everyone" | "team",
+    ) {
+      if (!this.isMerged) {
+        return index;
+      }
+
+      if (!this.channelVisible(channel)) {
+        return -1;
+      }
+
+      const other = channel === "team" ? "everyone" : "team";
+      if (!this.channelVisible(other)) {
+        return index;
+      }
+
+      const otherLobby = other === "team" ? this.teamLobby : this.lobby;
+      const time = chatMessageTime(message);
+
+      // Ties sort everyone ahead of team, as the merged stream does.
+      const earlier = (otherLobby?.messages ?? NO_MESSAGES).filter(
+        (candidate) => {
+          const candidateTime = chatMessageTime(candidate);
+          return (
+            candidateTime < time ||
+            (candidateTime === time && other === "everyone")
+          );
+        },
+      ).length;
+
+      return index + earlier;
+    },
+    // The "New" line is a count from the top, so a line removed above it would
+    // otherwise drag it down onto a message that was already read.
+    handleDeletedMessage(
+      deleted: LobbyMessageDeleted,
+      channel: "everyone" | "team",
+    ) {
+      const position = this.renderedIndex(deleted, channel);
+
+      if (position !== -1 && position < this.lastReadMessageCount) {
+        this.lastReadMessageCount = Math.max(0, this.lastReadMessageCount - 1);
+      }
+
+      const key = chatMessageKey(deleted.message);
+      this.unseen[channel] = this.unseen[channel].filter(
+        (unseenKey) => unseenKey !== key,
+      );
+    },
     handleIncomingMessage(
       message: LobbyMessage,
       channel: "everyone" | "team" = "everyone",
@@ -762,7 +865,7 @@ export default {
       // Only what the filter is actively hiding. A message in a room that is
       // on screen has been shown, whether or not it was read.
       if (this.isMerged && !isOwnMessage && !this.channelVisible(channel)) {
-        this.unseen[channel]++;
+        this.unseen[channel].push(chatMessageKey(message));
       }
 
       // Auto-scroll only when already at the bottom.
@@ -861,7 +964,7 @@ export default {
       handler() {
         for (const channel of ["everyone", "team"] as const) {
           if (this.channelVisible(channel)) {
-            this.unseen[channel] = 0;
+            this.unseen[channel] = [];
           }
         }
       },
@@ -891,6 +994,10 @@ export default {
         lobby.on("lobby:chat", (message: LobbyMessage) => {
           this.handleIncomingMessage(message, "everyone");
         });
+
+        lobby.on("lobby:deleted", (deleted: LobbyMessageDeleted) => {
+          this.handleDeletedMessage(deleted, "everyone");
+        });
       },
     },
     // The second room. joinLobby is refcounted per call and hands back its own
@@ -924,6 +1031,10 @@ export default {
         lobby.on("lobby:chat", (message: LobbyMessage) => {
           this.handleIncomingMessage(message, "team");
         });
+
+        lobby.on("lobby:deleted", (deleted: LobbyMessageDeleted) => {
+          this.handleDeletedMessage(deleted, "team");
+        });
       },
     },
     messages: {
diff --git a/components/chat/ChatMessage.vue b/components/chat/ChatMessage.vue
index e8406b976..d4ed95127 100644
--- a/components/chat/ChatMessage.vue
+++ b/components/chat/ChatMessage.vue
@@ -2,6 +2,7 @@
 import { dateLocale } from "~/utilities/dateLocale";
 import TimeAgo from "~/components/TimeAgo.vue";
 import PlayerDisplay from "~/components/PlayerDisplay.vue";
+import ChatMessageActions from "~/components/chat/ChatMessageActions.vue";
 </script>
 
 <template>
@@ -77,10 +78,28 @@ import PlayerDisplay from "~/components/PlayerDisplay.vue";
         {{ message.message }}
       </p>
     </div>
+
+    <!-- Centred on the first line rather than hung off its top: the trigger is
+         taller than a line of chat. -->
+    <ChatMessageActions
+      v-if="hasActions"
+      class="absolute right-0 z-10"
+      :style="{ top: `calc(${padTopRem}rem - 0.25rem)` }"
+      :message="message"
+      :room="room"
+      :permissions="permissions"
+    />
   </div>
 </template>
 
 <script lang="ts">
+import type { PropType } from "vue";
+import type { ChatType } from "~/web-sockets/Socket";
+import {
+  chatMessagePermissions,
+  hasChatMessageActions,
+} from "~/utilities/chatMessageActions";
+
 export default {
   props: {
     message: {
@@ -95,8 +114,28 @@ export default {
       type: Object,
       required: false,
     },
+    // The room this line lives in. Without one there is nothing to act on, so
+    // no actions are offered.
+    room: {
+      type: Object as PropType<{ type: ChatType; id: string } | null>,
+      default: null,
+    },
+    canModerate: {
+      type: Boolean,
+      default: false,
+    },
   },
   computed: {
+    permissions() {
+      return chatMessagePermissions({
+        message: this.message,
+        canModerate: this.canModerate,
+        roomType: this.room?.type ?? "",
+      });
+    },
+    hasActions() {
+      return !!this.room && hasChatMessageActions(this.permissions);
+    },
     // Stamped by ChatLobby when it merges the match room with a lineup room.
     // Absent everywhere else, which is what keeps every other chat surface
     // rendering exactly as before.
@@ -144,7 +183,15 @@ export default {
       // Same gutter either way. The rail is drawn inside it rather than added
       // to it, so a team line starts on the same column as every other line and
       // the avatars stay in one straight edge down the list.
-      const classes = ["group relative pl-12 text-[11px] leading-snug"];
+      const classes = [
+        "group group/chat-message relative pl-12 text-[11px] leading-snug",
+      ];
+
+      // Room for the actions trigger kept whether or not it is showing, so a
+      // hover never rewraps the line under the pointer.
+      if (this.hasActions) {
+        classes.push("pr-7");
+      }
 
       if (!this.isTeamMessage) {
         classes.push(
@@ -153,7 +200,10 @@ export default {
         return classes;
       }
 
-      classes.push("pr-2 bg-[hsl(var(--tac-amber)/0.05)]");
+      classes.push("bg-[hsl(var(--tac-amber)/0.05)]");
+      if (!this.hasActions) {
+        classes.push("pr-2");
+      }
 
       // Inside a run the separation between speakers is padding, not margin, so
       // the tinted block and the rail stay unbroken. The amount comes from
diff --git a/components/chat/ChatMessageActions.vue b/components/chat/ChatMessageActions.vue
new file mode 100644
index 000000000..80d07c675
--- /dev/null
+++ b/components/chat/ChatMessageActions.vue
@@ -0,0 +1,126 @@
+<script setup lang="ts">
+import { onBeforeUnmount, ref, watch } from "vue";
+import { MoreVertical, Trash2 } from "lucide-vue-next";
+import { useRightSidebar } from "~/composables/useRightSidebar";
+import socket, { type ChatType, type LobbyMessage } from "~/web-sockets/Socket";
+import {
+  chatErrorFailed,
+  toastChatError,
+  type ChatError,
+} from "~/utilities/chatErrors";
+import type { ChatMessagePermissions } from "~/utilities/chatMessageActions";
+
+const props = defineProps<{
+  message: LobbyMessage;
+  // The room the message is in, which on a merged match panel is not always
+  // the room the panel was opened for.
+  room: { type: ChatType; id: string };
+  permissions: ChatMessagePermissions;
+}>();
+
+const menuOpen = ref(false);
+const confirmDelete = ref(false);
+
+// The menu and the confirm after it sit over the right hub, which closes itself
+// when the pointer leaves. Both count as still interacting with it.
+function holdRightHub(open: boolean, wasOpen: boolean) {
+  const rightSidebar = useRightSidebar();
+
+  if (open && !wasOpen) {
+    rightSidebar.suspendHoverClose();
+  } else if (!open && wasOpen) {
+    rightSidebar.resumeHoverClose();
+  }
+}
+
+watch(menuOpen, holdRightHub);
+watch(confirmDelete, holdRightHub);
+
+onBeforeUnmount(() => {
+  for (const open of [menuOpen.value, confirmDelete.value]) {
+    if (open) {
+      useRightSidebar().resumeHoverClose();
+    }
+  }
+});
+
+async function deleteMessage() {
+  if (!props.message?.id) {
+    return;
+  }
+
+  try {
+    await socket.deleteMessage(
+      props.room.type,
+      props.room.id,
+      props.message.id,
+    );
+    confirmDelete.value = false;
+  } catch (error) {
+    toastChatError(error as ChatError);
+
+    if (!chatErrorFailed(error as ChatError)) {
+      confirmDelete.value = false;
+    }
+  }
+}
+</script>
+
+<template>
+  <div
+    class="opacity-0 transition-opacity duration-150 focus-within:opacity-100 group-hover/chat-message:opacity-100 has-[[data-state=open]]:opacity-100 motion-reduce:transition-none [@media(hover:none)]:opacity-100"
+  >
+    <DropdownMenu v-model:open="menuOpen" :modal="false">
+      <DropdownMenuTrigger as-child>
+        <Button
+          variant="ghost"
+          size="icon"
+          class="h-6 w-6 text-muted-foreground hover:bg-[hsl(var(--tac-amber)/0.12)] hover:text-[hsl(var(--tac-amber))] [&_svg]:size-3.5"
+          :aria-label="$t('chat.message_actions')"
+        >
+          <MoreVertical />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" class="w-48" data-right-hub-interactive>
+        <DropdownMenuItem
+          v-if="permissions.canDelete"
+          class="text-destructive focus:text-destructive"
+          @select="confirmDelete = true"
+        >
+          <Trash2 />
+          <span>{{ $t("chat.delete_message") }}</span>
+        </DropdownMenuItem>
+      </DropdownMenuContent>
+    </DropdownMenu>
+
+    <AlertDialog v-model:open="confirmDelete">
+      <AlertDialogContent data-right-hub-interactive>
+        <AlertDialogHeader>
+          <AlertDialogTitle>
+            {{ $t("chat.delete_confirm_title") }}
+          </AlertDialogTitle>
+          <AlertDialogDescription>
+            {{
+              $t("chat.delete_confirm_description", {
+                name: message.from?.name || $t("common.unknown"),
+              })
+            }}
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <!-- The overlay hides the chat, so the line being removed is repeated
+             here rather than left to memory. -->
+        <blockquote
+          class="line-clamp-3 whitespace-pre-wrap break-words rounded-md border border-border/60 bg-card/40 px-3 py-2 text-xs text-muted-foreground"
+        >
+          {{ message.message }}
+        </blockquote>
+        <AlertDialogFooter>
+          <AlertDialogCancel>{{ $t("common.cancel") }}</AlertDialogCancel>
+          <Button variant="destructive" @click="deleteMessage">
+            {{ $t("common.delete") }}
+          </Button>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  </div>
+</template>
diff --git a/components/chat/ChatMessages.vue b/components/chat/ChatMessages.vue
index 509d7e83c..a6d60ba8a 100644
--- a/components/chat/ChatMessages.vue
+++ b/components/chat/ChatMessages.vue
@@ -52,6 +52,8 @@
             :message="message"
             :previous-message="messages[index - 1]"
             :next-message="messages[index + 1]"
+            :room="messageRoom ? messageRoom(message) : null"
+            :can-moderate="canModerate"
           />
         </div>
       </TransitionGroup>
@@ -60,8 +62,10 @@
 </template>
 
 <script lang="ts">
+import type { PropType } from "vue";
 import ChatMessage from "~/components/chat/ChatMessage.vue";
 import { chatMessageKey } from "~/web-sockets/Socket";
+import type { ChatType, LobbyMessage } from "~/web-sockets/Socket";
 
 export default {
   components: {
@@ -92,6 +96,18 @@ export default {
       type: String,
       default: "",
     },
+    // Which room a line belongs to, for acting on it. Hand back the same object
+    // for the same room, or every row re-renders on every new message.
+    messageRoom: {
+      type: Function as PropType<
+        (message: LobbyMessage) => { type: ChatType; id: string } | null
+      >,
+      required: false,
+    },
+    canModerate: {
+      type: Boolean,
+      default: false,
+    },
   },
   emits: ["bottom-state-change"],
   data() {
diff --git a/components/hub/ChatPanel.vue b/components/hub/ChatPanel.vue
index 6847ee5ad..8314ac18b 100644
--- a/components/hub/ChatPanel.vue
+++ b/components/hub/ChatPanel.vue
@@ -14,6 +14,7 @@ import { useRouter } from "#app";
 import ChatLobby from "~/components/chat/ChatLobby.vue";
 import ChatParticipants from "~/components/chat/ChatParticipants.vue";
 import FadeSwap from "~/components/ui/transitions/FadeSwap.vue";
+import AnimatedStat from "~/components/AnimatedStat.vue";
 import { useChatTabs, type ChatTab } from "~/composables/useChatTabs";
 import { cancelChatTabRestore } from "~/composables/useChatTabPersistence";
 import { useDirectConversationBar } from "~/composables/useDirectConversationBar";
@@ -48,6 +49,18 @@ const { remove, reorder, directRoomIds } = useDirectConversationBar();
 const matchLobbyStore = useMatchLobbyStore();
 const isMobile = useMediaQuery("(max-width: 768px)");
 
+const formatBadgeCount = (count: number) =>
+  count > 100 ? "100+" : String(count);
+
+const badgePopTransition = {
+  enterActiveClass:
+    "[transition:transform_0.3s_cubic-bezier(0.34,1.56,0.64,1),opacity_0.2s_ease] motion-reduce:[transition:none]",
+  enterFromClass: "scale-0 opacity-0",
+  leaveActiveClass:
+    "[transition:transform_0.15s_ease-in,opacity_0.15s_ease-in] motion-reduce:[transition:none]",
+  leaveToClass: "scale-0 opacity-0",
+};
+
 // A match tab is a room, and one side of that match is a second room the tab
 // never offered -- so team chat used to exist on the match page and vanish the
 // moment you read the same match here. Derived rather than stored on the tab so
@@ -719,12 +732,16 @@ function handlePopOut() {
                           class="w-3.5 h-3.5"
                         />
                       </div>
-                      <span
-                        v-if="unreadCounts[tab.id] && !wiggling"
-                        class="absolute -top-1 -right-1 inline-flex items-center justify-center rounded-full bg-red-500 text-white text-[9px] px-1 min-w-[1.05rem] h-4 leading-none"
-                      >
-                        {{ unreadCounts[tab.id] }}
-                      </span>
+                      <Transition v-bind="badgePopTransition">
+                        <span
+                          v-if="unreadCounts[tab.id] > 0 && !wiggling"
+                          class="absolute -top-1 -right-1 inline-flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-red-500 px-0.5 text-[0.55rem] font-bold leading-none text-white shadow-sm ring-1 ring-background origin-center"
+                        >
+                          <AnimatedStat
+                            :value="formatBadgeCount(unreadCounts[tab.id])"
+                          />
+                        </span>
+                      </Transition>
                       <!-- Editing mode's remove badge, in place of the unread
                            count. The only removal a touch device can reach
                            without a right button. -->
diff --git a/components/ui/dropdown-menu/DropdownMenuContent.vue b/components/ui/dropdown-menu/DropdownMenuContent.vue
index 99f35fae7..1f2a0d473 100644
--- a/components/ui/dropdown-menu/DropdownMenuContent.vue
+++ b/components/ui/dropdown-menu/DropdownMenuContent.vue
@@ -2,6 +2,7 @@
 import type { DropdownMenuContentEmits, DropdownMenuContentProps } from "reka-ui"
 import type { HTMLAttributes } from "vue"
 import { reactiveOmit } from "@vueuse/core"
+import { useAttrs } from "vue"
 import {
   DropdownMenuContent,
   DropdownMenuPortal,
@@ -9,6 +10,13 @@ import {
 } from "reka-ui"
 import { cn } from "@/lib/utils"
 
+// Same as ContextMenuContent: the portal root is a fragment, so anything the
+// call site put on this component (data-right-hub-interactive) was dropped with
+// a warning instead of reaching the menu. Forwarded by hand.
+defineOptions({
+  inheritAttrs: false,
+})
+
 const props = withDefaults(
   defineProps<DropdownMenuContentProps & { class?: HTMLAttributes["class"] }>(),
   {
@@ -18,6 +26,7 @@ const props = withDefaults(
 const emits = defineEmits<DropdownMenuContentEmits>()
 
 const delegatedProps = reactiveOmit(props, "class")
+const attrs = useAttrs()
 
 const forwarded = useForwardPropsEmits(delegatedProps, emits)
 </script>
@@ -25,7 +34,7 @@ const forwarded = useForwardPropsEmits(delegatedProps, emits)
 <template>
   <DropdownMenuPortal>
     <DropdownMenuContent
-      v-bind="forwarded"
+      v-bind="{ ...forwarded, ...attrs }"
       :class="cn('z-50 min-w-32 overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2', props.class)"
     >
       <slot />
diff --git a/composables/useChatReadState.ts b/composables/useChatReadState.ts
index 9c023a899..5bf040e44 100644
--- a/composables/useChatReadState.ts
+++ b/composables/useChatReadState.ts
@@ -49,23 +49,21 @@ export function useChatReadState() {
     };
   }
 
-  function unreadSince(
+  function isUnread(
     type: string,
     lobbyId: string,
-    messages: Array<{ timestamp?: string; from?: { steam_id?: string } }>,
+    message: { timestamp?: string; from?: { steam_id?: string } },
     mySteamId?: string | null,
   ) {
+    if (String(message?.from?.steam_id) === String(mySteamId)) {
+      return false;
+    }
+
     const cursor = cursors.value[chatThreadKey(type, lobbyId)];
     const readAt = cursor ? new Date(cursor).getTime() : 0;
 
-    return messages.filter((message) => {
-      if (String(message?.from?.steam_id) === String(mySteamId)) {
-        return false;
-      }
-
-      return new Date(message?.timestamp ?? 0).getTime() > readAt;
-    }).length;
+    return new Date(message?.timestamp ?? 0).getTime() > readAt;
   }
 
-  return { cursors, hydrate, markRead, setCursor, unreadSince };
+  return { cursors, hydrate, isUnread, markRead, setCursor };
 }
diff --git a/composables/useChatTabSetup.ts b/composables/useChatTabSetup.ts
index 767609827..7de185cbc 100644
--- a/composables/useChatTabSetup.ts
+++ b/composables/useChatTabSetup.ts
@@ -5,7 +5,10 @@ import { useChatReadState } from "~/composables/useChatReadState";
 import { useMatchLobbyStore } from "~/stores/MatchLobbyStore";
 import { useAuthStore } from "~/stores/AuthStore";
 import { e_player_roles_enum } from "~/generated/zeus";
-import socket, { type Lobby } from "~/web-sockets/Socket";
+import socket, {
+  type Lobby,
+  type LobbyMessageDeleted,
+} from "~/web-sockets/Socket";
 
 export function tournamentChatTab(tournament: {
   id: string;
@@ -37,9 +40,10 @@ export function useChatTabSetup() {
     closeTab,
     setPinned,
     incrementUnread,
+    decrementUnread,
     setUnread,
   } = useChatTabs();
-  const { hydrate: hydrateReadState, unreadSince } = useChatReadState();
+  const { hydrate: hydrateReadState, isUnread } = useChatReadState();
 
   const matchLobbyStore = useMatchLobbyStore();
   const authStore = useAuthStore();
@@ -68,6 +72,12 @@ export function useChatTabSetup() {
       }
     });
 
+    lobby.on("lobby:deleted", ({ message }: LobbyMessageDeleted) => {
+      if (message?.id) {
+        decrementUnread(tab.id, message.id);
+      }
+    });
+
     // The room's history, which arrives on join and on every rejoin. Counting
     // it against the server's cursor is what makes a badge survive a reload
     // and agree with the other devices -- the live handler above only ever
@@ -81,9 +91,14 @@ export function useChatTabSetup() {
         return;
       }
 
+      const unread = (messages ?? []).filter((message) =>
+        isUnread(tab.type, tab.lobbyId, message, authStore.me?.steam_id),
+      );
+
       setUnread(
         tab.id,
-        unreadSince(tab.type, tab.lobbyId, messages ?? [], authStore.me?.steam_id),
+        unread.length,
+        unread.map((message) => message?.id).filter(Boolean),
       );
     });
   }
diff --git a/composables/useChatTabs.ts b/composables/useChatTabs.ts
index 459648b62..b239655d3 100644
--- a/composables/useChatTabs.ts
+++ b/composables/useChatTabs.ts
@@ -21,8 +21,10 @@ export interface ChatTab {
 
 const tabsRef = ref<ChatTab[]>([]);
 const unreadCountsRef = ref<Record<string, number>>({});
-// A message can reach a badge twice, from direct:incoming and from its room's
-// lobby:chat, so a badge remembers which ids it has already counted.
+// Which messages each badge has counted. A message can reach a badge twice,
+// from direct:incoming and from its room's lobby:chat, and a deleted one only
+// comes off the count if it was ever in it -- a line read on screen is newer
+// than the read cursor too, but no badge counted it.
 const unreadMessageIds = new Map<string, Set<string>>();
 const MAX_UNREAD_MESSAGE_IDS = 200;
 const activeTabIdRef = ref<string | null>(null);
@@ -140,6 +142,16 @@ export function useChatTabs() {
     return true;
   }
 
+  function decrementUnread(id: string, messageId: string) {
+    if (!unreadMessageIds.get(id)?.delete(messageId)) {
+      return;
+    }
+
+    if (unreadCountsRef.value[id]) {
+      unreadCountsRef.value[id] -= 1;
+    }
+  }
+
   function resetUnread(id: string) {
     unreadMessageIds.delete(id);
 
@@ -148,12 +160,19 @@ export function useChatTabs() {
     }
   }
 
-  // A non-zero recount keeps the ids already counted, taking them to be part of
-  // the new number, so a late second delivery of one still isn't counted again.
-  function setUnread(id: string, value: number) {
+  // A recount that names its messages replaces what the badge counted. Without
+  // them a non-zero recount keeps the ids already counted, taking them to be
+  // part of the new number, so a late second delivery of one still isn't
+  // counted again.
+  function setUnread(id: string, value: number, messageIds?: string[]) {
     unreadCountsRef.value[id] = value;
 
-    if (!value) {
+    if (messageIds) {
+      unreadMessageIds.set(
+        id,
+        new Set(messageIds.slice(-MAX_UNREAD_MESSAGE_IDS)),
+      );
+    } else if (!value) {
       unreadMessageIds.delete(id);
     }
   }
@@ -176,6 +195,7 @@ export function useChatTabs() {
     setPinned,
     setTabPosition,
     incrementUnread,
+    decrementUnread,
     resetUnread,
     setUnread,
     clearAll,
diff --git a/i18n/locales/ar_SA.json b/i18n/locales/ar_SA.json
index a2fb09b2f..204ad7531 100644
--- a/i18n/locales/ar_SA.json
+++ b/i18n/locales/ar_SA.json
@@ -8467,6 +8467,14 @@
     "team_hint": "تشكيلتك فقط — ولا يظهر في دردشة اللعبة",
     "message_too_long": "الحد الأقصى لطول الرسالة هو {max} حرف.",
     "send_failed": "تعذّر إرسال رسالتك",
+    "gagged": "أنت ممنوع من الكتابة ولا يمكنك إرسال رسائل في الدردشة.",
+    "message_actions": "إجراءات الرسالة",
+    "delete_message": "حذف الرسالة",
+    "delete_confirm_title": "حذف الرسالة؟",
+    "delete_confirm_description": "ستُزال رسالة {name} لدى جميع من في هذه الدردشة.",
+    "delete_failed": "تعذّر حذف الرسالة",
+    "delete_timeout": "لم يستجب الخادم. قد تتم إزالة الرسالة لاحقًا.",
+    "message_already_gone": "تمت إزالة الرسالة بالفعل",
     "direct": {
       "message": "رسالة",
       "empty": "لا رسائل بعد. ألقِ التحية."
diff --git a/i18n/locales/da_DK.json b/i18n/locales/da_DK.json
index 371b0df19..827a19e03 100644
--- a/i18n/locales/da_DK.json
+++ b/i18n/locales/da_DK.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Kun din opstilling — vises ikke i spillets chat",
     "message_too_long": "Beskeder kan højst være på {max} tegn.",
     "send_failed": "Din besked kunne ikke sendes",
+    "gagged": "Din chat er lukket, så du kan ikke sende chatbeskeder.",
+    "message_actions": "Beskedhandlinger",
+    "delete_message": "Slet besked",
+    "delete_confirm_title": "Slet besked?",
+    "delete_confirm_description": "Beskeden fra {name} bliver fjernet for alle i denne chat.",
+    "delete_failed": "Beskeden kunne ikke slettes",
+    "delete_timeout": "Serveren svarede ikke. Beskeden kan stadig blive fjernet.",
+    "message_already_gone": "Beskeden er allerede fjernet",
     "direct": {
       "message": "Besked",
       "empty": "Ingen beskeder endnu. Sig hej."
diff --git a/i18n/locales/de_DE.json b/i18n/locales/de_DE.json
index dd4dd9589..a77c4ee1b 100644
--- a/i18n/locales/de_DE.json
+++ b/i18n/locales/de_DE.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Nur dein Lineup — wird nicht im Spielchat angezeigt",
     "message_too_long": "Nachrichten dürfen höchstens {max} Zeichen lang sein.",
     "send_failed": "Deine Nachricht konnte nicht gesendet werden",
+    "gagged": "Du bist im Chat gesperrt und kannst keine Nachrichten senden.",
+    "message_actions": "Nachrichtenaktionen",
+    "delete_message": "Nachricht löschen",
+    "delete_confirm_title": "Nachricht löschen?",
+    "delete_confirm_description": "Die Nachricht von {name} wird für alle in diesem Chat entfernt.",
+    "delete_failed": "Nachricht konnte nicht gelöscht werden",
+    "delete_timeout": "Der Server hat nicht geantwortet. Die Nachricht wird eventuell trotzdem entfernt.",
+    "message_already_gone": "Nachricht wurde bereits entfernt",
     "direct": {
       "message": "Nachricht",
       "empty": "Noch keine Nachrichten. Sag Hallo."
diff --git a/i18n/locales/en.json b/i18n/locales/en.json
index 31bbbfee2..3fe63f253 100644
--- a/i18n/locales/en.json
+++ b/i18n/locales/en.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Your lineup only — not shown in game chat",
     "message_too_long": "Messages can be up to {max} characters.",
     "send_failed": "Failed to send message",
+    "gagged": "You're gagged and can't send chat messages.",
+    "message_actions": "Message actions",
+    "delete_message": "Delete Message",
+    "delete_confirm_title": "Delete Message?",
+    "delete_confirm_description": "The message from {name} will be removed for everyone in this chat.",
+    "delete_failed": "Failed to delete message",
+    "delete_timeout": "The server didn't answer. The message may still be removed.",
+    "message_already_gone": "Message already removed",
     "direct": {
       "message": "Message",
       "empty": "No messages yet. Say hello."
diff --git a/i18n/locales/es_ES.json b/i18n/locales/es_ES.json
index 09eefbd91..4d3e91052 100644
--- a/i18n/locales/es_ES.json
+++ b/i18n/locales/es_ES.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Solo tu alineación: no se muestra en el chat del juego",
     "message_too_long": "Los mensajes pueden tener un máximo de {max} caracteres.",
     "send_failed": "No se ha podido enviar tu mensaje",
+    "gagged": "Estás silenciado en el chat y no puedes enviar mensajes.",
+    "message_actions": "Acciones del mensaje",
+    "delete_message": "Eliminar mensaje",
+    "delete_confirm_title": "¿Eliminar mensaje?",
+    "delete_confirm_description": "El mensaje de {name} se eliminará para todos en este chat.",
+    "delete_failed": "No se ha podido eliminar el mensaje",
+    "delete_timeout": "El servidor no ha respondido. Puede que el mensaje se elimine de todos modos.",
+    "message_already_gone": "El mensaje ya se había eliminado",
     "direct": {
       "message": "Mensaje",
       "empty": "Aún no hay mensajes. Saluda."
diff --git a/i18n/locales/fr_FR.json b/i18n/locales/fr_FR.json
index 75d56f574..eb5fd0ae1 100644
--- a/i18n/locales/fr_FR.json
+++ b/i18n/locales/fr_FR.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Votre composition uniquement — non affiché dans le chat du jeu",
     "message_too_long": "Les messages peuvent contenir jusqu'à {max} caractères.",
     "send_failed": "Votre message n'a pas pu être envoyé",
+    "gagged": "Vous êtes bâillonné et ne pouvez pas envoyer de messages dans le chat.",
+    "message_actions": "Actions du message",
+    "delete_message": "Supprimer le message",
+    "delete_confirm_title": "Supprimer le message ?",
+    "delete_confirm_description": "Le message de {name} sera supprimé pour tous les participants de ce chat.",
+    "delete_failed": "Impossible de supprimer le message",
+    "delete_timeout": "Le serveur n'a pas répondu. Le message peut tout de même être supprimé.",
+    "message_already_gone": "Message déjà supprimé",
     "direct": {
       "message": "Message",
       "empty": "Aucun message pour l'instant. Dites bonjour."
diff --git a/i18n/locales/it_IT.json b/i18n/locales/it_IT.json
index fd8fea450..75cd5f3f6 100644
--- a/i18n/locales/it_IT.json
+++ b/i18n/locales/it_IT.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Solo la tua formazione — non mostrato nella chat di gioco",
     "message_too_long": "I messaggi possono contenere al massimo {max} caratteri.",
     "send_failed": "Non è stato possibile inviare il tuo messaggio",
+    "gagged": "Sei silenziato in chat e non puoi inviare messaggi.",
+    "message_actions": "Azioni messaggio",
+    "delete_message": "Elimina messaggio",
+    "delete_confirm_title": "Eliminare il messaggio?",
+    "delete_confirm_description": "Il messaggio di {name} verrà rimosso per tutti i partecipanti a questa chat.",
+    "delete_failed": "Impossibile eliminare il messaggio",
+    "delete_timeout": "Il server non ha risposto. Il messaggio potrebbe comunque essere rimosso.",
+    "message_already_gone": "Messaggio già rimosso",
     "direct": {
       "message": "Messaggio",
       "empty": "Ancora nessun messaggio. Fatti sentire."
diff --git a/i18n/locales/ja_JP.json b/i18n/locales/ja_JP.json
index 53046566a..d5400b3c7 100644
--- a/i18n/locales/ja_JP.json
+++ b/i18n/locales/ja_JP.json
@@ -8467,6 +8467,14 @@
     "team_hint": "自分のラインナップのみ — ゲーム内チャットには表示されません",
     "message_too_long": "メッセージは最大{max}文字までです。",
     "send_failed": "メッセージを送信できませんでした",
+    "gagged": "発言禁止中のため、チャットメッセージを送信できません。",
+    "message_actions": "メッセージの操作",
+    "delete_message": "メッセージを削除",
+    "delete_confirm_title": "メッセージを削除しますか？",
+    "delete_confirm_description": "{name} のメッセージは、このチャットの全員に対して削除されます。",
+    "delete_failed": "メッセージを削除できませんでした",
+    "delete_timeout": "サーバーから応答がありませんでした。メッセージは後で削除される可能性があります。",
+    "message_already_gone": "メッセージはすでに削除されています",
     "direct": {
       "message": "メッセージ",
       "empty": "まだメッセージはありません。あいさつしてみましょう。"
diff --git a/i18n/locales/ko_KR.json b/i18n/locales/ko_KR.json
index 737ae8488..7c3ba5779 100644
--- a/i18n/locales/ko_KR.json
+++ b/i18n/locales/ko_KR.json
@@ -8467,6 +8467,14 @@
     "team_hint": "내 라인업만 — 게임 내 채팅에는 표시되지 않습니다",
     "message_too_long": "메시지는 최대 {max}자까지 입력할 수 있습니다.",
     "send_failed": "메시지를 보내지 못했습니다",
+    "gagged": "채팅이 금지되어 메시지를 보낼 수 없습니다.",
+    "message_actions": "메시지 작업",
+    "delete_message": "메시지 삭제",
+    "delete_confirm_title": "메시지를 삭제할까요?",
+    "delete_confirm_description": "{name}님의 메시지가 이 채팅의 모든 사람에게서 삭제됩니다.",
+    "delete_failed": "메시지를 삭제하지 못했습니다",
+    "delete_timeout": "서버가 응답하지 않았습니다. 메시지가 나중에 삭제될 수도 있습니다.",
+    "message_already_gone": "이미 삭제된 메시지입니다",
     "direct": {
       "message": "메시지",
       "empty": "아직 메시지가 없습니다. 인사를 건네보세요."
diff --git a/i18n/locales/pl_PL.json b/i18n/locales/pl_PL.json
index 021c96bb5..3b397aeae 100644
--- a/i18n/locales/pl_PL.json
+++ b/i18n/locales/pl_PL.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Tylko twój skład — nie jest pokazywane na czacie w grze",
     "message_too_long": "Wiadomość może mieć maksymalnie {max} znaków.",
     "send_failed": "Nie udało się wysłać wiadomości",
+    "gagged": "Masz zablokowany czat i nie możesz wysyłać wiadomości.",
+    "message_actions": "Akcje wiadomości",
+    "delete_message": "Usuń wiadomość",
+    "delete_confirm_title": "Usunąć wiadomość?",
+    "delete_confirm_description": "Wiadomość od {name} zostanie usunięta dla wszystkich na tym czacie.",
+    "delete_failed": "Nie udało się usunąć wiadomości",
+    "delete_timeout": "Serwer nie odpowiedział. Wiadomość może mimo to zostać usunięta.",
+    "message_already_gone": "Wiadomość została już usunięta",
     "direct": {
       "message": "Wiadomość",
       "empty": "Brak wiadomości. Przywitaj się."
diff --git a/i18n/locales/pt_BR.json b/i18n/locales/pt_BR.json
index 15d2ec955..42edcb57e 100644
--- a/i18n/locales/pt_BR.json
+++ b/i18n/locales/pt_BR.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Apenas sua equipe — não mostrado no chat do jogo",
     "message_too_long": "As mensagens podem ter no máximo {max} caracteres.",
     "send_failed": "Não foi possível enviar sua mensagem",
+    "gagged": "Você está censurado no chat e não pode enviar mensagens.",
+    "message_actions": "Ações da mensagem",
+    "delete_message": "Excluir Mensagem",
+    "delete_confirm_title": "Excluir Mensagem?",
+    "delete_confirm_description": "A mensagem de {name} será removida para todos neste chat.",
+    "delete_failed": "Não foi possível excluir a mensagem",
+    "delete_timeout": "O servidor não respondeu. A mensagem ainda pode ser removida.",
+    "message_already_gone": "Mensagem já removida",
     "direct": {
       "message": "Mensagem",
       "empty": "Nenhuma mensagem ainda. Diga Olá."
diff --git a/i18n/locales/ru_RU.json b/i18n/locales/ru_RU.json
index 577298aa6..e84155eda 100644
--- a/i18n/locales/ru_RU.json
+++ b/i18n/locales/ru_RU.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Только ваш состав — в игровом чате не отображается",
     "message_too_long": "Сообщение может содержать не более {max} символов.",
     "send_failed": "Не удалось отправить сообщение",
+    "gagged": "Вам отключили чат, и вы не можете отправлять сообщения.",
+    "message_actions": "Действия с сообщением",
+    "delete_message": "Удалить сообщение",
+    "delete_confirm_title": "Удалить сообщение?",
+    "delete_confirm_description": "Сообщение от {name} будет удалено у всех участников этого чата.",
+    "delete_failed": "Не удалось удалить сообщение",
+    "delete_timeout": "Сервер не ответил. Сообщение всё ещё может быть удалено.",
+    "message_already_gone": "Сообщение уже удалено",
     "direct": {
       "message": "Сообщение",
       "empty": "Сообщений пока нет. Поздоровайтесь."
diff --git a/i18n/locales/sv_SE.json b/i18n/locales/sv_SE.json
index 0bf7de94f..32a583093 100644
--- a/i18n/locales/sv_SE.json
+++ b/i18n/locales/sv_SE.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Bara din laguppställning — visas inte i spelets chatt",
     "message_too_long": "Meddelanden får vara högst {max} tecken långa.",
     "send_failed": "Ditt meddelande kunde inte skickas",
+    "gagged": "Din chatt är avstängd och du kan inte skicka chattmeddelanden.",
+    "message_actions": "Meddelandeåtgärder",
+    "delete_message": "Ta bort meddelande",
+    "delete_confirm_title": "Ta bort meddelande?",
+    "delete_confirm_description": "Meddelandet från {name} tas bort för alla i den här chatten.",
+    "delete_failed": "Meddelandet kunde inte tas bort",
+    "delete_timeout": "Servern svarade inte. Meddelandet kan fortfarande tas bort.",
+    "message_already_gone": "Meddelandet har redan tagits bort",
     "direct": {
       "message": "Meddelande",
       "empty": "Inga meddelanden än. Säg hej."
diff --git a/i18n/locales/tr_TR.json b/i18n/locales/tr_TR.json
index f49c14d41..e3cbc8333 100644
--- a/i18n/locales/tr_TR.json
+++ b/i18n/locales/tr_TR.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Yalnızca kendi kadron — oyun içi sohbette görünmez",
     "message_too_long": "Mesajlar en fazla {max} karakter olabilir.",
     "send_failed": "Mesajın gönderilemedi",
+    "gagged": "Sohbetin kapatıldı, sohbet mesajı gönderemezsin.",
+    "message_actions": "Mesaj işlemleri",
+    "delete_message": "Mesajı sil",
+    "delete_confirm_title": "Mesaj silinsin mi?",
+    "delete_confirm_description": "{name} adlı oyuncunun mesajı bu sohbetteki herkes için kaldırılacak.",
+    "delete_failed": "Mesaj silinemedi",
+    "delete_timeout": "Sunucu yanıt vermedi. Mesaj yine de kaldırılabilir.",
+    "message_already_gone": "Mesaj zaten kaldırılmış",
     "direct": {
       "message": "Mesaj",
       "empty": "Henüz mesaj yok. Merhaba de."
diff --git a/i18n/locales/uk_UA.json b/i18n/locales/uk_UA.json
index dcc07cb7d..d0defe9c3 100644
--- a/i18n/locales/uk_UA.json
+++ b/i18n/locales/uk_UA.json
@@ -8467,6 +8467,14 @@
     "team_hint": "Лише ваш склад — в ігровому чаті не показується",
     "message_too_long": "Повідомлення може містити не більше {max} символів.",
     "send_failed": "Не вдалося надіслати повідомлення",
+    "gagged": "Вам вимкнули чат, тож ви не можете надсилати повідомлення.",
+    "message_actions": "Дії з повідомленням",
+    "delete_message": "Видалити повідомлення",
+    "delete_confirm_title": "Видалити повідомлення?",
+    "delete_confirm_description": "Повідомлення від {name} буде видалено для всіх учасників цього чату.",
+    "delete_failed": "Не вдалося видалити повідомлення",
+    "delete_timeout": "Сервер не відповів. Повідомлення ще може бути видалено.",
+    "message_already_gone": "Повідомлення вже видалено",
     "direct": {
       "message": "Повідомлення",
       "empty": "Повідомлень поки немає. Привітайтеся."
diff --git a/i18n/locales/zh_Hans.json b/i18n/locales/zh_Hans.json
index e800cb9b8..bb49b53b6 100644
--- a/i18n/locales/zh_Hans.json
+++ b/i18n/locales/zh_Hans.json
@@ -8467,6 +8467,14 @@
     "team_hint": "仅限你的阵容 — 不会显示在游戏内聊天",
     "message_too_long": "消息最多 {max} 个字符。",
     "send_failed": "消息发送失败",
+    "gagged": "你已被禁言，无法发送聊天消息。",
+    "message_actions": "消息操作",
+    "delete_message": "删除消息",
+    "delete_confirm_title": "要删除消息吗？",
+    "delete_confirm_description": "{name} 的这条消息将对本聊天中的所有人移除。",
+    "delete_failed": "消息删除失败",
+    "delete_timeout": "服务器没有响应。该消息仍可能被移除。",
+    "message_already_gone": "该消息已被移除",
     "direct": {
       "message": "消息",
       "empty": "还没有消息，先打个招呼吧。"
diff --git a/i18n/locales/zh_Hant.json b/i18n/locales/zh_Hant.json
index 63248280e..ceebc0354 100644
--- a/i18n/locales/zh_Hant.json
+++ b/i18n/locales/zh_Hant.json
@@ -8467,6 +8467,14 @@
     "team_hint": "僅限你的名單 — 不會顯示在遊戲內聊天",
     "message_too_long": "訊息最多 {max} 個字元。",
     "send_failed": "訊息傳送失敗",
+    "gagged": "你已被禁言，無法傳送聊天訊息。",
+    "message_actions": "訊息操作",
+    "delete_message": "刪除訊息",
+    "delete_confirm_title": "要刪除訊息嗎？",
+    "delete_confirm_description": "{name} 的這則訊息將對此聊天中的所有人移除。",
+    "delete_failed": "訊息刪除失敗",
+    "delete_timeout": "伺服器沒有回應。該訊息仍可能被移除。",
+    "message_already_gone": "該訊息已被移除",
     "direct": {
       "message": "訊息",
       "empty": "還沒有訊息，先打個招呼吧。"
diff --git a/tests/components/ChatLobby.spec.ts b/tests/components/ChatLobby.spec.ts
new file mode 100644
index 000000000..4aa819e5c
--- /dev/null
+++ b/tests/components/ChatLobby.spec.ts
@@ -0,0 +1,289 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { flushPromises } from "@vue/test-utils";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import ChatLobby from "~/components/chat/ChatLobby.vue";
+import ChatMessage from "~/components/chat/ChatMessage.vue";
+import { useAuthStore } from "~/stores/AuthStore";
+import socket, { type LobbyMessage } from "~/web-sockets/Socket";
+
+vi.mock("~/graphql/getGraphqlClient", () => ({
+  default: () => ({
+    query: vi.fn().mockResolvedValue({ data: {} }),
+    mutate: vi.fn().mockResolvedValue({ data: {} }),
+    subscribe: () => ({ subscribe: () => ({ unsubscribe() {} }) }),
+  }),
+}));
+
+const ME = "76561198000000001";
+const OTHER = "76561198000000002";
+const GAGGED = "You're gagged and can't send chat messages.";
+const TRIGGER = 'button[aria-label="Message actions"]';
+
+const line = (id: string, minute: number, from = OTHER): LobbyMessage => ({
+  id,
+  message: `line ${id}`,
+  timestamp: new Date(Date.UTC(2026, 8, 28, 12, minute)).toISOString(),
+  from: { steam_id: from, name: `Player ${from}` },
+});
+
+let lobbyCounter = 0;
+let unmount: (() => void) | undefined;
+
+function signIn(me: Record<string, unknown>) {
+  useAuthStore().me = { steam_id: ME, role: "user", ...me } as any;
+}
+
+async function mountLobby(props: Record<string, unknown> = {}) {
+  const wrapper = await mountSuspended(ChatLobby, {
+    props: {
+      instance: "chat-lobby-spec",
+      type: "match",
+      lobbyId: `match-${++lobbyCounter}`,
+      playNotificationSound: false,
+      ...props,
+    },
+  });
+  unmount = () => wrapper.unmount();
+  return wrapper;
+}
+
+beforeEach(() => {
+  vi.spyOn(console, "info").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  unmount?.();
+  unmount = undefined;
+  vi.restoreAllMocks();
+});
+
+describe("ChatLobby gag", () => {
+  it("swaps the composer for the gag hint in a group room", async () => {
+    signIn({ is_gagged: true });
+
+    const wrapper = await mountLobby();
+
+    expect(wrapper.find("textarea").exists()).toBe(false);
+    expect(wrapper.text()).toContain(GAGGED);
+  });
+
+  it("leaves a direct conversation alone", async () => {
+    signIn({ is_gagged: true });
+
+    const wrapper = await mountLobby({
+      type: "direct",
+      lobbyId: `${ME}:${OTHER}`,
+    });
+
+    expect(wrapper.find("textarea").exists()).toBe(true);
+    expect(wrapper.text()).not.toContain(GAGGED);
+  });
+
+  it("keeps the room's own reason when the room was read-only anyway", async () => {
+    signIn({ is_gagged: true });
+
+    const wrapper = await mountLobby({
+      canSend: false,
+      readonlyHint: "Only players can chat here.",
+    });
+
+    expect(wrapper.text()).toContain("Only players can chat here.");
+    expect(wrapper.text()).not.toContain(GAGGED);
+  });
+
+  it("offers the composer to a player who isn't gagged", async () => {
+    signIn({ is_gagged: false });
+
+    const wrapper = await mountLobby();
+
+    expect(wrapper.find("textarea").exists()).toBe(true);
+  });
+});
+
+describe("ChatLobby moderation", () => {
+  async function mountWithHistory(
+    type: string,
+    lobbyId: string,
+    messages: LobbyMessage[],
+    props: Record<string, unknown> = {},
+  ) {
+    const wrapper = await mountLobby({ type, lobbyId, ...props });
+    socket.emit(`lobby:${type}:${lobbyId}:messages`, { messages });
+    await flushPromises();
+    return wrapper;
+  }
+
+  it("offers a moderator message actions in a group room", async () => {
+    signIn({ role: "moderator" });
+
+    const wrapper = await mountWithHistory("match", "moderated-match", [
+      line("a", 0),
+    ]);
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(true);
+  });
+
+  it("offers a moderator nothing in a direct conversation", async () => {
+    signIn({ role: "administrator" });
+
+    const wrapper = await mountWithHistory("direct", `${ME}:${OTHER}`, [
+      line("a", 0),
+    ]);
+
+    expect(wrapper.text()).toContain("line a");
+    expect(wrapper.find(TRIGGER).exists()).toBe(false);
+  });
+
+  it("offers a streamer nothing", async () => {
+    signIn({ role: "streamer" });
+
+    const wrapper = await mountWithHistory("match", "streamed-match", [
+      line("a", 0),
+    ]);
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(false);
+  });
+
+  it("points a team line at the team room on a merged panel", async () => {
+    signIn({ role: "moderator" });
+
+    const wrapper = await mountLobby({
+      lobbyId: "merged-match",
+      teamLobbyId: "merged-match:lineup-1",
+    });
+    socket.emit("lobby:match:merged-match:messages", {
+      messages: [line("everyone-line", 0)],
+    });
+    socket.emit("lobby:match_team:merged-match:lineup-1:messages", {
+      messages: [line("team-line", 1)],
+    });
+    await flushPromises();
+
+    const rows = wrapper.findAllComponents(ChatMessage);
+
+    expect(
+      rows.map((row) => [row.props("message").id, row.props("room")]),
+    ).toEqual([
+      ["everyone-line", { type: "match", id: "merged-match" }],
+      ["team-line", { type: "match_team", id: "merged-match:lineup-1" }],
+    ]);
+    expect(wrapper.findAll(TRIGGER)).toHaveLength(2);
+  });
+
+  it("counts the other room's lines when a merged line above the New line goes", async () => {
+    signIn({ role: "user" });
+
+    const wrapper = await mountLobby({
+      lobbyId: "merged-divider",
+      teamLobbyId: "merged-divider:lineup-1",
+    });
+    socket.emit("lobby:match:merged-divider:messages", {
+      messages: [line("e1", 0), line("e2", 2), line("e3", 4)],
+    });
+    socket.emit("lobby:match_team:merged-divider:lineup-1:messages", {
+      messages: [line("t1", 1), line("t2", 3)],
+    });
+    await flushPromises();
+
+    const lobby = wrapper.vm as any;
+    lobby.lastReadMessageCount = 4;
+
+    socket.emit("lobby:match_team:merged-divider:lineup-1:deleted", {
+      id: "t2",
+    });
+    await flushPromises();
+
+    expect(lobby.lastReadMessageCount).toBe(3);
+
+    socket.emit("lobby:match:merged-divider:deleted", { id: "e3" });
+    await flushPromises();
+
+    expect(lobby.lastReadMessageCount).toBe(3);
+  });
+
+  it("counts only what the filter shows when a merged line goes", async () => {
+    signIn({ role: "user" });
+
+    const wrapper = await mountLobby({
+      lobbyId: "filtered-divider",
+      teamLobbyId: "filtered-divider:lineup-1",
+    });
+    socket.emit("lobby:match:filtered-divider:messages", {
+      messages: [line("e1", 0), line("e2", 2), line("e3", 4)],
+    });
+    socket.emit("lobby:match_team:filtered-divider:lineup-1:messages", {
+      messages: [line("t1", 1), line("t2", 3)],
+    });
+    await flushPromises();
+
+    const lobby = wrapper.vm as any;
+    lobby.viewFilter = "everyone";
+    lobby.lastReadMessageCount = 2;
+    await flushPromises();
+
+    socket.emit("lobby:match_team:filtered-divider:lineup-1:deleted", {
+      id: "t1",
+    });
+    await flushPromises();
+
+    expect(lobby.lastReadMessageCount).toBe(2);
+
+    socket.emit("lobby:match:filtered-divider:deleted", { id: "e2" });
+    await flushPromises();
+
+    expect(lobby.lastReadMessageCount).toBe(1);
+  });
+
+  it("clears a hidden room's mark when the line it stood for goes", async () => {
+    signIn({ role: "user" });
+
+    const wrapper = await mountLobby({
+      lobbyId: "unseen-match",
+      teamLobbyId: "unseen-match:lineup-1",
+    });
+    const lobby = wrapper.vm as any;
+    lobby.viewFilter = "everyone";
+    await flushPromises();
+
+    socket.emit("lobby:match_team:unseen-match:lineup-1:chat", line("t1", 1));
+    await flushPromises();
+
+    expect(lobby.unseenFor("team")).toBe(1);
+
+    socket.emit("lobby:match_team:unseen-match:lineup-1:deleted", {
+      id: "t1",
+    });
+    await flushPromises();
+
+    expect(lobby.unseenFor("team")).toBe(0);
+    expect(lobby.unseenFor("all")).toBe(0);
+  });
+
+  it("keeps the New line on the same message when a read line above it goes", async () => {
+    signIn({ role: "user" });
+
+    const wrapper = await mountWithHistory(
+      "match",
+      "divider-match",
+      [line("a", 0), line("b", 1), line("c", 2), line("d", 3)],
+      { isGlobalContext: true },
+    );
+    const lobby = wrapper.vm as any;
+    lobby.lastReadMessageCount = 2;
+
+    socket.emit("lobby:match:divider-match:deleted", { id: "a" });
+    await flushPromises();
+
+    expect(lobby.messages.map((m: LobbyMessage) => m.id)).toEqual([
+      "b",
+      "c",
+      "d",
+    ]);
+    expect(lobby.lastReadMessageCount).toBe(1);
+
+    socket.emit("lobby:match:divider-match:deleted", { id: "c" });
+    await flushPromises();
+
+    expect(lobby.lastReadMessageCount).toBe(1);
+  });
+});
diff --git a/tests/components/ChatMessageActions.spec.ts b/tests/components/ChatMessageActions.spec.ts
new file mode 100644
index 000000000..a757912fc
--- /dev/null
+++ b/tests/components/ChatMessageActions.spec.ts
@@ -0,0 +1,216 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { flushPromises } from "@vue/test-utils";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import ChatMessage from "~/components/chat/ChatMessage.vue";
+import ChatMessageActions from "~/components/chat/ChatMessageActions.vue";
+import { useRightSidebar } from "~/composables/useRightSidebar";
+import socket from "~/web-sockets/Socket";
+
+const { toast } = vi.hoisted(() => ({ toast: vi.fn() }));
+
+vi.mock("@/components/ui/toast", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@/components/ui/toast")>()),
+  toast,
+}));
+
+const MESSAGE = {
+  id: "7f1d0c2e-8b1a-4c6e-9f00-000000000001",
+  message: "gg",
+  source: "web",
+  timestamp: new Date(Date.UTC(2026, 8, 28, 12, 0)).toISOString(),
+  from: { steam_id: "76561198000000002", name: "Dana" },
+};
+
+const TRIGGER = 'button[aria-label="Message actions"]';
+
+let unmount: (() => void) | undefined;
+
+afterEach(() => {
+  unmount?.();
+  unmount = undefined;
+  vi.restoreAllMocks();
+  toast.mockClear();
+});
+
+describe("ChatMessage actions", () => {
+  async function mountMessage(props: Record<string, unknown>) {
+    const wrapper = await mountSuspended(ChatMessage, {
+      props: { message: MESSAGE, ...props },
+    });
+    unmount = () => wrapper.unmount();
+    return wrapper;
+  }
+
+  it("offers them to a moderator in a group room", async () => {
+    const wrapper = await mountMessage({
+      canModerate: true,
+      room: { type: "match", id: "match-1" },
+    });
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(true);
+  });
+
+  it("offers nothing in a direct conversation", async () => {
+    const wrapper = await mountMessage({
+      canModerate: true,
+      room: { type: "direct", id: "1:2" },
+    });
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(false);
+  });
+
+  it("offers nothing to a player who can't moderate", async () => {
+    const wrapper = await mountMessage({
+      canModerate: false,
+      room: { type: "match", id: "match-1" },
+    });
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(false);
+  });
+
+  it("offers nothing where the room is unknown", async () => {
+    const wrapper = await mountMessage({ canModerate: true });
+
+    expect(wrapper.find(TRIGGER).exists()).toBe(false);
+  });
+});
+
+describe("ChatMessageActions", () => {
+  const hubHeld = () => useRightSidebar().hoverCloseSuspended.value;
+
+  const menuItem = (label: string) =>
+    Array.from(
+      document.body.querySelectorAll<HTMLElement>('[role="menuitem"]'),
+    ).find((item) => item.textContent?.trim() === label);
+
+  const dialog = () =>
+    document.body.querySelector<HTMLElement>('[role="alertdialog"]');
+
+  const dialogButton = (label: string) =>
+    Array.from(dialog()?.querySelectorAll("button") ?? []).find(
+      (button) => button.textContent?.trim() === label,
+    );
+
+  beforeEach(() => {
+    while (useRightSidebar().hoverCloseSuspended.value) {
+      useRightSidebar().resumeHoverClose();
+    }
+  });
+
+  async function openConfirm() {
+    const wrapper = await mountSuspended(ChatMessageActions, {
+      props: {
+        message: MESSAGE,
+        room: { type: "match_team", id: "match-1:lineup-1" },
+        permissions: { canDelete: true },
+      },
+      attachTo: document.body,
+    });
+    unmount = () => wrapper.unmount();
+
+    await wrapper.get(TRIGGER).trigger("keydown", { key: "Enter" });
+    await flushPromises();
+
+    expect(hubHeld()).toBe(true);
+    expect(
+      document.body
+        .querySelector('[role="menu"]')
+        ?.hasAttribute("data-right-hub-interactive"),
+    ).toBe(true);
+
+    menuItem("Delete Message")!.click();
+    await flushPromises();
+
+    expect(dialog()?.hasAttribute("data-right-hub-interactive")).toBe(true);
+
+    return wrapper;
+  }
+
+  it("asks before deleting, from the room the message lives in", async () => {
+    const deleteMessage = vi
+      .spyOn(socket, "deleteMessage")
+      .mockResolvedValue(undefined);
+
+    await openConfirm();
+
+    expect(dialog()?.textContent).toContain("Delete Message?");
+    expect(dialog()?.textContent).toContain(
+      "The message from Dana will be removed for everyone in this chat.",
+    );
+    expect(dialog()?.querySelector("blockquote")?.textContent?.trim()).toBe(
+      "gg",
+    );
+    expect(deleteMessage).not.toHaveBeenCalled();
+    expect(hubHeld()).toBe(true);
+
+    dialogButton("Delete")!.click();
+    await flushPromises();
+
+    expect(deleteMessage).toHaveBeenCalledWith(
+      "match_team",
+      "match-1:lineup-1",
+      MESSAGE.id,
+    );
+    expect(dialog()).toBeNull();
+    expect(hubHeld()).toBe(false);
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it("stays open and reports a delete that failed", async () => {
+    vi.spyOn(socket, "deleteMessage").mockRejectedValue({
+      code: "not_allowed",
+      action: "delete",
+    });
+
+    await openConfirm();
+
+    dialogButton("Delete")!.click();
+    await flushPromises();
+
+    expect(toast).toHaveBeenCalledWith({
+      title: "Failed to delete message",
+      description: undefined,
+      variant: "destructive",
+    });
+    expect(dialog()).not.toBeNull();
+    expect(hubHeld()).toBe(true);
+  });
+
+  it("closes quietly when the message was already gone", async () => {
+    vi.spyOn(socket, "deleteMessage").mockRejectedValue({
+      code: "not_found",
+      action: "delete",
+    });
+
+    await openConfirm();
+
+    dialogButton("Delete")!.click();
+    await flushPromises();
+
+    expect(toast).toHaveBeenCalledWith({ title: "Message already removed" });
+    expect(dialog()).toBeNull();
+    expect(hubHeld()).toBe(false);
+  });
+
+  it("does nothing on cancel", async () => {
+    const deleteMessage = vi.spyOn(socket, "deleteMessage");
+
+    await openConfirm();
+
+    dialogButton("Cancel")!.click();
+    await flushPromises();
+
+    expect(deleteMessage).not.toHaveBeenCalled();
+    expect(dialog()).toBeNull();
+    expect(hubHeld()).toBe(false);
+  });
+
+  it("lets go of the hub when the message goes away mid-confirm", async () => {
+    await openConfirm();
+
+    unmount?.();
+    unmount = undefined;
+
+    expect(hubHeld()).toBe(false);
+  });
+});
diff --git a/tests/composables/useChatTabSetupDeletes.spec.ts b/tests/composables/useChatTabSetupDeletes.spec.ts
new file mode 100644
index 000000000..846d5c893
--- /dev/null
+++ b/tests/composables/useChatTabSetupDeletes.spec.ts
@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { defineComponent, h } from "vue";
+import { flushPromises } from "@vue/test-utils";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import { useChatTabs } from "~/composables/useChatTabs";
+import { useChatTabSetup } from "~/composables/useChatTabSetup";
+import { useRightSidebar } from "~/composables/useRightSidebar";
+import { setActiveHub } from "~/composables/useHubState";
+import { useMatchLobbyStore } from "~/stores/MatchLobbyStore";
+import { chatThreadKey } from "~/utilities/chatThread";
+import socket, { type LobbyMessage } from "~/web-sockets/Socket";
+
+const ME = "76561198000000001";
+const OTHER = "76561198000000002";
+
+// A fresh lobby per test: the socket is a singleton and keeps a room's state,
+// tombstones included, for as long as anything holds it.
+let lobbyId = "";
+let tabId = "";
+let room = "";
+let lobbyCounter = 0;
+
+const at = (minute: number) =>
+  new Date(Date.UTC(2026, 8, 28, 12, minute)).toISOString();
+
+const line = (id: string, minute: number, from = OTHER): LobbyMessage => ({
+  id,
+  message: `line ${id}`,
+  timestamp: at(minute),
+  from: { steam_id: from },
+});
+
+let unmount: (() => void) | undefined;
+
+async function mountSetup() {
+  const wrapper = await mountSuspended(
+    defineComponent({
+      setup() {
+        useChatTabSetup();
+        return () => h("div");
+      },
+    }),
+  );
+  unmount = () => wrapper.unmount();
+  await flushPromises();
+}
+
+const unread = () => useChatTabs().unreadCounts.value[tabId];
+
+beforeEach(async () => {
+  lobbyId = `lobby-deletes-${++lobbyCounter}`;
+  tabId = `matchmaking:${lobbyId}`;
+  room = `lobby:matchmaking:${lobbyId}`;
+  vi.spyOn(console, "info").mockImplementation(() => {});
+  useChatTabs().clearAll();
+  useMatchLobbyStore().chatTournaments = [];
+  useMatchLobbyStore().myMatches = [];
+  useRightSidebar().setRightSidebarOpen(false);
+  useAuthStore().me = {
+    steam_id: ME,
+    current_lobby_id: lobbyId,
+    role: "user",
+  } as any;
+  vi.stubGlobal(
+    "$fetch",
+    vi.fn().mockResolvedValue({
+      threads: [
+        {
+          thread: chatThreadKey("matchmaking", lobbyId),
+          lastReadAt: at(1),
+        },
+      ],
+    }),
+  );
+
+  await mountSetup();
+
+  socket.emit(`${room}:messages`, {
+    messages: [line("read", 0), line("unread", 2), line("mine", 3, ME)],
+  });
+  socket.emit(`${room}:chat`, line("live", 4));
+});
+
+afterEach(() => {
+  unmount?.();
+  unmount = undefined;
+  useAuthStore().me = undefined;
+  useChatTabs().clearAll();
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("useChatTabSetup deletes", () => {
+  it("takes an unread line out of the badge", () => {
+    expect(unread()).toBe(2);
+
+    socket.emit(`${room}:deleted`, { id: "unread" });
+    expect(unread()).toBe(1);
+
+    socket.emit(`${room}:deleted`, { id: "live" });
+    expect(unread()).toBe(0);
+  });
+
+  it("leaves the badge alone for a line it never counted", () => {
+    socket.emit(`${room}:deleted`, { id: "read" });
+    socket.emit(`${room}:deleted`, { id: "mine" });
+
+    expect(unread()).toBe(2);
+  });
+
+  it("goes by the latest recount, not what it counted before", () => {
+    useChatTabs().setUnread(tabId, 0);
+
+    socket.emit(`${room}:deleted`, { id: "unread" });
+
+    expect(unread()).toBe(0);
+  });
+
+  it("leaves the badge alone for a line read on screen and deleted later", () => {
+    useChatTabs().resetUnread(tabId);
+    useChatTabs().setActiveTab(tabId);
+    useRightSidebar().setRightSidebarOpen(true);
+    setActiveHub("chat");
+
+    socket.emit(`${room}:chat`, line("spam", 5));
+    expect(unread()).toBe(0);
+
+    useRightSidebar().setRightSidebarOpen(false);
+    socket.emit(`${room}:chat`, line("teammate", 6));
+    expect(unread()).toBe(1);
+
+    socket.emit(`${room}:deleted`, { id: "spam" });
+    expect(unread()).toBe(1);
+
+    socket.emit(`${room}:deleted`, { id: "teammate" });
+    expect(unread()).toBe(0);
+  });
+
+  it("forgets what it counted once the room has been read", () => {
+    useChatTabs().resetUnread(tabId);
+    socket.emit(`${room}:chat`, line("after", 5));
+    expect(unread()).toBe(1);
+
+    socket.emit(`${room}:deleted`, { id: "unread" });
+
+    expect(unread()).toBe(1);
+  });
+});
diff --git a/tests/composables/useChatTabs.spec.ts b/tests/composables/useChatTabs.spec.ts
index d2ca79306..86b81ea23 100644
--- a/tests/composables/useChatTabs.spec.ts
+++ b/tests/composables/useChatTabs.spec.ts
@@ -109,6 +109,31 @@ describe("useChatTabs incrementUnread", () => {
     expect(count()).toBe(5);
   });
 
+  it("takes on a recount's ids in place of what it counted", () => {
+    const { incrementUnread, setUnread } = useChatTabs();
+
+    incrementUnread(TAB, "m1");
+    setUnread(TAB, 1, ["m2"]);
+
+    expect(incrementUnread(TAB, "m2")).toBe(false);
+    expect(incrementUnread(TAB, "m1")).toBe(true);
+    expect(count()).toBe(2);
+  });
+
+  it("takes a deleted message off only if it counted it", () => {
+    const { incrementUnread, decrementUnread } = useChatTabs();
+
+    incrementUnread(TAB, "m1");
+    incrementUnread(TAB, "m2");
+
+    decrementUnread(TAB, "never-counted");
+    expect(count()).toBe(2);
+
+    decrementUnread(TAB, "m1");
+    decrementUnread(TAB, "m1");
+    expect(count()).toBe(1);
+  });
+
   it("forgets what it counted once the badge is cleared", () => {
     const { incrementUnread, resetUnread, setUnread } = useChatTabs();
 
diff --git a/tests/utilities/chatErrors.spec.ts b/tests/utilities/chatErrors.spec.ts
index 7fa82ed25..1e70732db 100644
--- a/tests/utilities/chatErrors.spec.ts
+++ b/tests/utilities/chatErrors.spec.ts
@@ -1,5 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { chatErrorDescription } from "~/utilities/chatErrors";
+import {
+  chatErrorAction,
+  chatErrorDescription,
+  chatErrorFailed,
+  chatErrorTitle,
+} from "~/utilities/chatErrors";
 import { CHAT_MESSAGE_MAX_LENGTH } from "~/constants/chat";
 
 const t = (key: string, params?: Record<string, unknown>) =>
@@ -23,6 +28,12 @@ describe("chatErrorDescription", () => {
     expect(chatErrorDescription({ code: "not_allowed" }, t)).toBeUndefined();
   });
 
+  it("tells a gagged player why the send was refused", () => {
+    expect(chatErrorDescription({ code: "gagged", action: "send" }, t)).toBe(
+      "chat.gagged",
+    );
+  });
+
   it.each(["invalid", "some_future_code", ""])(
     "treats %j as a plain failed send",
     (code) => {
@@ -34,3 +45,46 @@ describe("chatErrorDescription", () => {
     expect(chatErrorDescription(undefined as any, t)).toBeUndefined();
   });
 });
+
+describe("chat error actions", () => {
+  it("reads a missing action as a send, like an older api sends", () => {
+    expect(chatErrorAction({ code: "too_long" })).toBe("send");
+    expect(chatErrorTitle({ code: "too_long" }, t)).toBe("chat.send_failed");
+  });
+
+  it("titles a failed delete as a delete", () => {
+    expect(chatErrorTitle({ code: "not_allowed", action: "delete" }, t)).toBe(
+      "chat.delete_failed",
+    );
+  });
+
+  it("reports a message someone else removed first as gone, not failed", () => {
+    const error = { code: "not_found", action: "delete" as const };
+
+    expect(chatErrorFailed(error)).toBe(false);
+    expect(chatErrorTitle(error, t)).toBe("chat.message_already_gone");
+    expect(chatErrorDescription(error, t)).toBeUndefined();
+  });
+
+  it("only treats not_found as gone for a delete", () => {
+    expect(chatErrorFailed({ code: "not_found" })).toBe(true);
+    expect(chatErrorFailed({ code: "not_allowed", action: "delete" })).toBe(
+      true,
+    );
+  });
+
+  it("says a delete the api never answered may still go through", () => {
+    expect(chatErrorDescription({ code: "timeout", action: "delete" }, t)).toBe(
+      "chat.delete_timeout",
+    );
+  });
+
+  it.each(["not_allowed", "offline", "gagged", "too_long"])(
+    "adds nothing to a failed delete for %s",
+    (code) => {
+      expect(
+        chatErrorDescription({ code, action: "delete" }, t),
+      ).toBeUndefined();
+    },
+  );
+});
diff --git a/tests/utilities/chatLobbyMessages.spec.ts b/tests/utilities/chatLobbyMessages.spec.ts
new file mode 100644
index 000000000..5010f863d
--- /dev/null
+++ b/tests/utilities/chatLobbyMessages.spec.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it } from "vitest";
+import {
+  chatMessageKey,
+  insertChatMessage,
+  isChatMessageDeleted,
+  mergeChatSnapshot,
+  removeChatMessage,
+} from "~/utilities/chatLobbyMessages";
+import type { LobbyMessage } from "~/web-sockets/Socket";
+
+const line = (id: string | undefined, minute: number): LobbyMessage => ({
+  id,
+  message: `line ${id ?? minute}`,
+  timestamp: new Date(Date.UTC(2026, 8, 28, 12, minute)).toISOString(),
+  from: { steam_id: "76561198000000001" },
+});
+
+const ids = (messages: LobbyMessage[]) => messages.map((message) => message.id);
+
+describe("removeChatMessage", () => {
+  it("removes the line and says where it was", () => {
+    const messages = [line("a", 0), line("b", 1), line("c", 2)];
+
+    const removed = removeChatMessage(messages, "b");
+
+    expect(removed).not.toBeNull();
+    expect(ids(removed!.messages)).toEqual(["a", "c"]);
+    expect(removed!.message.id).toBe("b");
+    expect(removed!.index).toBe(1);
+    expect(ids(messages)).toEqual(["a", "b", "c"]);
+  });
+
+  it("returns null for a line it does not hold", () => {
+    expect(removeChatMessage([line("a", 0)], "gone")).toBeNull();
+  });
+
+  it("never matches a line that has no id", () => {
+    expect(removeChatMessage([line(undefined, 0)], "")).toBeNull();
+  });
+});
+
+describe("insertChatMessage", () => {
+  it("places a late line by its time", () => {
+    const messages = insertChatMessage(
+      [line("a", 0), line("c", 2)],
+      line("b", 1),
+    );
+
+    expect(ids(messages)).toEqual(["a", "b", "c"]);
+  });
+
+  it("keeps arrival order between lines with the same time", () => {
+    const messages = insertChatMessage([line("a", 1)], line("b", 1));
+
+    expect(ids(messages)).toEqual(["a", "b"]);
+  });
+});
+
+describe("isChatMessageDeleted", () => {
+  it("matches only a tombstoned id", () => {
+    const deleted = new Set(["b"]);
+
+    expect(isChatMessageDeleted(line("b", 0), deleted)).toBe(true);
+    expect(isChatMessageDeleted(line("a", 0), deleted)).toBe(false);
+    expect(isChatMessageDeleted(line(undefined, 0), deleted)).toBe(false);
+  });
+});
+
+describe("mergeChatSnapshot", () => {
+  it("replaces what is held with the server's history", () => {
+    const merged = mergeChatSnapshot(
+      [line("expired", 0), line("a", 1)],
+      [line("a", 1), line("b", 2)],
+      new Set(),
+    );
+
+    expect(ids(merged)).toEqual(["a", "b"]);
+  });
+
+  it("keeps a live line newer than the snapshot", () => {
+    const merged = mergeChatSnapshot(
+      [line("a", 1), line("live", 3)],
+      [line("a", 1), line("b", 2)],
+      new Set(),
+    );
+
+    expect(ids(merged)).toEqual(["a", "b", "live"]);
+  });
+
+  it("drops a deleted line a stale snapshot still carries", () => {
+    const merged = mergeChatSnapshot(
+      [line("a", 1)],
+      [line("a", 1), line("deleted", 2), line("b", 3)],
+      new Set(["deleted"]),
+    );
+
+    expect(ids(merged)).toEqual(["a", "b"]);
+  });
+
+  it("drops a deleted line from the newer tail it keeps", () => {
+    const merged = mergeChatSnapshot(
+      [line("a", 1), line("deleted", 3), line("live", 4)],
+      [line("a", 1)],
+      new Set(["deleted"]),
+    );
+
+    expect(ids(merged)).toEqual(["a", "live"]);
+  });
+
+  it("treats a missing snapshot as an empty room", () => {
+    expect(mergeChatSnapshot([line("a", 1)], null, new Set())).toEqual([
+      line("a", 1),
+    ]);
+  });
+});
+
+describe("chatMessageKey", () => {
+  it("falls back to a composite key for a line with no id", () => {
+    const message = line(undefined, 0);
+
+    expect(chatMessageKey(message)).toBe(
+      `76561198000000001|${message.timestamp}|${message.message}`,
+    );
+  });
+});
diff --git a/tests/utilities/chatMessageActions.spec.ts b/tests/utilities/chatMessageActions.spec.ts
new file mode 100644
index 000000000..49fffae1c
--- /dev/null
+++ b/tests/utilities/chatMessageActions.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import {
+  chatMessagePermissions,
+  hasChatMessageActions,
+} from "~/utilities/chatMessageActions";
+
+const message = {
+  id: "7f1d0c2e-8b1a-4c6e-9f00-000000000001",
+  message: "gg",
+  timestamp: "2026-09-28T12:00:00.000Z",
+  from: { steam_id: "76561198000000002" },
+};
+
+const viewerSteamId = "76561198000000001";
+
+describe("chatMessagePermissions", () => {
+  it.each([
+    "match",
+    "match_team",
+    "matchmaking",
+    "tournament",
+    "draft",
+    "organizers",
+  ])("lets a moderator delete in a %s room", (roomType) => {
+    expect(
+      chatMessagePermissions({
+        message,
+        viewerSteamId,
+        canModerate: true,
+        roomType,
+      }),
+    ).toEqual({ canDelete: true });
+  });
+
+  it("never offers a delete in a direct conversation", () => {
+    expect(
+      chatMessagePermissions({
+        message,
+        viewerSteamId,
+        canModerate: true,
+        roomType: "direct",
+      }).canDelete,
+    ).toBe(false);
+  });
+
+  it("offers nothing to someone who can't moderate", () => {
+    expect(
+      chatMessagePermissions({
+        message,
+        viewerSteamId,
+        canModerate: false,
+        roomType: "match",
+      }).canDelete,
+    ).toBe(false);
+  });
+
+  it("offers nothing for a line the api can't address", () => {
+    expect(
+      chatMessagePermissions({
+        message: { ...message, id: undefined },
+        viewerSteamId,
+        canModerate: true,
+        roomType: "match",
+      }).canDelete,
+    ).toBe(false);
+  });
+});
+
+describe("hasChatMessageActions", () => {
+  it("is true only when something is permitted", () => {
+    expect(hasChatMessageActions({ canDelete: true })).toBe(true);
+    expect(hasChatMessageActions({ canDelete: false })).toBe(false);
+  });
+});
diff --git a/tests/web-sockets/SocketChatError.spec.ts b/tests/web-sockets/SocketChatError.spec.ts
index 4afc2b3f2..25278883e 100644
--- a/tests/web-sockets/SocketChatError.spec.ts
+++ b/tests/web-sockets/SocketChatError.spec.ts
@@ -1,5 +1,5 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import socket from "~/web-sockets/Socket";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import socket, { type LobbyMessage } from "~/web-sockets/Socket";
 
 const { toast } = vi.hoisted(() => ({ toast: vi.fn() }));
 
@@ -8,6 +8,50 @@ vi.mock("@/components/ui/toast", async (importOriginal) => ({
   toast,
 }));
 
+const line = (id: string, minute: number): LobbyMessage => ({
+  id,
+  message: `line ${id}`,
+  timestamp: new Date(Date.UTC(2026, 8, 28, 12, minute)).toISOString(),
+  from: { steam_id: "76561198000000002" },
+});
+
+const ids = (messages: readonly LobbyMessage[]) =>
+  messages.map((message) => message.id);
+
+function connect() {
+  const send = vi.fn();
+  (socket as any).connected = true;
+  (socket as any).connection = { send };
+  return send;
+}
+
+function disconnect() {
+  (socket as any).connected = false;
+  (socket as any).connection = undefined;
+}
+
+function sentDeletes(send: ReturnType<typeof vi.fn>) {
+  return send.mock.calls
+    .map(([payload]) => JSON.parse(payload))
+    .filter(({ event }) => event === "lobby:delete")
+    .map(({ data }) => data);
+}
+
+async function settled(promise: Promise<unknown>) {
+  let state = "pending";
+  promise.then(
+    () => {
+      state = "resolved";
+    },
+    () => {
+      state = "rejected";
+    },
+  );
+  await Promise.resolve();
+  await Promise.resolve();
+  return state;
+}
+
 describe("Socket chat:error", () => {
   beforeEach(() => {
     toast.mockClear();
@@ -23,16 +67,265 @@ describe("Socket chat:error", () => {
     });
   });
 
-  it.each(["not_allowed", "invalid", "gagged"])(
-    "toasts a failed send for %s",
-    (code) => {
-      socket.emit("chat:error", { code });
+  it.each(["not_allowed", "invalid"])("toasts a failed send for %s", (code) => {
+    socket.emit("chat:error", { code });
 
-      expect(toast).toHaveBeenCalledWith({
-        title: "Failed to send message",
-        description: undefined,
-        variant: "destructive",
-      });
-    },
-  );
+    expect(toast).toHaveBeenCalledWith({
+      title: "Failed to send message",
+      description: undefined,
+      variant: "destructive",
+    });
+  });
+
+  it("tells a gagged player why their send was refused", () => {
+    socket.emit("chat:error", { code: "gagged", action: "send" });
+
+    expect(toast).toHaveBeenCalledWith({
+      title: "Failed to send message",
+      description: "You're gagged and can't send chat messages.",
+      variant: "destructive",
+    });
+  });
+
+  it("titles a delete nobody is waiting on as a failed delete", () => {
+    socket.emit("chat:error", {
+      code: "not_allowed",
+      action: "delete",
+      requestId: "nobody-asked",
+    });
+
+    expect(toast).toHaveBeenCalledWith({
+      title: "Failed to delete message",
+      description: undefined,
+      variant: "destructive",
+    });
+  });
+
+  it("reports a message that was already gone without calling it a failure", () => {
+    socket.emit("chat:error", { code: "not_found", action: "delete" });
+
+    expect(toast).toHaveBeenCalledWith({ title: "Message already removed" });
+  });
+});
+
+describe("Socket deleteMessage", () => {
+  let send: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    toast.mockClear();
+    send = connect();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    disconnect();
+  });
+
+  it("asks the api to delete the message with a request id", () => {
+    void socket.deleteMessage("match", "match-1", "message-1").catch(() => {});
+
+    const [request] = sentDeletes(send);
+    expect(request).toMatchObject({
+      type: "match",
+      id: "match-1",
+      messageId: "message-1",
+    });
+    expect(typeof request.requestId).toBe("string");
+  });
+
+  it("resolves on the ack for its own request", async () => {
+    const pending = socket.deleteMessage("match", "match-1", "message-1");
+    const [{ requestId }] = sentDeletes(send);
+
+    socket.emit("chat:ack", { requestId: "someone-else", action: "delete" });
+    expect(await settled(pending)).toBe("pending");
+
+    socket.emit("chat:ack", {
+      requestId,
+      messageId: "message-1",
+      action: "send",
+    });
+    expect(await settled(pending)).toBe("pending");
+
+    socket.emit("chat:ack", {
+      requestId,
+      messageId: "message-1",
+      action: "delete",
+    });
+    await expect(pending).resolves.toBeUndefined();
+  });
+
+  it("rejects on the error for its own request without a global toast", async () => {
+    const pending = socket.deleteMessage("match", "match-1", "message-1");
+    const [{ requestId }] = sentDeletes(send);
+
+    socket.emit("chat:error", {
+      code: "not_allowed",
+      action: "delete",
+      requestId,
+    });
+
+    await expect(pending).rejects.toMatchObject({
+      code: "not_allowed",
+      action: "delete",
+    });
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it("gives up when the api never answers", async () => {
+    vi.useFakeTimers();
+    const pending = socket.deleteMessage("match", "match-1", "message-1");
+
+    vi.advanceTimersByTime(7999);
+    expect(await settled(pending)).toBe("pending");
+
+    vi.advanceTimersByTime(1);
+    await expect(pending).rejects.toMatchObject({
+      code: "timeout",
+      action: "delete",
+    });
+  });
+
+  it("takes a late answer quietly instead of reporting it twice", async () => {
+    vi.useFakeTimers();
+    const pending = socket.deleteMessage("match", "match-1", "message-1");
+    const [{ requestId }] = sentDeletes(send);
+    pending.catch(() => {});
+
+    vi.advanceTimersByTime(8000);
+    socket.emit("chat:error", {
+      code: "not_allowed",
+      action: "delete",
+      requestId,
+    });
+
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it("stops recognising a late answer after a minute", async () => {
+    vi.useFakeTimers();
+    const pending = socket.deleteMessage("match", "match-1", "message-1");
+    const [{ requestId }] = sentDeletes(send);
+    pending.catch(() => {});
+
+    vi.advanceTimersByTime(8000 + 60000);
+    socket.emit("chat:error", {
+      code: "not_allowed",
+      action: "delete",
+      requestId,
+    });
+
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect((socket as any).pendingRequests.has(requestId)).toBe(false);
+  });
+
+  it("refuses straight away while offline and sends nothing", async () => {
+    disconnect();
+
+    await expect(
+      socket.deleteMessage("match", "match-1", "message-1"),
+    ).rejects.toMatchObject({ code: "offline", action: "delete" });
+    expect(sentDeletes(send)).toEqual([]);
+    expect((socket as any).offlineQueue).not.toContainEqual(
+      expect.objectContaining({ event: "lobby:delete" }),
+    );
+  });
+});
+
+describe("Socket lobby deletes", () => {
+  let lobby: ReturnType<typeof socket.joinLobby>;
+  let deleted: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.spyOn(console, "info").mockImplementation(() => {});
+    lobby = socket.joinLobby("socket-spec", "match", "match-1");
+    deleted = vi.fn();
+    lobby.on("lobby:deleted", deleted);
+    socket.emit("lobby:match:match-1:messages", {
+      messages: [line("a", 0), line("b", 1), line("c", 2)],
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    lobby.leave();
+    disconnect();
+    vi.restoreAllMocks();
+  });
+
+  it("removes the message and tells the lobby where it was", () => {
+    socket.emit("lobby:match:match-1:deleted", { id: "b" });
+
+    expect(ids(lobby.messages)).toEqual(["a", "c"]);
+    expect(deleted).toHaveBeenCalledWith({ message: line("b", 1), index: 1 });
+  });
+
+  it("keeps a deleted message out of a stale snapshot and a replayed chat", () => {
+    socket.emit("lobby:match:match-1:deleted", { id: "b" });
+
+    socket.emit("lobby:match:match-1:messages", {
+      messages: [line("a", 0), line("b", 1), line("c", 2)],
+    });
+    socket.emit("lobby:match:match-1:chat", line("b", 1));
+
+    expect(ids(lobby.messages)).toEqual(["a", "c"]);
+  });
+
+  it("drops a message deleted before it ever arrived", () => {
+    socket.emit("lobby:match:match-1:deleted", { id: "d" });
+    socket.emit("lobby:match:match-1:chat", line("d", 3));
+
+    expect(ids(lobby.messages)).toEqual(["a", "b", "c"]);
+    expect(deleted).not.toHaveBeenCalled();
+  });
+
+  it("ignores a delete with no id", () => {
+    socket.emit("lobby:match:match-1:deleted", {});
+
+    expect(ids(lobby.messages)).toEqual(["a", "b", "c"]);
+  });
+
+  it("removes the message on the ack, before the room hears about it", async () => {
+    const send = connect();
+    const pending = socket.deleteMessage("match", "match-1", "b");
+    const [{ requestId }] = sentDeletes(send);
+
+    socket.emit("chat:ack", { requestId, messageId: "b", action: "delete" });
+    await pending;
+
+    expect(ids(lobby.messages)).toEqual(["a", "c"]);
+
+    socket.emit("lobby:match:match-1:deleted", { id: "b" });
+    expect(deleted).toHaveBeenCalledTimes(1);
+  });
+
+  it("applies an ack that lands after the timeout", async () => {
+    vi.useFakeTimers();
+    const send = connect();
+    const pending = socket.deleteMessage("match", "match-1", "b");
+    const [{ requestId }] = sentDeletes(send);
+    pending.catch(() => {});
+
+    vi.advanceTimersByTime(8000);
+    await expect(pending).rejects.toMatchObject({ code: "timeout" });
+
+    socket.emit("chat:ack", { requestId, messageId: "b", action: "delete" });
+
+    expect(ids(lobby.messages)).toEqual(["a", "c"]);
+  });
+
+  it("removes a message the api says is already gone", async () => {
+    const send = connect();
+    const pending = socket.deleteMessage("match", "match-1", "b");
+    const [{ requestId }] = sentDeletes(send);
+
+    socket.emit("chat:error", {
+      code: "not_found",
+      action: "delete",
+      requestId,
+    });
+
+    await expect(pending).rejects.toMatchObject({ code: "not_found" });
+    expect(ids(lobby.messages)).toEqual(["a", "c"]);
+  });
 });
diff --git a/utilities/chatErrors.ts b/utilities/chatErrors.ts
index a606e3d55..ef8a50ec0 100644
--- a/utilities/chatErrors.ts
+++ b/utilities/chatErrors.ts
@@ -1,23 +1,63 @@
 import { toast } from "@/components/ui/toast";
 import { CHAT_MESSAGE_MAX_LENGTH } from "~/constants/chat";
 
+// Echoed by the api on `chat:ack` and `chat:error`. An api that predates it
+// sends none, and only ever answered sends.
+export type ChatAction = "send" | "delete";
+
 export interface ChatError {
   code: string;
+  action?: ChatAction;
   max?: number;
   requestId?: string;
 }
 
 type Translate = (key: string, params?: Record<string, unknown>) => string;
 
+export function chatErrorAction(error: ChatError): ChatAction {
+  return error?.action ?? "send";
+}
+
+// A delete the api can't find a message for has still left the room without
+// it, which is all the moderator asked for.
+export function chatErrorFailed(error: ChatError) {
+  return !(chatErrorAction(error) === "delete" && error?.code === "not_found");
+}
+
+export function chatErrorTitle(error: ChatError, t: Translate): string {
+  switch (chatErrorAction(error)) {
+    case "delete":
+      if (!chatErrorFailed(error)) {
+        return t("chat.message_already_gone");
+      }
+      return t("chat.delete_failed");
+    case "send":
+    default:
+      return t("chat.send_failed");
+  }
+}
+
 export function chatErrorDescription(
   error: ChatError,
   t: Translate,
 ): string | undefined {
+  if (chatErrorAction(error) === "delete") {
+    switch (error?.code) {
+      case "timeout":
+        return t("chat.delete_timeout");
+      case "not_allowed":
+      default:
+        return undefined;
+    }
+  }
+
   switch (error?.code) {
     case "too_long":
       return t("chat.message_too_long", {
         max: error.max ?? CHAT_MESSAGE_MAX_LENGTH,
       });
+    case "gagged":
+      return t("chat.gagged");
     // Also sent when a send queued while offline reaches the server before the
     // lobby rejoin does, so it must not tell the user they are barred.
     case "not_allowed":
@@ -30,8 +70,13 @@ export function toastChatError(error: ChatError) {
   const { $i18n } = useNuxtApp();
   const t: Translate = (key, params) => $i18n.t(key, params ?? {});
 
+  if (!chatErrorFailed(error)) {
+    toast({ title: chatErrorTitle(error, t) });
+    return;
+  }
+
   toast({
-    title: t("chat.send_failed"),
+    title: chatErrorTitle(error, t),
     description: chatErrorDescription(error, t),
     variant: "destructive",
   });
diff --git a/utilities/chatLobbyMessages.ts b/utilities/chatLobbyMessages.ts
new file mode 100644
index 000000000..ff2c88099
--- /dev/null
+++ b/utilities/chatLobbyMessages.ts
@@ -0,0 +1,104 @@
+import type { LobbyMessage } from "~/web-sockets/Socket";
+
+// The live `chat` event and the history snapshot sent on every (re)join can
+// carry the same message, so a message needs an identity the client can compare
+// them by. Anything written before the server started stamping an id falls back
+// to a composite key.
+export function chatMessageKey(message: LobbyMessage) {
+  if (message?.id) {
+    return message.id;
+  }
+
+  return [
+    message?.from?.steam_id ?? "",
+    message?.timestamp ?? "",
+    message?.message ?? "",
+  ].join("|");
+}
+
+export function chatMessageTime(message: LobbyMessage) {
+  return new Date(message?.timestamp).getTime() || 0;
+}
+
+export function isChatMessageDeleted(
+  message: LobbyMessage,
+  deleted: ReadonlySet<string>,
+) {
+  return !!message?.id && deleted.has(message.id);
+}
+
+// The server sends its whole history for the room, so the snapshot replaces
+// what we hold rather than being unioned into it. A union never drops what the
+// server has since expired, and leaves the list growing for the life of the
+// handle.
+//
+// Anything newer than the snapshot is kept: a live message can land in the
+// window between the server building the snapshot and it arriving here. The
+// same window means a snapshot can still carry a message deleted since, so the
+// tombstones apply to both halves.
+export function mergeChatSnapshot(
+  current: LobbyMessage[],
+  snapshot: LobbyMessage[] | null | undefined,
+  deleted: ReadonlySet<string>,
+) {
+  const history = snapshot || [];
+  const snapshotKeys = new Set(history.map(chatMessageKey));
+
+  const newest = history.reduce(
+    (latest, message) => Math.max(latest, chatMessageTime(message)),
+    0,
+  );
+
+  const merged = history
+    .concat(
+      current.filter((message) => {
+        return (
+          !snapshotKeys.has(chatMessageKey(message)) &&
+          chatMessageTime(message) >= newest
+        );
+      }),
+    )
+    .filter((message) => !isChatMessageDeleted(message, deleted));
+
+  merged.sort((a, b) => chatMessageTime(a) - chatMessageTime(b));
+
+  return merged;
+}
+
+export function insertChatMessage(
+  current: LobbyMessage[],
+  message: LobbyMessage,
+) {
+  const messages = current.slice();
+  const timestamp = chatMessageTime(message);
+
+  let index = messages.length;
+  while (index > 0 && chatMessageTime(messages[index - 1]) > timestamp) {
+    index--;
+  }
+  messages.splice(index, 0, message);
+
+  return messages;
+}
+
+export interface RemovedChatMessage {
+  messages: LobbyMessage[];
+  message: LobbyMessage;
+  index: number;
+}
+
+export function removeChatMessage(
+  current: LobbyMessage[],
+  messageId: string,
+): RemovedChatMessage | null {
+  const index = current.findIndex((message) => message?.id === messageId);
+
+  if (index === -1) {
+    return null;
+  }
+
+  const messages = current.slice();
+  const [message] = messages.splice(index, 1);
+
+  return { messages, message, index };
+}
diff --git a/utilities/chatMessageActions.ts b/utilities/chatMessageActions.ts
new file mode 100644
index 000000000..a00744ea9
--- /dev/null
+++ b/utilities/chatMessageActions.ts
@@ -0,0 +1,31 @@
+import type { ChatType, LobbyMessage } from "~/web-sockets/Socket";
+
+export interface ChatMessagePermissions {
+  canDelete: boolean;
+}
+
+export interface ChatMessagePermissionInput {
+  message: LobbyMessage | null | undefined;
+  viewerSteamId?: string | null;
+  canModerate: boolean;
+  roomType: ChatType | string;
+}
+
+// Mirrors the api's ChatService.canDelete, so the menu never offers what the
+// server would refuse. The api only addresses a message by its id; lines from
+// before it stamped one can't be targeted at all.
+export function chatMessagePermissions({
+  message,
+  canModerate,
+  roomType,
+}: ChatMessagePermissionInput): ChatMessagePermissions {
+  const addressable = !!message?.id;
+
+  return {
+    canDelete: addressable && canModerate && roomType !== "direct",
+  };
+}
+
+export function hasChatMessageActions(permissions: ChatMessagePermissions) {
+  return Object.values(permissions).some(Boolean);
+}
diff --git a/web-sockets/Socket.ts b/web-sockets/Socket.ts
index c171ee413..133e68c98 100644
--- a/web-sockets/Socket.ts
+++ b/web-sockets/Socket.ts
@@ -3,7 +3,22 @@ import { shallowRef, type ShallowRef } from "vue";
 import type { e_match_types_enum } from "~/generated/zeus";
 import { toast } from "@/components/ui/toast";
 import { useChatReadState } from "~/composables/useChatReadState";
-import { toastChatError } from "~/utilities/chatErrors";
+import {
+  toastChatError,
+  type ChatAction,
+  type ChatError,
+} from "~/utilities/chatErrors";
+import {
+  chatMessageKey,
+  insertChatMessage,
+  isChatMessageDeleted,
+  mergeChatSnapshot,
+  removeChatMessage,
+  type RemovedChatMessage,
+} from "~/utilities/chatLobbyMessages";
+import guid from "~/utilities/uuid";
+
+export { chatMessageKey, chatMessageTime } from "~/utilities/chatLobbyMessages";
 
 export interface LobbyMessage {
   id?: string;
@@ -30,9 +45,14 @@ export interface Lobby {
   leave: () => void;
 }
 
+export type LobbyMessageDeleted = Omit<RemovedChatMessage, "messages">;
+
 interface LobbyState {
   messages: ShallowRef<LobbyMessage[]>;
   seen: Set<string>;
+  // Ids the room has deleted. A history snapshot built before the delete can
+  // still arrive after it, and must not bring the message back.
+  deleted: Set<string>;
   instances: Set<string>;
   callbacks: Map<string, (data: any) => void>;
   listeners: ReturnType<typeof Socket.prototype.listen>[];
@@ -52,24 +72,17 @@ export type ChatType =
   // sorted ascending and joined with ":" -- see useDirectMessages.
   | "direct";
 
-// The live `chat` event and the history snapshot sent on every (re)join can
-// carry the same message, so a message needs an identity the client can compare
-// them by. Anything written before the server started stamping an id falls back
-// to a composite key.
-export function chatMessageKey(message: LobbyMessage) {
-  if (message?.id) {
-    return message.id;
-  }
-
-  return [
-    message?.from?.steam_id ?? "",
-    message?.timestamp ?? "",
-    message?.message ?? "",
-  ].join("|");
+interface ChatAck {
+  requestId?: string;
+  messageId?: string;
+  action?: ChatAction;
 }
 
-export function chatMessageTime(message: LobbyMessage) {
-  return new Date(message?.timestamp).getTime() || 0;
+interface PendingChatRequest {
+  action: ChatAction;
+  resolve: () => void;
+  reject: (error: ChatError) => void;
+  timer: ReturnType<typeof setTimeout>;
 }
 
 export class Socket extends EventEmitter {
@@ -101,6 +114,12 @@ export class Socket extends EventEmitter {
 
   private lobbies: Map<string, LobbyState> = new Map();
   private instanceCounter = 0;
+  private pendingRequests: Map<string, PendingChatRequest> = new Map();
+  // The api answers a request it failed to carry out with nothing at all.
+  private static readonly REQUEST_TIMEOUT_MS = 8000;
+  // How long a request that timed out still recognises its answer, so a slow
+  // one is applied quietly instead of being reported a second time.
+  private static readonly LATE_ANSWER_MS = 60000;
   private rooms: Map<
     string,
     {
@@ -392,6 +411,83 @@ export class Socket extends EventEmitter {
     });
   }
 
+  // Never queued: a moderator told the delete failed must not have it carried
+  // out behind their back once the connection comes back.
+  public deleteMessage(
+    type: ChatType,
+    id: string,
+    messageId: string,
+  ): Promise<void> {
+    if (!this.connected || !this.connection) {
+      return Promise.reject({ code: "offline", action: "delete" });
+    }
+
+    const requestId = guid();
+    const lobbyId = `${type}:${id}`;
+
+    return new Promise<void>((resolve, reject) => {
+      const pending: PendingChatRequest = {
+        action: "delete",
+        resolve: () => {
+          this.removeMessageFromLobby(lobbyId, messageId);
+          resolve();
+        },
+        reject: (error) => {
+          if (error?.code === "not_found") {
+            this.removeMessageFromLobby(lobbyId, messageId);
+          }
+          reject(error);
+        },
+        timer: setTimeout(() => {
+          reject({ code: "timeout", action: "delete", requestId });
+          pending.timer = setTimeout(() => {
+            this.pendingRequests.delete(requestId);
+          }, Socket.LATE_ANSWER_MS);
+        }, Socket.REQUEST_TIMEOUT_MS),
+      };
+
+      this.pendingRequests.set(requestId, pending);
+
+      this.event(`lobby:delete`, {
+        id,
+        type,
+        messageId,
+        requestId,
+      });
+    });
+  }
+
+  public resolveChatRequest(ack: ChatAck) {
+    this.takeChatRequest(ack)?.resolve();
+  }
+
+  public rejectChatRequest(error: ChatError) {
+    const pending = this.takeChatRequest(error);
+    if (!pending) {
+      return false;
+    }
+
+    pending.reject(error);
+    return true;
+  }
+
+  private takeChatRequest(answer: ChatAck | ChatError) {
+    const requestId = answer?.requestId;
+    if (!requestId) {
+      return undefined;
+    }
+
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending || (answer.action ?? "send") !== pending.action) {
+      return undefined;
+    }
+
+    this.pendingRequests.delete(requestId);
+    clearTimeout(pending.timer);
+
+    return pending;
+  }
+
   // Server-side read state, so a room's unread count survives a reload and
   // doesn't come back on another device -- and so no push is sent for a
   // message that has already been read here.
@@ -485,6 +581,7 @@ export class Socket extends EventEmitter {
       instances: new Set([instanceKey]),
       messages: shallowRef([]),
       seen: new Set(),
+      deleted: new Set(),
       callbacks: new Map(),
       listeners: [],
     };
@@ -523,6 +620,12 @@ export class Socket extends EventEmitter {
       }),
     );
 
+    lobby.listeners.push(
+      this.listen(`lobby:${lobbyId}:deleted`, (data: { id?: string }) => {
+        this.removeLobbyMessage(lobby, data?.id);
+      }),
+    );
+
     this.join(`lobby`, {
       id: _id,
       type,
@@ -532,32 +635,12 @@ export class Socket extends EventEmitter {
   }
 
   private mergeLobbyMessages(lobby: LobbyState, messages: LobbyMessage[]) {
-    const snapshot = messages || [];
-    const snapshotKeys = new Set(snapshot.map(chatMessageKey));
-
-    // The server sends its whole history for the room, so the snapshot replaces
-    // what we hold rather than being unioned into it. A union never drops what
-    // the server has since expired, and leaves both the list and `seen` growing
-    // for the life of the handle.
-    //
-    // Anything newer than the snapshot is kept: a live message can land in the
-    // window between the server building the snapshot and it arriving here.
-    const newest = snapshot.reduce(
-      (latest, message) => Math.max(latest, chatMessageTime(message)),
-      0,
+    const merged = mergeChatSnapshot(
+      lobby.messages.value,
+      messages,
+      lobby.deleted,
     );
 
-    const merged = snapshot.concat(
-      lobby.messages.value.filter((message) => {
-        return (
-          !snapshotKeys.has(chatMessageKey(message)) &&
-          chatMessageTime(message) >= newest
-        );
-      }),
-    );
-
-    merged.sort((a, b) => chatMessageTime(a) - chatMessageTime(b));
-
     lobby.seen.clear();
     for (const message of merged) {
       lobby.seen.add(chatMessageKey(message));
@@ -569,22 +652,42 @@ export class Socket extends EventEmitter {
 
   private addLobbyMessage(lobby: LobbyState, message: LobbyMessage) {
     const key = chatMessageKey(message);
-    if (lobby.seen.has(key)) {
+    if (lobby.seen.has(key) || isChatMessageDeleted(message, lobby.deleted)) {
       return;
     }
     lobby.seen.add(key);
 
-    const messages = lobby.messages.value.slice();
-    const timestamp = chatMessageTime(message);
+    lobby.messages.value = insertChatMessage(lobby.messages.value, message);
+    this.emitToLobbyInstances(lobby, "lobby:chat", message);
+  }
 
-    let index = messages.length;
-    while (index > 0 && chatMessageTime(messages[index - 1]) > timestamp) {
-      index--;
+  private removeMessageFromLobby(lobbyId: string, messageId: string) {
+    const lobby = this.lobbies.get(lobbyId);
+    if (lobby) {
+      this.removeLobbyMessage(lobby, messageId);
     }
-    messages.splice(index, 0, message);
+  }
 
-    lobby.messages.value = messages;
-    this.emitToLobbyInstances(lobby, "lobby:chat", message);
+  private removeLobbyMessage(lobby: LobbyState, messageId?: string) {
+    if (typeof messageId !== "string" || !messageId) {
+      return;
+    }
+
+    lobby.deleted.add(messageId);
+
+    const removed = removeChatMessage(lobby.messages.value, messageId);
+    if (!removed) {
+      return;
+    }
+
+    lobby.seen.delete(chatMessageKey(removed.message));
+    lobby.messages.value = removed.messages;
+
+    const event: LobbyMessageDeleted = {
+      message: removed.message,
+      index: removed.index,
+    };
+    this.emitToLobbyInstances(lobby, "lobby:deleted", event);
   }
 
   private emitToLobbyInstances(
@@ -673,7 +776,18 @@ socket.listen(
   },
 );
 
-socket.listen("chat:error", toastChatError);
+socket.listen("chat:ack", (ack: ChatAck) => {
+  socket.resolveChatRequest(ack);
+});
+
+// A request with someone waiting on it is theirs to report.
+socket.listen("chat:error", (error: ChatError) => {
+  if (socket.rejectChatRequest(error)) {
+    return;
+  }
+
+  toastChatError(error);
+});
 
 socket.listen("matchmaking:region-stats", (data) => {
   useMatchmakingStore().regionStats = data;