gloomberb 0.16.2 → 0.16.4

package/src/plugins/builtin/broker-manager/sign-in-end.ts

@@ -0,0 +1,82 @@
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+import { apiClient } from "../../../api-client";
+import { fetchSignedInBrokerConnection, type SignedInBrokerConnection } from "../../../brokers/signed-in/client";
+import { isSignedInBrokerProfile, signedInBrokerId } from "../../../brokers/signed-in/profile";
+import { tf } from "../../../i18n";
+import { useAsyncResource } from "../../../react/async-resource";
+import type { BrokerInstanceConfig } from "../../../types/config";
+import { formatDetailDate, formatShortDate } from "../../../utils/datetime-format";
+
+/**
+ * Some brokers end a sign-in on their own clock, however often it was
+ * refreshed, and Gloom flags it a day before. Only that case shows anything: a
+ * server that predates the flag, or a sign-in with no end in sight, adds nothing.
+ */
+export type SignInEnds = ReadonlyMap<string, number>;
+
+/** When the broker ends the sign-in, if Gloom says it is time to connect again. */
+export function signInEndOf(connection: Pick<SignedInBrokerConnection, "expiresAt" | "expiresSoon">): number | null {
+  if (connection.expiresSoon !== true || !connection.expiresAt) return null;
+  const endsAt = Date.parse(connection.expiresAt);
+  return Number.isFinite(endsAt) ? endsAt : null;
+}
+
+/** The profile row's status, in the place of "Connected": "Ends Oct 10". */
+export function signInEndStatus(endsAt: number, now = Date.now()): string {
+  const date = formatShortDate(endsAt, { year: false });
+  return endsAt > now ? tf("Ends {date}", { date }) : tf("Ended {date}", { date });
+}
+
+/** The profile detail's note: "Sign-in ends Oct 10, 2026 at 3:00 PM". */
+export function signInEndNote(endsAt: number, now = Date.now()): string {
+  const when = formatDetailDate(endsAt);
+  return endsAt > now ? tf("Sign-in ends {when}", { when }) : tf("Sign-in ended {when}", { when });
+}
+
+/**
+ * When each signed-in profile's sign-in ends, by instance id, for the profiles
+ * whose broker is about to end it. Read from Gloom when the pane opens and
+ * after a connect or sync; a failed read is the same as nothing to say.
+ */
+export function useSignInEnds(
+  instances: readonly BrokerInstanceConfig[],
+): { ends: SignInEnds; reload: () => void } {
+  const profiles = useMemo(
+    () => instances.flatMap((instance) => isSignedInBrokerProfile(instance) && instance.enabled !== false
+      ? [{ id: instance.id, broker: signedInBrokerId(instance) }]
+      : []),
+    [instances],
+  );
+  // One read per broker, however many profiles name it.
+  const brokers = useMemo(() => [...new Set(profiles.map((profile) => profile.broker).filter(Boolean))].sort(), [profiles]);
+  const brokerKey = brokers.join(",");
+  const signedIn = useSyncExternalStore(
+    (listener) => apiClient.subscribeCurrentUser(listener),
+    () => apiClient.isSignedIn(),
+    () => apiClient.isSignedIn(),
+  );
+  const loader = useMemo(() => brokerKey && signedIn
+    ? async () => {
+      const reads = await Promise.all(brokerKey.split(",").map(async (broker) => {
+        try {
+          return [broker, signInEndOf(await fetchSignedInBrokerConnection(broker))] as const;
+        } catch {
+          return [broker, null] as const;
+        }
+      }));
+      return new Map(reads);
+    }
+    : null, [brokerKey, signedIn]);
+  const { data, reload } = useAsyncResource(loader, { keepPreviousData: true });
+
+  const ends = useMemo<SignInEnds>(() => {
+    const byInstance = new Map<string, number>();
+    for (const profile of profiles) {
+      const endsAt = data?.get(profile.broker);
+      if (endsAt != null) byInstance.set(profile.id, endsAt);
+    }
+    return byInstance;
+  }, [data, profiles]);
+  const refresh = useCallback(() => { void reload(); }, [reload]);
+  return { ends, reload: refresh };
+}

package/src/plugins/builtin/broker-manager/table.ts

@@ -4,6 +4,7 @@ import { colors } from "../../../theme/colors";
 import { formatRelativeAge } from "../../../utils/datetime-format";
 import type { BrokerDisplayState, BrokerProfileRow } from "./model";
 import { t } from "../../../i18n";
+import { signInEndStatus } from "./sign-in-end";
 
 type BrokerColumnId = "profile" | "status" | "broker" | "mode" | "accounts" | "updated";
 export type BrokerColumn = DataTableColumn & { id: BrokerColumnId };
@@ -45,6 +46,10 @@ export function renderBrokerCell(row: BrokerProfileRow, column: BrokerColumn): D
         attributes: TextAttributes.BOLD,
       };
     case "status":
+      // A sign-in the broker is about to end replaces "Connected" until it is renewed.
+      if (row.signInEndsAt !== null) {
+        return { text: signInEndStatus(row.signInEndsAt), color: colors.warning };
+      }
       return {
         text: row.stateLabel,
         color: stateColor(row.state),

package/src/plugins/builtin/builtin-plugin-meta.ts

@@ -2,8 +2,9 @@
 // the browser catalog (catalog-browser.ts). Keep this file import-free so the
 // browser catalog can read it without pulling in native-only modules.
 //
-// Market Overview and Macro ship fewer panes on the web, so each catalog gives
-// them its own description rather than advertising panes it lacks.
+// Screeners & Movers, Ownership & Insiders and Earnings ship fewer panes on
+// the web, so each catalog gives them their own description rather than
+// advertising panes they lack.
 
 export const applicationPluginMeta = {
   id: "application",
@@ -20,11 +21,44 @@ export const portfolioPluginMeta = {
   toggleable: true,
 };
 
-export const tickerResearchPluginMeta = {
-  id: "ticker-research",
+// Ticker Research's successors. Every module keeps the `ticker-research`
+// state namespace: these four declare it, Alt Data and Quant default to it,
+// and Credit & Bonds and Earnings compose theirs with an override.
+// `ticker-research` itself now stands for all eight in disabledPlugins (see
+// ownership.ts). The core keeps the name people know.
+
+export const tickerCorePluginMeta = {
+  id: "ticker-core",
+  stateId: "ticker-research",
   name: "Ticker Research",
   version: "1.0.0",
-  description: "Company research workspace: overview, charts, financials, filings, ownership, options, analyst research, and events.",
+  description: "Company overview, charts, financials, quotes and returns, analyst research and estimates, KPIs and segments, valuation, dividends, executives, and time and sales.",
+  toggleable: true,
+};
+
+export const optionsVolatilityPluginMeta = {
+  id: "options-volatility",
+  stateId: "ticker-research",
+  name: "Options & Volatility",
+  version: "1.0.0",
+  description: "Option chains and positioning, a pricing calculator, scenarios, the volatility surface, and realized and implied volatility history.",
+  toggleable: true,
+};
+
+export const ownershipPluginMeta = {
+  id: "ownership",
+  stateId: "ticker-research",
+  name: "Ownership & Insiders",
+  version: "1.0.0",
+  toggleable: true,
+};
+
+export const filingsPluginMeta = {
+  id: "filings",
+  stateId: "ticker-research",
+  name: "Filings & Events",
+  version: "1.0.0",
+  description: "SEC filings, risk factors, 8-K events, catalysts and litigation, and M&A and distress.",
   toggleable: true,
 };
 
@@ -36,16 +70,92 @@ export const newsPluginMeta = {
   toggleable: true,
 };
 
-export const marketOverviewPluginMeta = {
-  id: "market-overview",
-  name: "Market Overview",
+// Market Overview's successors. Its modules keep the `market-overview` state
+// namespace; Alt Data and Quant default to `ticker-research`, where their
+// Ticker Research modules keep theirs, and compose their Market Overview
+// modules with a `market-overview` override. `market-overview` itself
+// now stands for all six in disabledPlugins (see ownership.ts).
+
+export const globalMarketsPluginMeta = {
+  id: "global-markets",
+  stateId: "market-overview",
+  name: "Global Markets",
+  version: "1.0.0",
+  description: "World indices, the world map with chokepoint transits, sector and thematic performance, the FX matrix, and relative rotation.",
+  toggleable: true,
+};
+
+export const screenersPluginMeta = {
+  id: "screeners",
+  stateId: "market-overview",
+  name: "Screeners & Movers",
+  version: "1.0.0",
+  toggleable: true,
+};
+
+export const futuresCommoditiesPluginMeta = {
+  id: "futures-commodities",
+  stateId: "market-overview",
+  name: "Futures & Commodities",
+  version: "1.0.0",
+  description: "Futures board and curves, CFTC positioning, and EIA petroleum and gas storage.",
+  toggleable: true,
+};
+
+export const cryptoPluginMeta = {
+  id: "crypto",
+  stateId: "market-overview",
+  name: "Crypto & Perps",
+  version: "1.0.0",
+  description: "Top crypto assets by market cap, and perpetual funding, open interest and premiums.",
+  toggleable: true,
+};
+
+export const altDataPluginMeta = {
+  id: "alt-data",
+  stateId: "ticker-research",
+  name: "Supply Chain & Alt Data",
+  version: "1.0.0",
+  description: "Supply chains and exposure, government awards, hiring, apps and job postings, social mentions, research attention, GPU prices, and power queues.",
+  toggleable: true,
+};
+
+export const quantPluginMeta = {
+  id: "quant",
+  stateId: "ticker-research",
+  name: "Quant",
+  version: "1.0.0",
+  description: "Correlation matrix and relationship graphs, backtests, seasonality, and moves on macro release days.",
+  toggleable: true,
+};
+
+// Macro's successors keep its state namespace, so the pane state, settings and
+// caches saved while they were one plugin stay theirs; the Ticker Research
+// modules Credit & Bonds and Earnings hold keep `ticker-research`. `macro` itself now
+// stands for all three in disabledPlugins (see ownership.ts).
+
+export const ratesMacroPluginMeta = {
+  id: "rates-macro",
+  stateId: "macro",
+  name: "Rates & Macro",
+  version: "1.0.0",
+  description: "Economic calendar and statistics, consumer prices, yield curve, rate path, money markets, central bank rates, volatility, and market valuation.",
+  toggleable: true,
+};
+
+export const creditPluginMeta = {
+  id: "credit",
+  stateId: "macro",
+  name: "Credit & Bonds",
   version: "1.0.0",
+  description: "Single-name, index and sovereign CDS, credit spreads, Treasury auctions, a bond calculator, credit documents and covenants, and debt maturities.",
   toggleable: true,
 };
 
-export const macroPluginMeta = {
-  id: "macro",
-  name: "Macro",
+export const earningsPluginMeta = {
+  id: "earnings",
+  stateId: "macro",
+  name: "Earnings",
   version: "1.0.0",
   toggleable: true,
 };

package/src/plugins/builtin/catalysts/detail.tsx

@@ -18,7 +18,7 @@ function Evidence({ event, width, height }: { event: CatalystEvent; width: numbe
   const facts = catalystFacts(event);
   const procedures = Array.isArray(event.metadata?.proceduralStatements) ? event.metadata.proceduralStatements.filter((value): value is string => typeof value === "string") : [];
   const documents = Array.isArray(event.metadata?.documents) ? event.metadata.documents.filter((value): value is { url: string; title?: string; label?: string } => !!value && typeof value === "object" && "url" in value && typeof value.url === "string" && /^https?:\/\//.test(value.url)) : [];
-  return <ScrollBox width={width} height={desktop ? undefined : height} flexGrow={1} flexBasis={0} contentOptions={{ paddingX: 1 }}>
+  return <ScrollBox scrollY width={width} height={desktop ? undefined : height} flexGrow={1} flexBasis={0} contentOptions={{ paddingX: 1 }}>
     <KeyValueRow label="Classification" value={`${catalystLabel(event.type)} · ${catalystAgency(event.agency)} · ${event.country ?? event.jurisdiction}`} labelWidth={18} />
     <KeyValueRow label="Status" value={humanLabel(event.status)} detail={`Revision ${event.revision}`} labelWidth={18} />
     <KeyValueRow label="Announced" value={catalystDate(event, "announced")} labelWidth={18} />

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

@@ -1145,7 +1145,7 @@ export function ChartComposerPane({ paneId, focused, width, height }: PaneProps)
     }
   }, [follows, ownedIds, savedIds, setSpec, spec, stored, target, unlinkedFrom, updateSettings]);
   if (follows && !target && ownedIds.length > 0) {
-    return <EmptyState title={error ?? "No ticker selected."} />;
+    return <EmptyState title={error ?? "Select a ticker."} />;
   }
   return (
     <ChartComposerSurface

package/src/plugins/builtin/chat/channels.ts

@@ -3,9 +3,10 @@ import type { ChatChannel, ChatChannelState } from "../../../api-client";
 import type { AppConfig } from "../../../types/config";
 import { t } from "../../../i18n";
 import { chatController } from "./controller";
-import { formatChannelLabel } from "./channel-labels";
 import { describeConversationStartError, knownConversationRefusal } from "./direct-messages";
 import { buildChatUserByUsername } from "./content/user-map";
+import { chatConversationRow, chatNewDmRow, openChatConversation, openChatNewDm } from "./command-bar";
+import { buildChatConversations, selectChatConversations } from "./conversations";
 
 export const DEFAULT_CHAT_CHANNEL_ID = "everyone";
 export const LAST_VISITED_CHAT_CHANNEL_KEY = "lastChatChannelId";
@@ -42,20 +43,6 @@ export function getPreferredChatOpenChannelId(
   return normalizeChannelId(unreadConversation?.channelId ?? unreadStates[0]?.channelId ?? getLastVisitedChatChannelId(config));
 }
 
-function conversationDetail(channel: ChatChannel): string {
-  if (channel.kind === "direct") {
-    const displayName = channel.dmUser?.displayName?.trim();
-    const username = channel.dmUser?.username?.trim();
-    return [displayName && username ? displayName : null, t("Direct message")].filter(Boolean).join(" - ");
-  }
-  const members = (channel.members ?? [])
-    .map((member) => member.username ? `@${member.username}` : member.displayName)
-    .filter(Boolean)
-    .slice(0, 4);
-  const suffix = (channel.members?.length ?? 0) > members.length ? ` +${(channel.members?.length ?? 0) - members.length}` : "";
-  return members.length > 0 ? `${t("Group chat")} - ${members.join(", ")}${suffix}` : t("Group chat");
-}
-
 export function parseDmUsernames(value: string): string[] {
   const usernames = new Set<string>();
   for (const rawPart of value.split(/[\s,]+/)) {
@@ -106,18 +93,40 @@ export async function openDmTargetFromCommand(ctx: GloomPluginContext, usernames
   } catch (error) {
     throw new Error(describeConversationStartError(error, usernames, userByUsername));
   }
-  openChatChannelFromCommand(ctx, channel.id);
+  openChatConversation(ctx, channel.id);
 }
 
+/**
+ * `DM` in the command bar. Bare, it lists your DMs and groups, unread first,
+ * then the latest, and ends with New DM, which opens the Chat pane's dialog.
+ * With names after it, the conversations those names find come first, then
+ * the row that starts or opens a DM with exactly what was typed.
+ */
 export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): CommandResultDef[] {
+  const list = chatController.listConversations();
+  const conversations = list
+    ? buildChatConversations(list.states, list.userId)
+      .filter((conversation) => conversation.kind === "direct" || conversation.kind === "group")
+    : [];
+  const open = (channelId: string) => openChatConversation(ctx, channelId);
+  const category = "Chat";
   const trimmed = arg.trim();
   if (trimmed) {
     const usernames = parseDmUsernames(trimmed);
     const valid = hasOnlyDmUsernameArgs(trimmed) && usernames.length > 0;
+    const found = selectChatConversations(conversations, { kind: "search", text: trimmed });
+    const rows: CommandResultDef[] = found.map((conversation) => ({
+      ...chatConversationRow(conversation, open),
+      category,
+    }));
+    // The DM you already share is the row above; a second one would open it too.
+    const alreadyShared = usernames.length === 1
+      && found.some((conversation) => conversation.kind === "direct" && conversation.username === usernames[0]);
+    if (alreadyShared) return rows;
     const label = usernames.length <= 1
       ? `DM ${usernames[0] ? `@${usernames[0]}` : trimmed}`
       : `Group ${usernames.map((username) => `@${username}`).join(", ")}`;
-    return [{
+    return [...rows, {
       id: `start:${valid ? usernames.join(",") : trimmed}`,
       label,
       detail: valid
@@ -125,40 +134,29 @@ export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): Com
           ? t("Start or open direct message")
           : t("Start group chat")
         : t("Use @username, or multiple usernames for a group chat"),
-      category: t("Chat"),
-      right: "DM",
+      category,
+      // No tag: it starts a conversation, so it must not read as one.
+      right: "",
       disabled: !valid,
       execute: () => openDmTargetFromCommand(ctx, usernames),
     }];
   }
 
-  const conversations = chatController.getSnapshot().channels
-    .filter((channel) => channel.kind === "direct" || channel.kind === "group");
-  if (conversations.length === 0) {
+  if (!list) {
     return [{
       id: "empty",
       label: t("No DMs yet"),
       detail: t("Type DM @username to start one"),
-      category: t("Chat"),
+      category,
       right: "DM",
       disabled: true,
       execute: () => {},
     }];
   }
 
-  return conversations.map((channel) => ({
-    id: `channel:${channel.id}`,
-    label: formatChannelLabel(channel, channel.id),
-    detail: conversationDetail(channel),
-    category: t("Conversations"),
-    right: channel.kind === "group" ? t("Group") : t("DM"),
-    keywords: [
-      channel.name,
-      channel.dmUser?.username ?? "",
-      ...(channel.members ?? []).map((member) => member.username ?? member.displayName),
-    ],
-    execute: () => openChatChannelFromCommand(ctx, channel.id),
-  }));
+  const listed = selectChatConversations(conversations, { kind: "listing" })
+    .map((conversation) => ({ ...chatConversationRow(conversation, open), category }));
+  return [...listed, { ...chatNewDmRow(() => openChatNewDm(ctx)), category }];
 }
 
 /**

package/src/plugins/builtin/chat/command-bar.ts

@@ -0,0 +1,138 @@
+import { t, tf } from "../../../i18n";
+import type {
+  CommandBarResultDef,
+  CommandBarSearchProvider,
+  GloomPluginContext,
+} from "../../../types/plugin";
+import { chatController } from "./controller";
+import {
+  buildChatConversations,
+  parseChatConversationQuery,
+  selectChatConversations,
+  type ChatConversation,
+  type ChatConversationKind,
+  type ChatConversationList,
+} from "./conversations";
+import { requestChatPaneAction } from "./pane-requests";
+
+const CHAT_PANE_TEMPLATE_ID = "new-chat-pane";
+/**
+ * Pane template value: show the conversation in a Chat pane that is already
+ * open (switching it over) rather than in a pane of its own.
+ */
+export const CHAT_REUSE_PANE_VALUE = "reusePane";
+const CHAT_SEARCH_PROVIDER_ID = "chat:conversations";
+
+type OpenChatPane = Pick<GloomPluginContext, "createPaneFromTemplate">;
+
+/**
+ * Shows a conversation with its composer ready: in the open Chat pane, which
+ * switches to it, or in a new one when none is open.
+ */
+export function openChatConversation(ctx: OpenChatPane, channelId: string): void {
+  requestChatPaneAction({ action: "compose", channelId });
+  ctx.createPaneFromTemplate(CHAT_PANE_TEMPLATE_ID, {
+    arg: channelId,
+    values: { [CHAT_REUSE_PANE_VALUE]: "1" },
+  });
+}
+
+/** The Chat pane's own New DM dialog, in the open Chat pane or a new one. */
+export function openChatNewDm(ctx: OpenChatPane): void {
+  requestChatPaneAction({ action: "new-dm" });
+  ctx.createPaneFromTemplate(CHAT_PANE_TEMPLATE_ID, { values: { [CHAT_REUSE_PANE_VALUE]: "1" } });
+}
+
+const BADGES: Record<ChatConversationKind, string> = {
+  channel: "CHAT",
+  team: "TEAM",
+  direct: "DM",
+  group: "GROUP",
+};
+
+const DETAILS: Record<ChatConversationKind, string> = {
+  channel: "Channel",
+  team: "Team channel",
+  direct: "Direct message",
+  group: "Group chat",
+};
+
+function unreadLabel(count: number): string {
+  return tf("{count} unread", { count: count > 99 ? "99+" : String(count) });
+}
+
+/**
+ * One conversation as a command-bar row: a tag that tells channels from DMs,
+ * the name the Chat pane shows, and the unread count on the right. `right` is
+ * empty rather than unset so a command's shortcut never stands in for it.
+ */
+export function chatConversationRow(
+  conversation: ChatConversation,
+  open: (channelId: string) => void,
+): CommandBarResultDef {
+  return {
+    id: `conversation:${conversation.channelId}`,
+    label: conversation.title,
+    ...(conversation.name ? { name: conversation.name } : {}),
+    badge: BADGES[conversation.kind],
+    detail: t(DETAILS[conversation.kind]),
+    right: conversation.unreadCount > 0 ? unreadLabel(conversation.unreadCount) : "",
+    keywords: [...conversation.words, "chat", "messages"],
+    execute: () => open(conversation.channelId),
+  };
+}
+
+export function chatNewDmRow(open: () => void): CommandBarResultDef {
+  return {
+    id: "new-dm",
+    label: t("New DM"),
+    detail: t("Start a direct or group chat"),
+    right: "",
+    keywords: ["new", "dm", "direct", "message", "group", "chat"],
+    execute: open,
+  };
+}
+
+interface ChatSearchSource {
+  listConversations(): ChatConversationList | null;
+}
+
+/**
+ * The conversations that answer the command bar's text, from the chat state
+ * the Chat pane already keeps: nothing is asked of the server. Signed out or
+ * unverified there is nothing, and the Chat pane command is all there is.
+ */
+export function buildChatSearchRows(
+  ctx: OpenChatPane,
+  query: string,
+  source: ChatSearchSource = chatController,
+): CommandBarResultDef[] {
+  const list = source.listConversations();
+  if (!list) return [];
+  const parsed = parseChatConversationQuery(query);
+  const conversations = selectChatConversations(buildChatConversations(list.states, list.userId), parsed);
+  const rows = conversations.map((conversation) => chatConversationRow(conversation, (channelId) => {
+    openChatConversation(ctx, channelId);
+  }));
+  return parsed.kind === "listing" ? [...rows, chatNewDmRow(() => openChatNewDm(ctx))] : rows;
+}
+
+/**
+ * Channels and DMs in the command bar: typing part of a channel or a person
+ * finds the conversation, "chat" and "messages" list them, and the empty bar
+ * shows the unread and latest ones. Answered from memory on every keystroke.
+ */
+export function createChatSearchProvider(
+  ctx: OpenChatPane,
+  source: ChatSearchSource = chatController,
+): CommandBarSearchProvider {
+  const match = (query: string) => buildChatSearchRows(ctx, query, source);
+  return {
+    id: CHAT_SEARCH_PROVIDER_ID,
+    category: "Chat",
+    minQueryLength: 0,
+    shortcuts: ["CHAT"],
+    match,
+    provide: async (query) => match(query),
+  };
+}

package/src/plugins/builtin/chat/composer-commands.ts

@@ -1,13 +1,33 @@
 export type ChatComposerCommand =
   | { kind: "direct"; username: string; draft: string }
-  | { kind: "group"; usernames: string[]; name: string | undefined };
+  | { kind: "group"; usernames: string[]; name: string | undefined }
+  | DiscordComposerCommand;
+
+/** `usage` is anything after /discord that is not a subcommand: it answers with the usage instead of going to the channel as text. */
+export type DiscordComposerCommand =
+  | { kind: "discord"; action: "connect" | "unlink" | "usage" }
+  | { kind: "discord"; action: "mirror"; enabled: boolean };
 
 const USERNAME_PATTERN = "[A-Za-z][A-Za-z0-9_]{2,29}";
 const DIRECT_COMMAND_RE = new RegExp(`^/dm\\s+@?(${USERNAME_PATTERN})(?:\\s+([\\s\\S]+))?$`, "i");
 const GROUP_COMMAND_RE = /^\/group\s+(.+)$/i;
+const DISCORD_COMMAND_RE = /^\/discord(?:\s+([\s\S]*))?$/i;
 const GROUP_USERNAME_RE = new RegExp(`@(${USERNAME_PATTERN})`, "g");
 
+function parseDiscordArguments(rest: string): DiscordComposerCommand {
+  const [subcommand, value, ...extra] = rest.toLowerCase().split(/\s+/).filter(Boolean);
+  if (!subcommand) return { kind: "discord", action: "connect" };
+  if (subcommand === "unlink" && value === undefined) return { kind: "discord", action: "unlink" };
+  if (subcommand === "mirror" && extra.length === 0 && (value === "on" || value === "off")) {
+    return { kind: "discord", action: "mirror", enabled: value === "on" };
+  }
+  return { kind: "discord", action: "usage" };
+}
+
 export function parseChatComposerCommand(content: string): ChatComposerCommand | null {
+  const discordCommand = content.match(DISCORD_COMMAND_RE);
+  if (discordCommand) return parseDiscordArguments(discordCommand[1] ?? "");
+
   const directCommand = content.match(DIRECT_COMMAND_RE);
   if (directCommand) {
     return {

package/src/plugins/builtin/chat/content/composer-runtime.ts

@@ -5,7 +5,7 @@ import {
   COMPOSER_ACTION_WIDTH,
   formatInlinePreview,
 } from "../layout";
-import { parseChatComposerCommand } from "../composer-commands";
+import { parseChatComposerCommand, type DiscordComposerCommand } from "../composer-commands";
 import { t, tf } from "../../../../i18n";
 import type { ChatContentController } from "./types";
 import { getComposerCursorOffset, moveComposerCursorToOffset } from "./composer-cursor";
@@ -45,6 +45,7 @@ export function useChatComposerRuntime({
   draftAttachmentCount = 0,
   onPastedImagePaths,
   onConversationStartError,
+  onDiscordCommand,
 }: {
   applyingExternalDraftRef: MutableRef<boolean>;
   blurInput: () => void;
@@ -77,6 +78,8 @@ export function useChatComposerRuntime({
   onPastedImagePaths?: (paths: string[], pasted: string) => void;
   /** A `/dm` or `/group` command the server refused, with the names it asked for. */
   onConversationStartError?: (error: unknown, usernames: string[]) => void;
+  /** Runs a /discord command. Without it the command is sent as text. */
+  onDiscordCommand?: (command: DiscordComposerCommand) => void;
 }) {
   const replyToRef = useRef(replyTo);
   const draftAttachmentCountRef = useRef(draftAttachmentCount);
@@ -262,6 +265,11 @@ export function useChatComposerRuntime({
       }).catch((error: unknown) => onConversationStartError?.(error, [composerCommand.username]));
       return;
     }
+    if (composerCommand?.kind === "discord" && onDiscordCommand) {
+      replaceComposerDraft("");
+      onDiscordCommand(composerCommand);
+      return;
+    }
     if (composerCommand?.kind === "group") {
       void controller.openGroupChannel({
         usernames: composerCommand.usernames,
@@ -293,8 +301,10 @@ export function useChatComposerRuntime({
     inputValueRef,
     onChannelChange,
     onConversationStartError,
+    onDiscordCommand,
     expandDirectSection,
     persistDraft,
+    replaceComposerDraft,
     setEditingMessage,
     setFollowMessages,
     setSelectedIdx,

package/src/plugins/builtin/chat/content/footer.tsx

@@ -6,6 +6,7 @@ import type { InlineTickerCatalogEntry } from "../../../../state/hooks/inline-ti
 import type { ContextMenuItem } from "../../../../types/context-menu";
 import { useRendererHost, useUiCapabilities } from "../../../../ui";
 import { useOptionalDialog, type PromptContext } from "../../../../ui/dialog";
+import { chatAuthorName, isDiscordGhost } from "../ghost-user";
 import { chatMessageOpenTargets, type ChatOpenTarget } from "./open-targets";
 import { openChatImageViewer } from "../attachments/desktop";
 
@@ -105,7 +106,7 @@ export function useChatFooter({
         attachments: selectedMessage.attachments,
         index: target.index,
         caption: selectedMessage.content,
-        author: selectedMessage.user.username ?? "anon",
+        author: chatAuthorName(selectedMessage.user),
       });
       return;
     }
@@ -135,7 +136,8 @@ export function useChatFooter({
     if (target) openTarget(target);
   }, [dialog, openTarget, openTargets]);
 
-  const author = selectedMessage?.user ?? null;
+  // A Discord ghost has no card to show.
+  const author = selectedMessage && !isDiscordGhost(selectedMessage.user) ? selectedMessage.user : null;
   // A card opened from the keyboard follows the selection: moving on closes it.
   const keyboardProfileRef = useRef(false);
   const toggleAuthorProfile = useCallback(() => {
@@ -215,7 +217,7 @@ export function useChatFooter({
       else if (canSend) hints.push({ id: "reply", key: "Enter", label: "reply", title: "Reply", onPress: () => latest.current.beginReplyTo(latest.current.selectedIdx, { deferFocus: true }) });
       if (canEdit) hints.push({ id: "edit", key: "e", label: "dit", title: "Edit Message", onPress: () => { latest.current.beginEditMessage(latest.current.selectedIdx, { deferFocus: true }); } });
       if (openTargets.length > 0) hints.push({ id: "open", key: "o", label: "pen", title: openTargetTitle, onPress: () => { void latest.current.openSelectedTargets(); } });
-      // Every author has a card, if only their name and a way to write to them.
+      // Every author but a Discord ghost has a card, if only their name and a way to write to them.
       if (author) hints.push({ id: "profile", key: "p", label: "rofile", title: "Show Profile", onPress: () => latest.current.toggleAuthorProfile() });
     } else if (!composing && canSend) {
       hints.push({ id: "compose", key: "i", label: " compose", title: "Compose", onPress: () => queueMicrotask(() => latest.current.focusComposer()) });