gloomberb 0.16.4 → 0.16.6

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

@@ -1,95 +1,361 @@
-import { withConfigData } from "../../../cli/scoped-context";
+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, requireListingArg } from "../../../cli/listing-arg";
+import { EXCHANGE_OPTION, listingReadNotes, requireListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
+import type { AppConfig } from "../../../types/config";
 import type { CliCommandDef } from "../../../types/plugin";
 import { cliStyles } from "../../../utils/cli-output";
+import { numberErrorMessage } from "../../../utils/decimal-comma";
+import { newYorkToday } from "../earnings/board-model";
 import { createAlert, deserializeAlerts, rearmAlert, serializeAlerts } from "./alert-engine";
 import { ALERTS_KEY } from "./constants";
-import type { AlertCondition } from "./types";
+import { EVENT_ALERTS_KEY, MAX_EVENT_ALERTS, eventAlertTarget, readEventAlerts, toggleEventAlert, type EventAlertRule } from "./events";
+import { alertKindLabel } from "./history";
+import { MAX_LEAD_DAYS, type MacroAlertEvent } from "./research-rules";
+import {
+  MACRO_EVENT_CLI_NAMES,
+  createScheduledAlert,
+  eventDateUnavailableMessage,
+  leadStartDate,
+  lookupScheduledDates,
+  noUpcomingEventMessage,
+  parseLeadDays,
+  parseMacroEventName,
+  readScheduledRule,
+  rearmScheduledAlert,
+  scheduledAlertStatus,
+  scheduledEventName,
+  scheduledPhase,
+  scheduledTargetKey,
+  type ScheduledDateLookup,
+  type ScheduledEventSources,
+  type ScheduledEventTarget,
+} from "./scheduled";
+import { scheduledEventSources } from "./scheduled-sources";
+import type { AlertCondition, AlertRule } from "./types";
 
 const ALERTS_PLUGIN_ID = "alerts";
 
+const ADD_USAGE = "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>, alerts add <symbol> earnings [--days <n>], or alerts add <CPI|FOMC> [--days <n>]";
+const DAYS_RULE = `--days takes a whole number of days from 1 to ${MAX_LEAD_DAYS}; without it the alert goes off 1 day before.`;
+
+/** 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: "earnings"; symbol: string; leadDays: number }
+  | { kind: "macro"; event: MacroAlertEvent; leadDays: number };
+
+const CONDITIONS: readonly AlertCondition[] = ["above", "below", "crosses"];
+
+/**
+ * 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.
+ */
+export function parseAlertAddArgs(args: readonly string[], days: string | null | undefined): AlertAddRequest {
+  const [first, second, third] = args;
+  if (!first) throw new Error(ADD_USAGE);
+  const leadDays = () => {
+    const parsed = days === null ? null : parseLeadDays(days);
+    if (parsed == null) throw new Error(DAYS_RULE);
+    return parsed;
+  };
+  if (second === undefined) {
+    const event = parseMacroEventName(first);
+    if (event) return { kind: "macro", event, leadDays: leadDays() };
+    if (first.toLowerCase() === "earnings") {
+      throw new Error("Name the company: gloomberb alerts add <symbol> earnings, such as alerts add CRWV earnings --days 3.");
+    }
+    throw new Error(
+      `Unknown event "${first}". Event alerts take ${MACRO_EVENT_CLI_NAMES} (alerts add CPI --days 1) or a symbol with earnings (alerts add CRWV earnings --days 3); price alerts take a condition and a price (alerts add AAPL above 250).`,
+    );
+  }
+  if (second.toLowerCase() === "earnings") {
+    if (third !== undefined) throw new Error(`Earnings alerts take a symbol and --days, not "${third}". ${ADD_USAGE}`);
+    return { kind: "earnings", symbol: first, leadDays: leadDays() };
+  }
+  const condition = second.toLowerCase() as AlertCondition;
+  if (!CONDITIONS.includes(condition)) {
+    throw new Error(`Unknown alert "${second}". Use above, below or crosses with a price, or earnings with --days.`);
+  }
+  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 price = Number(third);
+  if (!Number.isFinite(price)) throw new Error(numberErrorMessage("Alert price must be a finite number.", third));
+  return { kind: "price", symbol: first, condition, price };
+}
+
+/** One row of `alerts list`: a price alert as stored, or an event alert with its next date. */
+type AlertListRow = Record<string, unknown> & {
+  id: string;
+  kind: string;
+  status: string;
+};
+
+function priceRow(alert: AlertRule): AlertListRow {
+  return { ...alert, kind: "price", target: alert.exchange ? `${alert.symbol}:${alert.exchange}` : alert.symbol };
+}
+
+function eventRow(rule: EventAlertRule, today: string, eventDate: string | null | undefined): AlertListRow {
+  const scheduled = readScheduledRule(rule);
+  if (!scheduled) {
+    return { id: rule.id, kind: rule.kind, target: eventAlertTarget(rule), status: rule.status, createdAt: rule.createdAt };
+  }
+  const date = eventDate ?? null;
+  return {
+    id: rule.id,
+    kind: rule.kind,
+    target: scheduled.target.kind === "earnings" ? scheduled.target.symbol : scheduled.target.event.toUpperCase(),
+    leadDays: scheduled.leadDays,
+    eventDate: date,
+    status: scheduledAlertStatus({ ...rule, eventDate: date ?? undefined }, scheduled.leadDays, today),
+    createdAt: rule.createdAt,
+  };
+}
+
+const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`;
+
+function textRow(row: AlertListRow): Record<string, unknown> {
+  const price = row.kind === "price";
+  return {
+    id: row.id,
+    kind: price ? "Price" : alertKindLabel(row.kind),
+    target: row.target,
+    trigger: price
+      ? `${row.condition} ${row.targetPrice}`
+      : typeof row.leadDays === "number" ? `${plural(row.leadDays, "day")} before` : "",
+    eventDate: typeof row.leadDays === "number" ? row.eventDate ?? "not known" : "",
+    status: row.status,
+    lastCheckedPrice: row.lastCheckedPrice,
+    triggeredAt: row.triggeredAt,
+  };
+}
+
+/** The next event date of each scheduled rule: the saved one while it is still ahead, otherwise looked up. */
+async function listEventDates(
+  rules: readonly EventAlertRule[],
+  today: string,
+  lookup: (targets: ScheduledEventTarget[]) => Promise<Map<string, ScheduledDateLookup>>,
+): Promise<{ dates: Map<string, string | null>; warnings: string[] }> {
+  const dates = new Map<string, string | null>();
+  const stale: Array<{ rule: EventAlertRule; target: ScheduledEventTarget }> = [];
+  for (const rule of rules) {
+    const scheduled = readScheduledRule(rule);
+    if (!scheduled) continue;
+    if (rule.eventDate && rule.eventDate >= today) dates.set(rule.id, rule.eventDate);
+    else stale.push({ rule, target: scheduled.target });
+  }
+  if (stale.length === 0) return { dates, warnings: [] };
+  const lookups = await lookup(stale.map((entry) => entry.target));
+  const warnings = new Set<string>();
+  for (const { rule, target } of stale) {
+    const lookup = lookups.get(scheduledTargetKey(target));
+    if (lookup && "date" in lookup) dates.set(rule.id, lookup.date);
+    else if (lookup) warnings.add(`Next ${scheduledEventName(target)} date unavailable: ${lookup.error}`);
+  }
+  return { dates, warnings: [...warnings] };
+}
+
+/** Looks up the next date for a new event alert, or fails saying why there is none. */
+async function requireEventDate(
+  target: ScheduledEventTarget,
+  sources: ScheduledEventSources,
+  today: string,
+  fail: (message: string) => never,
+): Promise<string> {
+  const lookup = (await lookupScheduledDates([target], sources, today)).get(scheduledTargetKey(target));
+  if (!lookup || "error" in lookup) fail(eventDateUnavailableMessage(target, lookup?.error ?? "no answer"));
+  if (!lookup.date) fail(noUpcomingEventMessage(target));
+  return lookup.date;
+}
+
+function readAlertStores(config: AppConfig) {
+  const pluginState = config.pluginConfig[ALERTS_PLUGIN_ID] ?? {};
+  const rawPrice = pluginState[ALERTS_KEY];
+  const rawEvents = pluginState[EVENT_ALERTS_KEY];
+  return {
+    pluginState,
+    alerts: deserializeAlerts(typeof rawPrice === "string" ? rawPrice : "[]"),
+    events: readEventAlerts(typeof rawEvents === "string" ? rawEvents : "[]"),
+  };
+}
+
 export const alertsCliCommand: CliCommandDef = {
   name: "alerts",
   aliases: ["alert"],
-  description: "List, add, and remove price alerts",
+  description: "List, add, and remove price alerts and alerts before earnings, CPI and FOMC",
   help: {
     group: CLI_COMMAND_GROUPS.portfolios,
-    usage: ["alerts list", "alerts add <symbol> <above|below|crosses> <price>", "alerts delete <id>", "alerts rearm <id>"],
-    options: [EXCHANGE_OPTION],
-    examples: ["alerts", "alerts add AAPL above 250", "alerts add SAN:EPA below 70", "alerts add BTC-USD below 60000"],
+    usage: [
+      "alerts list",
+      "alerts add <symbol> <above|below|crosses> <price>",
+      "alerts add <symbol> earnings [--days <n>]",
+      "alerts add <CPI|FOMC> [--days <n>]",
+      "alerts delete <id>",
+      "alerts rearm <id>",
+    ],
+    options: [
+      EXCHANGE_OPTION,
+      { flags: "--days <n>", description: `Days before the event the alert goes off, 1 to ${MAX_LEAD_DAYS} (default 1); earnings, CPI and FOMC alerts` },
+    ],
+    examples: [
+      "alerts",
+      "alerts add AAPL above 250",
+      "alerts add SAN:EPA below 70",
+      "alerts add CRWV earnings --days 3",
+      "alerts add CPI --days 1",
+    ],
   },
   execute: async (rawArgs, ctx) => {
     const args = [...rawArgs];
-    const exchange = takeOption(args, "--exchange");
+    const daysFlag = rawArgs.some((arg) => arg === "--days" || arg.startsWith("--days="));
+    const daysValue = takeOption(args, "--days");
+    const days = daysFlag && daysValue === undefined ? null : daysValue;
+    const exchangeOption = takeOption(args, "--exchange");
     const action = args[0] ?? "list";
-    const listing = action === "add" && args[1] ? await requireListingArg(args[1], exchange, ctx) : null;
+    const today = newYorkToday();
+
+    const parseAdd = (): AlertAddRequest => {
+      try {
+        return parseAlertAddArgs(args.slice(1), days);
+      } 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;
+    // 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;
+    if (request && request.kind !== "price") {
+      const target: ScheduledEventTarget = request.kind === "macro"
+        ? { kind: "macro", event: request.event }
+        : await requireListingArg(request.symbol, exchangeOption, ctx)
+          .then((listing) => {
+            read = listingReadNotes(listing);
+            return { kind: "earnings" as const, symbol: listing.symbol, exchange: listing.exchange };
+          });
+      // A listing the rule cannot follow fails before any request.
+      try {
+        createScheduledAlert(target, request.leadDays, null);
+      } catch (error) {
+        ctx.fail(error instanceof Error ? error.message : String(error));
+      }
+      const eventDate = target.kind === "earnings"
+        ? await withMarketData(ctx, (market) => requireEventDate(target, scheduledEventSources(market.dataProvider), today, (message) => ctx.fail(message)))
+        : await requireEventDate(target, scheduledEventSources(null), today, (message) => ctx.fail(message));
+      newEventRule = createScheduledAlert(target, request.leadDays, eventDate);
+    }
+
+    if (action === "list") {
+      const { alerts, events } = await withConfigData(ctx, (config) => readAlertStores(config.config));
+      // Earnings dates come through market data; CPI and FOMC dates do not need it.
+      const lookup = (targets: ScheduledEventTarget[]) => targets.some((target) => target.kind === "earnings")
+        ? withMarketData(ctx, (market) => lookupScheduledDates(targets, scheduledEventSources(market.dataProvider), today))
+        : lookupScheduledDates(targets, scheduledEventSources(null), today);
+      const { dates, warnings } = await listEventDates(events.rules, today, lookup);
+      const rows = [
+        ...alerts.map(priceRow),
+        ...events.rules.map((rule) => eventRow(rule, today, dates.has(rule.id) ? dates.get(rule.id) : rule.eventDate)),
+      ];
+      const allWarnings = [...(events.error ? [events.error] : []), ...warnings];
+      ctx.printResult({ data: rows, ...(allWarnings.length ? { warnings: allWarnings } : {}) }, {
+        rows: (data) => data.map(textRow),
+        textColumns: [
+          { key: "id", header: "ID", shrink: false },
+          { key: "kind", header: "Kind" },
+          { key: "target", header: "Target" },
+          { key: "trigger", header: "Trigger" },
+          { key: "eventDate", header: "Event Date" },
+          { key: "status", header: "Status" },
+          { key: "lastCheckedPrice", header: "Last Price", align: "right", optional: true },
+          { key: "triggeredAt", header: "Triggered", optional: true },
+        ],
+        empty: "No alerts. Add one with gloomberb alerts add AAPL above 250, alerts add CRWV earnings --days 3, or alerts add CPI --days 1.",
+      });
+      return;
+    }
+
     await withConfigData(ctx, async (config) => {
-      const raw = config.config.pluginConfig[ALERTS_PLUGIN_ID]?.[ALERTS_KEY];
-      const alerts = deserializeAlerts(typeof raw === "string" ? raw : "[]");
-      const saveAlerts = async (nextAlerts: typeof alerts) => {
+      const { pluginState, alerts, events } = readAlertStores(config.config);
+      const save = async (next: { alerts?: AlertRule[]; events?: EventAlertRule[] }) => {
         const nextConfig = {
           ...config.config,
           pluginConfig: {
             ...config.config.pluginConfig,
             [ALERTS_PLUGIN_ID]: {
-              ...(config.config.pluginConfig[ALERTS_PLUGIN_ID] ?? {}),
-              [ALERTS_KEY]: serializeAlerts(nextAlerts),
+              ...pluginState,
+              ...(next.alerts ? { [ALERTS_KEY]: serializeAlerts(next.alerts) } : {}),
+              ...(next.events ? { [EVENT_ALERTS_KEY]: JSON.stringify(next.events) } : {}),
             },
           },
         };
         if (!ctx.cliOptions.dryRun) await saveConfig(nextConfig);
       };
+      // Saved event alerts that do not read are never written over.
+      const requireEvents = () => {
+        if (events.error) ctx.fail(events.error);
+        return events.rules;
+      };
 
-      if (action === "list") {
-        ctx.printResult({ data: alerts }, {
-          textColumns: [
-            { key: "id", header: "ID", shrink: false },
-            { key: "symbol", header: "Symbol" },
-            { key: "condition", header: "Condition" },
-            { key: "targetPrice", header: "Target", align: "right" },
-            { key: "status", header: "Status" },
-            { key: "lastCheckedPrice", header: "Last Price", align: "right", optional: true },
-            { key: "createdAt", header: "Created", optional: true },
-            { key: "triggeredAt", header: "Triggered" },
-          ],
-          empty: "No alerts. Add one with gloomberb alerts add <symbol> <above|below|crosses> <price>.",
+      if (request?.kind === "price") {
+        const { condition, price } = request;
+        const symbol = requireArg(priceListing?.key, ADD_USAGE, ctx);
+        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)}`,
         });
         return;
       }
-      if (action === "add") {
-        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, 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)}`,
+      if (newEventRule) {
+        const rule = newEventRule;
+        const rules = requireEvents();
+        const scheduled = readScheduledRule(rule)!;
+        const name = scheduledEventName(scheduled.target);
+        const existing = rules.find((entry) => entry.kind === rule.kind && entry.value.toLowerCase() === rule.value.toLowerCase());
+        if (existing) ctx.fail(`An alert ${plural(scheduled.leadDays, "day")} before ${name} already exists (ID ${existing.id}).`);
+        if (rules.length >= MAX_EVENT_ALERTS) ctx.fail(`Keep at most ${MAX_EVENT_ALERTS} event alerts. Delete one with gloomberb alerts delete <id>.`);
+        await save({ events: [...rules, rule] });
+        const eventDate = rule.eventDate!;
+        const due = scheduledPhase(eventDate, scheduled.leadDays, undefined, today) === "due";
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert: rule }, ...(read.length > 0 ? { warnings: read } : {}) }, {
+          text: (data) => `Added alert ${data.alert.id}: ${name} on ${eventDate}, ${plural(scheduled.leadDays, "day")} before (${due
+            ? "already reached, so the app alerts at its next check"
+            : `the app alerts on ${leadStartDate(eventDate, scheduled.leadDays)}`}).${dryRunNote(data.dryRun)}`,
         });
         return;
       }
       if (action === "delete" || action === "rm") {
         const id = requireArg(args[1], "Usage: gloomberb alerts delete <id>", ctx);
-        const next = alerts.filter((alert) => alert.id !== id);
-        await saveAlerts(next);
-        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun && next.length !== alerts.length, dryRun: ctx.cliOptions.dryRun, id } }, {
-          text: (data) => next.length === alerts.length
-            ? cliStyles.muted(`No alert with ID ${id}.`)
-            : `Deleted alert ${id}.${dryRunNote(data.dryRun)}`,
+        const isPrice = alerts.some((alert) => alert.id === id);
+        const isEvent = !isPrice && events.rules.some((rule) => rule.id === id);
+        if (isPrice) await save({ alerts: alerts.filter((alert) => alert.id !== id) });
+        if (isEvent) await save({ events: requireEvents().filter((rule) => rule.id !== id) });
+        const changed = isPrice || isEvent;
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun && changed, dryRun: ctx.cliOptions.dryRun, id } }, {
+          text: (data) => changed
+            ? `Deleted alert ${id}.${dryRunNote(data.dryRun)}`
+            : cliStyles.muted(`No alert with ID ${id}.`),
         });
         return;
       }
       if (action === "rearm") {
         const id = requireArg(args[1], "Usage: gloomberb alerts rearm <id>", ctx);
-        const next = alerts.map((alert) => alert.id === id ? rearmAlert(alert) : alert);
-        await saveAlerts(next);
-        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, id } }, {
-          text: (data) => alerts.some((alert) => alert.id === id)
+        const isPrice = alerts.some((alert) => alert.id === id);
+        const rule = isPrice ? null : events.rules.find((entry) => entry.id === id) ?? null;
+        if (isPrice) await save({ alerts: alerts.map((alert) => alert.id === id ? rearmAlert(alert) : alert) });
+        if (rule) {
+          // A scheduled alert alerts again for its coming event; any other event alert resumes.
+          const next = readScheduledRule(rule) ? rearmScheduledAlert(rule) : rule.status === "paused" ? toggleEventAlert(rule) : rule;
+          await save({ events: requireEvents().map((entry) => entry.id === id ? next : entry) });
+        }
+        const found = isPrice || !!rule;
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun && found, dryRun: ctx.cliOptions.dryRun, id } }, {
+          text: (data) => found
             ? `Re-armed alert ${id}.${dryRunNote(data.dryRun)}`
             : cliStyles.muted(`No alert with ID ${id}.`),
         });

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

@@ -27,6 +27,23 @@ import { isResearchAlertKind } from "./research-rules";
 import { useAsyncResource } from "../../../public/react";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
+import { newYorkToday } from "../earnings/board-model";
+import { readScheduledRule, rearmScheduledAlert, scheduledAlertStatus } from "./scheduled";
+import { checkScheduledEventAlertsNow } from "./scheduled-check";
+import { alertTarget, alertViewHints, eventRuleSubject, useOpenAlertTarget } from "./targets";
+
+/** Earnings and macro event rules name the event day they wait for; the rest name what they follow. */
+function ruleTarget(rule: EventAlertRule): string {
+  const target = eventAlertTarget(rule);
+  if (!readScheduledRule(rule)) return target;
+  return `${target} · ${rule.eventDate ?? "date not known yet"}`;
+}
+
+function ruleState(rule: EventAlertRule, today: string): "Active" | "Paused" | "Alerted" {
+  const scheduled = readScheduledRule(rule);
+  const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, today) : rule.status;
+  return status === "paused" ? "Paused" : status === "triggered" ? "Alerted" : "Active";
+}
 
 const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
   { id: "kind", label: "Event", width: 15, align: "left" },
@@ -52,7 +69,7 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
       [...rules].sort((a, b) => {
         const value = (rule: EventAlertRule) =>
           sort.columnId === "target"
-            ? eventAlertTarget(rule)
+            ? ruleTarget(rule)
             : sort.columnId === "created"
               ? rule.createdAt
               : sort.columnId === "kind"
@@ -65,6 +82,10 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
     [rules, sort],
   );
   const selectedRule = items[Math.min(selected, Math.max(0, items.length - 1))];
+  const today = newYorkToday();
+  const selectedFired = !!selectedRule && ruleState(selectedRule, today) === "Alerted";
+  const openTarget = useOpenAlertTarget();
+  const selectedTarget = useMemo(() => selectedRule ? alertTarget(eventRuleSubject(selectedRule)) : null, [selectedRule]);
   // Research rules keep a dated observation in the Cloud; show its value and percentile.
   const access = usePlanAccess();
   const session = useResearchCloudSession();
@@ -94,6 +115,21 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
     },
     [setJson],
   );
+  // An earnings or macro alert that went off alerts again for the same event.
+  const rearm = useCallback(
+    (rule: EventAlertRule | undefined) => {
+      if (!rule) return;
+      setJson((current) => {
+        const result = readEventAlerts(current);
+        return result.error
+          ? current
+          : JSON.stringify(result.rules.map((entry) => (entry.id === rule.id ? rearmScheduledAlert(entry) : entry)));
+      });
+      // Once the write has landed, so it alerts now rather than at the next 15-minute check.
+      setTimeout(checkScheduledEventAlertsNow, 1_000);
+    },
+    [setJson],
+  );
   const remove = useCallback(async () => {
     if (!selectedRule) return;
     const id = selectedRule.id;
@@ -129,6 +165,7 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
       ],
       hints: [
         { id: "add", key: "a", label: "dd event", onPress: add, disabled: !!error },
+        ...alertViewHints(selectedTarget, openTarget),
         {
           id: "toggle",
           key: "p",
@@ -143,9 +180,12 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
           onPress: () => void remove(),
           disabled: !selectedRule,
         },
+        ...(selectedFired
+          ? [{ id: "rearm", key: "m", label: "re-arm", title: "Re-arm", onPress: () => rearm(selectedRule) }]
+          : []),
       ],
     }),
-    [status, error, selectedRule, add, toggle, remove],
+    [status, error, selectedRule, selectedFired, selectedTarget, add, toggle, rearm, remove, openTarget],
   );
   return (
     <DataTableView<EventAlertRule, DataTableColumn>
@@ -173,11 +213,9 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
                 ? ruleStateText(states.get(rule.id))
                 : ""
               : column.id === "target"
-              ? eventAlertTarget(rule)
+              ? ruleTarget(rule)
               : column.id === "status"
-                ? rule.status === "active"
-                  ? "Active"
-                  : "Paused"
+                ? ruleState(rule, today)
                 : new Date(rule.createdAt).toISOString().slice(0, 10),
         color: row.selected
           ? colors.selectedText
@@ -190,7 +228,7 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
         <PaneStatusBody
           empty
           emptyTitle="No event alerts"
-          emptyMessage="Follow filings, news, earnings, members, funds or market moves."
+          emptyMessage="Follow earnings and CPI or FOMC dates, filings, news, members, funds or market moves."
           actions={<Button label="Add event alert" compact onPress={add} />}
         />
       )}

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

@@ -11,6 +11,21 @@ export interface EventAlertRule {
   value: string;
   createdAt: number;
   status: "active" | "paused";
+  /**
+   * Scheduled events (earnings, a macro release): the date of the next one
+   * (YYYY-MM-DD), as last looked up, so a list can show it without a request.
+   */
+  eventDate?: string;
+  /** Scheduled events: the event date it already alerted for. The next event date arms it again. */
+  firedFor?: string;
+}
+
+const isDateKey = (value: unknown): value is string =>
+  typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(`${value}T00:00:00Z`));
+
+/** Earnings and macro event rules: they follow a dated event and alert a number of days before it. */
+export function isScheduledEventRule(rule: Pick<EventAlertRule, "kind">): boolean {
+  return rule.kind === "earnings_date" || rule.kind === "macro_event";
 }
 
 export const EVENT_ALERT_TEMPLATES = [
@@ -102,14 +117,20 @@ export function readEventAlerts(json: string): { rules: EventAlertRule[]; error:
         throw new Error();
       const normalized = research ? normalizeResearchRule(value.kind, value.value) : template!.normalize(value.value);
       if (normalized == null || (template?.field && !normalized)) throw new Error();
-      rules.push({
+      const rule: EventAlertRule = {
         id: value.id,
         kind: value.kind,
         target: value.target,
         value: normalized,
         status: value.status,
         createdAt: value.createdAt,
-      });
+      };
+      // A date that does not read is dropped, not the rule: the next lookup puts it back.
+      if (isScheduledEventRule(rule)) {
+        if (isDateKey(value.eventDate)) rule.eventDate = value.eventDate;
+        if (isDateKey(value.firedFor)) rule.firedFor = value.firedFor;
+      }
+      rules.push(rule);
       ids.add(value.id);
     }
     return { rules, error: null };

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

@@ -0,0 +1,27 @@
+let pendingPriceAlertId: string | null = null;
+const listeners = new Set<() => void>();
+
+function publish(): void {
+  for (const listener of listeners) listener();
+}
+
+/** Open on the Prices tab should select this rule once the table is up. */
+export function requestPriceAlertFocus(alertId: string): void {
+  pendingPriceAlertId = alertId;
+  publish();
+}
+
+export function getPriceAlertFocus(): string | null {
+  return pendingPriceAlertId;
+}
+
+export function clearPriceAlertFocus(): void {
+  if (!pendingPriceAlertId) return;
+  pendingPriceAlertId = null;
+  publish();
+}
+
+export function subscribePriceAlertFocus(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}

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

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import {
   DataTableView,
   PaneStatusBody,
@@ -17,6 +17,7 @@ import { usePlanAccess } from "../../../api-client/plan-access";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { alertKindLabel, fetchAlertHistory, type AlertHistoryItem } from "./history";
 import { relativeTime } from "./format";
+import { alertTarget, alertViewHints, deliveredAlertSubject, useOpenAlertTarget } from "./targets";
 
 const stamp = (value: string) => value.slice(0, 16).replace("T", " ");
 const itemId = (item: AlertHistoryItem) => item.id;
@@ -38,6 +39,9 @@ export function AlertHistoryPane({ focused, width, height }: PaneProps) {
   const loadingMore = history.loadingMore;
   const scrollRef = useRef<ScrollBoxRenderable | null>(null);
   const loadMoreOnScroll = useTableLoadMore(scrollRef, history.hasMore && !loadingMore, history.loadMore);
+  const selectedItem = items[Math.min(selected, Math.max(0, items.length - 1))];
+  const selectedTarget = useMemo(() => selectedItem ? alertTarget(deliveredAlertSubject(selectedItem)) : null, [selectedItem]);
+  const openTarget = useOpenAlertTarget();
 
   const columns: DataTableColumn[] = [
     { id: "time", label: "Sent (UTC)", width: 16, align: "left" },
@@ -62,8 +66,9 @@ export function AlertHistoryPane({ focused, width, height }: PaneProps) {
             },
           ]
         : [],
+      hints: alertViewHints(selectedTarget, openTarget),
     }),
-    [data, loadingMore],
+    [data, loadingMore, selectedTarget, openTarget],
   );
   if (!access.signedIn)
     return <SignInWall placement="alerts-history-signin" action="see delivered alerts" needsVerification={session.needsVerification} />;

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

@@ -8,6 +8,8 @@ export interface AlertHistoryItem {
   title: string;
   body: string;
   deliveredAt: string;
+  /** What the notification carried: the symbol, market or fund it is about. */
+  data?: Record<string, unknown>;
 }
 /** Latest source observation behind one research rule, with its percentile context. */
 export interface AlertRuleState {