gloomberb 0.17.6 → 0.18.0

package/src/ask-gloom/pane-context.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import type { ResolvedPane } from "../layout/pane-manager";
 import type { PluginRegistry } from "../plugins/registry";
 import { panePersonalData } from "../shares/personal-pane";
@@ -122,7 +123,8 @@ export function buildAskGloomPaneAttachment({
 function showsPersonalData(source: Parameters<typeof panePersonalData>[0]): boolean {
   try {
     return panePersonalData(source) !== null;
-  } catch {
+  } catch (error) {
+    logFailure("ask-gloom.pane-context", "Checking pane personal data failed")(error);
     return true;
   }
 }

package/src/brokers/signed-in/catalog.ts

@@ -6,6 +6,7 @@
  * restart everywhere) so the directory still lists them offline. The desktop's
  * Bun half never fetches; it picks up the list the view saved.
  */
+import { logFailure } from "../../utils/log-failure";
 import type { PluginPersistence } from "../../types/plugin";
 import { listSignedInBrokers, type SignedInBroker } from "./client";
 
@@ -102,7 +103,7 @@ export function createSignedInBrokerCatalog(
           persistence?.setState(STATE_KEY, { brokers: next, fetchedAt }, { schemaVersion: SCHEMA_VERSION });
         })
         // Offline or Cloud down: the last list stays, and the next open retries.
-        .catch(() => {})
+        .catch(logFailure("signed-in-brokers", "Broker catalog refresh failed"))
         .finally(() => {
           inFlight = null;
         });

package/src/brokers/signed-in/client.ts

@@ -52,11 +52,16 @@ export function fetchSignedInBrokerConnection(brokerId: string): Promise<SignedI
   return apiClient.brokerRequest(brokerId, "");
 }
 
+/**
+ * Opens a connect ticket. This app shows no code: it asks for a ticket that
+ * only the account's own Gloom session in the browser can continue. A Cloud
+ * that predates that still answers with a code, which the dialog then shows.
+ */
 export function startSignedInBrokerConnect(
   brokerId: string,
   write: boolean,
-): Promise<{ connectUrl: string; code: string; expiresAt: string }> {
-  return apiClient.brokerRequest(brokerId, "/connect", { method: "POST", body: { write } });
+): Promise<{ connectUrl: string; code?: string | null; expiresAt: string }> {
+  return apiClient.brokerRequest(brokerId, "/connect", { method: "POST", body: { write, code: false } });
 }
 
 export function disconnectSignedInBroker(brokerId: string): Promise<{ disconnected: boolean }> {

package/src/brokers/signed-in/sign-in-dialog.tsx

@@ -9,14 +9,18 @@
 import { useEffect, useRef, useState } from "react";
 import { apiClient, type AuthUser } from "../../api-client";
 import { SignInCodePanel } from "../../components/sign-in-code-panel";
+import { Button } from "../../components/ui/button";
+import { DialogActions } from "../../components/ui/dialog-actions";
+import { FORM_DIALOG_WIDTH, DialogFrame } from "../../components/ui/frame";
 import { t, tf } from "../../i18n";
 import { useAppLanguage } from "../../i18n/react";
 import { useViewport } from "../../react/input";
 import { colors } from "../../theme/colors";
+import { useThemeColors } from "../../theme/theme-context";
 import { Box, Text, TextAttributes, useUiCapabilities } from "../../ui";
-import { DialogHints } from "../../components/ui/dialog-actions";
 import { useDialog, useDialogKeyboard, type DialogApi, type PromptContext } from "../../ui/dialog";
 import { isPlainKey } from "../../utils/keyboard";
+import { wrapTextLines } from "../../utils/text-wrap";
 import { DeviceSignInDialog } from "../../account/device-signin-dialog";
 import type { SignedInBroker } from "./client";
 import {
@@ -43,7 +47,13 @@ export function brokerSignInStatus(snapshot: BrokerSignInSnapshot, broker: Signe
   }
 }
 
-/** Under the code: the broker's own note, or what connecting a single-connection broker does to other apps. */
+/** What every connect surface says under its title: the browser does the rest. */
+export const BROKER_CONNECT_SUBTITLE = "Continue in your browser.";
+
+/** The key every connect surface takes for a fresh link, as the desktop shows it. */
+export const BROKER_CONNECT_NEW_LINK = { key: "r", label: "new link" };
+
+/** Under the panel: the broker's own note, or what connecting a single-connection broker does to other apps. */
 export function brokerSignInNote(broker: SignedInBroker): string | null {
   return broker.capabilities.signupNote
     ?? (broker.capabilities.singleConnection
@@ -108,6 +118,18 @@ export async function promptGloomSignIn(dialog: DialogApi): Promise<boolean> {
   });
 }
 
+/**
+ * Rows the dialog's own lines take around the connect view: the terminal's
+ * margins, border and padding (7), title, subtitle and key line with the
+ * blank rows between them, and the desktop's frame, title block and Cancel.
+ */
+const TERMINAL_DIALOG_ROWS = 12;
+const DESKTOP_DIALOG_ROWS = 10;
+/** Columns the terminal's full dialog takes from the window: margins, border and padding. */
+const TERMINAL_DIALOG_INSET = 8;
+/** Cells the desktop dialog's padding takes from its width. */
+const DESKTOP_DIALOG_INSET = 4;
+
 function BrokerSignInDialog({
   resolve,
   dismiss,
@@ -117,7 +139,7 @@ function BrokerSignInDialog({
 }: PromptContext<BrokerSignInOutcome> & { broker: SignedInBroker; write: boolean; renew: boolean }) {
   useAppLanguage();
   const { nativePaneChrome } = useUiCapabilities();
-  const { height: termHeight } = useViewport();
+  const { width: termWidth, height: termHeight } = useViewport();
   // Close after a beat so "Connected" is visible; enter skips the wait. Signed
   // out closes at once, for the host to sign in to Gloom.
   const { snapshot, restart, finish } = useBrokerSignInAttempt(broker, write, resolve, { renew });
@@ -133,44 +155,116 @@ function BrokerSignInDialog({
     }
   });
 
-  const note = brokerSignInNote(broker);
-  // Title, spacing, note, and footer take about eleven rows around the panel.
-  const panelHeight = Math.max(4, termHeight - (note ? 12 : 10));
+  const title = tf("Connect {broker}", { broker: broker.name });
+  const subtitle = t(BROKER_CONNECT_SUBTITLE);
+
+  // The desktop frames it as New Portfolio frames its connect step: as wide,
+  // with Cancel at the foot and the key for a new link beside it.
+  if (nativePaneChrome) {
+    return (
+      <Box width={FORM_DIALOG_WIDTH} maxWidth="calc(100vw - 72px)" flexDirection="column">
+        <DialogFrame title={title} subtitle={subtitle} onClose={dismiss} desktopFooter={null}>
+          <BrokerConnectView
+            broker={broker}
+            snapshot={snapshot}
+            height={Math.max(4, termHeight - DESKTOP_DIALOG_ROWS)}
+            width={FORM_DIALOG_WIDTH - DESKTOP_DIALOG_INSET}
+          />
+          <Box style={{ marginTop: "var(--gloom-space-md)" }}>
+            <DialogActions alignEnd hints={{ keys: [BROKER_CONNECT_NEW_LINK] }}>
+              <Button label="Cancel" variant="secondary" desktopShortcut="Esc" onPress={dismiss} />
+            </DialogActions>
+          </Box>
+        </DialogFrame>
+      </Box>
+    );
+  }
 
   return (
     <Box flexDirection="column" alignItems="center">
       <Box height={1}>
-        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>
-          {tf("Connect {broker}", { broker: broker.name })}
-        </Text>
+        <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{title}</Text>
       </Box>
       <Box height={1}>
-        <Text fg={colors.textDim}>{t("Open the link and enter the code there.")}</Text>
+        <Text fg={colors.textDim}>{subtitle}</Text>
       </Box>
       <Box height={1} />
+      <BrokerConnectView
+        broker={broker}
+        snapshot={snapshot}
+        height={Math.max(4, termHeight - TERMINAL_DIALOG_ROWS)}
+        width={Math.max(10, termWidth - TERMINAL_DIALOG_INSET)}
+      />
+      <Box height={1} />
+      <Box height={1}>
+        <Text fg={colors.textMuted}>{t("r for a new link · esc to cancel")}</Text>
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * On the desktop a connect's note, under the panel, is set to a reading
+ * measure rather than the width of the dialog or pane. The terminal wraps it
+ * to the width it has, since every row it takes is one the QR code may need.
+ */
+const NOTE_MEASURE = 56;
+
+/**
+ * One attempt at connecting a signed-in broker as the user sees it: the link,
+ * QR code and status, with the broker's note wrapped under them. The connect
+ * dialog, Add Broker's step in the Brokers pane and New Portfolio's show it.
+ */
+export function BrokerConnectView({
+  broker,
+  snapshot,
+  height,
+  width,
+  browserKey = true,
+}: {
+  broker: SignedInBroker;
+  snapshot: BrokerSignInSnapshot;
+  /** Terminal rows for the panel and the note. */
+  height: number;
+  /** Terminal columns the note wraps to. */
+  width: number;
+  /** Whether `b` opens the link now. */
+  browserKey?: boolean;
+}) {
+  useAppLanguage();
+  const colors = useThemeColors();
+  const desktop = useUiCapabilities().nativePaneChrome === true;
+  const note = brokerSignInNote(broker);
+  const noteLines = note ? wrapTextLines(note, Math.max(10, desktop ? Math.min(width, NOTE_MEASURE) : width)) : [];
+  // The note goes under the panel, which gets the rows left.
+  const noteRows = note ? 1 + noteLines.length : 0;
+
+  return (
+    <Box flexDirection="column" alignItems="center">
       <SignInCodePanel
         url={snapshot.connectUrl}
         code={snapshot.code}
         status={brokerSignInStatus(snapshot, broker)}
-        height={panelHeight}
+        height={Math.max(4, height - noteRows)}
         shortcutScope="broker-signin:browser"
+        browserKey={browserKey}
       />
-      {note && (
-        <>
-          <Box height={1} />
-          <Box height={1}>
-            <Text fg={colors.textMuted}>{note}</Text>
+      {note && (desktop
+        ? (
+          <Box marginTop={1} maxWidth={NOTE_MEASURE}>
+            <Text fg={colors.textMuted} wrapText style={{ textAlign: "center" }}>{note}</Text>
           </Box>
-        </>
-      )}
-      <Box height={1} />
-      {nativePaneChrome ? (
-        <DialogHints keys={[{ key: "r", label: "new code" }, { key: "Esc", label: "cancel" }]} />
-      ) : (
-        <Box height={1}>
-          <Text fg={colors.textMuted}>{t("r for a new code · esc to cancel")}</Text>
-        </Box>
-      )}
+        )
+        : (
+          <>
+            <Box height={1} />
+            {noteLines.map((line, index) => (
+              <Box key={index} height={1}>
+                <Text fg={colors.textMuted}>{line}</Text>
+              </Box>
+            ))}
+          </>
+        ))}
     </Box>
   );
 }

package/src/brokers/signed-in/sign-in.ts

@@ -1,10 +1,11 @@
 /**
- * Connecting a signed-in broker: Gloom Cloud hands out a link and a short code,
- * the user opens the link, types the code, and signs in to the broker there.
- * The code is what ties the browser to this app, so a link someone else started
- * cannot attach their brokerage to this account. The connection itself lives in
- * the Cloud account, shared by every device and by the user's agents.
+ * Connecting a signed-in broker: Gloom Cloud hands out a link, the user opens
+ * it and signs in to the broker there. The link goes on only in a browser
+ * signed in to Gloom as this account, so a link someone else started cannot
+ * attach their brokerage to it. The connection itself lives in the Cloud
+ * account, shared by every device and by the user's agents.
  */
+import { logFailure } from "../../utils/log-failure";
 import { ApiRequestError } from "../../api-client/errors";
 import {
   fetchSignedInBrokerConnection,
@@ -19,6 +20,7 @@ type BrokerSignInPhase = "starting" | "waiting" | "connected" | "signed-out" | "
 export interface BrokerSignInSnapshot {
   phase: BrokerSignInPhase;
   connectUrl: string | null;
+  /** Only from a Cloud that still asks the browser for a code; none otherwise. */
   code: string | null;
   /** A transient poll failure while waiting, or why starting failed. */
   error: string | null;
@@ -37,7 +39,7 @@ export interface BrokerSignInOptions {
 }
 
 export interface BrokerSignInIo {
-  start(brokerId: string, write: boolean): Promise<{ connectUrl: string; code: string; expiresAt: string }>;
+  start(brokerId: string, write: boolean): Promise<{ connectUrl: string; code?: string | null; expiresAt: string }>;
   fetchConnection(brokerId: string): Promise<BrokerConnectionRead>;
   now(): number;
   delay(ms: number): Promise<void>;
@@ -46,7 +48,7 @@ export interface BrokerSignInIo {
 const POLL_INTERVAL_MS = 2_000;
 const RETRY_MAX_MS = 30_000;
 /** Used when the expiry is missing or unreadable, so polling can never run forever. */
-const DEFAULT_CODE_TTL_MS = 15 * 60_000;
+const DEFAULT_LINK_TTL_MS = 15 * 60_000;
 
 const defaultIo: BrokerSignInIo = {
   start: (brokerId, write) => startSignedInBrokerConnect(brokerId, write),
@@ -61,13 +63,13 @@ function describeStartError(error: unknown, broker: SignedInBroker): string {
 }
 
 /**
- * When a code stops working. An expiry this device's clock already sees as
- * past (the clock runs fast) counts as missing, or every code would expire
+ * When a link stops working. An expiry this device's clock already sees as
+ * past (the clock runs fast) counts as missing, or every link would expire
  * the moment it arrived.
  */
-function codeDeadline(expiresAt: string, now: number): number {
+function linkDeadline(expiresAt: string, now: number): number {
   const parsed = Date.parse(expiresAt);
-  return Number.isFinite(parsed) && parsed > now ? parsed : now + DEFAULT_CODE_TTL_MS;
+  return Number.isFinite(parsed) && parsed > now ? parsed : now + DEFAULT_LINK_TTL_MS;
 }
 
 function stamp(value: string | null | undefined): number | null {
@@ -96,7 +98,7 @@ export class BrokerSignInController {
   private generation = 0;
   /**
    * Renewing only: the account's connection as first seen. It outlives a
-   * restarted code, so a sign-in finished while "r" asked for a new one still
+   * restarted link, so a sign-in finished while "r" asked for a new one still
    * counts.
    */
   private before: BrokerConnectionRead | null = null;
@@ -125,7 +127,7 @@ export class BrokerSignInController {
     };
   }
 
-  /** Starts, or restarts with a fresh code. Safe to call repeatedly. */
+  /** Starts, or restarts with a fresh link. Safe to call repeatedly. */
   start(): void {
     const generation = ++this.generation;
     void this.run(generation);
@@ -143,16 +145,16 @@ export class BrokerSignInController {
   private async run(generation: number): Promise<void> {
     const stale = () => this.generation !== generation;
     let retryMs = POLL_INTERVAL_MS;
-    // Renewing: read before a code exists, so nothing the user does can come
+    // Renewing: read before a link exists, so nothing the user does can come
     // first. A failed read leaves the first poll to stand in for it: no
     // sign-in finishes within a poll interval.
     if (this.renew && !this.before) {
-      const read = await this.io.fetchConnection(this.broker.id).catch(() => null);
+      const read = await this.io.fetchConnection(this.broker.id).catch(logFailure("broker-signin", "Broker connection refresh failed", null));
       if (stale()) return;
       this.before ??= read;
     }
-    // Each iteration is one code: start, poll until connected, and loop again
-    // when the code expired so the link refreshes instead of dead-ending.
+    // Each iteration is one link: start, poll until connected, and loop again
+    // when the link expired so it refreshes instead of dead-ending.
     while (!stale()) {
       this.update({ phase: "starting", connectUrl: null, code: null, error: null });
       let started: Awaited<ReturnType<BrokerSignInIo["start"]>>;
@@ -174,9 +176,9 @@ export class BrokerSignInController {
       }
       if (stale()) return;
       retryMs = POLL_INTERVAL_MS;
-      this.update({ phase: "waiting", connectUrl: started.connectUrl, code: started.code, error: null });
-      const deadline = codeDeadline(started.expiresAt, this.io.now());
-      // At least one poll per code, so the next code is never asked for at once.
+      this.update({ phase: "waiting", connectUrl: started.connectUrl, code: started.code ?? null, error: null });
+      const deadline = linkDeadline(started.expiresAt, this.io.now());
+      // At least one poll per link, so the next link is never asked for at once.
       do {
         await this.io.delay(POLL_INTERVAL_MS);
         if (stale()) return;

package/src/brokers/sync-broker-instance.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import type { AppResourceStorePort, AppTickerRepositoryPort } from "../core/app-service-ports";
 import { persistBrokerAccounts } from "./account-cache";
 import type { BrokerAdapter, BrokerPosition } from "../types/broker";
@@ -218,7 +219,7 @@ export async function syncBrokerInstance({
     throw new Error(`Broker "${instance.brokerType}" is not available.`);
   }
 
-  const valid = await broker.validate(instance).catch(() => false);
+  const valid = await broker.validate(instance).catch(logFailure("broker-sync", "Broker validation failed", false));
   throwIfBrokerImportCancelled(signal);
   if (!valid) {
     throw new Error(`${broker.name} setup is incomplete.`);

package/src/capabilities/chart-series.ts

@@ -203,6 +203,7 @@ function resolvedOutput(value: unknown): ResolvedSeries {
   onlyKeys(input, "resolve output", [
     "id", "label", "color", "unit", "unitGroup", "nativeFrequency", "timestampMode", "dataShape", "style", "transform",
     "axis", "panelId", "interpolation", "timeBasis", "latestChangePercent", "points", "warning", "hidden", "attribution",
+    "priceOf",
   ]);
   if (!Array.isArray(input.points)) fail("resolve output points", "expected an array.");
   if (input.points.length > MAX_CHART_SERIES_POINTS) {
@@ -252,6 +253,7 @@ function resolvedOutput(value: unknown): ResolvedSeries {
     ...(input.hidden !== undefined
       ? typeof input.hidden === "boolean" ? { hidden: input.hidden } : fail("resolve output hidden", "expected a boolean.")
       : {}),
+    ...(input.priceOf !== undefined ? { priceOf: boundedString(input.priceOf, "resolve output price ticker", 64) } : {}),
   };
 }
 

package/src/capabilities/registry.ts

@@ -150,9 +150,7 @@ export class CapabilityRegistry {
     for (const subscriptionId of [...this.subscriptions.keys()]) {
       try {
         this.unsubscribe(subscriptionId);
-      } catch {
-        // Continue releasing the remaining subscriptions.
-      }
+      } catch { /* Intentional ignore: Teardown must attempt every subscription disposer even if one has already closed. */ }
     }
     this.capabilities.clear();
   }

package/src/cli/bank-section.ts

@@ -0,0 +1,147 @@
+import type { BankFiguresPayload } from "../api-client/bank-figures";
+import type { TickerFinancials } from "../types/financials";
+import type { CliReportEntry } from "./report-tables";
+import { isForeignIssuerForm, type StatementReportSources } from "./statement-filings";
+import { formatCompact, formatPercent } from "../utils/format";
+import { logFailure } from "../utils/log-failure";
+import { nonUsSecListingVenue } from "../utils/sec";
+
+/**
+ * The Bank section of `fundamentals` for a bank holding company: its deposits
+ * and their change on the quarter from its own filings, and its lead bank's
+ * uninsured share and CRE concentration from the FDIC call report. Every line
+ * names the quarter and the filing or report date it is from. Methodology is
+ * in docs/usage.md (Statement filings and bank figures).
+ */
+export interface BankSection {
+  /** Label and text, as the report prints them. */
+  lines: Array<[string, string]>;
+  /** The same figures for --csv and --ndjson. */
+  entries: CliReportEntry[];
+  /** Muted lines under the section: what is missing and why, and where NIM is. */
+  notes: string[];
+}
+
+const money = (value: number) => `${formatCompact(value)} USD`;
+const share = (value: number) => `${(value * 100).toFixed(1)}%`;
+const day = (stamp: string | null) => stamp?.slice(0, 10) ?? null;
+
+/** The screener on one company with its net interest margin, a Pro figure. */
+export function nimCommand(symbol: string): string {
+  const definition = JSON.stringify({
+    version: 1, currency: null, criteria: [{ field: "symbol", op: "in", value: [symbol] }], sort: { field: "symbol", direction: "asc" },
+  });
+  return `gloomberb fn EQS --metric kpiNimPercent --definition '${definition}'`;
+}
+
+/** Gloom Cloud's note for a company with no US GAAP deposits tag, which reads as if it filed 10-Qs; a foreign issuer files neither. */
+const NO_DEPOSITS_TAG_NOTE = "The company's 10-Q and 10-K tag no total deposits.";
+
+export function bankSection(bank: BankFiguresPayload, symbol: string, { latestStatementDate, annualReportForm }: {
+  /** The newest statement period, YYYY-MM-DD. */
+  latestStatementDate: string | null;
+  /** The company's annual report form: a 20-F or 40-F names a foreign group, whose FDIC-insured bank is only its US arm. */
+  annualReportForm: string | null;
+}): BankSection | null {
+  if (!bank.bank) return null;
+  const foreignGroup = isForeignIssuerForm(annualReportForm);
+  const lines: Array<[string, string]> = [];
+  const entries: CliReportEntry[] = [];
+  const notes = foreignGroup ? bank.notes.filter((note) => note !== NO_DEPOSITS_TAG_NOTE) : [...bank.notes];
+  const { deposits, leadBank, callReport } = bank;
+
+  if (leadBank) {
+    const largest = leadBank.otherBanks > 0
+      ? `largest of ${leadBank.otherBanks + 1} insured banks by assets${leadBank.reportDate ? ` at ${leadBank.reportDate}` : ""}`
+      : null;
+    const role = foreignGroup
+      ? ["US bank subsidiary only", largest].filter(Boolean).join(", ")
+      : !leadBank.holdingCompany ? "the company is the bank" : largest ?? "its insured bank";
+    const asOf = day(leadBank.source.datasetAsOf);
+    lines.push(["Lead Bank", `${leadBank.name} (FDIC cert ${leadBank.cert}; ${role}${asOf ? `; FDIC data of ${asOf}` : ""})`]);
+    entries.push({ label: "Lead Bank", value: leadBank.name }, { label: "Lead Bank FDIC Cert", value: leadBank.cert });
+    if (foreignGroup) {
+      entries.push({ label: "Lead Bank Scope", value: "US bank subsidiary of a foreign group" });
+      notes.push(`${symbol} reports as a foreign issuer (${annualReportForm}): the FDIC figures are those of its US bank subsidiary, ${leadBank.name}, `
+        + `not the group's. Group deposits are in its ${annualReportForm} and not read here.`);
+    }
+  }
+
+  if (deposits) {
+    const { latest, previous } = deposits;
+    const parts = latest.basis === "sum" ? "; interest-bearing plus noninterest-bearing" : "";
+    lines.push(["Deposits", `${money(latest.value)} at ${latest.date} (${latest.form} filed ${latest.filed}${parts})`]);
+    entries.push(
+      { label: "Deposits", value: latest.value, unit: "USD" },
+      { label: "Deposits Date", value: latest.date },
+      { label: "Deposits Filing", value: `${latest.form} filed ${latest.filed}` },
+    );
+    if (previous && previous.value > 0) {
+      const depositsChange = latest.value / previous.value - 1;
+      lines.push(["Deposits QoQ", `${formatPercent(depositsChange)} from ${money(previous.value)} at ${previous.date} (${previous.form} filed ${previous.filed})`]);
+      entries.push({ label: "Deposits QoQ", value: depositsChange * 100, unit: "%" });
+    }
+    if (latestStatementDate && latest.date < latestStatementDate) {
+      notes.push(`Deposits are as of ${latest.date}: the company's later filings do not tag total deposits.`);
+    }
+  }
+
+  if (callReport) {
+    const asOf = day(callReport.source.datasetAsOf);
+    const report = `call report ${callReport.reportDate}${asOf ? `, FDIC data of ${asOf}` : ""}`;
+    // The FDIC's estimate covers deposits in domestic offices: its uninsured part over insured plus uninsured.
+    const { uninsuredShare, uninsuredDeposits, insuredDeposits } = callReport;
+    const estimated = uninsuredDeposits != null && insuredDeposits != null ? uninsuredDeposits + insuredDeposits : null;
+    lines.push(["Uninsured Deposits", uninsuredShare != null && uninsuredDeposits != null && estimated != null
+      ? `${share(uninsuredShare)} of domestic deposits (${formatCompact(uninsuredDeposits)} uninsured of ${money(estimated)} estimated insured plus uninsured; ${report})`
+      : `not reported: banks under $1B in assets do not file the estimate (${report})`]);
+    if (uninsuredShare != null) entries.push({ label: "Uninsured Share of Domestic Deposits", value: uninsuredShare * 100, unit: "%" });
+    if (uninsuredDeposits != null) entries.push({ label: "Uninsured Deposits", value: uninsuredDeposits, unit: "USD" });
+    // Deposits in foreign offices are outside the estimate, and FDIC insurance does not cover them.
+    const foreignOffices = callReport.totalDeposits != null && callReport.domesticDeposits != null
+      ? callReport.totalDeposits - callReport.domesticDeposits
+      : 0;
+    if (uninsuredShare != null && callReport.totalDeposits && foreignOffices / callReport.totalDeposits >= 0.005) {
+      entries.push({ label: "Foreign Office Deposits", value: foreignOffices, unit: "USD" });
+      notes.push(`The uninsured share covers domestic offices; another ${money(foreignOffices)} of deposits sits in foreign offices, which FDIC insurance does not cover.`);
+    }
+    if (callReport.cre && callReport.capital && callReport.creToCapital != null) {
+      lines.push(["CRE / Capital", `${share(callReport.creToCapital)}: CRE ${money(callReport.cre.total)} over ${callReport.capital.basis} ${money(callReport.capital.value)} (${report})`]);
+      entries.push(
+        { label: "CRE / Capital", value: callReport.creToCapital * 100, unit: "%" },
+        { label: "CRE Loans", value: callReport.cre.total, unit: "USD" },
+      );
+    }
+    entries.push({ label: "Call Report Date", value: callReport.reportDate });
+    if (asOf) entries.push({ label: "FDIC Data As Of", value: asOf });
+  }
+
+  notes.push(`NIM is a Pro figure in EQS: ${nimCommand(symbol)}`);
+  return { lines, entries, notes };
+}
+
+/** The line for a bank whose figures could not be read. */
+const BANK_FIGURES_UNAVAILABLE = "Bank figures (deposits, uninsured share, CRE) are unavailable right now.";
+
+/**
+ * A US-listed financial company's bank figures, or null: a company outside
+ * financial services is never asked about (Gloom Cloud answers a non-bank with
+ * `bank: false` anyway). A bank whose figures could not be read gets a one-line
+ * `note` in their place.
+ */
+export async function loadBankFigures(
+  sources: StatementReportSources | undefined,
+  listing: { symbol: string; exchange?: string },
+  financials: Pick<TickerFinancials, "profile">,
+): Promise<{ bank: BankFiguresPayload | null; note: string | null }> {
+  const profile = `${financials.profile?.sector ?? ""} ${financials.profile?.industry ?? ""}`;
+  if (!sources || !/financ|bank/i.test(profile) || nonUsSecListingVenue(listing.symbol, listing.exchange)) return { bank: null, note: null };
+  try {
+    const bank = await sources.bankFigures(listing.symbol);
+    return { bank: bank.bank ? bank : null, note: null };
+  } catch (error) {
+    logFailure("cli.bank-section", "Reading bank figures failed")(error);
+    // Only a bank's report misses them; another financial company's says nothing.
+    return { bank: null, note: /bank/i.test(financials.profile?.industry ?? "") ? BANK_FIGURES_UNAVAILABLE : null };
+  }
+}

package/src/cli/base-converter.ts

@@ -1,18 +1,21 @@
 import type { DataProvider } from "../types/data-provider";
+import { fixedUsdRate } from "../utils/currency-units";
+import { logFailure } from "../utils/log-failure";
 
 export function createBaseConverter(dataProvider: Pick<DataProvider, "getExchangeRate">, baseCurrency: string) {
   const rateCache = new Map<string, number>([["USD", 1]]);
 
   const getRate = async (currency: string): Promise<number> => {
     const normalizedCurrency = currency.toUpperCase();
-    const cached = rateCache.get(normalizedCurrency);
+    const cached = rateCache.get(normalizedCurrency) ?? fixedUsdRate(normalizedCurrency);
     if (cached != null) return cached;
     try {
       const rate = await dataProvider.getExchangeRate(normalizedCurrency);
       const validRate = Number.isFinite(rate) && rate > 0 ? rate : Number.NaN;
       rateCache.set(normalizedCurrency, validRate);
       return validRate;
-    } catch {
+    } catch (error) {
+      logFailure("cli-base-converter", "Could not load base conversion exchange rate")(error);
       return Number.NaN;
     }
   };

package/src/cli/board-coins.ts

@@ -0,0 +1,70 @@
+import { apiClient } from "../api-client";
+import type { CryptoMarketAsset } from "../api-client/crypto-markets";
+import { logFailure } from "../utils/log-failure";
+
+/** A coin on the crypto board as a hint names it: its one symbol and its name. */
+export interface BoardCoin {
+  symbol: string;
+  name: string;
+}
+
+type BoardEntry = Pick<CryptoMarketAsset, "symbol" | "code" | "name" | "marketCap">;
+
+/** How long a hint waits for the board; a slow board leaves the plain search hint. */
+const BOARD_TIMEOUT_MS = 4_000;
+const BARE_NOT_A_TICKER = /Not a ticker: ([A-Za-z0-9]+)\./;
+
+let board: readonly BoardEntry[] | null = null;
+let loading: Promise<void> | null = null;
+
+/**
+ * Reads the crypto board once, when some text says a bare word is not a
+ * ticker, so `boardCoinFor` can name the coin it may be. Never throws; a
+ * board that fails or is slow leaves the hints as they were.
+ */
+export async function primeBoardCoins(
+  texts: ReadonlyArray<string | null | undefined>,
+  load: () => Promise<{ assets: readonly BoardEntry[] }> = () => apiClient.getCloudCryptoMarkets(),
+): Promise<void> {
+  if (board || !texts.some((text) => !!text && BARE_NOT_A_TICKER.test(text))) return;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  loading ??= Promise.race([
+    load().then((data) => { board = boardEntries(data.assets); }),
+    new Promise<void>((resolve) => { timer = setTimeout(resolve, BOARD_TIMEOUT_MS); }),
+  ]).catch(logFailure("cli.board-coins", "Read the crypto board for a coin hint failed")).finally(() => clearTimeout(timer));
+  await loading;
+}
+
+/** The board's coins a hint can name: a symbol, a code and a name each. */
+function boardEntries(assets: unknown): BoardEntry[] {
+  return (Array.isArray(assets) ? assets : []).filter((asset): asset is BoardEntry => !!asset
+    && typeof asset.symbol === "string" && /^[A-Z0-9]+-USD$/.test(asset.symbol)
+    && typeof asset.code === "string" && !!asset.code && typeof asset.name === "string");
+}
+
+const compact = (text: string) => text.toUpperCase().replace(/[^\p{L}\p{N}]/gu, "");
+
+/**
+ * The board coin a bare word that is no ticker most likely means: its code
+ * (USDT, USDS, USDE) or its name (TETHER for Tether USDt, BITCOIN), the
+ * largest by market cap when several answer. Null before the board is read,
+ * and for anything else.
+ */
+export function boardCoinFor(typed: string): BoardCoin | null {
+  const id = typed.trim().replace(/^\$/, "").toUpperCase();
+  if (!board || !/^[A-Z0-9]+$/.test(id)) return null;
+  const byCode = board.filter((coin) => coin.code.toUpperCase() === id);
+  const byName = byCode.length ? [] : board.filter((coin) => {
+    const name = compact(coin.name);
+    const first = compact(coin.name.split(/\s+/)[0] ?? "");
+    return name === id || (id.length >= 5 && first === id);
+  });
+  const best = [...byCode.length ? byCode : byName].sort((left, right) => (right.marketCap ?? 0) - (left.marketCap ?? 0))[0];
+  return best ? { symbol: best.symbol, name: best.name } : null;
+}
+
+/** For tests: forget the board read. */
+export function resetBoardCoins(entries: readonly BoardEntry[] | null = null): void {
+  board = entries;
+  loading = null;
+}