gloomberb 0.17.3 → 0.17.4

package/src/components/ui/status.tsx

@@ -1,21 +1,153 @@
-import type { ReactNode } from "react";
+import { useEffect, useReducer, useRef, useState, type ReactNode } from "react";
 import { t, tf } from "../../i18n";
 import { useThemeColors } from "../../theme/theme-context";
 import { Box, Text, useUiCapabilities } from "../../ui";
+import { formatRelativeAge } from "../../utils/datetime-format";
 import { Spinner } from "./loading";
 import { ButtonActionScope } from "./action-scope";
+import { Button } from "./button";
+
+/**
+ * Asking again from an empty or failed state. The state draws the button
+ * (first, so it answers Enter), keeps it busy while the check runs, and when
+ * the answer comes back the same, says when it checked: otherwise a press that
+ * changes nothing on screen looks like a press that did nothing.
+ */
+export interface StatusRetry {
+  /** Asks again. A returned promise keeps the button busy until it settles. */
+  onRetry: () => unknown;
+  /** "Retry", unless the check has a better verb, such as "Look again". */
+  label?: string;
+  /** The label while it runs: "Retrying..." for the default label. */
+  pendingLabel?: string;
+  /**
+   * The same check running from anywhere (the button, `r`, a timer), such as
+   * a resource's `loading`. Needed when the old answer stays on screen while
+   * it runs, as an uncovered company does.
+   */
+  pending?: boolean;
+  /** Said after "Checked just now." when an empty state comes back the same, such as "Still no careers system." */
+  unchanged?: string;
+}
 
 export interface EmptyStateProps {
   title: string;
   message?: string;
   hint?: string;
   actions?: ReactNode;
+  retry?: StatusRetry;
   status?: "empty" | "error";
 }
 
-export function EmptyState({ title, message, hint, actions, status = "empty" }: EmptyStateProps) {
+type ShownStatus = "empty" | "error" | null;
+
+interface RetryFeedback {
+  pending: boolean;
+  press: () => void;
+  /** When a check ended on the state it started from; null once anything else is shown. */
+  checkedAt: number | null;
+}
+
+function isThenable(value: unknown): value is PromiseLike<unknown> {
+  return !!value && typeof (value as PromiseLike<unknown>).then === "function";
+}
+
+/**
+ * A check is the button's own promise, `retry.pending`, or the body showing
+ * its spinner (`shown === "loading"`) once a retry has been offered. When one
+ * ends on the empty or failed state it started from, the answer did not change.
+ */
+function useRetryFeedback(retry: StatusRetry | undefined, shown: ShownStatus | "loading"): RetryFeedback {
+  const [, rerender] = useReducer((count: number) => count + 1, 0);
+  const [checkedAt, setCheckedAt] = useState<number | null>(null);
+  const inFlight = useRef(0);
+  const mounted = useRef(true);
+  const track = useRef<{ offered: boolean; checking: boolean; from: ShownStatus; last: ShownStatus }>({
+    offered: false, checking: false, from: null, last: null,
+  });
+  if (retry) track.current.offered = true;
+  const pending = inFlight.current > 0 || retry?.pending === true;
+  const checking = pending || shown === "loading";
+  const begin = () => {
+    const state = track.current;
+    if (state.checking) return;
+    state.checking = true;
+    state.from = state.last;
+  };
+
+  useEffect(() => {
+    mounted.current = true;
+    return () => { mounted.current = false; };
+  }, []);
+
+  // After every commit: a check that just ended either confirms the state on
+  // screen or clears the line, and anything else shown clears it. A body that
+  // never offered a retry skips all of it.
+  useEffect(() => {
+    const state = track.current;
+    if (!state.offered) return;
+    if (checking) {
+      begin();
+      return;
+    }
+    // `shown` is not "loading" here: that counts as checking.
+    if (state.checking) {
+      state.checking = false;
+      setCheckedAt(shown !== null && shown === state.from ? Date.now() : null);
+    } else if (shown !== state.last) {
+      setCheckedAt(null);
+    }
+    state.last = shown;
+  });
+
+  // "just now" turns into "2m ago" while the line stays up.
+  const shownCheckedAt = checking ? null : checkedAt;
+  useEffect(() => {
+    if (shownCheckedAt === null) return;
+    const timer = setInterval(rerender, 30_000);
+    return () => clearInterval(timer);
+  }, [shownCheckedAt]);
+
+  const press = () => {
+    if (!retry || pending) return;
+    const result = retry.onRetry();
+    if (!isThenable(result)) return;
+    begin();
+    inFlight.current += 1;
+    rerender();
+    const done = () => {
+      inFlight.current -= 1;
+      if (mounted.current) rerender();
+    };
+    result.then(done, done);
+  };
+
+  return { pending, press, checkedAt: shownCheckedAt };
+}
+
+function retryNote(retry: StatusRetry, status: "empty" | "error", checkedAt: number): string {
+  const age = formatRelativeAge(checkedAt, Math.max(checkedAt, Date.now()));
+  if (status === "error") return tf("Tried again {age}.", { age });
+  const checked = tf("Checked {age}.", { age });
+  return retry.unchanged ? `${checked} ${t(retry.unchanged)}` : checked;
+}
+
+export function EmptyState(props: EmptyStateProps) {
+  const feedback = useRetryFeedback(props.retry, props.retry ? props.status ?? "empty" : null);
+  return <EmptyStateBody {...props} feedback={feedback} />;
+}
+
+function EmptyStateBody({ title, message, hint, actions, retry, status = "empty", feedback }: EmptyStateProps & { feedback: RetryFeedback }) {
   const colors = useThemeColors();
   const { nativePaneChrome } = useUiCapabilities();
+  const retryButton = retry ? (
+    <Button
+      label={retry.label ?? "Retry"}
+      pendingLabel={retry.pendingLabel ?? (retry.label ? undefined : "Retrying...")}
+      pending={feedback.pending}
+      onPress={feedback.press}
+    />
+  ) : null;
   // Provider messages must wrap at narrow pane widths rather than lose their tail.
   return (
     <Box flexDirection="column" data-gloom-status={status} data-gloom-ui="empty-state">
@@ -23,11 +155,14 @@ export function EmptyState({ title, message, hint, actions, status = "empty" }:
       {message && <Box><Text fg={colors.textMuted} wrapText>{t(message)}</Text></Box>}
       {hint && <Box><Text fg={colors.textMuted} wrapText>{t(hint)}</Text></Box>}
       {/* Wraps in a narrow pane rather than clipping the second action; a terminal wraps without a blank row. */}
-      {actions && (
+      {(retryButton || actions) && (
         <Box flexDirection="row" flexWrap="wrap" gap={1} rowGap={nativePaneChrome ? undefined : 0} marginTop={1}>
-          <ButtonActionScope>{actions}</ButtonActionScope>
+          <ButtonActionScope>{retryButton}{actions}</ButtonActionScope>
         </Box>
       )}
+      {retry && feedback.checkedAt !== null && (
+        <Box><Text fg={colors.textMuted} wrapText>{retryNote(retry, status, feedback.checkedAt)}</Text></Box>
+      )}
     </Box>
   );
 }
@@ -68,6 +203,8 @@ export interface PaneStatusBodyProps {
   emptyTitle?: string;
   emptyMessage?: string;
   actions?: ReactNode;
+  /** Asking again from the error or empty state; see StatusRetry. */
+  retry?: StatusRetry;
   align?: "start" | "center";
   width?: number;
   height?: number;
@@ -85,12 +222,16 @@ export function PaneStatusBody({
   emptyTitle,
   emptyMessage,
   actions,
+  retry,
   align = "start",
   width,
   height,
   children,
 }: PaneStatusBodyProps) {
   const status = error ? "error" : loading ? "loading" : empty ? "empty" : null;
+  // Here rather than in the state, so a retry that shows the spinner while it
+  // runs still says it tried once the same failure is back.
+  const feedback = useRetryFeedback(retry, status);
   if (!status) return <>{children}</>;
   // Keyed so content that starts with a bare Box never reuses this padded node.
   return (
@@ -107,11 +248,13 @@ export function PaneStatusBody({
       data-gloom-ui="pane-status"
     >
       {status === "loading" ? <Spinner label={loadingLabel ?? loadingText(subject)} /> : (
-        <EmptyState
+        <EmptyStateBody
           status={status}
           title={status === "error" ? errorTitle ?? (subject ? unavailableText(subject) : error!) : emptyTitle ?? t("Nothing to show yet.")}
           message={status === "error" ? (errorTitle || subject ? error! : undefined) : emptyMessage}
           actions={actions}
+          retry={retry}
+          feedback={feedback}
         />
       )}
     </Box>

package/src/layout-marketplace/gallery-desktop.tsx

@@ -193,7 +193,7 @@ function DiscoverStatus({ controller }: { controller: LayoutGalleryController })
         <EmptyState
           title={discover.state.error}
           status="error"
-          actions={<Button label={t("Retry")} compact onPress={discover.refresh} />}
+          retry={{ onRetry: discover.refresh }}
         />
       </SidebarState>
     );
@@ -219,7 +219,7 @@ function TeamStatus({ controller }: { controller: LayoutGalleryController }) {
         <EmptyState
           title={state.error}
           status="error"
-          actions={<Button label={t("Retry")} compact onPress={refresh} />}
+          retry={{ onRetry: refresh }}
         />
       </SidebarState>
     );

package/src/market-data/futures-board.ts

@@ -1,5 +1,6 @@
 export type FuturesSector =
   | "equity-index"
+  | "equity-sectors"
   | "rates"
   | "energy"
   | "metals"
@@ -38,7 +39,10 @@ export interface FuturesContract {
    * unset: the security keeps the code and the future is its `=F` symbol.
    * Checked with `gloomberb quote <code>` signed out on 2026-10-11: each of
    * these was "Not a ticker", or for ZT and ZF a quote last updated in 2023 and
-   * 2021 that search no longer lists.
+   * 2021 that search no longer lists. The sector, index and energy rows were
+   * checked the same way on 2026-10-14: XAR is an ETF, XAU Goldmoney, SXI
+   * Standex, SXT Sensient, RX BioSyent, EMD a closed-end fund, SOX the PHLX
+   * index, and RS1, MES, MYM, M2K, MCL, MNG and HH are listed abroad.
    */
   bareCode?: true;
 }
@@ -58,6 +62,37 @@ export const FUTURES_CONTRACTS: FuturesContract[] = [
   { symbol: "NQ=F", code: "NQ", name: "E-Mini Nasdaq 100", sector: "equity-index", venue: "CME", tick: 0.25, bareCode: true },
   { symbol: "YM=F", code: "YM", name: "E-Mini Dow", sector: "equity-index", venue: "CBT", tick: 1, bareCode: true },
   { symbol: "RTY=F", code: "RTY", name: "E-Mini Russell 2000", sector: "equity-index", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "EMD=F", code: "EMD", name: "E-Mini S&P MidCap 400", sector: "equity-index", venue: "CME", tick: 0.1 },
+  { symbol: "RS1=F", code: "RS1", name: "E-Mini Russell 1000", sector: "equity-index", venue: "CME", tick: 0.1 },
+  { symbol: "NKD=F", code: "NKD", name: "Nikkei 225 (USD)", sector: "equity-index", venue: "CME", tick: 5, bareCode: true },
+  // Quoted in yen: the same index points, each worth 500 yen, so the server has no dollar terms for it.
+  { symbol: "NIY=F", code: "NIY", name: "Nikkei 225 (Yen)", sector: "equity-index", venue: "CME", tick: 5, unit: "index points", bareCode: true },
+  { symbol: "MES=F", code: "MES", name: "Micro E-Mini S&P 500", sector: "equity-index", venue: "CME", tick: 0.25 },
+  { symbol: "MNQ=F", code: "MNQ", name: "Micro E-Mini Nasdaq 100", sector: "equity-index", venue: "CME", tick: 0.25, bareCode: true },
+  { symbol: "MYM=F", code: "MYM", name: "Micro E-Mini Dow", sector: "equity-index", venue: "CBT", tick: 1 },
+  { symbol: "M2K=F", code: "M2K", name: "Micro E-Mini Russell 2000", sector: "equity-index", venue: "CME", tick: 0.1 },
+
+  // CME's E-mini S&P Select Sector futures (XA*) and Select Industry futures
+  // (SX*), named by their S&P index: each sector followed by its industries in
+  // GICS order, then the Dow Jones U.S. Real Estate future on CBOT.
+  { symbol: "XAE=F", code: "XAE", name: "S&P Energy", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "SXO=F", code: "SXO", name: "S&P Oil & Gas E&P", sector: "equity-sectors", venue: "CME", tick: 0.5, bareCode: true },
+  { symbol: "XAB=F", code: "XAB", name: "S&P Materials", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "XAI=F", code: "XAI", name: "S&P Industrial", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "XAY=F", code: "XAY", name: "S&P Consumer Discretionary", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "SXR=F", code: "SXR", name: "S&P Retail", sector: "equity-sectors", venue: "CME", tick: 1, bareCode: true },
+  { symbol: "XAP=F", code: "XAP", name: "S&P Consumer Staples", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "XAV=F", code: "XAV", name: "S&P Health Care", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "SXT=F", code: "SXT", name: "S&P Biotechnology", sector: "equity-sectors", venue: "CME", tick: 1 },
+  { symbol: "XAF=F", code: "XAF", name: "S&P Financial", sector: "equity-sectors", venue: "CME", tick: 0.05, bareCode: true },
+  { symbol: "SXB=F", code: "SXB", name: "S&P Regional Banks", sector: "equity-sectors", venue: "CME", tick: 0.25, bareCode: true },
+  { symbol: "SXI=F", code: "SXI", name: "S&P Insurance", sector: "equity-sectors", venue: "CME", tick: 0.5 },
+  { symbol: "XAK=F", code: "XAK", name: "S&P Technology", sector: "equity-sectors", venue: "CME", tick: 0.1, bareCode: true },
+  { symbol: "SOX=F", code: "SOX", name: "PHLX Semiconductor", sector: "equity-sectors", venue: "CME", tick: 0.5 },
+  { symbol: "XAZ=F", code: "XAZ", name: "S&P Communication Services", sector: "equity-sectors", venue: "CME", tick: 0.05, bareCode: true },
+  { symbol: "XAU=F", code: "XAU", name: "S&P Utilities", sector: "equity-sectors", venue: "CME", tick: 0.1 },
+  { symbol: "XAR=F", code: "XAR", name: "S&P Real Estate", sector: "equity-sectors", venue: "CME", tick: 0.05 },
+  { symbol: "RX=F", code: "RX", name: "Dow Jones U.S. Real Estate", sector: "equity-sectors", venue: "CBT", tick: 0.1 },
 
   { symbol: "ZT=F", code: "ZT", name: "2-Year T-Note", sector: "rates", venue: "CBT", bareCode: true },
   { symbol: "ZF=F", code: "ZF", name: "5-Year T-Note", sector: "rates", venue: "CBT", bareCode: true },
@@ -72,6 +107,12 @@ export const FUTURES_CONTRACTS: FuturesContract[] = [
   { symbol: "TTF=F", code: "TTF", name: "Dutch TTF Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001, unit: "EUR / MWh", bareCode: true },
   { symbol: "RB=F", code: "RB", name: "RBOB Gasoline", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.0001 },
   { symbol: "HO=F", code: "HO", name: "Heating Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.0001 },
+  // Cash settled on the CL and NG final settlements.
+  { symbol: "QM=F", code: "QM", name: "E-Mini Crude Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.025, bareCode: true },
+  { symbol: "MCL=F", code: "MCL", name: "Micro WTI Crude Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.01 },
+  { symbol: "QG=F", code: "QG", name: "E-Mini Natural Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.005, bareCode: true },
+  { symbol: "MNG=F", code: "MNG", name: "Micro Henry Hub Natural Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001 },
+  { symbol: "HH=F", code: "HH", name: "Henry Hub Last Day Financial", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001 },
 
   { symbol: "GC=F", code: "GC", name: "Gold", sector: "metals", venue: "CMX", tick: 0.1 },
   { symbol: "SI=F", code: "SI", name: "Silver", sector: "metals", venue: "CMX", tick: 0.005 },
@@ -109,6 +150,7 @@ export const FUTURES_CONTRACTS: FuturesContract[] = [
 
 export const FUTURES_SECTOR_LABELS: Record<FuturesSector, string> = {
   "equity-index": "Equity Index",
+  "equity-sectors": "Equity Sectors",
   rates: "Rates",
   energy: "Energy",
   metals: "Metals",
@@ -119,6 +161,7 @@ export const FUTURES_SECTOR_LABELS: Record<FuturesSector, string> = {
 
 export const FUTURES_SECTOR_ORDER: FuturesSector[] = [
   "equity-index",
+  "equity-sectors",
   "rates",
   "energy",
   "metals",

package/src/plugins/builtin/account-management/calendar-tab.tsx

@@ -165,7 +165,7 @@ export function CalendarAccountTab({ width, sessionMarker }: { width: number; se
       <EmptyState
         status="error"
         title={loadError}
-        actions={<Button label={t("Retry")} onPress={() => { void load(); }} />}
+        retry={{ onRetry: () => load(), pending: loading }}
       />
     );
   }

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

@@ -2,12 +2,14 @@ import { withConfigData, withMarketData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
-import { EXCHANGE_OPTION, listingReadNotes, requireListingArg } from "../../../cli/listing-arg";
+import { EXCHANGE_OPTION, listingReadNotes, requireListingArg, type ListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
 import type { AppConfig } from "../../../types/config";
-import type { CliCommandDef } from "../../../types/plugin";
+import type { CliCommandContext, CliCommandDef } from "../../../types/plugin";
+import { getActiveQuoteDisplay } from "../../../market-data/market/status";
+import { settleWithin } from "../../../utils/async-deadline";
 import { cliStyles } from "../../../utils/cli-output";
-import { ambiguousNumberMessage, parsePastedNumber } from "../../../utils/decimal-comma";
+import { ambiguousNumberMessage, meantThousandsDot, parsePastedNumber, thousandsDotReadings, type ThousandsDotReadings } from "../../../utils/decimal-comma";
 import { newYorkToday } from "../earnings/board-model";
 import { createAlert, deserializeAlerts, rearmAlert, serializeAlerts } from "./alert-engine";
 import { ALERTS_KEY } from "./constants";
@@ -43,20 +45,28 @@ const DAYS_RULE = `--days takes a whole number of days from 1 to ${MAX_LEAD_DAYS
 
 /** What `alerts add` was asked for, before any listing or date is looked up. */
 export type AlertAddRequest =
-  | { kind: "price"; symbol: string; condition: AlertCondition; price: number }
+  | {
+    kind: "price"; symbol: string; condition: AlertCondition; price: number;
+    /** A price typed as 81.000, which the last price may show was 81000 with a dot between thousands. */
+    thousandsDot?: ThousandsDotReadings & { text: string };
+  }
   | { kind: "earnings"; symbol: string; leadDays: number }
   | { kind: "macro"; event: MacroAlertEvent; leadDays: number };
 
 const CONDITIONS: readonly AlertCondition[] = ["above", "below", "crosses"];
 
+/** The first word of a price typed with a space between thousands and no quotes (`81 000`): one to three digits. */
+const LEADING_GROUP = /^[+-]?\d{1,3}$/;
+
 /**
  * Reads `alerts add` arguments: `<symbol> above 250`, `<symbol> earnings`, or
  * `CPI` / `FOMC`, with `--days` (already taken out of `args`, `null` when the
- * flag came without a value) for the event forms only. Throws a message that
- * names what the command takes.
+ * flag came without a value) for the event forms only, and `--exchange`, which
+ * a command to type again keeps. Throws a message that names what the command
+ * takes.
  */
-export function parseAlertAddArgs(args: readonly string[], days: string | null | undefined): AlertAddRequest {
-  const [first, second, third] = args;
+export function parseAlertAddArgs(args: readonly string[], days: string | null | undefined, exchange?: string | null): AlertAddRequest {
+  const [first, second, third, ...rest] = args;
   if (!first) throw new Error(ADD_USAGE);
   const leadDays = () => {
     const parsed = days === null ? null : parseLeadDays(days);
@@ -83,11 +93,57 @@ export function parseAlertAddArgs(args: readonly string[], days: string | null |
   }
   if (days !== undefined) throw new Error("--days is for earnings and CPI or FOMC alerts, not price alerts.");
   if (third === undefined) throw new Error(ADD_USAGE);
+  const retype = (price: number) => retypeCommand(first, condition, price, exchange);
+  // `81 000` without quotes arrives as 81 and a stray 000; neither reading is taken for granted.
+  const spaced = rest.length > 0 && LEADING_GROUP.test(third) ? parsePastedNumber([third, ...rest].join(" ")) : null;
+  if (spaced?.kind === "number") {
+    const typed = Number(third);
+    throw new Error(`${[third, ...rest].join(" ")} could be ${spaced.value} (thousands) or ${typed} and a stray ${rest.join(" ")}; type ${retype(spaced.value)} or ${retype(typed)}`);
+  }
   // A price pasted from a sheet (1.350,5, 1,350.5, 1 350,5) reads as it is written; `1,350` could be either, so it asks.
   const pasted = parsePastedNumber(third);
   if (pasted.kind === "ambiguous") throw new Error(ambiguousNumberMessage(third, pasted));
   if (pasted.kind === "invalid") throw new Error("Alert price must be a finite number.");
-  return { kind: "price", symbol: first, condition, price: pasted.value };
+  if (rest.length > 0) throw new Error(`A price alert takes one price, not "${rest.join(" ")}" after ${third}; type ${retype(pasted.value)}`);
+  const thousandsDot = thousandsDotReadings(third);
+  return { kind: "price", symbol: first, condition, price: pasted.value, ...(thousandsDot ? { thousandsDot: { ...thousandsDot, text: third.trim() } } : {}) };
+}
+
+/** `alerts add` as typed, with another price: what an error tells someone to type. */
+function retypeCommand(symbol: string, condition: AlertCondition, price: number, exchange: string | null | undefined): string {
+  return `gloomberb alerts add ${symbol} ${condition} ${price}${exchange ? ` --exchange ${exchange}` : ""}`;
+}
+
+const LAST_PRICE_TIMEOUT_MS = 10_000;
+
+/**
+ * The listing's last price, as the alert will check it, for telling 81.000
+ * typed for 81000 from 81; null when there is none, and the price is then
+ * read as written.
+ */
+async function lastPrice(listing: ListingArg, ctx: Pick<CliCommandContext, "initMarketData">): Promise<number | null> {
+  const quote = await settleWithin(
+    withMarketData(ctx, (market) => market.dataProvider.getQuote(listing.key.toUpperCase(), listing.exchange)),
+    LAST_PRICE_TIMEOUT_MS,
+  );
+  const price = quote ? getActiveQuoteDisplay(quote)?.price ?? quote.price : null;
+  return price != null && Number.isFinite(price) && price !== 0 ? price : null;
+}
+
+/**
+ * Asks which price `81.000` meant when the last price shows it was a dot
+ * between thousands: both readings, and the command to type for each.
+ */
+export function thousandsDotMessage(
+  request: Extract<AlertAddRequest, { kind: "price" }>,
+  listing: string,
+  last: number | null,
+  exchange?: string | null,
+): string | null {
+  const dot = request.thousandsDot;
+  if (!dot || !meantThousandsDot(dot, last)) return null;
+  const retype = (price: number) => retypeCommand(request.symbol, request.condition, price, exchange);
+  return `${dot.text} could be ${dot.thousands} (thousands) or ${dot.decimal} (decimal point), and ${listing.toUpperCase()} last traded at ${Number(last!.toFixed(2))}; type ${retype(dot.thousands)} or ${retype(dot.decimal)}`;
 }
 
 /** One row of `alerts list`: a price alert as stored, or an event alert with its next date. */
@@ -222,13 +278,17 @@ export const alertsCliCommand: CliCommandDef = {
 
     const parseAdd = (): AlertAddRequest => {
       try {
-        return parseAlertAddArgs(args.slice(1), days);
+        return parseAlertAddArgs(args.slice(1), days, exchangeOption);
       } catch (error) {
         return ctx.fail(error instanceof Error ? error.message : String(error));
       }
     };
     const request = action === "add" ? parseAdd() : null;
     const priceListing = request?.kind === "price" ? await requireListingArg(request.symbol, exchangeOption, ctx) : null;
+    if (request?.kind === "price" && request.thousandsDot && priceListing) {
+      const question = thousandsDotMessage(request, priceListing.key, await lastPrice(priceListing, ctx), exchangeOption);
+      if (question) ctx.fail(question);
+    }
     // What a typed listing was read as (7203:TSE as 7203:JPX), said beside what was added.
     let read = priceListing ? listingReadNotes(priceListing) : [];
     let newEventRule: EventAlertRule | null = null;
@@ -309,7 +369,8 @@ export const alertsCliCommand: CliCommandDef = {
         const alert = createAlert(symbol, condition, price, priceListing?.exchange);
         await save({ alerts: [...alerts, alert] });
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert }, ...(read.length > 0 ? { warnings: read } : {}) }, {
-          text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}.${dryRunNote(data.dryRun)}`,
+          // No full stop after the price, which would read as part of it (below 81.).
+          text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}${dryRunNote(data.dryRun)}`,
         });
         return;
       }

package/src/plugins/builtin/awards/headless.ts

@@ -1,6 +1,7 @@
 import type { AwardFilter, AwardRow, AwardType } from "../../../api-client/awards";
 import { notATickerSymbol } from "../../../sources/provider-errors";
 import type { HeadlessBundleSection, HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/headless";
+import { isoDateOption } from "../../../utils/calendar-date";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { fetchAward, fetchAwards } from "./client";
 import { AWARD_TABS, awardScope, awardsPreviewNote, awardTypeLabel, futureAwardDatesNote, money } from "./model";
@@ -85,7 +86,10 @@ export const awardsHeadless: HeadlessPaneDefinition<"bundle"> = {
   options: [
     { key: "tab", type: "enum", settingKey: "tab", defaultValue: "feed", values: [...AWARD_TABS.map(({ value }) => ({ value })), { value: "all" }], description: "Feed, company history, agencies, sectors, events, or all sections." },
     { key: "view", type: "enum", settingKey: "leaderView", defaultValue: "companies", values: [{ value: "companies" }, { value: "sectors" }], description: "Sectors tab: company leaders or sector totals." },
-    ...["jurisdiction", "currency", "source", "agency", "sector", "parentId", "from", "to", "query"].map((key) => ({ key, type: "string" as const, settingKey: key, description: `Filter by ${key}; dates use YYYY-MM-DD.` })),
+    ...FILTER_KEYS.map((key) => key === "from" || key === "to"
+      ? { key, type: "string" as const, settingKey: key, placeholder: "YYYY-MM-DD", description: `${key === "from" ? "Start" : "End"} of the date range. Dates use YYYY-MM-DD.`,
+        normalize: (value: string) => isoDateOption(value, key) }
+      : { key, type: "string" as const, settingKey: key, description: `Filter by ${key}.` }),
     { key: "type", type: "enum", settingKey: "awardType", defaultValue: "prime", values: [{ value: "prime" }, { value: "subaward" }, { value: "notice" }, { value: "modification" }], description: "Keep record types separate." },
     { key: "cursor", type: "string", description: "Continue after the previous response's nextCursor." },
     { key: "limit", type: "integer", minimum: 1, maximum: 200, defaultValue: 100, description: "Maximum feed rows in this response." },

package/src/plugins/builtin/catalysts/headless.ts

@@ -1,5 +1,6 @@
 import { CATALYST_TYPES } from "../../../api-client/catalysts";
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import { isoDateOption } from "../../../utils/calendar-date";
 import { fetchCatalystDetail, fetchCatalysts } from "./client";
 import { catalystCell, catalystChangeText, catalystDate, catalystQuery, catalystTickers } from "./model";
 
@@ -11,7 +12,10 @@ function definition(litigation: boolean): HeadlessPaneDefinition<"bundle"> {
     options: [
       { key: "tab", type: "enum", values: [{ value: "calendar" }, { value: "changes" }], defaultValue: "calendar", description: "Dated events or observed revisions." },
       { key: "type", type: "enum", values: CATALYST_TYPES.map((value) => ({ value })), description: "Event type." },
-      ...["agency", "country", "sector", "status", "search", "from", "to"].map((key) => ({ key, type: "string" as const, description: `Filter by ${key}. Dates use YYYY-MM-DD.` })),
+      ...["agency", "country", "sector", "status"].map((key) => ({ key, type: "string" as const, description: `Filter by ${key}.` })),
+      { key: "search", type: "string", description: "Filter by text." },
+      { key: "from", type: "string", placeholder: "YYYY-MM-DD", description: "Start of the calendar window. Dates use YYYY-MM-DD.", normalize: (value) => isoDateOption(value, "from") },
+      { key: "to", type: "string", placeholder: "YYYY-MM-DD", description: "End of the calendar window. Dates use YYYY-MM-DD.", normalize: (value) => isoDateOption(value, "to") },
       { key: "dateField", type: "enum", values: ["any", "announced", "effective", "deadline", "observed"].map((value) => ({ value })), defaultValue: "any", description: "Date field for the calendar window." },
       { key: "upcoming", type: "boolean", defaultValue: false, description: "Only future effective dates and deadlines." },
       { key: "offset", type: "integer", defaultValue: 0, description: "Zero-based event offset." },

package/src/plugins/builtin/chat/controller/connections.ts

@@ -21,6 +21,21 @@ export function getSafetyRefreshChannelIds(channelStates: Iterable<[string, Chan
   return active.length > 0 ? active : [DEFAULT_CHAT_CHANNEL_ID];
 }
 
+/**
+ * The channels read live, each marked to read its latest page in full on its
+ * next refresh: after the socket was down, what changed on messages already
+ * held (reactions, edits, removals) does not come with newer messages.
+ */
+export function markConnectedChannelsForBackfill(channelStates: Iterable<[string, ChannelRuntimeState]>): string[] {
+  const channelIds: string[] = [];
+  for (const [channelId, channel] of channelStates) {
+    if (!channel.wsConnected) continue;
+    channel.backfilled = false;
+    channelIds.push(channelId);
+  }
+  return channelIds;
+}
+
 export function getOpenConnectionChannelIds(channelStates: Iterable<[string, ChannelRuntimeState]>): Set<string> {
   const channelIds = new Set<string>([DEFAULT_CHAT_CHANNEL_ID]);
   for (const [channelId, channel] of channelStates) {
@@ -76,6 +91,9 @@ export function ensureChatChannelConnection({
   if (channel.wsConnected) return;
   channel.wsConnected = true;
 
+  // Reactions, edits and removals on messages already held while the channel
+  // was not read live come only with a full page, not with newer messages.
+  channel.backfilled = false;
   void refreshMessages().catch(() => {});
 
   channel.wsConnection = connectChannel(

package/src/plugins/builtin/chat/controller/fetch.ts

@@ -35,8 +35,11 @@ export async function fetchLatestChannelMessages(
       limit: MESSAGE_PAGE_SIZE,
       after: backfillGaps ? undefined : channel.lastCursor ?? undefined,
     });
-    channel.backfilled = true;
-    if (backfillGaps) channel.backfilledAs = readerId;
+    // A full page asked for while this read was out still happens next time.
+    if (backfillGaps) {
+      channel.backfilled = true;
+      channel.backfilledAs = readerId;
+    }
     if ((!hasIncrementalCursor || backfillGaps) && messages.length < MESSAGE_PAGE_SIZE) {
       channel.reachedOldestMessage = true;
     }