gloomberb 0.19.0 → 0.19.2

package/src/plugins/builtin/chat/controller/state.ts

@@ -46,12 +46,34 @@ export interface PersistedTranscript {
   messages: ChatMessage[];
 }
 
+/** An unread message for you: who sent it, and when. */
+export interface UnreadMessageForYou {
+  /** Null for a DM whose unread messages are not on this device: only the sender is known. */
+  messageId: string | null;
+  senderId: string;
+  /** The sender's username, or their name without one. */
+  senderName: string;
+  /** When it was sent, in ms; zero when not known. */
+  at: number;
+}
+
 /** Who the unread messages of one channel are from, by account id. */
 export interface ChannelUnreadPeople {
   /** Everyone who sent an unread message there. */
   senders: string[];
-  /** The ones among them with an unread message that mentions you. */
+  /** The ones among them with an unread message that mentions you or replies to you. */
   mentioners: string[];
+  /**
+   * The newest unread message for you: in a DM or group chat the newest
+   * unread message, elsewhere the newest that mentions or replies to you.
+   * Null when none is known on this device.
+   */
+  latestForYou: UnreadMessageForYou | null;
+  /**
+   * How many unread messages are for you: every one in a DM or group chat,
+   * the ones known to mention or reply to you elsewhere.
+   */
+  forYouCount: number;
 }
 
 export interface ChatControllerSnapshot {
@@ -83,7 +105,8 @@ export interface ChatControllerSnapshot {
   unreadMentionCount: number;
   /**
    * Who sent the unread messages of each channel with any, by channel id: what
-   * the app badge counts people from. Empty unless the badge asked for it
+   * the app badge counts people from and the status bar names them from.
+   * Empty unless one of them asked for it
    * ({@link ChatController.trackUnreadPeople}). A channel whose unread messages
    * are not on this device yet lists only the ones that are, until they load.
    */

package/src/plugins/builtin/chat/controller/unread-people.ts

@@ -1,5 +1,5 @@
 import { apiClient, type ChatChannel, type ChatMessage } from "../../../../api-client";
-import type { ChannelRuntimeState, ChannelUnreadPeople } from "./state";
+import type { ChannelRuntimeState, ChannelUnreadPeople, UnreadMessageForYou } from "./state";
 import { chatMessageMentionsUsername, normalizeChatUsername } from "./utils";
 
 /** The most messages the server returns for one request. */
@@ -18,38 +18,73 @@ interface Reader {
   username: string | null;
 }
 
-/** What the app badge needs of one unread message: who sent it, and whether it mentions you. */
-interface UnreadFact {
-  senderId: string;
+/** What the app badge and the status bar need of one unread message. */
+interface UnreadFact extends Omit<UnreadMessageForYou, "messageId"> {
+  messageId: string;
+  /** It mentions you, or replies to a message of yours. */
   mentionsYou: boolean;
 }
 
+function sentAt(createdAt: string | null | undefined): number {
+  const time = createdAt ? Date.parse(createdAt) : Number.NaN;
+  return Number.isFinite(time) ? time : 0;
+}
+
+/** Whether the message answers one of `reader`'s, by account or, from a server that leaves the id out, by username. */
+function repliesTo(message: ChatMessage, reader: Reader): boolean {
+  const author = message.replyTo?.user;
+  if (!author) return false;
+  if (author.id) return author.id === reader.id;
+  return !!reader.username && normalizeChatUsername(author.username) === reader.username;
+}
+
 function unreadFact(message: ChatMessage, reader: Reader): UnreadFact {
   return {
+    messageId: message.id,
     senderId: message.user.id,
-    mentionsYou: !!reader.username && chatMessageMentionsUsername(message.content, reader.username),
+    senderName: message.user.username?.trim() || message.user.displayName,
+    at: sentAt(message.createdAt),
+    mentionsYou: (!!reader.username && chatMessageMentionsUsername(message.content, reader.username))
+      || repliesTo(message, reader),
   };
 }
 
-function peopleOf(facts: Iterable<UnreadFact>): ChannelUnreadPeople {
+/**
+ * The people behind unread messages, and the newest one for you. In a DM or
+ * group chat (`everyMessageForYou`) every message is for you; elsewhere only
+ * the ones that mention or reply to you are.
+ */
+function peopleOf(facts: Iterable<UnreadFact>, everyMessageForYou: boolean): ChannelUnreadPeople {
   const senders = new Set<string>();
   const mentioners = new Set<string>();
+  let latestForYou: UnreadMessageForYou | null = null;
+  let forYouCount = 0;
   for (const fact of facts) {
     senders.add(fact.senderId);
     if (fact.mentionsYou) mentioners.add(fact.senderId);
+    if (!everyMessageForYou && !fact.mentionsYou) continue;
+    forYouCount += 1;
+    if (!latestForYou || fact.at >= latestForYou.at) {
+      latestForYou = { messageId: fact.messageId, senderId: fact.senderId, senderName: fact.senderName, at: fact.at };
+    }
   }
-  return { senders: [...senders], mentioners: [...mentioners] };
+  return { senders: [...senders], mentioners: [...mentioners], latestForYou, forYouCount };
 }
 
 /**
- * The people behind unread messages: who sent them and who mentioned
- * `reader`. Your own messages are never unread.
+ * The people behind unread messages: who sent them, who mentioned or replied
+ * to `reader`, and the newest message for them. Your own messages are never
+ * unread.
  */
 export function summarizeUnreadMessages(
   messages: readonly ChatMessage[],
   reader: { id: string; username: string | null },
+  { everyMessageForYou = false }: { everyMessageForYou?: boolean } = {},
 ): ChannelUnreadPeople {
-  return peopleOf(messages.filter((message) => message.user.id !== reader.id).map((message) => unreadFact(message, reader)));
+  return peopleOf(
+    messages.filter((message) => message.user.id !== reader.id).map((message) => unreadFact(message, reader)),
+    everyMessageForYou,
+  );
 }
 
 /** Messages read from the server for a channel whose unread messages are not all on this device. */
@@ -75,15 +110,16 @@ interface UnreadPeopleOptions {
 }
 
 /**
- * Who each channel's unread messages are from, for the app badge. The server
- * keeps a count per channel and a read marker, not the senders, so they come
- * from the messages after the marker: the ones this device holds, and for a
- * channel whose unread messages are not all here, the newest 300 of the rest
- * read from the server once (then only what is new). Nothing is guessed: a
- * channel that has not loaded yet reports the unread messages it does hold.
+ * Who each channel's unread messages are from, for the app badge and the
+ * status bar. The server keeps a count per channel and a read marker, not
+ * the senders, so they come from the messages after the marker: the ones
+ * this device holds, and for a channel whose unread messages are not all
+ * here, the newest 300 of the rest read from the server once (then only what
+ * is new). Nothing is guessed: a channel that has not loaded yet reports the
+ * unread messages it does hold.
  *
- * Only a host that keeps an app badge needs this, so it does nothing, and
- * makes no request, until something asks to {@link track} it.
+ * It does nothing, and makes no request, until something asks to
+ * {@link track} it: the app badge, and the status bar while signed in.
  */
 export class ChatControllerUnreadPeople {
   private readonly loaded = new Map<string, LoadedUnread>();
@@ -113,11 +149,21 @@ export class ChatControllerUnreadPeople {
     const people: Record<string, ChannelUnreadPeople> = {};
     for (const [channelId, state] of this.options.getChannelStates()) {
       if (state.unreadCount <= 0) continue;
-      const otherPerson = directPerson(channels.get(channelId));
+      const channel = channels.get(channelId);
+      const conversation = channel?.kind === "direct" || channel?.kind === "group";
+      const known = peopleOf(this.knownFacts(channelId, state, reader).values(), conversation);
+      // In a DM or group every unread message is for you, held here or not.
+      if (conversation) known.forYouCount = state.unreadCount;
+      const otherPerson = directPerson(channel);
       // Everything unread in a DM is from the one person on the other side.
       people[channelId] = otherPerson
-        ? { senders: [otherPerson], mentioners: [] }
-        : peopleOf(this.knownFacts(channelId, state, reader).values());
+        ? {
+          senders: [otherPerson.id],
+          mentioners: [],
+          latestForYou: known.latestForYou ?? newestFrom(otherPerson, state, channel),
+          forYouCount: known.forYouCount,
+        }
+        : known;
     }
     return people;
   }
@@ -216,9 +262,29 @@ export class ChatControllerUnreadPeople {
   }
 }
 
+/**
+ * The newest unread message of a DM whose read marker is not on this device:
+ * unread messages are the newest ones, so it is the newest message held from
+ * the other person, or failing one, just them as of the conversation's last
+ * message.
+ */
+function newestFrom(
+  person: NonNullable<ChatChannel["dmUser"]>,
+  state: ChannelRuntimeState,
+  channel: ChatChannel | undefined,
+): UnreadMessageForYou {
+  const held = state.messages.findLast((message) => message.user.id === person.id && !message.clientStatus);
+  return {
+    messageId: held?.id ?? null,
+    senderId: person.id,
+    senderName: person.username?.trim() || person.displayName,
+    at: Math.max(sentAt(held?.createdAt), sentAt(channel?.lastMessageAt)),
+  };
+}
+
 /** The one other person in a direct message, when the channel says who. */
-function directPerson(channel: ChatChannel | undefined): string | null {
-  return channel?.kind === "direct" ? channel.dmUser?.id ?? null : null;
+function directPerson(channel: ChatChannel | undefined): NonNullable<ChatChannel["dmUser"]> | null {
+  return channel?.kind === "direct" ? channel.dmUser ?? null : null;
 }
 
 /**

package/src/plugins/builtin/chat/controller/utils.ts

@@ -20,9 +20,14 @@ export function chatMessageMentionsUsername(content: string, username: string):
   return false;
 }
 
-/** The message as one short line, its images as `[image]` in front of the text. */
+/** The message on one line, its images as `[image]` in front of the text. */
+export function chatMessageLine(message: ChatMessage): string {
+  return chatTextWithImages(message.content, message.attachments?.length ?? 0).replace(/\s+/g, " ").trim();
+}
+
+/** The message as one short line. */
 function formatMessageSnippet(message: ChatMessage): string {
-  const normalized = chatTextWithImages(message.content, message.attachments?.length ?? 0).replace(/\s+/g, " ").trim();
+  const normalized = chatMessageLine(message);
   return normalized.length > 72 ? `${normalized.slice(0, 69)}...` : normalized;
 }
 

package/src/plugins/builtin/chat/status-preview.ts

@@ -0,0 +1,79 @@
+/** How long a message for you shows in the status bar before it folds into the chip. */
+const STATUS_PREVIEW_MS = 9_000;
+
+/** A message for you, as the status bar shows it on arrival. */
+export interface ChatStatusPreviewItem {
+  channelId: string;
+  messageId: string;
+  senderName: string;
+  /** It came in a DM or group chat; otherwise it mentions or replies to you. */
+  direct: boolean;
+  /** The message on one line. */
+  text: string;
+  /** When it was sent, in ms. */
+  at: number;
+}
+
+/** Whether the status bar has room for the item now. */
+type PreviewRoom = (item: ChatStatusPreviewItem) => boolean;
+
+/**
+ * The message for you that the status bar shows on arrival, in place of the
+ * chat toast, for {@link STATUS_PREVIEW_MS}: then it folds into the chip that
+ * names who wants you. The newest message wins; nothing stacks. It shows only
+ * while a status bar with room for it is mounted ({@link attach}); otherwise
+ * the toast goes up as before.
+ */
+export class ChatStatusPreview {
+  private current: ChatStatusPreviewItem | null = null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly rooms = new Set<PreviewRoom>();
+  private readonly listeners = new Set<() => void>();
+  durationMs = STATUS_PREVIEW_MS;
+
+  /** A status bar that can show the preview when `room` says it fits, until the returned release. */
+  attach(room: PreviewRoom): () => void {
+    this.rooms.add(room);
+    return () => {
+      this.rooms.delete(room);
+      if (this.rooms.size === 0) this.dismiss();
+    };
+  }
+
+  /**
+   * Takes the message for the status bar when one has room for it, and shows
+   * it unless a newer one is showing (that one stays; this one counts in the
+   * chip). False when no status bar can: the caller raises its toast instead.
+   */
+  offer(item: ChatStatusPreviewItem): boolean {
+    if (![...this.rooms].some((room) => room(item))) return false;
+    if (this.current && this.current.at > item.at) return true;
+    this.current = item;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.dismiss(), this.durationMs);
+    this.emit();
+    return true;
+  }
+
+  get = (): ChatStatusPreviewItem | null => this.current;
+
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  /** Folds the message into the chip now: opened, read, or no status bar left to show it. */
+  dismiss(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    if (!this.current) return;
+    this.current = null;
+    this.emit();
+  }
+
+  private emit(): void {
+    for (const listener of this.listeners) listener();
+  }
+}

package/src/plugins/builtin/chat/status-widget.tsx

@@ -1,9 +1,17 @@
 import { Button } from "../../../components/ui/button";
+import { Badge, ClippedText } from "../../../components/ui/display";
 import { Icon } from "../../../components/ui/icon";
-import { useEffect, useState, useSyncExternalStore } from "react";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import {
+  STATUS_WIDGET_COLUMNS,
+  useOtherStatusWidgetClaims,
+  useStatusWidgetClaim,
+  useStatusWidgetRoom,
+} from "../../../components/layout/status-widget-space";
 import { usePaneAppConfig } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
-import { Box, Span, Text, TextAttributes, useUiCapabilities } from "../../../ui";
+import { Box, Span, Text, useUiCapabilities } from "../../../ui";
+import { clipToDisplayWidth, displayWidth } from "../../../utils/format";
 import { usePluginAppActions } from "../../runtime";
 import { getNotificationLog, subscribeNotificationLog } from "../../../notifications/notification-log";
 import { InlineAuthActions } from "../cloud/auth-actions";
@@ -11,11 +19,75 @@ import {
   getPreferredChatOpenChannelId,
 } from "./channels";
 import { chatController, type ChatController } from "./controller";
+import type { ChatStatusPreviewItem } from "./status-preview";
 import { UNREAD_INBOX_TEMPLATE_ID } from "./unread-inbox";
-import { unreadTotal } from "./unread-badge";
+import { unreadForYou, unreadTotal } from "./unread-badge";
 
 interface ChatStatusWidgetProps {
-  controller?: Pick<ChatController, "getSnapshot" | "refreshSession" | "subscribe">;
+  controller?: Pick<ChatController, "getSnapshot" | "refreshSession" | "subscribe" | "trackUnreadPeople" | "statusPreview">;
+}
+
+/** The widget's claim on the status bar's spare columns, for the chip and the message on arrival. */
+const CLAIM_ID = "chat";
+/** A name in the chip is cut to this many columns. */
+const CHIP_NAME_COLUMNS = 12;
+/** The message on arrival never takes more columns than this, and does not show in fewer than the least. */
+const PREVIEW_MOST_COLUMNS = 48;
+const PREVIEW_LEAST_COLUMNS = 12;
+
+/** Who the chip names: the sender of the newest message for you, and whether it came in a DM or group chat. */
+interface ChipWho {
+  senderName: string;
+  direct: boolean;
+}
+
+interface ChipFace {
+  icon?: "mail";
+  label: string;
+  /** Terminal cells, its padding included. */
+  columns: number;
+}
+
+/**
+ * The chip: an envelope for a DM or group message, `@` for a mention or a
+ * reply, then the sender's name and how many others want you, each left out
+ * when `name` or `more` says so.
+ */
+function chipFace(who: ChipWho, others: number, { name, more }: { name: boolean; more: boolean }): ChipFace {
+  const label = [
+    who.direct ? "" : "@",
+    name ? clipToDisplayWidth(who.senderName, CHIP_NAME_COLUMNS) : "",
+    more && others > 0 ? `+${others}` : "",
+  ].filter(Boolean).join(" ");
+  // The glyph and its space (one cell wide in a terminal), then the label, inside one cell of padding each side.
+  const columns = (who.direct ? (label ? 2 : 1) : 0) + displayWidth(label) + 2;
+  return { ...(who.direct ? { icon: "mail" as const } : {}), label, columns };
+}
+
+/** The chip's faces from the fullest down: the name goes last, the count of others before it. */
+const CHIP_FACES = [
+  { name: true, more: true },
+  { name: true, more: false },
+  { name: false, more: true },
+  { name: false, more: false },
+];
+
+/**
+ * How the chip and the message fit in `spare` columns beside the account
+ * name: the full chip and the message, then the chip alone, shorter and
+ * shorter, or nothing. One space goes after the chip; the message takes one
+ * before it and one more after, so it does not run into the account name.
+ */
+function fitChip(who: ChipWho | null, others: number, text: string | null, spare: number): { face: ChipFace; previewColumns: number } | null {
+  if (!who) return null;
+  for (const [index, parts] of CHIP_FACES.entries()) {
+    const face = chipFace(who, others, parts);
+    if (face.columns + 1 > spare) continue;
+    const room = Math.min(PREVIEW_MOST_COLUMNS, spare - face.columns - 3);
+    const previewColumns = text && index === 0 && room >= PREVIEW_LEAST_COLUMNS ? Math.min(room, displayWidth(text)) : 0;
+    return { face, previewColumns };
+  }
+  return null;
 }
 
 function CloudStatusIcon() {
@@ -44,6 +116,7 @@ function CloudStatusIcon() {
 
 export function ChatStatusWidget({ controller = chatController }: ChatStatusWidgetProps) {
   const { createPaneFromTemplate } = usePluginAppActions();
+  const { nativePaneChrome } = useUiCapabilities();
   const config = usePaneAppConfig();
   const initialSnapshot = controller.getSnapshot();
   const [username, setUsername] = useState<string | null>(initialSnapshot.user?.username ?? null);
@@ -51,7 +124,34 @@ export function ChatStatusWidget({ controller = chatController }: ChatStatusWidg
   const [snapshot, setSnapshot] = useState(initialSnapshot);
   // What the Unread list shows as unread: chat, then missed price, catalyst, economic release and team notices.
   const notices = useSyncExternalStore(subscribeNotificationLog, getNotificationLog, getNotificationLog);
-  const unreadCount = unreadTotal(snapshot, notices);
+  const preview = useSyncExternalStore(controller.statusPreview.subscribe, controller.statusPreview.get, controller.statusPreview.get);
+  const room = useStatusWidgetRoom();
+  const othersClaimed = useOtherStatusWidgetClaims(CLAIM_ID);
+  const signedIn = !!username || hasSavedSession;
+
+  // Who wants you: the people the app badge counts, the newest of them named in the chip.
+  const forYou = unreadForYou(snapshot);
+  const total = unreadTotal(snapshot, notices);
+  // A message on arrival shows until its conversation is read.
+  const unreadIn = (channelId: string) => snapshot.channelStates.find((state) => state.channelId === channelId)?.unreadCount ?? 0;
+  const arriving = preview && unreadIn(preview.channelId) > 0 ? preview : null;
+  const who: ChipWho | null = arriving ?? forYou.latest;
+  const others = Math.max(0, forYou.people - 1);
+  // The status bar holds back its usual columns for every widget's own text; the chip and the message are extra.
+  const spare = room - STATUS_WIDGET_COLUMNS - othersClaimed;
+  const fit = signedIn ? fitChip(who, others, arriving?.text ?? null, spare) : null;
+  // Chatter and missed notices: the rest, once the chip names who wants you.
+  const rest = fit ? Math.max(0, total - forYou.messages) : total;
+  const showsMessage = !!arriving && !!fit && fit.previewColumns > 0;
+  useStatusWidgetClaim(CLAIM_ID, fit ? fit.face.columns + 1 + (showsMessage ? fit.previewColumns + 2 : 0) : 0);
+
+  // The alerts ask, as a message arrives, whether the bar has room to show it; if not, its toast goes up.
+  const fits = useRef<(item: ChatStatusPreviewItem) => boolean>(() => false);
+  fits.current = (item) => (fitChip(item, others, item.text, spare)?.previewColumns ?? 0) > 0;
+  useEffect(() => {
+    if (!signedIn) return;
+    return controller.statusPreview.attach((item) => fits.current(item));
+  }, [controller, signedIn]);
 
   const openChat = (event?: { preventDefault?: () => void; stopPropagation?: () => void }) => {
     event?.preventDefault?.();
@@ -66,6 +166,17 @@ export function ChatStatusWidget({ controller = chatController }: ChatStatusWidg
     createPaneFromTemplate(UNREAD_INBOX_TEMPLATE_ID);
   };
 
+  // The chip opens the conversation it names at the message.
+  const target = arriving ?? forYou.latest;
+  const openForYou = () => {
+    if (!target) return;
+    controller.statusPreview.dismiss();
+    createPaneFromTemplate("new-chat-pane", {
+      arg: target.channelId,
+      ...(target.messageId ? { values: { messageId: target.messageId } } : {}),
+    });
+  };
+
   useEffect(() => {
     const unsubscribe = controller.subscribe((nextSnapshot) => {
       setSnapshot(nextSnapshot);
@@ -76,17 +187,43 @@ export function ChatStatusWidget({ controller = chatController }: ChatStatusWidg
     return unsubscribe;
   }, [controller]);
 
+  // Who sent the unread messages is read only while someone is signed in.
+  useEffect(() => (signedIn ? controller.trackUnreadPeople() : undefined), [controller, signedIn]);
+
   return (
     <Box flexDirection="row" paddingRight={1}>
-      {!username && !hasSavedSession ? (
+      {!signedIn ? (
         <>
           <CloudStatusIcon />
           <InlineAuthActions showSignup={false} variant="plain" />
         </>
       ) : (
         <>
+          {fit && who ? (
+            <>
+              <Button
+                label={`Open the message from ${who.senderName}`}
+                variant="plain"
+                compact
+                flush
+                stopPropagation
+                onPress={openForYou}
+              >
+                <Box flexDirection="row" alignItems="center">
+                  <Badge label={fit.face.label} icon={fit.face.icon} tone="warning" translate={false} />
+                  {arriving && showsMessage ? (
+                    // The terminal sizes the message to its cells; the desktop and the web let it shrink to its text and cut it there.
+                    <Box {...(nativePaneChrome ? { maxWidth: fit.previewColumns + 1, flexShrink: 1 } : { width: fit.previewColumns + 1, flexShrink: 0 })} minWidth={0}>
+                      <ClippedText text={arriving.text} width={fit.previewColumns} lead=" " fg={colors.text} cut={clipToDisplayWidth} />
+                    </Box>
+                  ) : null}
+                </Box>
+              </Button>
+              <Text>{showsMessage ? "  " : " "}</Text>
+            </>
+          ) : null}
           <Button label={username ? `Open chat as ${username}` : "Open chat"} variant="plain" compact stopPropagation onPress={openChat}>
-            <Text fg={unreadCount > 0 ? colors.text : colors.textDim}>
+            <Text fg={total > 0 ? colors.text : colors.textDim}>
               <Span fg={colors.positive}>@</Span>
               {username ? (
                 <>
@@ -96,15 +233,15 @@ export function ChatStatusWidget({ controller = chatController }: ChatStatusWidg
               ) : null}
             </Text>
           </Button>
-          {unreadCount > 0 ? (
+          {rest > 0 ? (
             <Button
-              label={`Open ${unreadCount} unread`}
+              label={`Open ${rest} unread`}
               variant="plain"
               compact
               stopPropagation
               onPress={openUnread}
             >
-              <Text fg={colors.positive} attributes={TextAttributes.BOLD}>{` [${unreadCount}]`}</Text>
+              <Text fg={colors.textDim}>{` ${rest}`}</Text>
             </Button>
           ) : null}
         </>

package/src/plugins/builtin/chat/unread-badge.ts

@@ -23,22 +23,63 @@ function isPeopleConversation(channel: ChatChannel | undefined): boolean {
   return channel?.kind === "direct" || channel?.kind === "group";
 }
 
+/** The newest unread message for you, and where it is. */
+interface LatestUnreadForYou {
+  channelId: string;
+  /** Null for a DM whose unread messages are not on this device: it opens at the conversation. */
+  messageId: string | null;
+  senderName: string;
+  /** It came in a DM or group chat; otherwise it mentions or replies to you. */
+  direct: boolean;
+}
+
+/** Who wants you: the people the app badge counts, and the newest of their messages. */
+export interface UnreadForYou {
+  /** The person who wrote to you last; null when nobody wants you. */
+  latest: LatestUnreadForYou | null;
+  /** Everyone who sent you an unread DM or group message, or mentioned or replied to you, each once. */
+  people: number;
+  /** Their unread messages for you. */
+  messages: number;
+}
+
+const NOBODY: UnreadForYou = { latest: null, people: 0, messages: 0 };
+
 /**
- * What the app badge counts: people, not messages. Everyone who sent you an
- * unread DM or group message, and everyone whose unread message in any other
- * channel mentions you, each once however many messages they sent or where;
- * then every missed notice not yet read. Untagged channel messages add
- * nothing. Zero signed out. The status bar keeps counting every unread
- * message ({@link unreadTotal}).
+ * Everyone who sent you an unread DM or group message, and everyone whose
+ * unread message in any other channel mentions or replies to you, each once
+ * however many messages they sent or where; with the newest of those
+ * messages and how many there are. Untagged channel messages are not for
+ * you. Nobody signed out.
  */
-export function unreadBadgeCount(snapshot: BadgeSnapshot, notices: readonly NotificationLogEntry[]): number {
-  if (!snapshot.user && !snapshot.hasSavedSession) return 0;
+export function unreadForYou(snapshot: BadgeSnapshot): UnreadForYou {
+  if (!snapshot.user && !snapshot.hasSavedSession) return NOBODY;
   const channels = new Map(snapshot.channels.map((channel) => [channel.id, channel]));
   const people = new Set<string>();
+  let latest: LatestUnreadForYou | null = null;
+  let latestAt = Number.NEGATIVE_INFINITY;
+  let messages = 0;
   for (const [channelId, who] of Object.entries(snapshot.unreadPeople)) {
-    for (const id of isPeopleConversation(channels.get(channelId)) ? who.senders : who.mentioners) people.add(id);
+    const direct = isPeopleConversation(channels.get(channelId));
+    for (const id of direct ? who.senders : who.mentioners) people.add(id);
+    messages += who.forYouCount;
+    const newest = who.latestForYou;
+    if (!newest || newest.at <= latestAt) continue;
+    latest = { channelId, messageId: newest.messageId, senderName: newest.senderName, direct };
+    latestAt = newest.at;
   }
-  return people.size + unreadNotificationLogCount(notices);
+  return { latest, people: people.size, messages };
+}
+
+/**
+ * What the app badge counts: people, not messages ({@link unreadForYou}),
+ * then every missed notice not yet read. Untagged channel messages add
+ * nothing. Zero signed out. The status bar names the newest of those people
+ * and counts the rest of the unread messages ({@link unreadTotal}).
+ */
+export function unreadBadgeCount(snapshot: BadgeSnapshot, notices: readonly NotificationLogEntry[]): number {
+  if (!snapshot.user && !snapshot.hasSavedSession) return 0;
+  return unreadForYou(snapshot).people + unreadNotificationLogCount(notices);
 }
 
 interface UnreadBadgeOptions {