gloomberb 0.18.4 → 0.19.0

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

@@ -1,6 +1,10 @@
+import { METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY, closeBasis, metricName, metricReadingText } from "./metric-model";
+import { metricAvailabilityError } from "./metric-data";
+import { relativeAlertText } from "./metric-command";
+import { levelAlertStoreKey, readLevelAlertStores } from "./storage";
 import { Box, type ScrollBoxRenderable } from "../../../ui";
 import { Button, DetailScrollBody, KeyValueRow, Notice, PaneStatusBody, PaneFooterScope, usePaneTabs } from "../../../components";
-import { usePluginPaneState } from "../../runtime";
+import { usePluginPaneState, usePluginState } from "../../runtime";
 import { EventAlertsPane } from "./events-pane";
 import { AlertHistoryPane } from "./history-pane";
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore, type RefObject } from "react";
@@ -27,16 +31,21 @@ import {
   readAlertsStoreError,
   serializeAlerts,
 } from "./alert-engine";
-import { parseAlertCommandValues } from "./command";
+import { parseAlertEdit } from "./command";
 import { ALERT_TABS, ALERTS_KEY } from "./constants";
 import {
+  alertListing,
   conditionLabel,
   formatAlertDistance,
   formatAlertTargetPrice,
   formatCurrentPrice,
   formatQuoteChecked,
+  isoUtc,
+  listingWithCurrency,
   relativeTime,
 } from "./format";
+import { FIRED_LOG_KEY } from "./fired-log";
+import { withAlertChange } from "./alert-log";
 import type { AlertRule } from "./types";
 import { useQuoteEntries } from "../../../market-data/hooks";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
@@ -48,35 +57,37 @@ import { alertTarget, alertViewHints, priceRuleSubject, useOpenAlertTarget } fro
 type AlertColumnId =
   | "status"
   | "symbol"
+  | "metric"
   | "current"
   | "target"
   | "away"
   | "condition"
   | "quote"
-  | "triggered";
+  | "triggered"
+  | "created";
 
 type AlertColumn = DataTableColumn & { id: AlertColumnId };
 
 const ALERT_COLUMNS: AlertColumn[] = [
   { id: "status", label: "State", width: 9, align: "left" },
   { id: "symbol", label: "Symbol", width: 7, align: "left" },
-  { id: "current", label: "Current", width: 9, align: "right" },
-  { id: "target", label: "Target", width: 9, align: "right" },
+  { id: "metric", label: "Measure", width: 14, align: "left" },
+  { id: "current", label: "Current", width: 8, align: "right" },
+  { id: "target", label: "Target", width: 11, align: "right" },
   { id: "away", label: "Away", width: 8, align: "right" },
-  { id: "condition", label: "Trigger", width: 7, align: "left" },
-  { id: "quote", label: "Quote", width: 8, align: "left" },
+  { id: "condition", label: "Trigger", width: 12, align: "left" },
+  // Wide enough to say "not checked yet" for an alert no check has read.
+  { id: "quote", label: "Quote", width: 15, align: "left" },
   { id: "triggered", label: "Alerted", width: 8, align: "left" },
+  // The day the alert was made (UTC), as Events lists its rules; the detail gives the instant.
+  { id: "created", label: "Since", width: 10, align: "left" },
 ];
 
-const ALERT_TABLE_CONTENT_WIDTH = ALERT_COLUMNS.reduce(
-  (sum, column) => sum + column.width + 1,
-  2,
-);
-
 const DETAIL_ROW = { labelWidth: 10, emphasis: false } as const;
 
 /** "AAPL above 400.00": the rule, which titles its detail. */
 function alertTitle(alert: AlertRule): string {
+  if (alert.metric) return formatAlertDescription(alert);
   return `${alert.symbol} ${conditionLabel(alert.condition).toLowerCase()} ${formatAlertTargetPrice(alert)}`;
 }
 
@@ -88,19 +99,28 @@ function AlertDetail({ alert, scrollRef }: { alert: AlertRule; scrollRef: RefObj
   const reason = alert.lastCheckError
     ? alert.lastCheckError.includes(alert.symbol) ? alert.lastCheckError : `${alert.symbol}: ${alert.lastCheckError}`
     : null;
+  const basis = alert.metric ? closeBasis(alert.metric) : null;
   return (
     <DetailScrollBody ref={scrollRef} resetScrollKey={alert.id}>
       <Box flexDirection="column">
         {reason ? <Box paddingBottom={1}><Notice tone="warning">{reason}</Notice></Box> : null}
         <KeyValueRow {...DETAIL_ROW} label="State" value={alert.status === "triggered" ? "Triggered" : "Active"} tone={alert.status === "triggered" ? "positive" : "muted"} />
+        <KeyValueRow {...DETAIL_ROW} label="Listing" value={listingWithCurrency(alertListing(alert), alert.lastQuoteCurrency)} />
         {/* With no quote the reason above says why; the price and its distance wait for one. */}
+        {basis ? <KeyValueRow {...DETAIL_ROW} label="Close date" value={alert.lastDailyClose ?? `Awaiting ${basis}`} /> : null}
         {reason ? null : <KeyValueRow {...DETAIL_ROW} label="Current" value={formatCurrentPrice(alert, 24)} />}
+        {/* The two readings that place the quadrant, as RRG states them. */}
+        {!reason && alert.metric?.kind === "rrg" && alert.lastCheckedPrice != null && alert.lastCheckedTarget != null ? <>
+          <KeyValueRow {...DETAIL_ROW} label="Strength" value={alert.lastCheckedPrice.toFixed(2)} />
+          <KeyValueRow {...DETAIL_ROW} label="Momentum" value={alert.lastCheckedTarget.toFixed(2)} />
+        </> : null}
         {reason ? null : <KeyValueRow {...DETAIL_ROW} label="Away" value={formatAlertDistance(alert)} />}
         {reason
           ? alert.lastCheckedAt ? <KeyValueRow {...DETAIL_ROW} label="Checked" value={relativeTime(alert.lastCheckedAt)} tone="muted" /> : null
           : <KeyValueRow {...DETAIL_ROW} label="Quote" value={formatQuoteChecked(alert)} tone="muted" />}
         {alert.triggeredAt ? <KeyValueRow {...DETAIL_ROW} label="Alerted" value={relativeTime(alert.triggeredAt)} /> : null}
         <KeyValueRow {...DETAIL_ROW} label="Armed" value={relativeTime(alert.armedAt ?? alert.createdAt)} tone="muted" />
+        <KeyValueRow {...DETAIL_ROW} label="Created" value={isoUtc(alert.createdAt)} tone="muted" />
       </Box>
     </DetailScrollBody>
   );
@@ -141,18 +161,27 @@ export function AlertsPane(props: PaneProps) {
 
 function PriceAlertsPane({ focused, width, height }: PaneProps) {
   const [alertsJson, setAlertsJson] = usePluginConfigState<unknown>(ALERTS_KEY, "[]");
+  const [metricsJson, setMetricsJson] = usePluginConfigState<unknown>(METRIC_ALERTS_KEY, "[]");
+  const [relativeJson, setRelativeJson] = usePluginConfigState<unknown>(RELATIVE_ALERTS_KEY, "[]");
   const { openPluginCommandWorkflow, notify } = usePluginAppActions();
+  // Deleting or re-arming a rule goes in this device's alert log, beside the alerts that fired.
+  const [, setAlertLog] = usePluginState<unknown>(FIRED_LOG_KEY, []);
   const dialog = useDialog();
   const [selectedIdx, setSelectedIdx] = useState(0);
   const [detailOpen, setDetailOpen] = useState(false);
   // The alert the open detail shows, by id, so it never becomes whichever alert takes its row.
   const detailAlertId = useRef<string | null>(null);
   const detailScrollRef = useRef<ScrollBoxRenderable | null>(null);
-  const showHorizontalScrollbar = ALERT_TABLE_CONTENT_WIDTH > width;
-  const storeError = useMemo(() => readAlertsStoreError(alertsJson), [alertsJson]);
+  // Keep the rule and daily-close basis visible in a narrow pane; the detail keeps all figures.
+  const columns = width < 106 ? ALERT_COLUMNS.filter(column => column.id !== "away" && column.id !== "triggered" && column.id !== "created")
+    : width < 118 ? ALERT_COLUMNS.filter(column => column.id !== "created") : ALERT_COLUMNS;
+  const showHorizontalScrollbar = columns.reduce((sum, column) => sum + column.width + 1, 2) > width;
+  const stores = useMemo(() => readLevelAlertStores(key => key === ALERTS_KEY ? alertsJson : key === METRIC_ALERTS_KEY ? metricsJson : relativeJson),
+    [alertsJson, metricsJson, relativeJson]);
+  const storeError = stores.error;
 
   const { alerts, rows } = useMemo(() => {
-    const parsed = deserializeAlerts(alertsJson);
+    const parsed = stores.alerts;
     const activeAlerts = parsed.filter((a) => a.status === "active");
     const triggeredAlerts = parsed
       .filter((a) => a.status === "triggered")
@@ -162,7 +191,7 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
       alerts: parsed,
       rows: [...activeAlerts, ...triggeredAlerts],
     };
-  }, [alertsJson]);
+  }, [stores]);
 
   const focusedAlertId = useSyncExternalStore(subscribePriceAlertFocus, getPriceAlertFocus, getPriceAlertFocus);
   useEffect(() => {
@@ -177,7 +206,7 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
   // symbol streams the table shows its live price instead.
   const liveInstruments = useMemo(() => {
     const unique = new Map(rows
-      .filter((alert) => alert.status === "active")
+      .filter((alert) => !alert.metric && alert.status === "active")
       .map((alert) => [buildQuoteKey(alertInstrument(alert)), alertInstrument(alert)] as const));
     return [...unique.values()];
   }, [rows]);
@@ -189,22 +218,27 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
     syncAlertQuoteStream();
   }, [liveSymbolsKey]);
   const displayRows = useMemo(() => rows.map((alert) => {
+    if (alert.metric) {
+      const error = metricAvailabilityError(alert) ?? alert.lastCheckError;
+      return error ? { ...alert, lastCheckError: error } : alert;
+    }
     if (alert.status !== "active") return alert;
     const quote = streamedAlertQuote(resolveEntryData(liveEntries.get(buildQuoteKey(alertInstrument(alert)))));
     return quote ? { ...alert, ...quoteAlertFields(quote, quote.receivedAt) } : alert;
   }), [liveEntries, rows]);
 
-  const savePaneAlerts = useCallback((next: (current: AlertRule[]) => AlertRule[]): string | null => {
+  const savePaneAlerts = useCallback((id: string, next: (current: AlertRule[]) => AlertRule[]): string | null => {
+    const found = alerts.find(alert => alert.id === id);
+    const key = found ? levelAlertStoreKey(found) : ALERTS_KEY;
+    if (stores.errors[key]) return stores.errors[key];
     let error: string | null = null;
-    setAlertsJson((currentJson: unknown) => {
+    const setJson = key === METRIC_ALERTS_KEY ? setMetricsJson : key === RELATIVE_ALERTS_KEY ? setRelativeJson : setAlertsJson;
+    setJson((currentJson: unknown) => {
       error = readAlertsStoreError(currentJson);
-      // The config hook skips persistence when the updater returns the unchanged value.
-      if (error) return currentJson;
-      const current = deserializeAlerts(currentJson);
-      return serializeAlerts(next(current));
+      return error ? currentJson : serializeAlerts(next(deserializeAlerts(currentJson)));
     });
     return error;
-  }, [setAlertsJson]);
+  }, [alerts, setAlertsJson, setMetricsJson, setRelativeJson, stores]);
 
   const deleteAlert = useCallback(async (id: string) => {
     const alert = alerts.find((a) => a.id === id);
@@ -215,20 +249,29 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
       confirmLabel: "Delete",
     });
     if (!confirmed) return;
-    const error = savePaneAlerts((current) => current.filter((a) => a.id !== id));
+    const error = savePaneAlerts(id, (current) => current.filter((a) => a.id !== id));
     if (error) {
       notify({ body: error, type: "error" });
       return;
     }
+    setAlertLog((saved: unknown) => withAlertChange(saved, "deleted", alert));
     setSelectedIdx((prev) => Math.max(0, Math.min(prev, rows.length - 2)));
-  }, [alerts, dialog, notify, rows.length, savePaneAlerts]);
+  }, [alerts, dialog, notify, rows.length, savePaneAlerts, setAlertLog]);
 
   const rearmAlert = useCallback((id: string) => {
-    const error = savePaneAlerts(
-      (current) => current.map((a) => (a.id === id ? rebuildAlert(a) : a)),
-    );
-    if (error) notify({ body: error, type: "error" });
-  }, [notify, savePaneAlerts]);
+    // Only an alert that went off is re-armed, as the store reads at the write: one still waiting is left, and not logged.
+    const rearmed: AlertRule[] = [];
+    const error = savePaneAlerts(id, (current) => current.map((a) => {
+      if (a.id !== id || a.status !== "triggered") return a;
+      rearmed.push(a);
+      return rebuildAlert(a);
+    }));
+    if (error) {
+      notify({ body: error, type: "error" });
+      return;
+    }
+    for (const alert of rearmed) setAlertLog((saved: unknown) => withAlertChange(saved, "rearmed", alert));
+  }, [notify, savePaneAlerts, setAlertLog]);
 
   const startAddAlert = useCallback(() => {
     openPluginCommandWorkflow("set-alert");
@@ -266,13 +309,12 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
             description: "SYMBOL above|below|crosses PRICE",
             placeholder: "AAPL above 200",
           }}
-          currentValue={`${selected.symbol} ${selected.condition} ${selected.targetPrice}`}
+          currentValue={relativeAlertText(selected) ?? (selected.metric ? formatAlertDescription(selected).replace(" (TTM)", "").replace(" · on daily close", "") : `${selected.symbol} ${selected.condition} ${selected.targetPrice}`)}
           onApply={async (value) => {
-            const parsed = parseAlertCommandValues({ shortcut: value });
-            if (!parsed) throw new Error("Use SYMBOL above|below|crosses PRICE.");
-            const error = savePaneAlerts((current) => current.map((alert) => (
+            const parsed = parseAlertEdit(selected, value);
+            const error = savePaneAlerts(selected.id, (current) => current.map((alert) => (
               alert.id === selected.id
-                ? editAlert(alert, parsed.symbol, parsed.condition, parsed.price)
+                ? { ...editAlert(alert, parsed.symbol, parsed.condition, parsed.price), ...(parsed.metric ? { metric: parsed.metric } : {}) }
                 : alert
             )));
             if (error) throw new Error(error);
@@ -356,7 +398,7 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
     switch (column.id) {
       case "status":
         return {
-          text: alert.status === "triggered" ? "Triggered" : "Active",
+          text: alert.status === "triggered" ? "Triggered" : alert.lastCheckError && alert.metric ? "Blocked" : "Active",
           color: alert.status === "triggered" ? colors.positive : colors.textDim,
           attributes: alert.status === "triggered" ? TextAttributes.BOLD : TextAttributes.NONE,
         };
@@ -366,9 +408,14 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
           color: colors.textBright,
           attributes: TextAttributes.BOLD,
         };
+      case "metric":
+        return { text: alert.metric ? metricName(alert.metric) : "Price" };
       case "current":
         return {
           text: formatCurrentPrice(alert, column.width),
+          // The quadrant word exports with the readings that place it.
+          ...(alert.metric?.kind === "rrg" && !alert.lastCheckError && alert.lastCheckedPrice != null && alert.lastCheckedTarget != null
+            ? { value: metricReadingText(alert.metric, { value: alert.lastCheckedPrice, target: alert.lastCheckedTarget }) } : {}),
           color: alert.lastCheckError ? colors.negative : colors.text,
         };
       case "target":
@@ -379,10 +426,12 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
           color: colors.textDim,
         };
       case "condition":
-        return { text: conditionLabel(alert.condition) };
+        return { text: alert.metric?.kind === "ma_cross" ? `Cross ${alert.metric.direction}` : alert.metric?.kind === "rrg" ? "Enters" : conditionLabel(alert.condition) };
       case "quote":
         return {
           text: formatQuoteChecked(alert),
+          // A settled close exports as its session date.
+          ...(alert.metric && closeBasis(alert.metric) && alert.lastDailyClose && !alert.lastCheckError ? { value: alert.lastDailyClose } : {}),
           color: alert.lastCheckError ? colors.negative : colors.textDim,
         };
       case "triggered":
@@ -390,6 +439,8 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
           text: alert.triggeredAt ? relativeTime(alert.triggeredAt) : "-",
           color: colors.textDim,
         };
+      case "created":
+        return { text: isoUtc(alert.createdAt).slice(0, 10), color: colors.textDim };
     }
   }, []);
 
@@ -410,7 +461,7 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
       rootWidth={width}
       rootHeight={height}
       rootBackgroundColor={colors.bg}
-      columns={ALERT_COLUMNS}
+      columns={columns}
       items={displayRows}
       sortColumnId={null}
       sortDirection="asc"

package/src/plugins/builtin/alerts/quotes.ts

@@ -2,6 +2,7 @@ import type { DataProvider } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
 import { getActiveQuoteDisplay } from "../../../market-data/market/status";
 import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
+import { canonicalExchange } from "../../../utils/exchanges";
 import type { AlertRule } from "./types";
 
 export function normalizeAlertSymbol(value: string | null | undefined): string {
@@ -46,13 +47,18 @@ export function quoteAlertFields(
   | "lastQuoteUpdatedAt"
   | "lastQuoteSource"
   | "lastQuoteProviderId"
+  | "lastQuoteCurrency"
+  | "lastQuoteExchange"
 > & { lastCheckError?: undefined } {
+  const exchange = quote.listingExchangeName || quote.exchangeName;
   return {
     lastCheckedPrice: quote.price,
     lastCheckedAt: checkedAt,
     lastQuoteUpdatedAt: quote.lastUpdated,
     lastQuoteSource: quote.dataSource,
     lastQuoteProviderId: quote.providerId,
+    ...(quote.currency ? { lastQuoteCurrency: quote.currency } : {}),
+    ...(exchange ? { lastQuoteExchange: canonicalExchange(exchange) } : {}),
     lastCheckError: undefined,
   };
 }

package/src/plugins/builtin/alerts/storage.ts

@@ -1,3 +1,4 @@
+import { METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY, metricAlertsKey } from "./metric-model";
 import type { AppConfig } from "../../../types/config";
 import type { GloomPluginContext } from "../../../types/plugin";
 import {
@@ -10,30 +11,56 @@ import { readEventAlertStores } from "./events";
 import type { AlertRule } from "./types";
 
 export function loadAlerts(ctx: GloomPluginContext): AlertRule[] {
-  const json = ctx.configState.get<unknown>(ALERTS_KEY);
-  // Background evaluation must not notify from a partial store it cannot safely update.
-  if (readAlertsStoreError(json)) return [];
-  return deserializeAlerts(json);
+  const result = readLevelAlertStores((key) => ctx.configState.get<unknown>(key));
+  return result.alerts;
 }
 
 export async function saveAlerts(
   ctx: GloomPluginContext,
   alerts: AlertRule[],
+  scope: "all" | "price" | "metric" = "all",
 ): Promise<void> {
-  const error = readAlertsStoreError(ctx.configState.get<unknown>(ALERTS_KEY));
-  if (error) throw new Error(error);
-  await ctx.configState.set(ALERTS_KEY, serializeAlerts(alerts));
+  const stores = readLevelAlertStores((key) => ctx.configState.get<unknown>(key));
+  // An unreadable list is never written over; one that has nothing to write does not hold up the others.
+  const entries = Object.entries(writeLevelAlertStores(alerts)).filter(([key, value]) => (scope === "all"
+    || (scope === "price" ? key === ALERTS_KEY : key !== ALERTS_KEY)) && !(stores.errors[key] && value === "[]"));
+  for (const [key] of entries) if (stores.errors[key]) throw new Error(stores.errors[key]!);
+  for (const [key, value] of entries) {
+    if (ctx.configState.get<unknown>(key) !== value) await ctx.configState.set(key, value);
+  }
 }
 
 /** Both alert stores as the saved config holds them, for the CLI and the reports, which have no plugin context. */
 export function readAlertStores(config: AppConfig) {
   const pluginState = config.pluginConfig[ALERTS_PLUGIN_ID] ?? {};
-  const rawPrice = pluginState[ALERTS_KEY];
+  const levels = readLevelAlertStores((key) => pluginState[key]);
   return {
     pluginState,
-    alerts: deserializeAlerts(rawPrice),
-    alertsError: readAlertsStoreError(rawPrice),
+    alerts: levels.alerts,
+    alertsError: levels.error,
+    levelErrors: levels.errors,
     // The event alerts, and the IV levels kept apart from them.
     events: readEventAlertStores((key) => pluginState[key]),
   };
 }
+
+export function readLevelAlertStores(get: (key: string) => unknown): { alerts: AlertRule[]; error: string | null; errors: Record<string, string | null> } {
+  const alerts: AlertRule[] = [];
+  const errors: Record<string, string | null> = {};
+  for (const key of LEVEL_ALERT_KEYS) {
+    const raw = get(key);
+    let error = readAlertsStoreError(raw);
+    const rows = error ? [] : deserializeAlerts(raw);
+    if (rows.some(a => levelAlertStoreKey(a) !== key)) error = "Saved alerts contain a rule in the wrong list. Original data has been kept.";
+    errors[key] = key === METRIC_ALERTS_KEY ? error?.replaceAll("price alerts", "valuation and technical alerts") ?? null
+      : key === RELATIVE_ALERTS_KEY ? error?.replaceAll("price alerts", "relative strength alerts") ?? null : error;
+    if (!error) alerts.push(...rows);
+  }
+  return { alerts, errors, error: Object.values(errors).filter(Boolean).join(" ") || null };
+}
+export function writeLevelAlertStores(alerts: AlertRule[]): Record<string, string> {
+  return Object.fromEntries(LEVEL_ALERT_KEYS.map(key => [key, serializeAlerts(alerts.filter(a => levelAlertStoreKey(a) === key))]));
+}
+/** Price, valuation/technical and relative strength rules each keep their own synced list. */
+const LEVEL_ALERT_KEYS = [ALERTS_KEY, METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY] as const;
+export const levelAlertStoreKey = (alert: Pick<AlertRule, "metric">): string => alert.metric ? metricAlertsKey(alert.metric) : ALERTS_KEY;

package/src/plugins/builtin/alerts/types.ts

@@ -9,6 +9,9 @@ export interface AlertRule {
   exchange?: string;
   condition: AlertCondition;
   targetPrice: number;
+  metric?: import("./metric-model").AlertMetric;
+  lastDailyClose?: string;
+  lastCheckedTarget?: number;
   createdAt: number;
   /** When an edit or re-arm last armed the rule; createdAt until then. Gloom Cloud emails a trigger once per arming. */
   armedAt?: number;
@@ -20,5 +23,9 @@ export interface AlertRule {
   lastQuoteUpdatedAt?: number;
   lastQuoteSource?: QuoteDataSource;
   lastQuoteProviderId?: string;
+  /** The currency of the quote the alert was last checked on (USD): its listing's, which lists show beside it. */
+  lastQuoteCurrency?: string;
+  /** The venue that quote was from (ARCA), which names the listing of a rule set by symbol alone. */
+  lastQuoteExchange?: string;
   message?: string;
 }

package/src/plugins/builtin/analytics/index.tsx

@@ -1,6 +1,7 @@
 import { usePaneSettingValue } from "../../../public/react";
 import { PortfolioRiskPane } from "./risk-pane";
 import { portfolioRiskHeadless } from "./risk-headless";
+import { NO_HOLDINGS_HINT } from "./risk-model";
 import { portfolioRiskCache } from "./risk-client";
 import { Box, Text } from "../../../ui";
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -398,7 +399,7 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
                 message={accountsError ?? undefined}
                 hint={accountsError
                   ? "Reconnect the broker in the Brokers pane (BR), then refresh."
-                  : "Add holdings from the Portfolio pane (PF), or connect a broker in BR to sync them."}
+                  : NO_HOLDINGS_HINT}
               />
             </Box>
           ) : historyOnly ? (

package/src/plugins/builtin/analytics/risk-client.ts

@@ -58,7 +58,12 @@ interface RiskMarketHistory {
    * Set when the listing quotes in another currency and its closes were
    * restated in USD at same-date daily FX closes; quote and closeMark are then in USD.
    */
-  converted?: { currency: string; fxAsOf: string } | null;
+  converted?: {
+    currency: string;
+    fxAsOf: string;
+    /** US sessions converted at the FX close before them, the pair having none that day (bridgedFxClose). */
+    fxBridged?: string[];
+  } | null;
   error: string | null;
 }
 export interface RiskMarketSnapshot {
@@ -162,6 +167,8 @@ export function validateRiskHistory(
   closeMark: { price: number; date: string; currency: string } | null;
   /** Latest completed close in the returns' currency, whatever marks the holding. */
   latestClose: { price: number; date: string };
+  /** With a conversion, the US sessions converted at the FX close before them (bridgedFxClose). */
+  fxBridged?: string[];
 } {
   if (
     response.status !== "success" ||
@@ -244,13 +251,14 @@ export function validateRiskHistory(
   if (local.integrity)
     throw new Error("Daily history has inconsistent OHLC observations");
   // A converted series is on the NYSE calendar the basket and SPY share.
-  const series = conversion
+  const usd = conversion
     ? convertClosesToUsd(
         points.map((point) => ({ date: new Date(point.date).toISOString().slice(0, 10), close: point.close })),
         conversion.fx,
         conversion.divisor,
       )
-    : prices;
+    : null;
+  const series = usd ? usd.points : prices;
   const returns = conversion ? resolveDatedReturns(series).returns : local.returns;
   const cadence = qualifySharpeCadence(returns, [
     { symbol: instrument.symbol, exchange: conversion ? "NYSE" : exchange, history: series },
@@ -264,6 +272,7 @@ export function validateRiskHistory(
   };
   return {
     returns,
+    ...(usd?.bridged.length ? { fxBridged: usd.bridged } : {}),
     asOf: latestClose.date,
     // A missing or stale quote is not a current mark; the latest dated close is.
     closeMark:
@@ -591,7 +600,7 @@ export async function fetchPortfolioRiskMarket(
             historyParams,
             signal ? { signal } : undefined,
           );
-          const { latestClose, ...resolved } = validateRiskHistory(
+          const { latestClose, fxBridged, ...resolved } = validateRiskHistory(
             response,
             instrument,
             quote,
@@ -610,7 +619,9 @@ export async function fetchPortfolioRiskMarket(
               quote: current,
               currency: "USD",
               closeMark: current ? null : { ...latestClose, currency: "USD" },
-              converted: { currency: conversion.listingCurrency, fxAsOf: fxCloses.asOf },
+              converted: {
+                currency: conversion.listingCurrency, fxAsOf: fxCloses.asOf, ...(fxBridged?.length ? { fxBridged } : {}),
+              },
               error: null,
             };
             continue;