gloomberb 0.18.3 → 0.18.4

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

@@ -1,13 +1,13 @@
 /**
- * `gloomberb fn ALRT`: the Alerts pane's three tabs as reports. Prices lists
+ * `gloom fn ALRT`: the Alerts pane's three tabs as reports. Prices lists
  * the price alerts as the pane's table does, Events the event alerts (earnings,
- * CPI and FOMC with their dates, filings, news, market moves), History the
- * alerts delivered to the account over the last 90 days.
+ * CPI, FOMC and other calendar releases with their dates, filings, news, IV levels, market moves),
+ * History the alerts this device's app fired, with the ones Gloom Cloud
+ * delivered to the account over the last 90 days when signed in.
  */
 import type { HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneRow, HeadlessRowsResult } from "../../../types/headless";
 import type { PaneLock } from "../../../types/plugin";
-import { newYorkToday } from "../earnings/board-model";
-import { explainRefusal } from "../shared/cloud-denied";
+import { refusedLock } from "../shared/cloud-denied";
 import { ALERT_TABS, ALERTS_PLUGIN_ID } from "./constants";
 import { ruleState } from "./event-rows";
 import { eventAlertTarget, type EventAlertRule } from "./events";
@@ -19,7 +19,10 @@ import {
   formatQuoteChecked,
   relativeTime,
 } from "./format";
+import { FIRED_LOG_KEY, firedAlertTime, quoteSourceWords, readFiredAlerts } from "./fired-log";
 import { alertKindLabel, validateAlertHistory, type AlertHistory, type AlertHistoryItem } from "./history";
+import { ALERT_HISTORY_VIA, mergeAlertHistory, type AlertHistoryRow } from "./history-rows";
+import { IV_LEVEL_CHECKS_KEY, ivLevelCheckText, readIvLevelChecks, type IvLevelCheck } from "./iv-level";
 import { readScheduledRule, scheduledEventName } from "./scheduled";
 import { readAlertStores } from "./storage";
 import type { AlertRule } from "./types";
@@ -33,40 +36,71 @@ const plural = (count: number, word: string) => `${count} ${word}${count === 1 ?
 const asAlert = (row: HeadlessPaneRow) => row as unknown as AlertRule;
 const text = (value: unknown) => (typeof value === "string" && value ? value : "");
 
-/** The text report words each cell as the pane does; CSV and JSON keep the stored numbers and times. */
+const percent = (value: unknown) => (typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}%` : "");
+const instant = (value: unknown) => (typeof value === "number" ? firedAlertTime(value) ?? "" : "");
+
+/**
+ * The text report words each cell as the pane does: the quote's age and feed, the distance signed.
+ * CSV and JSON keep the stored numbers, with Away in %, and the quote's own time and feed in Quote
+ * and Quote source, apart from when the app last checked the alert.
+ */
 const PRICE_COLUMNS: HeadlessPaneColumn[] = [
   { key: "status", header: "State", format: (value) => (value === "triggered" ? "Triggered" : "Active") },
   { key: "symbol", header: "Symbol", format: (value, row) => (row.exchange ? `${text(value)}:${text(row.exchange)}` : text(value)) },
   { key: "lastCheckedPrice", header: "Current", align: "right", textFormat: (_value, row) => formatCurrentPrice(asAlert(row), 14) },
   { key: "targetPrice", header: "Target", align: "right", textFormat: (_value, row) => formatAlertTargetPrice(asAlert(row), 14) },
-  { key: "awayPercent", header: "Away", align: "right", textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
+  { key: "awayPercent", header: "Away", align: "right", format: percent, textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
   { key: "condition", header: "Trigger", format: (value) => conditionLabel(value as AlertRule["condition"]) },
-  { key: "lastCheckedAt", header: "Quote", textFormat: (_value, row) => formatQuoteChecked(asAlert(row)) },
-  { key: "triggeredAt", header: "Alerted", textFormat: (value) => (typeof value === "number" ? relativeTime(value) : "-") },
+  { key: "quoteAt", header: "Quote", textFormat: (_value, row) => formatQuoteChecked(asAlert(row)) },
+  { key: "quoteSource", header: "Quote source" },
+  { key: "lastCheckedAt", header: "Checked", format: instant },
+  { key: "triggeredAt", header: "Alerted", format: instant, textFormat: (value) => (typeof value === "number" ? relativeTime(value) : "-") },
 ];
+/** The terminal table keeps the pane's columns: the Quote cell already says the quote's age and feed. */
+const PRICE_TEXT_COLUMNS = PRICE_COLUMNS.filter((column) => column.key !== "quoteSource" && column.key !== "lastCheckedAt");
 
 const EVENT_COLUMNS: HeadlessPaneColumn[] = [
   { key: "event", header: "Event" },
   { key: "following", header: "Following" },
   { key: "eventDate", header: "Event date", textFormat: (value, row) => text(value) || (row.leadDays == null ? "" : "not known yet") },
-  { key: "leadDays", header: "Days before", align: "right" },
+  // A results alert waits for the report instead of a lead time.
+  { key: "leadDays", header: "Days before", align: "right", textFormat: (value, row) => (row.when === "results" ? "results" : value == null ? "-" : String(value)) },
   { key: "state", header: "State" },
   { key: "since", header: "Since" },
 ];
 
+const minute = (value: unknown) => text(value).slice(0, 16).replace("T", " ");
+const valueText = (value: unknown, row: HeadlessPaneRow) => (typeof value === "number" && Number.isFinite(value)
+  ? `${Number(value.toFixed(4))}${row.unit === "%" ? "%" : row.unit ? ` ${text(row.unit)}` : ""}` : "");
+
+/**
+ * One line per alert, the app's and Gloom Cloud's together, newest first: when it went off, what
+ * sent it, the rule, the figure in its unit, and the quote behind it with its own time and feed.
+ */
 const HISTORY_COLUMNS: HeadlessPaneColumn[] = [
-  { key: "deliveredAt", header: "Sent (UTC)", format: (value) => text(value).slice(0, 16).replace("T", " ") },
+  { key: "time", header: "Time (UTC)", format: minute },
+  { key: "via", header: "Via" },
   { key: "event", header: "Event" },
-  { key: "title", header: "Alert" },
-  { key: "body", header: "Detail" },
+  { key: "alert", header: "Alert" },
+  { key: "value", header: "Value", align: "right", unitKey: "unit", textFormat: valueText },
+  { key: "quoteAt", header: "Quote time (UTC)", format: minute },
+  { key: "quoteSource", header: "Quote source" },
+  { key: "detail", header: "Detail", shrink: true },
 ];
+const HISTORY_TEXT_COLUMNS = HISTORY_COLUMNS.filter((column) => column.key !== "via");
 
-/** A price alert as the Prices table lists it: the stored fields, without the quote's provider id, and the distance to target. */
+/** A price alert as the Prices table lists it: the stored fields, without the quote's provider id, the distance to target, and its quote's own time and feed. */
 function priceRow(alert: AlertRule): HeadlessPaneRow {
   const { lastQuoteProviderId: _provider, ...stored } = alert;
   const price = alert.lastCheckError ? null : alert.lastCheckedPrice;
   const away = price == null || !Number.isFinite(price) || price === 0 ? null : ((alert.targetPrice - price) / price) * 100;
-  return { ...stored, awayPercent: away != null && Number.isFinite(away) ? away : null };
+  const quoted = !alert.lastCheckError;
+  return {
+    ...stored,
+    awayPercent: away != null && Number.isFinite(away) ? Number(away.toFixed(2)) : null,
+    quoteAt: quoted ? firedAlertTime(alert.lastQuoteUpdatedAt) : null,
+    quoteSource: quoted ? quoteSourceWords(alert.lastQuoteSource) : null,
+  };
 }
 
 /** Active alerts first, then the ones that went off, latest first, as the pane orders them. */
@@ -75,15 +109,16 @@ function pricesResult(alerts: readonly AlertRule[], error: string | null, events
   const triggered = alerts.filter((alert) => alert.status === "triggered").sort((a, b) => (b.triggeredAt ?? 0) - (a.triggeredAt ?? 0));
   return {
     columns: PRICE_COLUMNS,
+    textColumns: PRICE_TEXT_COLUMNS,
     rows: [...active, ...triggered].map(priceRow),
-    empty: "No price alerts. Add one with gloomberb alerts add AAPL above 250.",
+    empty: "No price alerts. Add one with gloom alerts add AAPL above 250.",
     ...(error ? { errors: [error], complete: false } : {}),
-    ...(events > 0 ? { notes: [`${plural(events, "event alert")} not listed here: gloomberb fn ALRT --tab events`] } : {}),
+    ...(events > 0 ? { notes: [`${plural(events, "event alert")} not listed here: gloom fn ALRT --tab events`] } : {}),
   };
 }
 
 /** An event alert as the Events table lists it: a scheduled one with its event date and lead time apart. */
-function eventRow(rule: EventAlertRule, today: string): HeadlessPaneRow {
+function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLevelCheck>): HeadlessPaneRow {
   const scheduled = readScheduledRule(rule);
   return {
     id: rule.id,
@@ -92,40 +127,54 @@ function eventRow(rule: EventAlertRule, today: string): HeadlessPaneRow {
     following: scheduled ? scheduledEventName(scheduled.target) : eventAlertTarget(rule),
     eventDate: scheduled ? rule.eventDate ?? null : null,
     leadDays: scheduled?.leadDays ?? null,
-    state: ruleState(rule, today),
+    ...(scheduled?.trigger === "results" ? { when: "results" } : {}),
+    state: ruleState(rule, now),
     since: new Date(rule.createdAt).toISOString().slice(0, 10),
+    // An IV level's last reading, or why there was none, on its own row.
+    ...rule.kind === "iv_level" ? { lastCheck: ivLevelCheckText(rule, checks[rule.id]) } : {},
   };
 }
 
-function eventsResult(rules: readonly EventAlertRule[], error: string | null): HeadlessRowsResult {
-  const today = newYorkToday();
+function eventsResult(rules: readonly EventAlertRule[], error: string | null, checks: Record<string, IvLevelCheck>): HeadlessRowsResult {
+  const now = Date.now();
+  const checked = rules.some((rule) => rule.kind === "iv_level");
   return {
-    columns: EVENT_COLUMNS,
-    rows: [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, today)),
-    empty: "No event alerts. Add one with gloomberb alerts add CRWV earnings --days 3 or gloomberb alerts add CPI --days 1.",
+    // A Last check column only when an IV level rule has a reading to show.
+    columns: checked ? [...EVENT_COLUMNS.slice(0, -2), { key: "lastCheck", header: "Last check" }, ...EVENT_COLUMNS.slice(-2)] : EVENT_COLUMNS,
+    rows: [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, now, checks)),
+    empty: "No event alerts. Add one with gloom alerts add CRWV earnings --days 3, gloom alerts add CPI --days 1 or gloom alerts add CN PMI.",
     ...(error ? { errors: [error], complete: false } : {}),
   };
 }
 
-function historyRow(item: AlertHistoryItem): HeadlessPaneRow {
-  return { id: item.id, deliveredAt: item.deliveredAt, kind: item.kind, event: alertKindLabel(item.kind), title: item.title, body: item.body };
+/** One alert that went off: fired by this app, delivered by Gloom Cloud, or both, on one line. */
+function historyRow(row: AlertHistoryRow): HeadlessPaneRow {
+  return {
+    id: row.fired?.id ?? row.delivered?.id ?? row.id, time: row.time, via: ALERT_HISTORY_VIA[row.via], kind: row.kind,
+    event: alertKindLabel(row.kind), alert: row.alert, value: row.value, unit: row.unit, quoteAt: row.quoteAt,
+    quoteSource: row.source, detail: row.detail,
+  };
 }
 
-/** What a signed-out read of History says: the tab is the account's own list of delivered alerts. */
+/** What a signed-out read of History adds: only this device's own alerts are listed. */
 export function alertHistoryLockNote({ verifyEmail }: PaneLock): string {
   const account = verifyEmail
     ? "verify your email (Ctrl+P, Resend Verification Email)"
     : "log in or sign up free from the command bar (Ctrl+P, Log In or Sign Up)";
   return [
-    `ALRT History needs a free Gloom sign-in: it lists the alerts Gloom delivered to your account over the last 90 days. ${verifyEmail ? "Until the email is verified" : "Signed out"} it shows none of them.`,
-    `To read it, open the app (gloomberb), ${account}; gloomberb fn ALRT --tab history then reads with that session.`,
+    `Only the alerts this app fired are listed: the ones Gloom Cloud delivered to your phone or email over the last 90 days need a free Gloom sign-in${verifyEmail ? " with a verified email" : ""}.`,
+    `To add them, open the app (gloom), ${account}; gloom fn ALRT --tab history then reads with that session.`,
   ].join("\n");
 }
 
+/** The app's own fired alerts, newest first, with Gloom Cloud's deliveries merged in when the session can read them. */
 async function historyResult(ctx: HeadlessPaneContext): Promise<HeadlessRowsResult> {
+  const fired = readFiredAlerts(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, FIRED_LOG_KEY));
   const items: AlertHistoryItem[] = [];
   let first: AlertHistory | null = null;
   let more = false;
+  let refused: string | null = null;
+  let failed: string | null = null;
   try {
     for (let offset: number | null = 0, page = 0; offset != null; page += 1) {
       if (page === HISTORY_PAGES) {
@@ -139,28 +188,38 @@ async function historyResult(ctx: HeadlessPaneContext): Promise<HeadlessRowsResu
       offset = history.hasMore ? history.nextOffset : null;
     }
   } catch (error) {
-    throw await explainRefusal(error, alertHistoryLockNote, { symbol: null, token: "ALRT" });
+    // Signed out, the app's own log is the history; any other failure is said beside it.
+    const lock = refusedLock(error);
+    if (lock?.gate === "sign-in") refused = alertHistoryLockNote({ ...lock, symbol: null, token: "ALRT" });
+    else failed = error instanceof Error ? error.message : String(error);
   }
   const unavailable = first?.status === "unavailable";
+  const rows = mergeAlertHistory(fired, items).map(historyRow);
+  const errors = [...unavailable ? [first?.warning ?? "Delivered alerts are unavailable."] : [], ...failed ? [`Delivered alerts: ${failed}`] : []];
+  const notes = [
+    ...refused ? [refused] : [],
+    ...more ? [`Showing the latest ${items.length} delivered alerts; the pane loads older ones as you scroll.`] : [],
+  ];
   return {
     columns: HISTORY_COLUMNS,
-    rows: items.map(historyRow),
-    empty: "No alerts delivered in the last 90 days.",
-    freshness: { source: "Gloom Cloud", status: "not-a-feed", basis: "delivered alerts", ...(first ? { asOf: first.asOf } : {}) },
-    ...(unavailable ? { errors: [first?.warning ?? "Alert history is unavailable."], complete: false } : {}),
-    ...(more ? { notes: [`Showing the latest ${items.length} delivered alerts; the pane loads older ones as you scroll.`] } : {}),
+    textColumns: HISTORY_TEXT_COLUMNS,
+    rows,
+    empty: refused ? "This app has fired no alerts yet." : "No alerts fired by this app or delivered in the last 90 days.",
+    freshness: { source: first ? "This app and Gloom Cloud" : "This app", status: "not-a-feed", basis: "fired and delivered alerts", ...(first ? { asOf: first.asOf } : {}) },
+    ...(errors.length ? { errors, complete: false } : {}),
+    ...(notes.length ? { notes } : {}),
     metadata: { deviceEnabled: first?.deviceEnabled ?? null },
   };
 }
 
 export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
-  description: "Your alerts: price alerts with current price and distance to target, event alerts (earnings, CPI and FOMC dates, filings, news, market moves) or the alerts delivered to your account.",
+  description: "Your alerts: price alerts with current price and distance to target, event alerts (earnings, CPI, FOMC and other economic calendar releases, filings, news, IV levels, market moves) or the alerts that went off, from this app and, signed in, Gloom Cloud.",
   freshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
   argument: { kind: "none" },
   options: [{
     key: "tab",
-    description: "Alerts tab: prices, events or history (delivered alerts, signed in).",
+    description: "Alerts tab: prices, events or history (alerts that went off; Gloom Cloud's deliveries when signed in).",
     type: "enum",
     values: ALERT_TABS.map(({ value }) => ({ value })),
     defaultValue: "prices",
@@ -169,7 +228,7 @@ export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
   }],
   discovery: {
     screenshotReadiness: "live-dom",
-    dataRequirements: ["Your saved alerts; the History tab needs a Gloom sign-in"],
+    dataRequirements: ["Your saved alerts and this device's log of fired alerts; History adds Gloom Cloud's deliveries when signed in"],
     limitations: ["Current price and quote time are what the app saved at its last check, blank until it has checked the alert."],
   },
   describe: (args) => `Alerts | ${String(args.options.tab ?? "prices")}`,
@@ -177,6 +236,8 @@ export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
     const tab = (args.options.tab ?? "prices") as AlertsTab;
     if (tab === "history") return historyResult(ctx);
     const { alerts, alertsError, events } = readAlertStores(ctx.config);
-    return tab === "events" ? eventsResult(events.rules, events.error) : pricesResult(alerts, alertsError, events.rules.length);
+    return tab === "events"
+      ? eventsResult(events.rules, events.error, readIvLevelChecks(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, IV_LEVEL_CHECKS_KEY)))
+      : pricesResult(alerts, alertsError, events.rules.length);
   },
 };

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

@@ -12,20 +12,55 @@ import { handleRefreshKey } from "../../../components/data-table/table-pane";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import type { ScrollBoxRenderable } from "../../../ui";
-import { SignInWall } from "../cloud/auth-actions";
 import { usePlanAccess } from "../../../api-client/plan-access";
+import { usePluginState } from "../../runtime";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
+import { FIRED_LOG_KEY, readFiredAlerts } from "./fired-log";
 import { alertKindLabel, fetchAlertHistory, type AlertHistoryItem } from "./history";
+import { mergeAlertHistory, type AlertHistoryRow, type AlertHistoryVia } from "./history-rows";
 import { relativeTime } from "./format";
-import { alertTarget, alertViewHints, deliveredAlertSubject, useOpenAlertTarget } from "./targets";
+import { alertTarget, alertViewHints, deliveredAlertSubject, useOpenAlertTarget, type AlertSubject } from "./targets";
 
 const stamp = (value: string) => value.slice(0, 16).replace("T", " ");
 const itemId = (item: AlertHistoryItem) => item.id;
+/** Where a line comes from, in the Via column's few cells. */
+const VIA_TEXT: Record<AlertHistoryVia, string> = { app: "App", cloud: "Cloud", both: "App, Cloud" };
 
-/** Alerts the push service accepted for this account over the last 90 days. */
+/** One line of History: an alert this app fired, one Gloom Cloud delivered, or both for the one alert. */
+interface HistoryRow {
+  id: string;
+  time: string;
+  kind: string;
+  alert: string;
+  /** The figure in its unit, or what the alert said. */
+  value: string;
+  quoteAt: string | null;
+  source: string;
+  via: AlertHistoryVia;
+  subject: AlertSubject;
+}
+
+function historyRow(row: AlertHistoryRow): HistoryRow {
+  const figure = row.value == null ? null
+    : `${Number(row.value.toFixed(4))}${row.unit === "%" ? "%" : row.unit ? ` ${row.unit}` : ""}`;
+  return {
+    id: row.id, time: row.time, kind: row.kind, alert: row.alert, value: figure ?? row.detail,
+    quoteAt: row.quoteAt, source: row.source ?? "", via: row.via,
+    subject: row.fired
+      ? { kind: row.fired.kind, symbol: row.fired.symbol, exchange: row.fired.exchange }
+      : deliveredAlertSubject(row.delivered!),
+  };
+}
+
+/**
+ * The alerts that went off, newest first: the ones this app fired, kept on the device, and, signed in,
+ * the ones Gloom Cloud delivered to the account's phone or email over the last 90 days.
+ */
 export function AlertHistoryPane({ focused, width, height }: PaneProps) {
   const access = usePlanAccess();
   const session = useResearchCloudSession();
+  const [firedLog] = usePluginState<unknown>(FIRED_LOG_KEY, []);
+  const fired = useMemo(() => readFiredAlerts(firedLog), [firedLog]);
   const [selected, setSelected] = useState(0);
   // A new session starts the history over. A failed later page leaves what is
   // loaded, and the next scroll to the end asks again.
@@ -35,84 +70,92 @@ export function AlertHistoryPane({ focused, width, height }: PaneProps) {
   }, [session.requestKey]);
   const history = usePagedRows(access.signedIn ? loadPage : null, { getId: itemId });
   const data = history.pages[0] ?? null;
-  const items = history.rows;
+  const cloudError = access.signedIn
+    ? data?.status === "unavailable" ? data.warning ?? "Delivered alerts are unavailable." : !data ? history.error?.message ?? null : null
+    : null;
+  // One line per alert: a delivery of one this app fired too joins its line.
+  const items = useMemo(
+    () => mergeAlertHistory(fired, data?.status === "unavailable" ? [] : history.rows).map(historyRow),
+    [fired, data, history.rows],
+  );
   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 selectedIndex = Math.min(selected, Math.max(0, items.length - 1));
+  const selectedItem = items[selectedIndex];
+  const selectedTarget = useMemo(() => selectedItem ? alertTarget(selectedItem.subject) : null, [selectedItem]);
   const openTarget = useOpenAlertTarget();
 
   const columns: DataTableColumn[] = [
-    { id: "time", label: "Sent (UTC)", width: 16, align: "left" },
+    { id: "time", label: "Time (UTC)", width: 16, align: "left" },
     { id: "kind", label: "Event", width: 15, align: "left" },
-    { id: "title", label: "Alert", width: Math.max(16, Math.min(28, width - 60)), align: "left" },
-    ...(width >= 70 ? [{ id: "body", label: "Detail", width: 20, flexGrow: 1, align: "left" as const }] : []),
+    { id: "alert", label: "Alert", width: 20, flexGrow: 1, align: "left" },
+    ...(width >= 70 ? [{ id: "value", label: "Value", width: 16, align: "left" as const }] : []),
+    ...(width >= 115
+      ? [
+          { id: "quote", label: "Quote (UTC)", width: 16, align: "left" as const },
+          { id: "source", label: "Source", width: 14, align: "left" as const },
+          { id: "via", label: "Via", width: 10, align: "left" as const },
+        ]
+      : []),
   ];
   usePaneFooter(
     "alert-history",
     () => ({
-      info: data
-        ? [
-            ...(loadingMore ? [{ id: "more", parts: [{ text: "loading more", tone: "muted" as const }] }] : []),
-            {
+      info: [
+        ...(loadingMore ? [{ id: "more", parts: [{ text: "loading more", tone: "muted" as const }] }] : []),
+        ...(cloudError && items.length > 0 ? [{ id: "cloud-error", parts: [{ text: cloudError, tone: "warning" as const }] }] : []),
+        ...(data && data.status !== "unavailable"
+          ? [{
               id: "device",
-              parts: [
-                {
-                  text: `${data.deviceEnabled ? "phone connected" : "no phone connected"} · checked ${relativeTime(Date.parse(data.asOf))}`,
-                  tone: data.deviceEnabled ? ("muted" as const) : ("warning" as const),
-                },
-              ],
-            },
-          ]
-        : [],
+              parts: [{
+                text: `${data.deviceEnabled ? "phone connected" : "no phone connected"} · checked ${relativeTime(Date.parse(data.asOf))}`,
+                tone: data.deviceEnabled ? ("muted" as const) : ("warning" as const),
+              }],
+            }]
+          : []),
+        ...(!access.signedIn ? [{ id: "account", parts: [{ text: "signed out · this app's alerts only", tone: "muted" as const }] }] : []),
+      ],
       hints: alertViewHints(selectedTarget, openTarget),
     }),
-    [data, loadingMore, selectedTarget, openTarget],
+    [data, loadingMore, cloudError, items.length, access.signedIn, selectedTarget, openTarget],
   );
-  if (!access.signedIn)
-    return <SignInWall placement="alerts-history-signin" action="see delivered alerts" needsVerification={session.needsVerification} />;
   return (
     <PaneStatusBody
-      loading={history.loading && !data}
-      error={!data ? history.error?.message ?? null : null}
+      loading={history.loading && !data && fired.length === 0}
+      error={cloudError && items.length === 0 ? cloudError : null}
       subject="alert history"
     >
-      {data?.status === "unavailable" ? (
-        <PaneStatusBody error={data.warning ?? "Alert history is unavailable."} subject="alert history" />
-      ) : (
-        <DataTableView<AlertHistoryItem, DataTableColumn>
-          focused={focused}
-          rootWidth={width}
-          rootHeight={height}
-          columns={columns}
-          items={items}
-          scrollRef={scrollRef}
-          onBodyScrollActivity={loadMoreOnScroll}
-          selection={{
-            kind: "index",
-            selectedIndex: Math.min(selected, Math.max(0, items.length - 1)),
-            onChange: setSelected,
-          }}
-          getItemKey={(item) => item.id}
-          onRootKeyDown={(event) => handleRefreshKey(event, history.reload)}
-          sortColumnId={null}
-          sortDirection="desc"
-          renderCell={(item, column, _index, row) => ({
-            text:
-              column.id === "time"
-                ? stamp(item.deliveredAt)
-                : column.id === "kind"
-                  ? alertKindLabel(item.kind)
-                  : column.id === "title"
-                    ? item.title
-                    : item.body,
-            color: row.selected ? colors.selectedText : column.id === "time" ? colors.textMuted : colors.text,
-          })}
-          emptyStateTitle="No alerts delivered in the last 90 days"
-          emptyStateHint={data?.deviceEnabled ? undefined : "Alerts push to the Gloomberb phone app once it is signed in."}
-        />
-      )}
+      <DataTableView<HistoryRow, DataTableColumn>
+        focused={focused}
+        rootWidth={width}
+        rootHeight={height}
+        columns={columns}
+        items={items}
+        scrollRef={scrollRef}
+        onBodyScrollActivity={loadMoreOnScroll}
+        selection={{ kind: "index", selectedIndex, onChange: setSelected }}
+        getItemKey={(item) => item.id}
+        onRootKeyDown={(event) => handleRefreshKey(event, history.reload)}
+        sortColumnId={null}
+        sortDirection="desc"
+        renderCell={(item, column, _index, row) => ({
+          text:
+            column.id === "time" ? stamp(item.time)
+              : column.id === "kind" ? alertKindLabel(item.kind)
+              : column.id === "alert" ? item.alert
+              : column.id === "value" ? item.value
+              : column.id === "quote" ? (item.quoteAt ? stamp(item.quoteAt) : "")
+              : column.id === "via" ? VIA_TEXT[item.via]
+              : item.source,
+          color: row.selected ? colors.selectedText
+            : column.id === "time" || column.id === "quote" || column.id === "source" || column.id === "via" ? colors.textMuted : colors.text,
+        })}
+        emptyStateTitle={access.signedIn ? "No alerts in the last 90 days" : "No alerts fired yet"}
+        emptyStateHint={access.signedIn
+          ? data?.deviceEnabled ? undefined : "Alerts push to the Gloom phone app once it is signed in."
+          : "Sign in to list the alerts Gloom Cloud delivers too."}
+      />
     </PaneStatusBody>
   );
 }

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

@@ -0,0 +1,89 @@
+import type { FiredAlert } from "./fired-log";
+import type { AlertHistoryItem } from "./history";
+
+/** Where a line of History comes from: this app's log, Gloom Cloud's deliveries, or both for the one alert. */
+export type AlertHistoryVia = "app" | "cloud" | "both";
+
+export const ALERT_HISTORY_VIA: Record<AlertHistoryVia, string> = {
+  app: "This app",
+  cloud: "Gloom Cloud",
+  both: "This app and Gloom Cloud",
+};
+
+/** One alert that went off, as History lists it. */
+export interface AlertHistoryRow {
+  id: string;
+  /** When it went off: the app's own time when it fired it, otherwise Gloom Cloud's delivery. */
+  time: string;
+  via: AlertHistoryVia;
+  kind: string;
+  /** The rule as the app read it, or the notification's title. */
+  alert: string;
+  value: number | null;
+  unit: string | null;
+  quoteAt: string | null;
+  source: string | null;
+  /** What the notification said beside the figure. */
+  detail: string;
+  fired?: FiredAlert;
+  delivered?: AlertHistoryItem;
+}
+
+/**
+ * How far apart the app and Gloom Cloud send the same alert: a price alert is
+ * checked minutes apart by each; an earnings alert goes off once on its day.
+ */
+const PRICE_MATCH_MS = 60 * 60_000;
+const EVENT_MATCH_MS = 24 * 3_600_000;
+
+const upper = (value: unknown) => (typeof value === "string" && value ? value.toUpperCase() : null);
+
+/**
+ * Whether a Cloud delivery is the same alert the app fired: the same price
+ * alert (Gloom Cloud names its id), or the same kind of alert on the same
+ * symbol, within the time the two take to send it.
+ */
+function sameAlert(entry: FiredAlert, item: AlertHistoryItem): boolean {
+  if (item.kind !== entry.kind) return false;
+  const apart = Math.abs(Date.parse(item.deliveredAt) - Date.parse(entry.firedAt));
+  if (!Number.isFinite(apart)) return false;
+  if (entry.kind === "price") return item.data?.alertId === entry.ruleId && apart <= PRICE_MATCH_MS;
+  const symbol = upper(item.data?.symbol);
+  return !!symbol && symbol === upper(entry.symbol) && apart <= EVENT_MATCH_MS;
+}
+
+function firedRow(entry: FiredAlert, delivered: AlertHistoryItem | undefined): AlertHistoryRow {
+  return {
+    id: `app:${entry.id}`, time: entry.firedAt, via: delivered ? "both" : "app", kind: entry.kind, alert: entry.rule,
+    value: entry.value, unit: entry.unit ?? null, quoteAt: entry.quoteAt, source: entry.source,
+    detail: entry.detail ?? delivered?.body ?? "", fired: entry, ...delivered ? { delivered } : {},
+  };
+}
+
+function deliveredRow(item: AlertHistoryItem): AlertHistoryRow {
+  return {
+    id: `cloud:${item.id}`, time: item.deliveredAt, via: "cloud", kind: item.kind, alert: item.title,
+    value: null, unit: null, quoteAt: null, source: null, detail: item.body, delivered: item,
+  };
+}
+
+/**
+ * The alerts this app fired and the ones Gloom Cloud delivered, newest first,
+ * one line per alert: a delivery of an alert the app fired too is that line,
+ * with the app's figure and quote and `both` as where it came from.
+ */
+export function mergeAlertHistory(fired: readonly FiredAlert[], delivered: readonly AlertHistoryItem[]): AlertHistoryRow[] {
+  const matched = new Set<AlertHistoryItem>();
+  const rows = [...fired]
+    .sort((a, b) => Date.parse(b.firedAt) - Date.parse(a.firedAt))
+    .map((entry) => {
+      // The nearest delivery in time, each matched once.
+      const candidates = delivered.filter((item) => !matched.has(item) && sameAlert(entry, item));
+      const nearest = candidates.sort((a, b) => Math.abs(Date.parse(a.deliveredAt) - Date.parse(entry.firedAt))
+        - Math.abs(Date.parse(b.deliveredAt) - Date.parse(entry.firedAt)))[0];
+      if (nearest) matched.add(nearest);
+      return firedRow(entry, nearest);
+    });
+  rows.push(...delivered.filter((item) => !matched.has(item)).map(deliveredRow));
+  return rows.sort((a, b) => Date.parse(b.time) - Date.parse(a.time));
+}