gloomberb 0.16.0 → 0.16.2

package/src/api-client/market-discovery.ts

@@ -46,6 +46,12 @@ export interface MarketHeatmapAsset {
   industry: string | null;
   marketState: string | null;
   source: MarketHeatmapSource;
+  /**
+   * The move of the last completed regular session, which `price`, `change`
+   * and `changePercent` then are. Null while the regular session trades, and
+   * for a name without that session's close.
+   */
+  regularChangePercent?: number | null;
 }
 
 export interface MarketHeatmapResult {
@@ -53,6 +59,10 @@ export interface MarketHeatmapResult {
   universe: MarketHeatmapUniverseId;
   source: MarketHeatmapSource;
   fetchedAt: number;
+  /** The US market session the snapshot describes; null when the server cannot tell. */
+  session?: "REGULAR" | "PRE" | "POST" | "CLOSED" | null;
+  /** The completed regular session every stored tile describes outside the regular session, as a New York date; null while it trades. */
+  regularSessionDate?: string | null;
   assets: MarketHeatmapAsset[];
 }
 

package/src/api-client/members.ts

@@ -0,0 +1,26 @@
+interface MemberFund { ticker: string; name: string; aliases: string[]; changes: "sp500" | "announcements" | "none" }
+export interface FundMember {
+  id: string; symbol: string | null; name: string; sector: string | null;
+  weight: number | null; shares: number; holdingPrice: number; marketValue: number;
+  price: number | null; priceAsOf: string | null; changePercent: number | null; dailyAsOf: string | null;
+  return1WPercent: number | null; return1MPercent: number | null; returnYtdPercent: number | null;
+  contribution: number | null; stale: boolean;
+}
+export interface FundMembersPayload {
+  fund: MemberFund; asOf: string; fetchedAt: string; excludedDerivatives: number; stale: boolean;
+  quotesUnavailable: boolean; snapshotAsOf: string | null; fundDailyAsOf: string | null; quoteCap: number;
+  members: FundMember[];
+  aggregate: { sum: number | null; fundReturn: number | null; residual: number | null; tolerancePp: number;
+    withinTolerance: boolean | null; covered: number; total: number; coveredWeight: number; holdingsWeight: number; fresh1D: number };
+}
+export interface FundChange {
+  id: string; fund: string; effectiveDate: string | null; announcedAt: string | null;
+  added: string | null; removed: string | null; reason: string; headline: string | null; url: string;
+  kind: "history" | "announcement"; daysToGo: number | null;
+  estimates: { symbol: string; usd: number; advUsd: number; days: number; asOf: string; advAsOf: string | null }[];
+}
+export interface FundChangesPayload {
+  fund: MemberFund; changes: FundChange[]; asOf: string | null; stale: boolean; available: boolean;
+  estimateLabel: string; attribution: { text: string; url: string } | null;
+}
+export interface MemberFundsPayload { funds: (MemberFund & { asOf: string | null })[] }

package/src/api-client/paths.ts

@@ -4,7 +4,9 @@ import type {
   CloudTweetQueryType,
 } from "./types";
 import { isUsListingExchange, normalizeSymbol, parsePublicTickerKey, publicTickerKey } from "../utils/exchanges";
+import { nonUsSecListingVenue } from "../utils/sec";
 import type { HistoryRetention } from "../sources/history-retention";
+import type { CloudBeneficialOwnersParams } from "./beneficial-owners";
 
 export type CloudHistoryParams = {
   interval?: string;
@@ -228,6 +230,10 @@ export function cloudCreditBoardPath(board: "cdx" | "sovr", params: { days?: num
 
 export type CloudSecFilingsParams = {
   ticker: string;
+  /** The listing's venue. Sent only for a venue outside the US, with `name`. */
+  exchange?: string;
+  /** The listing's company name, from its own quote. */
+  name?: string;
   limit?: number;
   offset?: number;
 };
@@ -343,13 +349,36 @@ export function cloudProxyStatementPath(ticker: string, year: number): string {
   return `/cloud/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
 }
 
+/**
+ * A US listing, or a symbol with no venue, looks up its US ticker as before.
+ * A listing elsewhere sends its bare symbol with the venue and company name:
+ * its symbol can be another company's US ticker.
+ */
 export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
-  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
+  const venue = nonUsSecListingVenue(params.ticker, params.exchange);
+  const search = new URLSearchParams({
+    ticker: venue ? parsePublicTickerKey(params.ticker).symbol : normalizeIssuerResearchTicker(params.ticker),
+  });
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
+  if (venue) {
+    search.set("exchange", venue);
+    const name = params.name?.trim();
+    if (name) search.set("name", name);
+  }
   return appendQuery("/cloud/sec/filings", search);
 }
 
+/** Schedule 13D and 13G reports about the issuer behind `ticker`. */
+export function cloudSecBeneficialOwnersPath(params: CloudBeneficialOwnersParams): string {
+  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
+  if (params.form) search.set("form", params.form);
+  if (params.history) search.set("history", "1");
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  return appendQuery("/cloud/sec/beneficial-owners", search);
+}
+
 export function cloudSecFilingDocumentsPath(
   params: CloudSecFilingParams,
 ): string {

package/src/api-client/perps.ts

@@ -71,6 +71,7 @@ interface PerpCandle {
 
 interface UnderlyingReference {
   symbol: string
+  listingExchange?: string
   price: number
   currency: string
   asOf: string
@@ -78,7 +79,30 @@ interface UnderlyingReference {
   sourceUrl: string
 }
 
+/**
+ * The venue's latest long/short account reading for one contract, in its own hourly bucket. Shares are
+ * fractions and may sum to less than one (flat accounts); OKX publishes only the ratio, so its shares are derived.
+ */
+export interface PerpLongShortRatio {
+  venue: string
+  /** Key of what is counted, such as `accounts_all`; `definitionText` says it in words. */
+  definition: string
+  definitionText: string
+  period: string
+  longShare: number
+  shortShare: number
+  ratio: number | null
+  derived: boolean
+  bucketAt: string
+  observedAt: string
+  /** The bucket is more than three hours old. */
+  stale: boolean
+}
+/** Why a row has no reading: the venue publishes none, collection is off, or nothing is stored yet. */
+type PerpLongShortReason = "unsupported" | "off" | "collecting"
+
 export interface PerpBoardRow extends PerpMarket {
+  equityMatch?: { listing: PerpEquityListing; underlying: PerpEquityListing; basis: "listing" | "issuer" }
   stale: boolean
   oiChange1h: number | null
   oiChange24h: number | null
@@ -87,6 +111,19 @@ export interface PerpBoardRow extends PerpMarket {
   underlying: UnderlyingReference | null
   underlyingPremium: number | null
   closedMarketPremium: number | null
+  /** Absent from servers older than the long/short series: read as null. */
+  longShortRatio?: PerpLongShortRatio | null
+  longShortRatioReason?: PerpLongShortReason | null
+}
+
+export type PerpLongShortPoint = {
+  time: string
+  definition: string
+  longShare: number
+  shortShare: number
+  ratio: number | null
+  derived: boolean
+  observedAt: string
 }
 
 type PerpHistoryPoint = {
@@ -105,11 +142,15 @@ type PerpHistoryPoint = {
 }
 
 export interface PerpBoardPayload {
+  listing?: PerpEquityListing | null;
   status: string; asOf: string | null; rows: PerpBoardRow[]; total: number; locked: number;
   access: "pro" | "preview"; sources?: unknown[];
 }
+export interface PerpEquityListing { symbol: string; exchange: string }
 export interface PerpHistoryPayload {
   status: string; marketId: string; rows: PerpHistoryPoint[]; funding: PerpFunding[]; candles: PerpCandle[];
+  /** Absent from servers older than the long/short series: read as empty. */
+  longShortRatio?: PerpLongShortPoint[];
   locked: boolean; access: "pro" | "preview"; asOf: string | null;
   from?: string; to?: string; resolution?: "minute" | "hour" | "day"; truncated?: boolean;
 }

package/src/api-client/request.ts

@@ -3,6 +3,7 @@ import { withDeadline } from "../utils/async-deadline";
 import {
   ApiRequestError,
   parseApiErrorCode,
+  parseApiErrorDetails,
   parseApiErrorMessage,
   parseRetryAfterMs,
   type RevisionConflictError,
@@ -391,6 +392,7 @@ export class CloudApiRequestTransport {
           res.status,
           parseRetryAfterMs(res.headers.get("Retry-After")),
           parseApiErrorCode(text),
+          parseApiErrorDetails(text),
         );
       }
 
@@ -404,8 +406,9 @@ export class CloudApiRequestTransport {
     };
     // Crash reports, usage counts and command-search reports are background
     // traffic: a rate-limited, timed-out or missing one must not show up as a
-    // Cloud outage in the connections pane.
-    if (path.startsWith("/telemetry/") || path === "/assist/searches") return request();
+    // Cloud outage in the connections pane. Nor must the map's probe for geo
+    // layers, which a server without them answers with 404.
+    if (path.startsWith("/telemetry/") || path === "/assist/searches" || path === "/cloud/geo/layers") return request();
     return this.connectionHealth.track(
       GLOOM_CLOUD_HTTP_CONNECTION_ID,
       operation,

package/src/api-client/types.ts

@@ -12,6 +12,8 @@ import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
 export interface ChatUserSummary {
   id: string;
+  /** A person, a managed assistant (Gloombot), or a Discord user bridged into public channels. */
+  accountType?: "human" | "managed_llm" | "discord";
   username: string | null;
   displayName: string;
   bio?: string | null;
@@ -295,7 +297,9 @@ export interface CloudSyncPushResponse {
   settings: SyncSettings;
 }
 
-export interface CloudQuotePayload extends Omit<Quote, "change" | "changePercent"> {
+export interface CloudQuotePayload extends Omit<Quote, "change" | "changePercent" | "priceBasis" | "priceObservation"> {
+  /** The service labels daily NAV here; the app separates observation kind from price units. */
+  priceBasis?: Quote["priceBasis"] | "nav";
   // JSON encodes the provider's unavailable numeric values as null.
   change?: number | null;
   changePercent?: number | null;
@@ -1375,6 +1379,10 @@ export interface CloudMarketScreenerItem {
   change: number;
   changePercent: number;
   volume: number;
+  /** Available average volume for this listing, independent of public ranking membership. */
+  avgVolume?: number;
+  /** Observation time of the optional retained metadata. */
+  metadataAsOf?: string;
   tradeCount?: number;
   currency: string;
   high52w?: number;

package/src/app/global-shortcuts.ts

@@ -8,7 +8,7 @@ import type { AppAction, AppState } from "../state/app/context";
 import type { TickerRecord } from "../types/ticker";
 import { findPaneInstance } from "../types/config";
 import type { ReleaseInfo } from "../updater";
-import { canSelfUpdate } from "../updater";
+import { canRestartToApply, canSelfUpdate } from "../updater";
 import { getVisiblePaneCycleOrder } from "../components/layout/pane/cycle-order";
 import { requestFunctionHelp, useFunctionHelpHost } from "../plugins/builtin/help/function-card";
 import { buildRegistryHelpIndex, helpFunctionForPane } from "../plugins/builtin/help/function-index";
@@ -34,9 +34,10 @@ import {
 const KEYBINDING_NOTICE_DURATION_MS = 15_000;
 
 /**
- * Whether the install-update key has something to do: a release this build
+ * Whether the install-update key has something to retry: a release this build
  * can install itself whose last attempt failed. A fresh one downloads on its
- * own, and a manual or managed one names its own command.
+ * own, and a manual or managed one names its own command. (A downloaded
+ * desktop update has its own use of the key: restarting into it.)
  */
 export function canRetryUpdate(
   state: Pick<AppState, "updateAvailable" | "updateProgress" | "updateCheckInProgress">,
@@ -91,6 +92,7 @@ export function useAppGlobalShortcuts({
   keybindings = getDefaultKeybindings(),
   pluginRegistry,
   refreshTicker,
+  restartToApplyUpdate,
   startUpdate,
   state,
 }: {
@@ -101,6 +103,8 @@ export function useAppGlobalShortcuts({
   keybindings?: ResolvedKeybindings;
   pluginRegistry: PluginRegistry;
   refreshTicker: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
+  /** Applies a downloaded desktop update and relaunches. Runs only on the user's key press. */
+  restartToApplyUpdate: () => void;
   startUpdate: (release: ReleaseInfo) => void;
   state: AppState;
 }) {
@@ -249,9 +253,13 @@ export function useAppGlobalShortcuts({
         refreshTicker(ticker.metadata.ticker, ticker.metadata.exchange, ticker, 1);
       }
     } else if (action === "install-update") {
-      // A release that can install itself starts on its own, so the key is
-      // for the one that failed: it tries again.
-      if (canRetryUpdate(state)) {
+      // A release that can install itself downloads on its own, so the key is
+      // for the one that waits for a restart and for the one that failed.
+      if (!isDetachedWindow && canRestartToApply(state.updateProgress)) {
+        event.preventDefault();
+        event.stopPropagation();
+        restartToApplyUpdate();
+      } else if (canRetryUpdate(state)) {
         event.preventDefault();
         event.stopPropagation();
         startUpdate(state.updateAvailable!);

package/src/app/keybindings/actions.ts

@@ -129,7 +129,7 @@ export const KEYBINDING_ACTIONS: readonly KeybindingActionDef[] = [
   {
     id: "install-update",
     category: "Global Keys",
-    description: "Install an available app update when one is shown.",
+    description: "Restart into a downloaded app update, or retry one that failed.",
     defaults: ["U"],
   },
   {

package/src/app/runtime/update.ts

@@ -1,8 +1,10 @@
-import { useCallback, useEffect, type Dispatch } from "react";
+import { useCallback, useEffect, useRef, type Dispatch } from "react";
 import type { PluginRegistry } from "../../plugins/registry";
 import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import type { AppAction, AppState } from "../../state/app/context";
 import {
+  applyUpdate,
+  canRestartToApply,
   canSelfUpdate,
   checkForUpdateDetailed,
   performUpdate,
@@ -15,6 +17,11 @@ import { runAutomated } from "../../telemetry/usage-counts";
 
 const UPDATE_CHECK_INTERVAL_MS = 60 * 60_000; // hourly
 
+/** An update is being downloaded, applied, or is downloaded and waiting for a restart. */
+function updateInFlight(progress: AppState["updateProgress"]): boolean {
+  return progress?.phase === "downloading" || progress?.phase === "replacing" || progress?.phase === "ready";
+}
+
 export function useAppUpdateRuntime({
   enabled = true,
   dispatch,
@@ -36,7 +43,13 @@ export function useAppUpdateRuntime({
 }): {
   runUpdateCheck: (manual?: boolean) => Promise<void>;
   startUpdate: (release: ReleaseInfo) => void;
+  /** Installs the downloaded desktop update and relaunches. Does nothing unless one is ready. */
+  restartToApplyUpdate: () => void;
+  /** The command bar's Check for Updates: restarts into a downloaded update, otherwise checks. */
+  runUpdateCommand: () => void;
 } {
+  const restartingRef = useRef(false);
+
   const startUpdate = useCallback((release: ReleaseInfo) => {
     dispatch({ type: "SET_UPDATE_PROGRESS", progress: { phase: "downloading", percent: 0 } });
     void performUpdate(release, (progress) => {
@@ -44,7 +57,23 @@ export function useAppUpdateRuntime({
     });
   }, [dispatch]);
 
+  const restartToApplyUpdate = useCallback(() => {
+    if (!enabled || isDetachedWindow) return;
+    // The app relaunches here, so this must only ever follow the user's own
+    // request, and a second one while the first is working changes nothing.
+    if (restartingRef.current || !canRestartToApply(stateRef.current.updateProgress)) return;
+    restartingRef.current = true;
+    dispatch({ type: "SET_UPDATE_PROGRESS", progress: { phase: "replacing" } });
+    void applyUpdate((progress) => {
+      if (progress.phase === "error") restartingRef.current = false;
+      dispatch({ type: "SET_UPDATE_PROGRESS", progress });
+    });
+  }, [dispatch, enabled, isDetachedWindow, stateRef]);
+
   const runUpdateCheck = useCallback(async (manual = false) => {
+    // A staged update is the answer until it is applied: another check would
+    // swap the release under the "ready" state, and the host has nothing to add.
+    if (updateInFlight(stateRef.current.updateProgress)) return;
     if (manual) {
       dispatch({ type: "SET_UPDATE_CHECK_IN_PROGRESS", checking: true });
       dispatch({ type: "SET_UPDATE_NOTICE", notice: null });
@@ -88,7 +117,12 @@ export function useAppUpdateRuntime({
     }
 
     dispatch({ type: "SET_UPDATE_NOTICE", notice: `Update check failed: ${result.error}` });
-  }, [dispatch]);
+  }, [dispatch, stateRef]);
+
+  const runUpdateCommand = useCallback(() => {
+    if (canRestartToApply(stateRef.current.updateProgress)) restartToApplyUpdate();
+    else void runUpdateCheck(true);
+  }, [restartToApplyUpdate, runUpdateCheck, stateRef]);
 
   useEffect(() => {
     if (!enabled || isDetachedWindow) return;
@@ -121,7 +155,9 @@ export function useAppUpdateRuntime({
   }, [enabled, isDetachedWindow, startUpdate, updateAvailable, updateCheckInProgress, updateProgress]);
 
   return {
+    restartToApplyUpdate,
     runUpdateCheck,
+    runUpdateCommand,
     startUpdate,
   };
 }

package/src/app.tsx

@@ -268,7 +268,7 @@ function AppInner({
     tickerRepository,
   });
 
-  const { runUpdateCheck, startUpdate } = useAppUpdateRuntime({
+  const { restartToApplyUpdate, runUpdateCheck, runUpdateCommand, startUpdate } = useAppUpdateRuntime({
     enabled: updatesEnabled,
     dispatch,
     isDetachedWindow,
@@ -409,6 +409,7 @@ function AppInner({
     keybindings,
     pluginRegistry,
     refreshTicker,
+    restartToApplyUpdate,
     startUpdate,
     state,
   });
@@ -450,10 +451,13 @@ function AppInner({
         desktopWindowBridge={desktopWindowBridge}
       >
         <ThemedAppRoot>
-          <Header onOpenHelp={() => {
-            recordFunctionOpen({ shortcut: "HELP", externalPluginId: null });
-            pluginRegistry.showPane("help");
-          }} />
+          <Header
+            onOpenHelp={() => {
+              recordFunctionOpen({ shortcut: "HELP", externalPluginId: null });
+              pluginRegistry.showPane("help");
+            }}
+            onRestartForUpdate={updatesEnabled && !isDetachedWindow ? restartToApplyUpdate : undefined}
+          />
           <TransientLayoutProvider>
             <Shell
               pluginRegistry={pluginRegistry}
@@ -486,7 +490,7 @@ function AppInner({
               tickerRepository={tickerRepository}
               pluginRegistry={pluginRegistry}
               quitApp={() => rendererHost.requestExit()}
-              onCheckForUpdates={updatesEnabled ? () => runUpdateCheck(true) : undefined}
+              onCheckForUpdates={updatesEnabled ? runUpdateCommand : undefined}
               onNativeOccluderChange={setCommandBarNativeOccluder}
             />
           )}

package/src/brokers/account-cache.ts

@@ -84,6 +84,30 @@ export function loadPersistedBrokerAccounts(
   })?.value.accounts ?? null;
 }
 
+/**
+ * The newest saved account snapshot of a profile, for readers without its
+ * adapter such as the CLI. Read only: without the adapter the current source
+ * key is unknown, so nothing is pruned.
+ */
+export function peekPersistedBrokerAccounts(
+  resources: Pick<AppResourceStorePort, "list">,
+  instance: BrokerInstanceConfig,
+): BrokerAccount[] | null {
+  const records = resources.list<PersistedBrokerAccountSnapshot>({
+    namespace: brokerAccountNamespace(instance),
+    kind: BROKER_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+  }, {
+    schemaVersion: BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+  const newest = records.reduce<(typeof records)[number] | null>(
+    (latest, record) => (!latest || record.fetchedAt > latest.fetchedAt ? record : latest),
+    null,
+  );
+  return newest?.value.accounts ?? null;
+}
+
 export function persistBrokerAccounts(
   resources: AppResourceStorePort,
   instance: BrokerInstanceConfig,

package/src/cli/commands/command-utils.ts

@@ -15,6 +15,14 @@ export function takeOption(args: string[], name: string): string | undefined {
   return value;
 }
 
+/** Removes a boolean flag (`--history`) from `args` and says whether it was there. */
+export function takeFlag(args: string[], name: string): boolean {
+  const index = args.indexOf(name);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
 export function parseJsonPayload(value: string | undefined, ctx: CliCommandContext): unknown {
   if (!value) return {};
   try {

package/src/cli/commands/crypto-hints.ts

@@ -0,0 +1,75 @@
+import { isCryptoInstrumentType } from "../../tickers/search/ranking";
+import type { Quote } from "../../types/financials";
+import { isCryptoPairSymbol } from "../../utils/crypto-pair";
+
+/** Where a crypto pair that will not load can still be read. `fn CRYP` takes no argument. */
+export const CRYPTO_BOARD_HINT = "Crypto prices may be briefly unavailable; the CRYP function (gloomberb fn CRYP) shows the crypto board.";
+
+// The coins whose bare ticker is most often typed for the coin itself. The label is how the note
+// names the coin and what a listing's name has to say before the note applies.
+const MAJOR_COINS = new Map([
+  ["BTC", "bitcoin"],
+  ["ETH", "ethereum"],
+  ["SOL", "solana"],
+  ["XRP", "XRP"],
+  ["DOGE", "dogecoin"],
+  ["ADA", "cardano"],
+  ["LTC", "litecoin"],
+  ["BCH", "bitcoin cash"],
+  ["AVAX", "avalanche"],
+  ["DOT", "polkadot"],
+  ["LINK", "chainlink"],
+  ["BNB", "BNB"],
+]);
+
+/**
+ * A bare coin ticker usually resolves to a listed fund, not the coin. The note applies only when
+ * the listing is not crypto and its own name says the coin (a "Bitcoin" trust), so a company that
+ * happens to share the letters (Interlink Electronics on LINK) is left alone.
+ */
+function notTheCoinNote(symbol: string, quote: Pick<Quote, "name" | "instrumentType"> | null | undefined): string | null {
+  const coin = MAJOR_COINS.get(symbol);
+  const type = quote?.instrumentType?.trim();
+  const name = quote?.name?.trim();
+  if (!coin || !name || !type || isCryptoInstrumentType(type)) return null;
+  if (!new RegExp(`\\b${coin}\\b`, "i").test(name)) return null;
+  return `${symbol} is ${name}, not ${coin}. For ${coin} use ${symbol}-USD.`;
+}
+
+interface QuoteNoteResult {
+  target: { symbol: string };
+  quote: Pick<Quote, "name" | "instrumentType"> | null;
+  error: string | null;
+}
+
+/** The router words a failure as "<reason> for <symbol>"; drop the symbol so equal reasons group. */
+function failureReason(message: string, symbol: string): string {
+  const line = (message.split("\n")[0] ?? "").trim().replace(/\.+$/, "");
+  const suffix = ` for ${symbol}`;
+  return line.toLowerCase().endsWith(suffix.toLowerCase()) ? line.slice(0, -suffix.length) : line;
+}
+
+/**
+ * Text-mode notes under a quote table: one line per distinct failure reason (with the crypto board
+ * pointer when a failed symbol is a crypto pair), then a line for each bare coin ticker that
+ * resolved to something else. `--exchange` names the listing on purpose, so it gets no coin note.
+ */
+export function quoteNotes(results: QuoteNoteResult[], options: { exchange?: string } = {}): string[] {
+  const failures = new Map<string, string[]>();
+  for (const result of results) {
+    if (!result.error || result.quote) continue;
+    const reason = failureReason(result.error, result.target.symbol);
+    const symbols = failures.get(reason) ?? [];
+    if (!symbols.includes(result.target.symbol)) failures.set(reason, [...symbols, result.target.symbol]);
+  }
+  const notes = [...failures].map(([reason, symbols]) => (
+    `${symbols.join(", ")}: ${reason}${symbols.some(isCryptoPairSymbol) ? `. ${CRYPTO_BOARD_HINT}` : ""}`
+  ));
+  if (!options.exchange) {
+    for (const result of results) {
+      const note = notTheCoinNote(result.target.symbol, result.quote);
+      if (note) notes.push(note);
+    }
+  }
+  return notes;
+}