gloomberb 0.16.1 → 0.16.2

package/src/market-data/market/session-close-note.ts

@@ -0,0 +1,57 @@
+import { canonicalExchange } from "../../utils/exchanges";
+import { futuresListingVenue } from "../../utils/futures-generic";
+import { regularSessionCloseUtcMinute } from "./freshness";
+
+interface SessionLeg {
+  symbol: string;
+  /** The listing's exchange; without one the close is unknown and no note is made. */
+  exchange?: string;
+  /** What the reader typed, when it differs from the symbol. */
+  label?: string;
+}
+
+const MINUTES_PER_DAY = 1440;
+/** Crypto and FX carry no regular session. */
+const ALWAYS_OPEN_EXCHANGES = new Set(["CCC", "CCY"]);
+
+const clock = (minute: number) => `${String(Math.floor(minute / 60) % 24).padStart(2, "0")}:${String(minute % 60).padStart(2, "0")}`;
+
+function offsetText(minutes: number): string {
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return [hours ? `${hours} h` : "", rest ? `${rest} min` : ""].filter(Boolean).join(" ");
+}
+
+/**
+ * Where a daily bar of the listing falls on its date. A venue with a listed
+ * regular close closes at that UTC time. Crypto, FX and futures carry a bar
+ * dated 00:00 UTC, which closes when the next UTC day starts. A venue with
+ * neither is unknown.
+ */
+function dailyBarClose(leg: SessionLeg, time: number): { minute: number; text: string } | null {
+  const label = leg.label ?? leg.symbol;
+  const minute = regularSessionCloseUtcMinute(leg.exchange, time);
+  if (minute !== null) return { minute, text: `${label} closes ${clock(minute)} UTC` };
+  const exchange = canonicalExchange(leg.exchange);
+  return exchange && (ALWAYS_OPEN_EXCHANGES.has(exchange) || futuresListingVenue(leg.symbol, exchange))
+    ? { minute: MINUTES_PER_DAY, text: `${label} bar is ${clock(0)} UTC` }
+    : null;
+}
+
+/**
+ * One line for a daily pair whose two sides close at different times, such as
+ * a US equity against crypto, or null when they close together (two US
+ * equities) or a close is not known. Daily closes pair by UTC date, so a
+ * reader of a correlation or ratio should know the two prices are not taken
+ * at the same moment. `dateKey` is the date the pair is read on, which
+ * settles daylight time.
+ */
+export function mixedSessionCloseNote(left: SessionLeg, right: SessionLeg, dateKey?: string | null): string | null {
+  const parsed = dateKey ? Date.parse(`${dateKey}T23:59:59Z`) : Number.NaN;
+  const time = Number.isFinite(parsed) ? parsed : Date.now();
+  const a = dailyBarClose(left, time);
+  const b = dailyBarClose(right, time);
+  if (!a || !b) return null;
+  const offset = Math.abs(a.minute - b.minute);
+  return offset === 0 ? null : `${a.text}; ${b.text} (${offsetText(offset)} offset). Daily pairs are matched by date.`;
+}

package/src/market-data/market/status.ts

@@ -1,5 +1,7 @@
 import type { MarketState, Quote } from "../../types/financials";
 import { blendHex, colors, priceColor, type ThemeColors } from "../../theme/colors";
+import { isFiniteNumber } from "../../utils/guards";
+import { quoteTradingDay } from "../quotes/day-range";
 
 const CLOSED_CHANGE_MUTING_RATIO = 0.55;
 const US_SESSION_TIME = new Intl.DateTimeFormat("en-US", {
@@ -20,6 +22,12 @@ export interface ActiveQuoteDisplay {
   changePercent?: number;
 }
 
+export type ExtendedSession = "PRE" | "POST";
+
+export interface ExtendedSessionDisplay extends ActiveQuoteDisplay {
+  session: ExtendedSession;
+}
+
 export function marketStateLabel(state: MarketState): string {
   switch (state) {
     case "PRE": return "PRE-MKT";
@@ -124,6 +132,11 @@ export function exchangeShortName(exchangeName?: string, fullExchangeName?: stri
   return map[name] || name;
 }
 
+/**
+ * The live print against the daily reference, extended hours included: what
+ * a position is worth now and its day P&L. A headline that shows an
+ * extended-hours line beside it uses getRegularSessionDisplay instead.
+ */
 export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
   if (!quote) return null;
   if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
@@ -141,3 +154,141 @@ export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQu
   }
   return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
 }
+
+function isPositive(value: number | undefined): value is number {
+  return isFiniteNumber(value) && value > 0;
+}
+
+interface CompletedRegularSession {
+  close: number;
+  /** The close's move from the session before it, when the quote reports it with the close. */
+  reported: { change: number; changePercent: number } | null;
+}
+
+function reportedRegularMove(quote: Quote, close: number): CompletedRegularSession["reported"] {
+  const change = quote.regularChange;
+  if (!isFiniteNumber(change)) return null;
+  const reference = close - change;
+  const changePercent = isFiniteNumber(quote.regularChangePercent)
+    ? quote.regularChangePercent
+    : isPositive(reference) ? (change / reference) * 100 : null;
+  return changePercent == null ? null : { change, changePercent };
+}
+
+/**
+ * The regular session the quote's day follows, once it is over: after hours,
+ * overnight, and through a weekend or holiday until the next pre-market, and
+ * in the pre-market when the quote reports the last session's close and move,
+ * which its own previous close can no longer give once the day has rolled.
+ * Only a US listing with extended trading reports one. Without a reported
+ * close, an after-hours print less its move from the close gives it. Null in
+ * the regular session.
+ */
+function completedRegularSession(quote: Quote): CompletedRegularSession | null {
+  const state = quote.marketState;
+  if (state == null || state === "REGULAR") return null;
+  const close = quote.regularClose;
+  if (isPositive(close)) {
+    const closeDate = quote.regularCloseSessionDate;
+    const reported = reportedRegularMove(quote, close);
+    if (state === "PRE") {
+      // The quote's own day is today; the close must be an earlier one, with its move.
+      const today = quoteTradingDay(quote);
+      return reported && closeDate && today && closeDate < today ? { close, reported } : null;
+    }
+    if (closeDate ? closeDate === quoteTradingDay(quote) : state === "POST") return { close, reported };
+  }
+  if (state === "POST" && isFiniteNumber(quote.postMarketPrice) && isFiniteNumber(quote.postMarketChange)) {
+    const derived = quote.postMarketPrice - quote.postMarketChange;
+    if (derived > 0) return { close: derived, reported: null };
+  }
+  return null;
+}
+
+function completedRegularClose(quote: Quote): number | null {
+  return completedRegularSession(quote)?.close ?? null;
+}
+
+/**
+ * The day's headline: the regular session, which stops at its close. Once it
+ * is over, and in the pre-market while the quote carries the last session's
+ * close and move, the price is that close and the move is its own, so
+ * extended trading never moves it; the extended print is
+ * getExtendedSessionDisplay. A close without its reported move is measured
+ * against the previous close. In the pre-market without that close and move
+ * the headline is the live price against the previous close, as the
+ * pre-market line is.
+ */
+export function getRegularSessionDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  if (!quote) return null;
+  const session = completedRegularSession(quote);
+  if (session == null) return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
+  const { close, reported } = session;
+  if (reported) return { price: close, ...reported };
+  const reference = isPositive(quote.previousClose)
+    ? quote.previousClose
+    : isFiniteNumber(quote.change) && isPositive(quote.price - quote.change) ? quote.price - quote.change : null;
+  if (reference == null) return { price: close };
+  const change = close - reference;
+  return { price: close, change, changePercent: (change / reference) * 100 };
+}
+
+/**
+ * getRegularSessionDisplay once the regular session is over (and in the
+ * pre-market, while the quote carries the last session's close and move), null
+ * while it is open. A table row headlines this when it has a column for the
+ * extended move: the close and its move stay put, and the extended column is
+ * the only figure that follows the extended print.
+ */
+export function getCompletedRegularSessionDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  return quote && completedRegularClose(quote) != null ? getRegularSessionDisplay(quote) : null;
+}
+
+/**
+ * The pre-market or after-hours print, measured from the regular close before
+ * it, while the quote has one: the pre-market until the open, the after-hours
+ * session from the close, and its last print until the next pre-market. Null
+ * when there is no extended print to show.
+ */
+export function getExtendedSessionDisplay(quote: Quote | null | undefined): ExtendedSessionDisplay | null {
+  if (!quote) return null;
+  const state = quote.marketState;
+  if (state === "PRE" || state === "PREPRE") {
+    if (isFiniteNumber(quote.preMarketPrice)) {
+      // Against the close the headline shows, so the two cannot disagree about it.
+      const close = state === "PRE" && quote.preMarketPrice > 0 ? completedRegularClose(quote) : null;
+      if (close != null) {
+        const change = quote.preMarketPrice - close;
+        return { session: "PRE", price: quote.preMarketPrice, change, changePercent: (change / close) * 100 };
+      }
+      return { session: "PRE", price: quote.preMarketPrice, change: quote.preMarketChange, changePercent: quote.preMarketChangePercent };
+    }
+    if (state === "PRE") return null;
+  }
+  const close = completedRegularClose(quote);
+  if (close == null) {
+    return state === "POST" && isFiniteNumber(quote.postMarketPrice)
+      ? { session: "POST", price: quote.postMarketPrice, change: quote.postMarketChange, changePercent: quote.postMarketChangePercent }
+      : null;
+  }
+  const price = state === "POST" ? quote.postMarketPrice ?? quote.price : quote.price;
+  // Once the session is over, a last print at the close means nothing traded after it.
+  if (!isPositive(price) || (state !== "POST" && price === close)) return null;
+  const change = price - close;
+  return { session: "POST", price, change, changePercent: (change / close) * 100 };
+}
+
+/** The extended display only while its session is open: the pre-market or the after-hours session. */
+function getOpenExtendedSessionDisplay(quote: Quote | null | undefined): ExtendedSessionDisplay | null {
+  return quote?.marketState === "PRE" || quote?.marketState === "POST" ? getExtendedSessionDisplay(quote) : null;
+}
+
+/**
+ * The move a board of tiles colors by: the open pre-market or after-hours
+ * session's, from the regular close, otherwise the day's regular session.
+ */
+export function getSessionMoveDisplay(
+  quote: Quote | null | undefined,
+): (ActiveQuoteDisplay & { session?: ExtendedSession }) | null {
+  return getOpenExtendedSessionDisplay(quote) ?? getRegularSessionDisplay(quote);
+}

package/src/market-data/published-apac-sessions.ts

@@ -0,0 +1,66 @@
+// Published full-day closures (weekend dates omitted) for Asia-Pacific venues,
+// not a holiday-rule engine. A year a venue has not published is unknown, not
+// open: every weekday of it reads as a session. Half-day sessions (HKEX and
+// SGX eves, ASX's 14:10 closes) are not modelled. Checked 2026-10-09:
+// KRX, also KOSDAQ: http://open.krx.co.kr/contents/MKD/01/0110/01100305/MKD01100305.jsp
+// TWSE, whose closures TPEx shares: https://www.twse.com.tw/en/trading/holiday.html
+//   (2027 not yet published; 12 and 13 Feb 2026 are clearing-only days without trading)
+// HKEX: https://www.hkex.com.hk/-/media/HKEX-Market/Services/Circulars-and-Notices/Participant-and-Members-Circulars/SEHK/2025/ce_SEHK_CT_075_2025.pdf
+//   and https://www.hkex.com.hk/-/media/HKEX-Market/Services/Circulars-and-Notices/Participant-and-Members-Circulars/SEHK/2026/ce_SEHK_CT_077_2026.pdf
+// SGX closes on Singapore's gazetted public holidays, one on a Sunday moving to the Monday:
+//   https://www.sgx.com/stock-exchange/trading and https://www.mom.gov.sg/employment-practices/public-holidays
+// ASX: https://www.asx.com.au/markets/market-resources/trading-hours-calendar/cash-market-trading-hours/trading-calendar
+const KRX_CLOSURES: Record<number, readonly string[]> = {
+  2026: [
+    "01-01", "02-16", "02-17", "02-18", "03-02", "05-01", "05-05", "05-25", "06-03",
+    "07-17", "08-17", "09-24", "09-25", "10-05", "10-09", "12-25", "12-31",
+  ],
+  2027: [
+    "01-01", "02-08", "02-09", "03-01", "05-03", "05-05", "05-13", "07-19", "08-16",
+    "09-14", "09-15", "09-16", "10-04", "10-11", "12-27", "12-31",
+  ],
+};
+
+const TWSE_CLOSURES: Record<number, readonly string[]> = {
+  2026: [
+    "01-01", "02-12", "02-13", "02-16", "02-17", "02-18", "02-19", "02-20", "02-27",
+    "04-03", "04-06", "05-01", "06-19", "09-25", "09-28", "10-09", "10-26", "12-25",
+  ],
+};
+
+/** Closures by canonical venue code. */
+export const PUBLISHED_APAC_CLOSURES: Readonly<Record<string, Record<number, readonly string[]>>> = {
+  KRX: KRX_CLOSURES,
+  KOSDAQ: KRX_CLOSURES,
+  TWSE: TWSE_CLOSURES,
+  TPEX: TWSE_CLOSURES,
+  HKEX: {
+    2026: [
+      "01-01", "02-17", "02-18", "02-19", "04-03", "04-06", "04-07", "05-01", "05-25",
+      "06-19", "07-01", "10-01", "10-19", "12-25",
+    ],
+    2027: [
+      "01-01", "02-08", "02-09", "03-26", "03-29", "04-05", "05-13", "06-09", "07-01",
+      "09-16", "10-01", "10-08", "12-27",
+    ],
+  },
+  SGX: {
+    2026: ["01-01", "02-17", "02-18", "04-03", "05-01", "05-27", "06-01", "08-10", "11-09", "12-25"],
+    2027: ["01-01", "02-08", "03-10", "03-26", "05-17", "05-20", "08-09", "10-28"],
+  },
+  ASX: {
+    2026: ["01-01", "01-26", "04-03", "04-06", "06-08", "12-25", "12-28"],
+    2027: ["01-01", "01-26", "03-26", "03-29", "06-14", "12-27", "12-28"],
+  },
+};
+
+/** True only for a published full-day closure; unpublished years are unknown, not open. */
+export function isPublishedApacClosure(exchange: string, date: string): boolean {
+  if (!Object.hasOwn(PUBLISHED_APAC_CLOSURES, exchange)) return false;
+  return PUBLISHED_APAC_CLOSURES[exchange]![Number(date.slice(0, 4))]?.includes(date.slice(5)) ?? false;
+}
+
+/** True when the venue's closures of that year are published. */
+export function hasPublishedApacCalendar(exchange: string, year: number): boolean {
+  return Object.hasOwn(PUBLISHED_APAC_CLOSURES, exchange) && PUBLISHED_APAC_CLOSURES[exchange]![year] !== undefined;
+}

package/src/market-data/quotes/contributions.ts

@@ -177,6 +177,8 @@ export function mergeQuoteContribution(
     priceBasis: next.priceBasis,
     regularClose: next.regularClose,
     regularCloseSessionDate: next.regularClose != null ? next.regularCloseSessionDate : undefined,
+    regularChange: next.regularClose != null ? next.regularChange : undefined,
+    regularChangePercent: next.regularClose != null ? next.regularChangePercent : undefined,
   };
 
   if (isOtherTradingDay(current, next)) {

package/src/market-data/quotes/resolution.ts

@@ -496,6 +496,8 @@ export function resolveCanonicalQuote(
     previousClose: resolved.previousClose as Quote["previousClose"],
     regularClose: priceProvider?.regularClose,
     regularCloseSessionDate: priceProvider?.regularClose != null ? priceProvider.regularCloseSessionDate : undefined,
+    regularChange: priceProvider?.regularClose != null ? priceProvider.regularChange : undefined,
+    regularChangePercent: priceProvider?.regularClose != null ? priceProvider.regularChangePercent : undefined,
     changeSessionDate: resolved.changeSessionDate as Quote["changeSessionDate"],
     high52w: resolved.high52w as Quote["high52w"],
     low52w: resolved.low52w as Quote["low52w"],

package/src/market-data/quotes/screener-live-quotes.ts

@@ -5,6 +5,7 @@ import { buildQuoteKey, resolveEntryData } from "../selectors";
 import type { QueryEntry } from "../result-types";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { isFiniteNumber } from "../../utils/guards";
+import { getCompletedRegularSessionDisplay, getSessionMoveDisplay, type ExtendedSession } from "../market/status";
 
 const STREAM_FRESHNESS_MS = 2 * 60_000;
 const STREAM_CONNECTING_GRACE_MS = 15_000;
@@ -20,6 +21,24 @@ export interface ScreenerQuoteRow {
   exchange: string;
   lastUpdated?: number;
   previousClose?: number;
+  /** Set when the price and move are an open pre-market or after-hours session's (see `extendedSessions`). */
+  extendedSession?: ExtendedSession;
+  /** Set when the price and move are the last completed regular session's close and its move; the move, in percent. */
+  regularChangePercent?: number | null;
+}
+
+export interface ScreenerQuoteOverlayOptions {
+  /**
+   * While a pre-market or after-hours session is open, show its price and its
+   * move from the regular close, marked with `extendedSession`; otherwise the
+   * regular session's, which stops at the close. Without it a row shows the
+   * live price against the previous close. A row that is a completed regular
+   * session's close and move (`regularChangePercent`) keeps them outside the
+   * regular session when its quote has neither an open extended print nor
+   * that session's close of its own, so its price and move never come from
+   * two different days.
+   */
+  extendedSessions?: boolean;
 }
 
 export interface ScreenerQuoteFreshness {
@@ -64,12 +83,14 @@ function overlayCurrency(row: ScreenerQuoteRow, quote: Quote): string {
  * entries map, but most rows' quotes did not move; returning the same row
  * object for those lets memoized table rows skip the render.
  */
-const overlayCache = new WeakMap<object, { quote: Quote; row: ScreenerQuoteRow }>();
+const overlayCache = new WeakMap<object, { quote: Quote; extended: boolean; row: ScreenerQuoteRow }>();
 
 export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
   rows: readonly T[],
   entries: ReadonlyMap<string, QueryEntry<Quote>>,
+  options: ScreenerQuoteOverlayOptions = {},
 ): T[] {
+  const extended = options.extendedSessions === true;
   return rows.map((row) => {
     const quote = resolveEntryData(entries.get(quoteKey(row)));
     if (!quote || !isFiniteNumber(quote.price)) return row;
@@ -81,9 +102,9 @@ export function overlayScreenerQuoteEntries<T extends ScreenerQuoteRow>(
       return row;
     }
     const cached = overlayCache.get(row);
-    if (cached?.quote === quote) return cached.row as T;
-    const overlaid = overlayQuote(row, quote);
-    overlayCache.set(row, { quote, row: overlaid });
+    if (cached?.quote === quote && cached.extended === extended) return cached.row as T;
+    const overlaid = extended ? overlaySessionQuote(row, quote) : overlayQuote(row, quote);
+    overlayCache.set(row, { quote, extended, row: overlaid });
     return overlaid;
   });
 }
@@ -101,6 +122,30 @@ function overlayQuote<T extends ScreenerQuoteRow>(row: T, quote: Quote): T {
     currency: overlayCurrency(row, quote),
     previousClose: isFiniteNumber(quote.previousClose) ? quote.previousClose : undefined,
     lastUpdated: quote.lastUpdated,
+    // The streamed price and move are no longer the snapshot's completed session.
+    ...(row.regularChangePercent !== undefined ? { regularChangePercent: null } : {}),
+  };
+}
+
+function overlaySessionQuote<T extends ScreenerQuoteRow>(row: T, quote: Quote): T {
+  const overlaid = overlayQuote(row, quote);
+  const display = getSessionMoveDisplay(quote);
+  if (!display || !isFiniteNumber(display.price)) return overlaid;
+  if (
+    !display.session
+    && row.regularChangePercent != null
+    && quote.marketState != null
+    && quote.marketState !== "REGULAR"
+    && !getCompletedRegularSessionDisplay(quote)
+  ) {
+    return { ...overlaid, price: row.price, change: row.change, changePercent: row.changePercent, regularChangePercent: row.regularChangePercent };
+  }
+  return {
+    ...overlaid,
+    price: display.price,
+    change: isFiniteNumber(display.change) ? display.change : null,
+    changePercent: isFiniteNumber(display.changePercent) ? display.changePercent : null,
+    extendedSession: display.session,
   };
 }
 

package/src/plugins/builtin/account-management/pane.tsx

@@ -22,11 +22,13 @@ import {
   ScrollBox,
   Textarea,
   TextAttributes,
+  useUiCapabilities,
   type ScrollBoxRenderable,
   type TextareaRenderable,
 } from "../../../ui";
 import { useDialog, type AlertContext } from "../../../ui/dialog";
 import type { SelectControl } from "../../../components/ui/select-button";
+import { FRAMED_TEXTAREA_DESKTOP_STYLE } from "../../../components/ui/fields";
 import { apiClient, type AccountProfile, type CloudPricing } from "../../../api-client";
 import { chatController } from "../chat/controller";
 import { SignInWall } from "../cloud/auth-actions";
@@ -220,6 +222,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
     setActiveField(ACCOUNT_TAB_FIELD_ORDER[tab][0] ?? "username");
   }), []);
   const syncStatus = useCloudSyncStatus();
+  const { nativePaneChrome } = useUiCapabilities();
   const bioRef = useRef<TextareaRenderable | null>(null);
   const portfolioSelectRef = useRef<SelectControl | null>(null);
   const refreshedSyncRevisionRef = useRef<number | null>(null);
@@ -821,6 +824,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
                     backgroundColor={colors.panel}
                     flexGrow={1}
                     wrapText
+                    {...(nativePaneChrome ? { style: FRAMED_TEXTAREA_DESKTOP_STYLE } : {})}
                     onInput={(value: string) => setDraftValue("bio", value)}
                   />
                 </Box>

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

@@ -1,7 +1,8 @@
 import { withConfigData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
-import { requireArg } from "../../../cli/commands/command-utils";
+import { requireArg, takeOption } from "../../../cli/commands/command-utils";
+import { EXCHANGE_OPTION, requireListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
 import type { CliCommandDef } from "../../../types/plugin";
 import { cliStyles } from "../../../utils/cli-output";
@@ -18,10 +19,14 @@ export const alertsCliCommand: CliCommandDef = {
   help: {
     group: CLI_COMMAND_GROUPS.portfolios,
     usage: ["alerts list", "alerts add <symbol> <above|below|crosses> <price>", "alerts delete <id>", "alerts rearm <id>"],
-    examples: ["alerts", "alerts add AAPL above 250", "alerts add BTC-USD below 60000"],
+    options: [EXCHANGE_OPTION],
+    examples: ["alerts", "alerts add AAPL above 250", "alerts add SAN:EPA below 70", "alerts add BTC-USD below 60000"],
   },
-  execute: async (args, ctx) => {
+  execute: async (rawArgs, ctx) => {
+    const args = [...rawArgs];
+    const exchange = takeOption(args, "--exchange");
     const action = args[0] ?? "list";
+    const listing = action === "add" && args[1] ? await requireListingArg(args[1], exchange, ctx) : null;
     await withConfigData(ctx, async (config) => {
       const raw = config.config.pluginConfig[ALERTS_PLUGIN_ID]?.[ALERTS_KEY];
       const alerts = deserializeAlerts(typeof raw === "string" ? raw : "[]");
@@ -56,12 +61,12 @@ export const alertsCliCommand: CliCommandDef = {
         return;
       }
       if (action === "add") {
-        const symbol = requireArg(args[1]?.toUpperCase(), "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx);
+        const symbol = requireArg(listing?.key, "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx);
         const condition = requireArg(args[2], "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx) as AlertCondition;
         if (!["above", "below", "crosses"].includes(condition)) ctx.fail("Condition must be above, below, or crosses.");
         const price = Number(requireArg(args[3], "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>", ctx));
         if (!Number.isFinite(price)) ctx.fail("Alert price must be a finite number.");
-        const alert = createAlert(symbol, condition, price);
+        const alert = createAlert(symbol, condition, price, listing?.exchange);
         await saveAlerts([...alerts, alert]);
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert } }, {
           text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}.${dryRunNote(data.dryRun)}`,

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

@@ -282,6 +282,7 @@ export const alertsPlugin: GloomPlugin = {
 
     ctx.registerPane({
       id: "alerts",
+      reportFreshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
       name: "Alerts",
       icon: "A",
       component: AlertsPane,

package/src/plugins/builtin/analytics/metrics.ts

@@ -33,13 +33,18 @@ export function syntheticPositionUnsupportedReason(ticker: TickerRecord, quoteCu
   if (positions.some((position) => position.side === "short" || position.shares < 0)) {
     return "Short positions: signed exposure history required";
   }
+  const category = (ticker.metadata.assetCategory ?? "").toUpperCase();
+  // Crypto trades every day at another close, so its daily returns do not pair with the equity factor proxies.
+  if (category.startsWith("CRYPTO") || /-[A-Z]{3,4}$/.test(ticker.metadata.ticker)) {
+    return "Crypto is not covered by the equity basket";
+  }
   // "Common Stock" is the category provider search hands a ticker added from
   // the command bar, so a plain equity must not read as unsupported.
   const equityCategories = new Set(["", "STK", "STOCK", "COMMON STOCK", "EQUITY", "ETF", "ETN", "FUND", "ADR", "REIT"]);
-  if (!equityCategories.has((ticker.metadata.assetCategory ?? "").toUpperCase())
+  if (!equityCategories.has(category)
     || positions.some((position) => position.multiplier != null && position.multiplier !== 1)
-    || /=[A-Z]+$|-[A-Z]{3,4}$|\d{6}[CP]\d{8}$/.test(ticker.metadata.ticker)) {
-    return "Unsupported asset: equity basket estimate only";
+    || /=[A-Z]+$|\d{6}[CP]\d{8}$/.test(ticker.metadata.ticker)) {
+    return "Asset type is not covered by the equity basket";
   }
   if (quoteCurrency !== "USD") return "Foreign holdings: historical FX returns required";
   return null;