gloomberb 0.18.3 → 0.18.4

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

@@ -1,4 +1,5 @@
 import type { AlertCondition } from "./types";
+import { readAlertPrice } from "./price";
 import { normalizeAlertSymbol } from "./quotes";
 
 export interface AlertCommandInput {
@@ -54,17 +55,13 @@ export function parseAlertShortcutValues(
     values.condition = condition;
   }
 
-  if (parts[2]) {
-    const price = Number.parseFloat(parts[2]!.replace(/^\$/, ""));
-    if (!Number.isFinite(price)) {
-      throw new Error("Use a numeric target price.");
-    }
-    values.price = String(price);
-  }
+  // The price reads as `alerts add` reads it: 81k is 81000, 81,000 asks which was meant, and text that is no number says what to type.
+  if (parts[2]) values.price = String(readAlertPrice(parts[2].replace(/^\$/, "")));
 
   return values;
 }
 
+/** The alert a command's values name: null while one is missing, and a price that reads two ways or as no number throws (`readAlertPrice`). */
 export function parseAlertCommandValues(
   values?: Record<string, string>,
 ): AlertCommandInput | null {
@@ -80,7 +77,5 @@ export function parseAlertCommandValues(
   const condition = parseAlertCondition(values?.condition);
   const priceStr = values?.price?.trim();
   if (!symbol || !condition || !priceStr) return null;
-  const price = Number.parseFloat(priceStr);
-  if (!Number.isFinite(price)) return null;
-  return { symbol, condition, price };
+  return { symbol, condition, price: readAlertPrice(priceStr.replace(/^\$/, "")) };
 }

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

@@ -1,16 +1,20 @@
 import { eventAlertTarget, type EventAlertRule } from "./events";
-import { readScheduledRule, scheduledAlertStatus } from "./scheduled";
+import { readScheduledRule, scheduledAlertStatus, scheduledToday } from "./scheduled";
 
-/** Earnings and macro event rules name the event day they wait for; the rest name what they follow. */
+/** Earnings, macro and calendar event rules name the event day they wait for; the rest name what they follow. */
 export function ruleTarget(rule: EventAlertRule): string {
   const target = eventAlertTarget(rule);
   if (!readScheduledRule(rule)) return target;
   return `${target} · ${rule.eventDate ?? "date not known yet"}`;
 }
 
-/** The state word the Events tab shows: a scheduled rule is Alerted once it has gone off for its coming event. */
-export function ruleState(rule: EventAlertRule, today: string): "Active" | "Paused" | "Alerted" {
+/**
+ * The state word the Events tab shows: a scheduled rule is Alerted once it has gone off for its coming
+ * event, an IV level once its level was reached, until it is re-armed.
+ */
+export function ruleState(rule: EventAlertRule, now: number = Date.now()): "Active" | "Paused" | "Alerted" {
   const scheduled = readScheduledRule(rule);
-  const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, today) : rule.status;
+  const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, scheduledToday(scheduled.target, now), scheduled.trigger)
+    : rule.status === "active" && rule.kind === "iv_level" && rule.triggeredAt ? "triggered" : rule.status;
   return status === "paused" ? "Paused" : status === "triggered" ? "Alerted" : "Active";
 }

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

@@ -13,12 +13,16 @@ import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { useDialog } from "../../../ui/dialog";
 import { useCloudSyncStatus } from "../../../sync/react";
-import { usePluginAppActions, usePluginConfigState } from "../../runtime";
+import { usePluginAppActions, usePluginConfigState, usePluginState } from "../../runtime";
 import {
+  CALENDAR_ALERTS_KEY,
   EVENT_ALERTS_KEY,
+  IV_LEVEL_ALERTS_KEY,
+  eventAlertStoreKey,
   eventAlertTarget,
-  readEventAlerts,
+  readEventAlertStores,
   toggleEventAlert,
+  updateEventAlerts,
   type EventAlertRule,
 } from "./events";
 import { ruleState, ruleTarget } from "./event-rows";
@@ -28,9 +32,9 @@ 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 { rearmScheduledAlert } from "./scheduled";
 import { checkScheduledEventAlertsNow } from "./scheduled-check";
+import { checkIvLevelAlertsNow, IV_LEVEL_CHECKS_KEY, ivLevelCheckText, readIvLevelChecks, rearmIvLevelAlert } from "./iv-level";
 import { alertTarget, alertViewHints, eventRuleSubject, useOpenAlertTarget } from "./targets";
 
 const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
@@ -46,7 +50,24 @@ const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
 export function EventAlertsPane({ focused, width, height }: PaneProps) {
   const [catalystStatus] = usePluginConfigState<string>(CATALYST_POLL_STATUS, "Catalyst alerts check every five minutes while the app is open");
   const [json, setJson] = usePluginConfigState<string>(EVENT_ALERTS_KEY, "[]");
-  const { rules, error } = useMemo(() => readEventAlerts(json), [json]);
+  // IV levels and calendar events are kept in their own lists, which released versions never read.
+  const [ivJson, setIvJson] = usePluginConfigState<string>(IV_LEVEL_ALERTS_KEY, "[]");
+  const [calendarJson, setCalendarJson] = usePluginConfigState<string>(CALENDAR_ALERTS_KEY, "[]");
+  const { rules, error } = useMemo(
+    () => readEventAlertStores((key) => key === IV_LEVEL_ALERTS_KEY ? ivJson : key === CALENDAR_ALERTS_KEY ? calendarJson : json),
+    [json, ivJson, calendarJson],
+  );
+  // Their readings stay on this device.
+  const [savedChecks] = usePluginState<unknown>(IV_LEVEL_CHECKS_KEY, {});
+  const checks = useMemo(() => readIvLevelChecks(savedChecks), [savedChecks]);
+  /** Changes one rule in the list it is kept in, leaving what that list holds of kinds this version does not know. */
+  const updateRules = useCallback(
+    (rule: EventAlertRule, update: (rules: EventAlertRule[]) => EventAlertRule[]) => {
+      const key = eventAlertStoreKey(rule);
+      (key === IV_LEVEL_ALERTS_KEY ? setIvJson : key === CALENDAR_ALERTS_KEY ? setCalendarJson : setJson)((current) => updateEventAlerts(current, update));
+    },
+    [setJson, setIvJson, setCalendarJson],
+  );
   const [selected, setSelected] = useState(0);
   const [sort, setSort] = useState<{ columnId: string; direction: SortDirection }>({ columnId: "created", direction: "desc" });
   const sync = useCloudSyncStatus();
@@ -70,21 +91,22 @@ 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 now = Date.now();
+  const selectedFired = !!selectedRule && ruleState(selectedRule, now) === "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();
-  const hasResearch = rules.some((rule) => isResearchAlertKind(rule.kind));
+  const hasResearch = rules.some((rule) => isResearchAlertKind(rule.kind) && rule.kind !== "iv_level");
   const stateLoader = useCallback(() => fetchAlertHistory(0), [session.requestKey]);
   const history = useAsyncResource(access.signedIn && hasResearch ? stateLoader : null);
   const states = useMemo(
     () => new Map((history.data?.states ?? []).map((state) => [state.ruleId, state])),
     [history.data],
   );
-  const columns = columnsFor(width, hasResearch && !!history.data);
+  // An IV level is read by this app, so its last reading needs no session.
+  const columns = columnsFor(width, (hasResearch && !!history.data) || rules.some((rule) => rule.kind === "iv_level"));
   const add = useCallback(
     () => openPluginCommandWorkflow("set-event-alert"),
     [openPluginCommandWorkflow],
@@ -92,48 +114,31 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
   const toggle = 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 ? toggleEventAlert(entry) : entry)),
-            );
-      });
+      updateRules(rule, (rules) => rules.map((entry) => (entry.id === rule.id ? toggleEventAlert(entry) : entry)));
     },
-    [setJson],
+    [updateRules],
   );
-  // An earnings or macro alert that went off alerts again for the same event.
+  // An earnings or macro alert that went off alerts again for the same event; an IV level watches its level again.
   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)));
-      });
+      const ivLevel = rule.kind === "iv_level";
+      updateRules(rule, (rules) => rules.map((entry) => (entry.id === rule.id ? ivLevel ? rearmIvLevelAlert(entry) : rearmScheduledAlert(entry) : entry)));
       // Once the write has landed, so it alerts now rather than at the next 15-minute check.
-      setTimeout(checkScheduledEventAlertsNow, 1_000);
+      setTimeout(ivLevel ? checkIvLevelAlertsNow : checkScheduledEventAlertsNow, 1_000);
     },
-    [setJson],
+    [updateRules],
   );
   const remove = useCallback(async () => {
     if (!selectedRule) return;
-    const id = selectedRule.id;
+    const rule = selectedRule;
     const confirmed = await confirmDialog(dialog, {
       title: "Delete event alert?",
-      body: [eventAlertTarget(selectedRule)],
+      body: [eventAlertTarget(rule)],
       confirmLabel: "Delete",
     });
-    if (confirmed)
-      setJson((current) => {
-        const result = readEventAlerts(current);
-        return result.error
-          ? current
-          : JSON.stringify(result.rules.filter((rule) => rule.id !== id));
-      });
-  }, [dialog, selectedRule, setJson]);
+    if (confirmed) updateRules(rule, (rules) => rules.filter((entry) => entry.id !== rule.id));
+  }, [dialog, selectedRule, updateRules]);
   const status =
     error ??
     (selectedRule?.kind === "catalyst" ? catalystStatus : null) ??
@@ -192,31 +197,41 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
       sortColumnId={sort.columnId}
       sortDirection={sort.direction}
       onHeaderClick={(id) => setSort((current) => nextHeaderSort(current, id))}
-      renderCell={(rule, column, _index, row) => ({
-        text:
-          column.id === "kind"
-            ? alertKindLabel(rule.kind)
-            : column.id === "last"
-              ? isResearchAlertKind(rule.kind)
-                ? ruleStateText(states.get(rule.id))
-                : ""
-              : column.id === "target"
-              ? ruleTarget(rule)
-              : column.id === "status"
-                ? ruleState(rule, today)
-                : new Date(rule.createdAt).toISOString().slice(0, 10),
-        color: row.selected
-          ? colors.selectedText
-          : rule.status === "paused"
-            ? colors.textMuted
-            : colors.text,
-      })}
+      renderCell={(rule, column, _index, row) => {
+        // An IV level that could not be read says so on its own row: No data in State, the reason in Last check.
+        const check = rule.kind === "iv_level" ? checks[rule.id] : undefined;
+        const unread = rule.kind === "iv_level" && rule.status === "active" && !rule.triggeredAt && check?.value === null;
+        const state = ruleState(rule, now);
+        return {
+          text:
+            column.id === "kind"
+              ? alertKindLabel(rule.kind)
+              : column.id === "last"
+                ? rule.kind === "iv_level"
+                  ? ivLevelCheckText(rule, check)
+                  : isResearchAlertKind(rule.kind)
+                    ? ruleStateText(states.get(rule.id))
+                    : ""
+                : column.id === "target"
+                ? ruleTarget(rule)
+                : column.id === "status"
+                  ? unread ? "No data" : state
+                  : new Date(rule.createdAt).toISOString().slice(0, 10),
+          color: row.selected
+            ? colors.selectedText
+            : unread && (column.id === "status" || column.id === "last")
+              ? colors.negative
+              : rule.status === "paused"
+                ? colors.textMuted
+                : colors.text,
+        };
+      }}
       emptyStateTitle={error ?? "No event alerts"}
       emptyContent={error ? undefined : (
         <PaneStatusBody
           empty
           emptyTitle="No event alerts"
-          emptyMessage="Follow earnings and CPI or FOMC dates, filings, news, members, funds or market moves."
+          emptyMessage="Follow earnings and CPI or FOMC dates, filings, news, IV levels, members, funds or market moves."
           actions={<Button label="Add event alert" compact onPress={add} />}
         />
       )}

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

@@ -2,8 +2,30 @@ import { CATALYST_TYPES } from "../../../api-client/catalysts";
 import { isResearchAlertKind, normalizeResearchRule, type ResearchAlertKind } from "./research-rules";
 import { researchAlertDescription } from "./research-builder";
 export const EVENT_ALERTS_KEY = "eventAlerts";
+/**
+ * IV level rules, kept apart from `eventAlerts`: released versions read every
+ * rule there and refuse the whole list over a kind they do not know, so a rule
+ * synced from a newer app would stop every event alert on a device not yet
+ * updated. They never read this key.
+ */
+export const IV_LEVEL_ALERTS_KEY = "ivLevelAlerts";
+/**
+ * Calendar event rules (any release in the economic calendar), kept apart for
+ * the same reason: a released version refuses the whole `eventAlerts` list
+ * over one. CPI and FOMC stay `macro_event` rules in `eventAlerts`, which
+ * every version reads.
+ */
+export const CALENDAR_ALERTS_KEY = "calendarAlerts";
 export const MAX_EVENT_ALERTS = 40;
 
+/** The config key a rule is kept under. */
+export const eventAlertStoreKey = (rule: Pick<EventAlertRule, "kind">) =>
+  rule.kind === "iv_level" ? IV_LEVEL_ALERTS_KEY : rule.kind === "calendar_event" ? CALENDAR_ALERTS_KEY : EVENT_ALERTS_KEY;
+
+/** Every config key event alerts are kept under. */
+export const EVENT_ALERT_STORE_KEYS = [EVENT_ALERTS_KEY, IV_LEVEL_ALERTS_KEY, CALENDAR_ALERTS_KEY] as const;
+type EventAlertStoreKey = (typeof EVENT_ALERT_STORE_KEYS)[number];
+
 export interface EventAlertRule {
   id: string;
   kind: "congress_trade" | "thirteenf_filing" | "catalyst" | ResearchAlertKind;
@@ -18,14 +40,22 @@ export interface EventAlertRule {
   eventDate?: string;
   /** Scheduled events: the event date it already alerted for. The next event date arms it again. */
   firedFor?: string;
+  /** Macro and calendar events: the event date whose figures (actual, forecast, prior) it already sent. */
+  printedFor?: string;
+  /**
+   * IV level: when the level was reached. The rule stays Alerted until it is
+   * re-armed. Its readings stay on the device (`ivLevelChecks`), so synced
+   * config changes only when a rule goes off or is edited.
+   */
+  triggeredAt?: number;
 }
 
 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. */
+/** Earnings, macro and calendar 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";
+  return rule.kind === "earnings_date" || rule.kind === "macro_event" || rule.kind === "calendar_event";
 }
 
 export const EVENT_ALERT_TEMPLATES = [
@@ -87,11 +117,28 @@ export function createEventAlert(
   };
 }
 
-export function readEventAlerts(json: string): { rules: EventAlertRule[]; error: string | null } {
+/** A saved list of event alerts: the rules this version reads, and the ones of kinds it does not know. */
+export interface EventAlertList {
+  rules: EventAlertRule[];
+  error: string | null;
+  /**
+   * Saved rules of kinds this version does not know (a newer app's), as they
+   * were saved: they are left out of every list and check, and written back
+   * unchanged with the rest.
+   */
+  kept: unknown[];
+}
+
+/** A kind this version reads: a template's, or a research rule's. */
+const isKnownEventAlertKind = (kind: string) =>
+  EVENT_ALERT_TEMPLATES.some((template) => template.kind === kind) || isResearchAlertKind(kind);
+
+export function readEventAlerts(json: string): EventAlertList {
   try {
     const parsed: unknown = JSON.parse(json);
     if (!Array.isArray(parsed)) throw new Error();
     const rules: EventAlertRule[] = [];
+    const kept: unknown[] = [];
     const ids = new Set<string>();
     for (const value of parsed) {
       if (
@@ -102,6 +149,12 @@ export function readEventAlerts(json: string): { rules: EventAlertRule[]; error:
         ids.has(value.id)
       )
         throw new Error();
+      // A newer app's kind is kept as it is, so it neither stops this list nor is lost when it is saved.
+      if (typeof value.kind === "string" && !isKnownEventAlertKind(value.kind)) {
+        kept.push(value);
+        ids.add(value.id);
+        continue;
+      }
       const template = EVENT_ALERT_TEMPLATES.find(
         (entry) => entry.kind === value.kind && entry.target === value.target,
       );
@@ -129,15 +182,64 @@ export function readEventAlerts(json: string): { rules: EventAlertRule[]; error:
       if (isScheduledEventRule(rule)) {
         if (isDateKey(value.eventDate)) rule.eventDate = value.eventDate;
         if (isDateKey(value.firedFor)) rule.firedFor = value.firedFor;
+        if (isDateKey(value.printedFor)) rule.printedFor = value.printedFor;
       }
+      if (rule.kind === "iv_level" && Number.isFinite(value.triggeredAt) && value.triggeredAt > 0) rule.triggeredAt = value.triggeredAt;
       rules.push(rule);
       ids.add(value.id);
     }
-    return { rules, error: null };
+    return { rules, error: null, kept };
   } catch {
     // Intentional ignore: invalid saved rules return the error displayed by callers.
-    return { rules: [], error: "Saved event alerts could not be read." };
+    return { rules: [], error: "Saved event alerts could not be read.", kept: [] };
+  }
+}
+
+/** A list as it is saved: its rules, then the ones of kinds this version does not know, unchanged. */
+function writeEventAlerts(rules: readonly EventAlertRule[], kept: readonly unknown[] = []): string {
+  return JSON.stringify([...rules, ...kept]);
+}
+
+/** A saved list with `update` applied to its rules; a list that does not read is left as it is. */
+export function updateEventAlerts(json: string | null | undefined, update: (rules: EventAlertRule[]) => EventAlertRule[]): string {
+  const current = json ?? "[]";
+  const list = readEventAlerts(current);
+  return list.error ? current : writeEventAlerts(update(list.rules), list.kept);
+}
+
+/** Every saved list, read through `get`: the rules of each, together, and each list as read. */
+export function readEventAlertStores(get: (key: string) => unknown): {
+  rules: EventAlertRule[];
+  error: string | null;
+  lists: Record<EventAlertStoreKey, EventAlertList>;
+} {
+  const read = (key: string) => {
+    const raw = get(key);
+    return readEventAlerts(typeof raw === "string" && raw ? raw : "[]");
+  };
+  const lists = Object.fromEntries(EVENT_ALERT_STORE_KEYS.map((key) => [key, read(key)])) as Record<EventAlertStoreKey, EventAlertList>;
+  const all = Object.values(lists);
+  return { rules: all.flatMap((list) => list.rules), error: all.find((list) => list.error)?.error ?? null, lists };
+}
+
+/**
+ * `rules` saved back to the lists they belong in, each keeping what it held of
+ * kinds this version does not know. Only a list that changes is returned.
+ */
+export function writeEventAlertStores(
+  lists: ReturnType<typeof readEventAlertStores>["lists"],
+  rules: readonly EventAlertRule[],
+): Record<string, string> {
+  const written: Record<string, string> = {};
+  for (const [key, list] of Object.entries(lists)) {
+    // A list that does not read is never written over.
+    if (list.error) continue;
+    const own = rules.filter((rule) => eventAlertStoreKey(rule) === key);
+    const before = list.rules;
+    const same = own.length === before.length && own.every((rule, index) => rule === before[index]);
+    if (!same) written[key] = writeEventAlerts(own, list.kept);
   }
+  return written;
 }
 
 export function toggleEventAlert(rule: EventAlertRule, now = Date.now()): EventAlertRule {

package/src/plugins/builtin/alerts/fired-log.ts

@@ -0,0 +1,78 @@
+import type { PluginResumeState } from "../../../types/plugin";
+import type { QuoteDataSource } from "../../../types/financials";
+
+/**
+ * The alerts this device's app fired, kept on the device (plugin resume
+ * state, never synced): `fn ALRT --tab history` and the History tab read it
+ * signed out, and merge Gloom Cloud's deliveries in when signed in.
+ */
+export const FIRED_LOG_KEY = "firedLog";
+/** The newest entries kept; older ones fall off as new ones are added. */
+export const MAX_FIRED_ALERTS = 1000;
+
+export interface FiredAlert {
+  id: string;
+  /** When the app fired it, ISO. */
+  firedAt: string;
+  /** The rule's kind: `price`, `iv_level`, `earnings_date`, `macro_event`. */
+  kind: string;
+  ruleId: string;
+  /** The rule as it read when it went off: `BTC above 85000`, `IBIT · 30d ATM IV above 50%`. */
+  rule: string;
+  /** The figure that set it off, in `unit`; null for a dated event. */
+  value: number | null;
+  /** `value`'s unit: the quote's currency, `%`, `vol pts`. */
+  unit?: string;
+  /** What the notification said beside the figure, such as an earnings line. */
+  detail?: string;
+  /** When the quote behind `value` was observed, ISO. */
+  quoteAt: string | null;
+  /** How current that quote was: `real-time`, `15 min delayed`. */
+  source: string | null;
+  symbol?: string;
+  exchange?: string;
+}
+
+export type FiredAlertInput = Omit<FiredAlert, "id" | "firedAt"> & { firedAt: number };
+
+/** How current a quote was, in the words reports use. */
+export function quoteSourceWords(source: QuoteDataSource | undefined): string | null {
+  return source === "live" ? "real-time" : source === "delayed" ? "delayed" : source === "snapshot" ? "snapshot" : null;
+}
+
+/** A millisecond time as the log keeps it, ISO; null for none. */
+export function firedAlertTime(value: number | null | undefined): string | null {
+  return value != null && Number.isFinite(value) && value > 0 ? new Date(value).toISOString() : null;
+}
+
+const isText = (value: unknown): value is string => typeof value === "string";
+const optionalText = (value: unknown): value is string | undefined => value === undefined || typeof value === "string";
+
+/** Entries that read, oldest first; anything else in the store is dropped rather than shown wrong. */
+export function readFiredAlerts(value: unknown): FiredAlert[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is FiredAlert => !!entry && typeof entry === "object"
+    && isText(entry.id) && isText(entry.kind) && isText(entry.ruleId) && isText(entry.rule)
+    && isText(entry.firedAt) && Number.isFinite(Date.parse(entry.firedAt))
+    && (entry.value === null || Number.isFinite(entry.value))
+    && (entry.quoteAt === null || isText(entry.quoteAt)) && (entry.source === null || isText(entry.source))
+    && optionalText(entry.unit) && optionalText(entry.detail) && optionalText(entry.symbol) && optionalText(entry.exchange));
+}
+
+/** `entries` with one more at the end, the oldest dropped past the cap. */
+export function appendFiredAlert(entries: readonly FiredAlert[], input: FiredAlertInput, id: string = crypto.randomUUID()): FiredAlert[] {
+  const { firedAt, ...rest } = input;
+  const entry: FiredAlert = { id, firedAt: firedAlertTime(firedAt) ?? new Date().toISOString(), ...rest };
+  return [...entries, entry].slice(-MAX_FIRED_ALERTS);
+}
+
+/** Records a fired alert in the device's log. A log that cannot be written never stops the alert itself. */
+export function createFiredAlertRecorder(resume: Pick<PluginResumeState, "getState" | "setState">, onError: (error: unknown) => void) {
+  return (input: FiredAlertInput) => {
+    try {
+      resume.setState(FIRED_LOG_KEY, appendFiredAlert(readFiredAlerts(resume.getState(FIRED_LOG_KEY)), input));
+    } catch (error) {
+      onError(error);
+    }
+  };
+}

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

@@ -45,8 +45,9 @@ export function formatAlertDistance(alert: AlertRule): string {
   return `${/[1-9]/.test(fixed) ? (percent > 0 ? "+" : "-") : ""}${fixed}%`;
 }
 
+/** The Quote cell: the quote's age and feed, or, on the row of an alert that got none, why (a stale quote, or none). */
 export function formatQuoteChecked(alert: AlertRule): string {
-  if (alert.lastCheckError) return "No quote";
+  if (alert.lastCheckError) return /\bstale\b/i.test(alert.lastCheckError) ? "Stale" : "No quote";
   if (alert.lastQuoteUpdatedAt) {
     return formatQuoteAgeWithSource({
       lastUpdated: alert.lastQuoteUpdatedAt,