@gloom-sh/terminal 0.19.0 → 0.19.1

package/src/plugins/builtin/cds/model.ts

@@ -5,6 +5,7 @@ import type { HeadlessPaneFreshness } from "../../../types/headless";
 import type { TickerRecord } from "../../../types/ticker";
 import { formatCompact } from "../../../utils/format";
 import { compareSortValues, type SortPreference } from "../../../utils/sort-values";
+import { typoDistance } from "../../../utils/typo-distance";
 import { formatMove } from "../credit-boards/model";
 
 export const CDS_PANE_ID = "cds";
@@ -20,7 +21,7 @@ const DECIMAL_TO_BP = 10_000;
 
 export interface CdsTrade {
   id: string;
-  /** Reported spelling, kept verbatim so a display name can be chosen later. */
+  /** The issuer's best spelling on the tape, the same on every print of it (see `normalizeCdsTrades`). */
   issuer: string;
   /** Alias-collapsed grouping key. Internal only; never shown or sent. */
   issuerKey: string;
@@ -31,8 +32,13 @@ export interface CdsTrade {
   notionalCapped: boolean;
   currency: string | null;
   couponBp: number | null;
-  /** Only what the report carried. Never derived from upfront or coupon. */
+  /**
+   * Only what the report carried. Never derived from upfront or coupon, and
+   * empty when the field held points upfront (`pointsUpfront`).
+   */
   spreadBp: number | null;
+  /** The quote of a print whose spread field held points upfront, not bp. */
+  pointsUpfront: number | null;
   /** Source inputs retained even when their notation cannot supply a bp rate. */
   reportedSpread: number | null;
   spreadNotation: string | null;
@@ -143,6 +149,66 @@ export function issuerGroupKey(name: string): string {
   return (meaningful.length > 0 ? meaningful : tokens).join(" ") || name.trim().toLowerCase();
 }
 
+/** Fewer letters than this are a symbol, not words of a name: `f` is Ford's ticker, not "F&G Annuities & Life". */
+const MIN_NAME_LETTERS = 3;
+
+/**
+ * The covered issuer a name stands for, by its words: the issuer of that very
+ * name, else one whose name holds those words in a row (`goodyear` is "The
+ * Goodyear Tire & Rubber Company"), one that starts with them first, then the
+ * shortest, so `ford` is Ford Motor Company and not Ford Motor Credit. Null
+ * when none does, and for fewer than three letters (`f`, `ge`), which are a
+ * symbol to look up.
+ */
+export function coveredIssuerMatch(name: string, covered: readonly string[]): string | null {
+  const wanted = issuerGroupKey(displayIssuerName(name));
+  if (wanted.replace(/[^\p{L}\p{N}]/gu, "").length < MIN_NAME_LETTERS) return null;
+  let best: { issuer: string; leading: boolean; words: number } | null = null;
+  for (const issuer of covered) {
+    const key = issuerGroupKey(displayIssuerName(issuer));
+    if (key === wanted) return displayIssuerName(issuer);
+    if (!` ${key} `.includes(` ${wanted} `)) continue;
+    const candidate = { issuer: displayIssuerName(issuer), leading: key.startsWith(`${wanted} `), words: key.split(" ").length };
+    if (!best
+      || (candidate.leading !== best.leading ? candidate.leading
+        : candidate.words !== best.words ? candidate.words < best.words
+          : candidate.issuer.localeCompare(best.issuer) < 0)) best = candidate;
+  }
+  return best?.issuer ?? null;
+}
+
+/** How many covered issuers an unmatched name offers. */
+const CLOSEST_ISSUERS = 3;
+
+/**
+ * How near a word is to one of a name's: a slip of the keys, or the same first
+ * letters (`goodyer`, `paramo`). Short words never count, or every name with
+ * "co" in it would be close.
+ */
+function wordCloseness(typed: string, word: string): number {
+  if (typed.length < 3 || word.length < 3) return 0;
+  if (typed.length >= 4 && typoDistance(typed, word) <= 1) return typed.length;
+  let shared = 0;
+  while (shared < Math.min(typed.length, word.length) && typed[shared] === word[shared]) shared += 1;
+  return shared >= 4 || (shared >= 3 && shared === typed.length) ? shared : 0;
+}
+
+/** The covered issuers closest to a name that matched none, closest first; none when nothing is near. */
+export function closestCoveredIssuers(name: string, covered: readonly string[]): string[] {
+  const typed = issuerGroupKey(displayIssuerName(name)).split(" ").filter(Boolean);
+  const scored = new Map<string, number>();
+  for (const issuer of covered) {
+    const words = issuerGroupKey(displayIssuerName(issuer)).split(" ");
+    const score = typed.reduce((sum, word) => sum + Math.max(0, ...words.map((other) => wordCloseness(word, other))), 0);
+    const shown = displayIssuerName(issuer);
+    if (score > 0 && score > (scored.get(shown) ?? 0)) scored.set(shown, score);
+  }
+  return [...scored]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+    .slice(0, CLOSEST_ISSUERS)
+    .map(([issuer]) => issuer);
+}
+
 /**
  * DTCC writes a comma inside a field as `;` ("CCO Holdings;LLC",
  * "Amazon.com;Inc."), so a name gets its comma back before it is shown,
@@ -207,6 +273,37 @@ function couponToBasisPoints(fixedRate: number | null): number | null {
   return fixedRate * DECIMAL_TO_BP;
 }
 
+/**
+ * How far a reported quote may sit from the points its upfront works out to
+ * and still be read as those points: accrued and rounding move the amount by
+ * about a tenth of a point.
+ */
+const POINTS_MATCH_PTS = 0.5;
+const POINTS_MATCH_SHARE = 0.05;
+
+/**
+ * Some desks key a distressed name's points upfront into the spread field and
+ * leave the coupon blank: Whirlpool's Dec 2028 contract printed `0.00065`,
+ * 6.5 read as bp, beside 319,861 upfront on 5M, which is 6.4 points. Without a
+ * coupon nothing makes the field a running spread, and when the amount over
+ * the notional reads as the same number in points, it is that many points.
+ * A real spread that low on a running coupon would need the upfront to land on
+ * the same number by chance, below 5bp.
+ */
+function pointsUpfrontOf(
+  spreadBp: number | null,
+  couponBp: number | null,
+  upfront: number | null,
+  notional: number | null,
+): number | null {
+  if (couponBp != null || spreadBp == null || !(spreadBp > 0)) return null;
+  if (upfront == null || !Number.isFinite(upfront) || notional == null || !(notional > 0)) return null;
+  const impliedPts = (Math.abs(upfront) / notional) * 100;
+  const tolerance = Math.max(POINTS_MATCH_PTS, impliedPts * POINTS_MATCH_SHARE);
+  // The decimal the field holds carries float noise (0.001525 is 15.249999...).
+  return Math.abs(spreadBp - impliedPts) <= tolerance ? Math.round(spreadBp * 1e6) / 1e6 : null;
+}
+
 /**
  * When the trade was struck, not when the tape carried it. A lifecycle
  * correction is disseminated long after the fact, so using the event time would
@@ -232,32 +329,46 @@ function issuerOf(trade: CloudCdsTradePayload): string | null {
   return underlier && identifiesIssuer(underlier) ? displayIssuerName(underlier) : null;
 }
 
+/**
+ * The tape's prints as rows. One issuer reads as one name on every print:
+ * the tape spells Whirlpool three ways in a week ("WHIRLPOOL CORPORATION",
+ * "Whirlpool Corp", "Whirlpool Corporation"), and each row takes the spelling
+ * the issuer list shows for them all.
+ */
 export function normalizeCdsTrades(trades: readonly CloudCdsTradePayload[]): CdsTrade[] {
   const rows: CdsTrade[] = [];
+  const names = new Map<string, string>();
   for (const trade of trades) {
     const eventAt = tapeTime(trade);
     if (eventAt == null) continue;
     const issuer = issuerOf(trade);
     // Nothing names the reference entity, so the row would invent one.
     if (!issuer) continue;
+    const issuerKey = issuerGroupKey(issuer);
+    const named = names.get(issuerKey);
+    names.set(issuerKey, named ? preferredIssuerName(named, issuer) : issuer);
+    const couponBp = couponToBasisPoints(trade.fixedRate);
+    const reportedBp = spreadToBasisPoints(trade.reportedSpread, trade.spreadNotation);
+    const pointsUpfront = pointsUpfrontOf(reportedBp, couponBp, trade.upfrontAmount, trade.notionalAmount);
     rows.push({
       id: trade.disseminationId,
       issuer,
-      issuerKey: issuerGroupKey(issuer),
+      issuerKey,
       eventAt,
       maturity: trade.maturityDate ?? trade.expirationDate,
       notional: trade.notionalAmount,
       notionalCapped: trade.notionalCapped,
       currency: trade.notionalCurrency,
-      couponBp: couponToBasisPoints(trade.fixedRate),
-      spreadBp: spreadToBasisPoints(trade.reportedSpread, trade.spreadNotation),
+      couponBp,
+      spreadBp: pointsUpfront == null ? reportedBp : null,
+      pointsUpfront,
       reportedSpread: trade.reportedSpread,
       spreadNotation: trade.spreadNotation,
       upfront: trade.upfrontAmount,
       upfrontCurrency: trade.upfrontCurrency,
     });
   }
-  return rows;
+  return rows.map((row) => ({ ...row, issuer: names.get(row.issuerKey) ?? row.issuer }));
 }
 
 /**
@@ -405,13 +516,23 @@ export function cdsFreshness(lastTrade: number | string | null): HeadlessPaneFre
  * What an empty view says: the window searched and, for one name, the
  * reference entity the query became, with what was typed when that differs.
  */
-export function noTradesMessage({ query, issuer, days }: {
+export function noTradesMessage({ query, issuer, days, unmatched = null }: {
   query: string | null;
   issuer: string | null;
   days: number;
+  /**
+   * A name that matched no covered issuer, once the tape has no trades and no
+   * line under it either: what the view says instead is that no issuer
+   * matches, with the covered ones closest to what was typed.
+   */
+  unmatched?: { nearest: readonly string[] } | null;
 }): string {
   const window = `in the last ${days} days`;
   if (!query) return `No single-name CDS trades ${window}.`;
+  if (unmatched) {
+    const nearest = unmatched.nearest.length ? ` Closest covered issuers: ${unmatched.nearest.join(", ")}.` : "";
+    return `No CDS issuer matches ${query}.${nearest}`;
+  }
   const name = issuer && issuer.toUpperCase() !== query.toUpperCase() ? `${issuer} (${query})` : issuer ?? query;
   return `No CDS trades for ${name} ${window}.`;
 }
@@ -610,22 +731,25 @@ export function sortIssuers(
   });
 }
 
-export type TradeColumnId = "time" | "maturity" | "notional" | "currency" | "coupon" | "spread" | "upfront";
+export type TradeColumnId = "time" | "maturity" | "notional" | "currency" | "coupon" | "spread" | "points" | "upfront";
 export type TradeColumn = DataTableColumn & { id: TradeColumnId };
 export type TradeSortPreference = SortPreference<TradeColumnId>;
 
-export const TRADE_SORT_COLUMN_IDS: readonly TradeColumnId[] = [
-  "time",
-  "maturity",
-  "notional",
-  "coupon",
-  "spread",
-  "upfront",
-];
 export const DEFAULT_TRADE_SORT: TradeSortPreference = { columnId: "time", direction: "desc" };
 
-export function buildTradeColumns(width: number): TradeColumn[] {
-  const maturityWidth = Math.max(10, Math.min(12, width - 59));
+/** Whether any print was quoted in points upfront, which is when the trades show a Points column. */
+export function hasPointsQuotes(trades: readonly Pick<CdsTrade, "pointsUpfront">[]): boolean {
+  return trades.some((trade) => trade.pointsUpfront != null);
+}
+
+/** The columns `]` and `[` cycle the trades' sort through: the ones shown. */
+export function tradeSortColumnIds(points: boolean): readonly TradeColumnId[] {
+  return ["time", "maturity", "notional", "coupon", "spread", ...(points ? ["points" as const] : []), "upfront"];
+}
+
+/** A Points column sits beside Spread only when a print was quoted in points. */
+export function buildTradeColumns(width: number, points = false): TradeColumn[] {
+  const maturityWidth = Math.max(10, Math.min(12, width - 59 - (points ? 9 : 0)));
   return [
     { id: "time", label: "TIME UTC", width: 16, align: "left" },
     { id: "maturity", label: "MATURITY", width: maturityWidth, align: "left" },
@@ -633,6 +757,7 @@ export function buildTradeColumns(width: number): TradeColumn[] {
     { id: "currency", label: "CCY", width: 5, align: "left" },
     { id: "coupon", label: "COUPON", width: 9, align: "right" },
     { id: "spread", label: "SPREAD", width: 10, align: "right" },
+    ...(points ? [{ id: "points" as const, label: "POINTS", width: 9, align: "right" as const }] : []),
     { id: "upfront", label: "ABS UPFRONT", width: 13, align: "right" },
   ];
 }
@@ -651,6 +776,8 @@ function tradeSortValue(columnId: TradeColumnId, row: CdsTrade): string | number
       return row.couponBp;
     case "spread":
       return row.spreadBp;
+    case "points":
+      return row.pointsUpfront;
     case "upfront":
       return row.upfront;
   }

package/src/plugins/builtin/cds/pane.tsx

@@ -40,7 +40,6 @@ import {
   DEFAULT_ISSUER_SORT,
   DEFAULT_TRADE_SORT,
   ISSUER_SORT_COLUMN_IDS,
-  TRADE_SORT_COLUMN_IDS,
   buildIssuerColumns,
   buildTradeColumns,
   cdsFreshness,
@@ -48,9 +47,11 @@ import {
   formatEventTime,
   formatMaturity,
   formatNotional,
+  formatPoints,
   formatQuoted,
   formatQuotedMove,
   formatUpfront,
+  hasPointsQuotes,
   issuerListSort,
   lastTradeOf,
   noLevelMessage,
@@ -63,6 +64,7 @@ import {
   spreadChartPoints,
   spreadFigures,
   summarizeIssuers,
+  tradeSortColumnIds,
   tradesForIssuer,
   withSpreadLevels,
   type CdsIssuerSummary,
@@ -138,6 +140,11 @@ function renderTradeCell(row: CdsTrade, column: TradeColumn, lineMaturity: strin
         text: formatBp(row.spreadBp),
         color: dimmed ?? (row.spreadBp == null ? colors.textDim : colors.textBright),
       };
+    case "points":
+      return {
+        text: formatPoints(row.pointsUpfront),
+        color: dimmed ?? (row.pointsUpfront == null ? colors.textDim : colors.textBright),
+      };
     case "upfront":
       return {
         text: formatUpfront(row),
@@ -175,7 +182,8 @@ function CdsTradeTable({
   /** What an empty table says: the window and the name searched. */
   emptyMessage: string;
 }) {
-  const columns = useMemo(() => buildTradeColumns(width), [width]);
+  const points = hasPointsQuotes(trades);
+  const columns = useMemo(() => buildTradeColumns(width, points), [points, width]);
   const renderTradeRow = useCallback((trade: CdsTrade, column: TradeColumn) => (
     renderTradeCell(trade, column, lineMaturity)
   ), [lineMaturity]);
@@ -276,7 +284,7 @@ function IssuerHeader({ issuer, line, trades, width, height, focused, loading, s
   });
   return (
     <ChartTableHeader width={width} height={height} tableRows={trades.length} figures={figures}
-      tableColumns={buildTradeColumns(width)}
+      tableColumns={buildTradeColumns(width, hasPointsQuotes(trades))}
       chart={points.length >= 2 || loading || why ? {
         series,
         formatValue: (value: number) => formatQuoted(unit, value),
@@ -388,12 +396,13 @@ export function CdsPane({
     setDetailOpen(false);
   }, [issuerQuery, issuers, selectedIssuerKey]);
 
+  const tradePoints = hasPointsQuotes(visibleTrades);
   const cycleTradeSort = useCallback((step: 1 | -1) => {
     setTradeSort((current) => {
-      const next = cycleSortPreference<TradeColumnId>(TRADE_SORT_COLUMN_IDS, current, step);
+      const next = cycleSortPreference<TradeColumnId>(tradeSortColumnIds(tradePoints), current, step);
       return { columnId: next.columnId ?? DEFAULT_TRADE_SORT.columnId, direction: next.direction };
     });
-  }, []);
+  }, [tradePoints]);
   const cycleIssuerSort = useCallback((step: 1 | -1) => {
     setIssuerSort((current) => {
       const next = cycleSortPreference<IssuerColumnId>(ISSUER_SORT_COLUMN_IDS, current, step);
@@ -451,6 +460,8 @@ export function CdsPane({
     query: issuerQuery ? activity?.query ?? issuerQuery : selectedSummary?.issuer ?? null,
     issuer: issuerQuery ? activity?.issuer ?? null : selectedSummary?.issuer ?? null,
     days: activity?.days ?? CDS_TRADE_DAYS,
+    // A name the covered issuers do not have, once the tape has neither trades nor a line under it.
+    unmatched: issuerQuery && activity?.unmatched && !trades.length && history.data && !history.data.issuer ? activity.unmatched : null,
   });
 
   if (status === "loading" && !activity) {

package/src/plugins/builtin/chart-composer/follow-binding.ts

@@ -21,6 +21,16 @@ function normalized(instrument: InstrumentRef): InstrumentRef {
 const key = (instrument: InstrumentRef) => instrumentIdentityKey(normalized(instrument));
 const publicKey = (instrument: InstrumentRef) => publicTickerKey(instrument.symbol, instrument.exchange);
 
+/**
+ * One listing however a series names it: the same symbol and broker contract, on the same venue
+ * or with the venue left out on either side (`AAPL` added beside a revenue line on `AAPL:NASDAQ`).
+ */
+function sameListing(left: InstrumentRef, right: InstrumentRef): boolean {
+  const a = normalized(left), b = normalized(right);
+  return key({ ...a, exchange: "" }) === key({ ...b, exchange: "" })
+    && (!a.exchange || !b.exchange || canonicalExchange(a.exchange) === canonicalExchange(b.exchange));
+}
+
 /** Bootstrap old charts once; persisted IDs keep ownership through comparison collisions. */
 export function resolveFollowSeriesIds(
   spec: ChartSpec,
@@ -44,8 +54,10 @@ export function resolveFollowSeriesIds(
     || (next && securities.find(series => series.source.kind === "security" && publicKey(normalized(series.source.instrument)) === publicKey(next)))
     || securities[0];
   if (!owner || owner.source.kind !== "security") return [];
-  const ownerKey = key(owner.source.instrument);
-  return securities.filter(series => series.source.kind === "security" && key(series.source.instrument) === ownerKey).map(series => series.id);
+  const ownerInstrument = owner.source.instrument;
+  // Every field of the followed ticker moves with it (revenue and total debt); other tickers stay.
+  return securities.filter(series => series.source.kind === "security" && sameListing(series.source.instrument, ownerInstrument))
+    .map(series => series.id);
 }
 
 /** Only the followed series move; other contracts and comparisons stay authored. */

package/src/plugins/builtin/chart-composer/index.tsx

@@ -10,7 +10,6 @@ import { parseTickerListInput } from "../../../tickers/list";
 import { canonicalExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
 import { tickerInstrumentLabel } from "../../../tickers/instrument-label";
 import type { ChartSpec } from "../../../time-series/types";
-import { isPriceOnlyMarketFieldId } from "../../../time-series/field-catalog";
 import { ChartComposerPane, ChartComposerResearchTab } from "./pane";
 import { DataCatalogPane } from "./data-catalog-pane";
 import { listFieldSeries } from "./field-series";
@@ -484,9 +483,10 @@ const chartComposerTemplates: PaneTemplateDef[] = [
 ];
 
 /**
- * A price chart of one security (GP, GIP, a custom price chart of one ticker) can follow a list.
- * A comparison would move only its first ticker, a FRED-only chart has no ticker to follow, and
- * fundamental and valuation graphs (GF, GE) stay out even for one ticker.
+ * A chart whose securities are all one ticker can follow a list: GP, GIP, and GF or GE of one
+ * ticker, whatever fields it shows (revenue beside total debt). Every series of that ticker moves
+ * to the selected one and keeps its field; FRED and other series stay as they are. A comparison
+ * of several tickers would move only one of them, and a FRED-only chart has no ticker to follow.
  */
 function chartShowsOneSecurity(pane: PaneInstanceConfig): boolean {
   const spec = parseChartSpec(pane.settings?.[CHART_SPEC_SETTING_KEY]);
@@ -495,7 +495,6 @@ function chartShowsOneSecurity(pane: PaneInstanceConfig): boolean {
   const symbols = new Set<string>();
   for (const series of spec.series) {
     if (series.source.kind !== "security") continue;
-    if (!isPriceOnlyMarketFieldId(series.source.fieldId)) return false;
     symbols.add(parsePublicTickerKey(series.source.instrument.symbol).symbol.toUpperCase());
   }
   return symbols.size === 1;

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

@@ -74,6 +74,7 @@ import { ChatControllerMessageLoading } from "./message-loading";
 import { ChatMentionCandidates } from "./mention-candidates";
 import { ChatControllerStorage } from "./storage";
 import { listUnreadInboxItems } from "../unread-inbox";
+import { ChatStatusPreview } from "../status-preview";
 import type { ChatConversationList } from "../conversations";
 import {
   conversationActivityAt,
@@ -118,6 +119,8 @@ export class ChatController {
   );
   private notifyFn: (notification: AppNotificationRequest) => AppNotificationDelivery | void = () => {};
   private openMessageFn: ((channelId: string, messageId: string) => void) | undefined;
+  /** A DM, mention or reply that shows in the status bar on arrival; the status bar widget draws it. */
+  readonly statusPreview = new ChatStatusPreview();
   private readonly alerts = new ChatNotificationAlerts({
     getAppActive: () => this.appActive,
     ensureChannelState: (channelId) => this.ensureChannelState(channelId),
@@ -125,6 +128,7 @@ export class ChatController {
     getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
     getNotify: () => this.notifyFn,
     getOpenMessage: () => this.openMessageFn,
+    statusPreview: this.statusPreview,
   });
 
   private readonly storage = new ChatControllerStorage({
@@ -271,7 +275,7 @@ export class ChatController {
    * Keeps who sent each channel's unread messages (`unreadPeople` in the
    * snapshot) current until the returned stop is called, reading what the
    * device does not hold. Nothing is read, and the snapshot leaves it empty,
-   * unless something tracks it: only the app badge needs it.
+   * unless something tracks it: the app badge and the status bar widget.
    */
   trackUnreadPeople(): () => void {
     return this.unreadPeople.track();

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

@@ -5,7 +5,9 @@ import type {
 import { apiClient, type ChatChannel, type ChatMessage, type ChatNotification } from "../../../../api-client";
 import type { ChannelRuntimeState, MergeMessagesOptions } from "./state";
 import { formatChatPaneTitle } from "../channel-labels";
+import type { ChatStatusPreview } from "../status-preview";
 import {
+  chatMessageLine,
   formatChannelToast,
   formatMentionToast,
   formatReplyToast,
@@ -28,6 +30,8 @@ interface ChatNotificationAlertsOptions {
   getChannel: (channelId: string) => ChatChannel | undefined;
   getNotify: () => Notify;
   getOpenMessage: () => ((channelId: string, messageId: string) => void) | undefined;
+  /** Where a message for you shows on arrival instead of a toast, while the status bar has room. */
+  statusPreview: ChatStatusPreview;
 }
 
 /** Whether this window holds the message as read: its read marker is at or after it. */
@@ -53,9 +57,9 @@ function acknowledge(notification: ChatNotification, seen: boolean): void {
 }
 
 /**
- * Decides, once per message, whether a chat notification becomes a toast or
- * a desktop banner. A message already read here or on another device stays
- * quiet, whether it arrives live or again on reconnect.
+ * Decides, once per message, whether a chat notification shows in the status
+ * bar, as a toast or as a desktop banner. A message already read here or on
+ * another device stays quiet, whether it arrives live or again on reconnect.
  */
 export class ChatNotificationAlerts {
   private readonly notifiedMessageIds = new Set<string>();
@@ -94,6 +98,7 @@ export class ChatNotificationAlerts {
     for (const timer of this.waiting.values()) clearTimeout(timer);
     this.waiting.clear();
     this.notifiedMessageIds.clear();
+    this.options.statusPreview.dismiss();
   }
 
   /** Read here, or open in front of the reader: nothing to raise, and the server hears it was seen. */
@@ -124,8 +129,33 @@ export class ChatNotificationAlerts {
     this.present(notification);
   }
 
+  /**
+   * A DM or group message, a mention or a reply, while the app is in front:
+   * the status bar shows it in place of the toast when it has room, and the
+   * server hears it was seen, as for a toast. Channel chatter never shows there.
+   */
+  private presentInStatusBar(notification: ChatNotification, channel: ChatChannel | undefined): boolean {
+    const direct = channel?.kind === "direct" || channel?.kind === "group";
+    if (!this.options.getAppActive() || (notification.type === "channel" && !direct)) return false;
+    const { message } = notification;
+    const sentAt = Date.parse(message.createdAt);
+    const shown = this.options.statusPreview.offer({
+      channelId: notification.channelId,
+      messageId: notification.messageId,
+      senderName: message.user.username?.trim() || message.user.displayName,
+      direct,
+      text: chatMessageLine(message),
+      at: Number.isFinite(sentAt) ? sentAt : Date.now(),
+    });
+    if (!shown) return false;
+    this.notifiedMessageIds.add(notification.messageId);
+    acknowledge(notification, true);
+    return true;
+  }
+
   private present(notification: ChatNotification): void {
     const channel = this.options.getChannel(notification.channelId);
+    if (this.presentInStatusBar(notification, channel)) return;
     const body = notification.type === "reply"
       ? formatReplyToast(notification.message)
       : notification.type === "mention"

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.
    */