@gloom-sh/terminal 0.18.5 → 0.19.0

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

@@ -1,5 +1,5 @@
 import { metricFormInput, metricShortcut, parseMetricAlert } from "./metric-command";
-import type { AlertMetric } from "./metric-model";
+import { isRelativeMetric, type AlertMetric } from "./metric-model";
 import type { AlertCondition } from "./types";
 import { readAlertPrice } from "./price";
 import { normalizeAlertSymbol } from "./quotes";
@@ -86,3 +86,27 @@ export function parseAlertCommandValues(
   if (!symbol || !condition || !priceStr) return null;
   return { symbol, condition, price: readAlertPrice(priceStr.replace(/^\$/, "")) };
 }
+
+/**
+ * The edit dialog's text read against the alert it changes. An edit keeps the alert in its kind and its synced list:
+ * price stays price, a valuation or technical measure stays one, and a ratio or RRG alert keeps its listings.
+ */
+export function parseAlertEdit(
+  selected: { symbol: string; metric?: AlertMetric },
+  value: string,
+): AlertCommandInput {
+  const parsed = parseAlertCommandValues({ shortcut: value });
+  if (!parsed) throw new Error("Use SYMBOL above|below|crosses PRICE.");
+  if (!!parsed.metric !== !!selected.metric) throw new Error("Add a new alert to change between price and a valuation or technical measure.");
+  if (!parsed.metric || !selected.metric) return parsed;
+  if (isRelativeMetric(parsed.metric) !== isRelativeMetric(selected.metric)) {
+    throw new Error("Add a new alert to change between a relative strength alert and a valuation or technical measure.");
+  }
+  if (!isRelativeMetric(selected.metric)) return parsed;
+  // The benchmark listing was confirmed when the alert was added; a different pair is a new alert.
+  if (parsed.metric.kind !== selected.metric.kind || parsed.symbol !== selected.symbol || !isRelativeMetric(parsed.metric)
+    || parsed.metric.benchmark !== selected.metric.benchmark) {
+    throw new Error("Add a new alert to compare other listings.");
+  }
+  return { ...parsed, metric: { ...parsed.metric, benchmarkExchange: selected.metric.benchmarkExchange } };
+}

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

@@ -36,6 +36,8 @@ 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";
+import { FIRED_LOG_KEY } from "./fired-log";
+import { withAlertChange } from "./alert-log";
 
 const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
   { id: "kind", label: "Event", width: 15, align: "left" },
@@ -59,6 +61,8 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
   );
   // Their readings stay on this device.
   const [savedChecks] = usePluginState<unknown>(IV_LEVEL_CHECKS_KEY, {});
+  // Deleting or re-arming a rule goes in this device's alert log, beside the alerts that fired.
+  const [, setAlertLog] = usePluginState<unknown>(FIRED_LOG_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(
@@ -123,11 +127,20 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
     (rule: EventAlertRule | undefined) => {
       if (!rule) return;
       const ivLevel = rule.kind === "iv_level";
-      updateRules(rule, (rules) => rules.map((entry) => (entry.id === rule.id ? ivLevel ? rearmIvLevelAlert(entry) : rearmScheduledAlert(entry) : entry)));
+      const now = Date.now();
+      // Only a rule that went off is re-armed, as the list reads at the write: one still waiting is left, and not logged.
+      const rearmed: EventAlertRule[] = [];
+      updateRules(rule, (rules) => rules.map((entry) => {
+        if (entry.id !== rule.id || ruleState(entry, now) !== "Alerted") return entry;
+        rearmed.push(entry);
+        return ivLevel ? rearmIvLevelAlert(entry) : rearmScheduledAlert(entry);
+      }));
+      if (!rearmed.length) return;
+      for (const entry of rearmed) setAlertLog((saved: unknown) => withAlertChange(saved, "rearmed", entry));
       // Once the write has landed, so it alerts now rather than at the next 15-minute check.
       setTimeout(ivLevel ? checkIvLevelAlertsNow : checkScheduledEventAlertsNow, 1_000);
     },
-    [updateRules],
+    [setAlertLog, updateRules],
   );
   const remove = useCallback(async () => {
     if (!selectedRule) return;
@@ -137,8 +150,10 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
       body: [eventAlertTarget(rule)],
       confirmLabel: "Delete",
     });
-    if (confirmed) updateRules(rule, (rules) => rules.filter((entry) => entry.id !== rule.id));
-  }, [dialog, selectedRule, updateRules]);
+    if (!confirmed) return;
+    updateRules(rule, (rules) => rules.filter((entry) => entry.id !== rule.id));
+    setAlertLog((saved: unknown) => withAlertChange(saved, "deleted", rule));
+  }, [dialog, selectedRule, setAlertLog, updateRules]);
   const status =
     error ??
     (selectedRule?.kind === "catalyst" ? catalystStatus : null) ??

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

@@ -5,11 +5,19 @@ import { ALERTS_PLUGIN_ID } from "./constants";
 /**
  * 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.
+ * signed out, and merge Gloom Cloud's deliveries in when signed in. Beside
+ * them it keeps when a rule was created, re-armed or deleted here, from the
+ * app or `gloom alerts` (`action`).
  */
 export const FIRED_LOG_KEY = "firedLog";
-/** The newest entries kept; older ones fall off as new ones are added. */
+/** The newest fired alerts kept; older ones fall off as new ones are added. */
 export const MAX_FIRED_ALERTS = 1000;
+/**
+ * The newest rule changes (created, re-armed, deleted) kept, apart from the
+ * fired alerts: a change never counts against them, so no number of changes
+ * pushes an alert that went off out of the log.
+ */
+export const MAX_ALERT_CHANGES = 200;
 
 export interface FiredAlert {
   id: string;
@@ -32,10 +40,30 @@ export interface FiredAlert {
   source: string | null;
   symbol?: string;
   exchange?: string;
+  /** A change to the rule rather than the alert going off: created, re-armed or deleted. */
+  action?: AlertLogAction;
 }
 
 export type FiredAlertInput = Omit<FiredAlert, "id" | "firedAt"> & { firedAt: number };
 
+const ALERT_LOG_ACTIONS = ["created", "rearmed", "deleted"] as const;
+export type AlertLogAction = (typeof ALERT_LOG_ACTIONS)[number];
+/** What History says of a change, in its Value column. */
+const ALERT_LOG_ACTION_TEXT: Record<AlertLogAction, string> = { created: "Created", rearmed: "Re-armed", deleted: "Deleted" };
+
+/** A change to a rule as the log keeps it: when, what was done, and the rule as it read. */
+export function alertChangeEntry(
+  action: AlertLogAction,
+  rule: { kind: string; ruleId: string; rule: string; symbol?: string; exchange?: string },
+  at = Date.now(),
+): FiredAlertInput {
+  return {
+    kind: rule.kind, ruleId: rule.ruleId, rule: rule.rule, firedAt: at, value: null, quoteAt: null, source: null, action,
+    detail: ALERT_LOG_ACTION_TEXT[action],
+    ...(rule.symbol ? { symbol: rule.symbol } : {}), ...(rule.exchange ? { exchange: rule.exchange } : {}),
+  };
+}
+
 /** 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;
@@ -57,7 +85,8 @@ export function readFiredAlerts(value: unknown): FiredAlert[] {
     && 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));
+    && optionalText(entry.unit) && optionalText(entry.detail) && optionalText(entry.symbol) && optionalText(entry.exchange)
+    && (entry.action === undefined || ALERT_LOG_ACTIONS.includes(entry.action)));
 }
 
 function firedAlertEntry(input: FiredAlertInput, id: string = crypto.randomUUID()): FiredAlert {
@@ -65,19 +94,39 @@ function firedAlertEntry(input: FiredAlertInput, id: string = crypto.randomUUID(
   return { id, firedAt: firedAlertTime(firedAt) ?? new Date().toISOString(), ...rest };
 }
 
-/** `entries` with one more at the end, the oldest dropped past the cap. */
+/**
+ * The log within its caps, oldest first: the newest MAX_FIRED_ALERTS fired
+ * alerts and, counted apart, the newest MAX_ALERT_CHANGES rule changes. Each
+ * kind of entry only ever drops its own oldest.
+ */
+function capAlertLog(entries: readonly FiredAlert[]): FiredAlert[] {
+  let changes = entries.reduce((count, entry) => count + (entry.action ? 1 : 0), 0);
+  let fired = entries.length - changes;
+  changes -= MAX_ALERT_CHANGES;
+  fired -= MAX_FIRED_ALERTS;
+  if (changes <= 0 && fired <= 0) return [...entries];
+  return entries.filter((entry) => {
+    if (entry.action ? changes <= 0 : fired <= 0) return true;
+    if (entry.action) changes -= 1;
+    else fired -= 1;
+    return false;
+  });
+}
+
+/** `entries` with one more at the end, the oldest of its kind (fired alert or rule change) dropped past its cap. */
 export function appendFiredAlert(entries: readonly FiredAlert[], input: FiredAlertInput, id: string = crypto.randomUUID()): FiredAlert[] {
-  return [...entries, firedAlertEntry(input, id)].slice(-MAX_FIRED_ALERTS);
+  return capAlertLog([...entries, firedAlertEntry(input, id)]);
 }
 
-/** `entries` keeping only the newest `max` of each kind in `kinds`; other kinds are untouched. */
+/** `entries` keeping only the newest `max` fired alerts of each kind in `kinds`; other kinds and rule changes are untouched. */
 function capFiredAlertKinds(entries: readonly FiredAlert[], kinds: ReadonlySet<string>, max: number): FiredAlert[] {
+  const counted = (entry: FiredAlert) => !entry.action && kinds.has(entry.kind);
   const over = new Map<string, number>();
-  for (const entry of entries) if (kinds.has(entry.kind)) over.set(entry.kind, (over.get(entry.kind) ?? 0) + 1);
+  for (const entry of entries) if (counted(entry)) over.set(entry.kind, (over.get(entry.kind) ?? 0) + 1);
   for (const [kind, count] of over) over.set(kind, count - max);
   // Oldest first: the first entries of a kind over its cap are the ones to drop.
   return entries.filter((entry) => {
-    const extra = over.get(entry.kind) ?? 0;
+    const extra = counted(entry) ? over.get(entry.kind) ?? 0 : 0;
     if (extra <= 0) return true;
     over.set(entry.kind, extra - 1);
     return false;
@@ -101,12 +150,27 @@ export function recordFiredAlertFor(
     let entries = [...readFiredAlerts(runtime.getResumeState(ALERTS_PLUGIN_ID, FIRED_LOG_KEY)), ...inputs.map((input) => firedAlertEntry(input))];
     // The source's own oldest entries go first, before the log's cap reaches anyone else's.
     if (keepAtMost != null) entries = capFiredAlertKinds(entries, new Set(inputs.map((input) => input.kind)), keepAtMost);
-    runtime.setResumeState(ALERTS_PLUGIN_ID, FIRED_LOG_KEY, entries.slice(-MAX_FIRED_ALERTS));
+    runtime.setResumeState(ALERTS_PLUGIN_ID, FIRED_LOG_KEY, capAlertLog(entries));
   } catch (error) {
     onError(error);
   }
 }
 
+/**
+ * Adds entries to the device's log through the plugin's saved state as the
+ * shell reads and writes it (`gloom alerts`), where there is no running
+ * plugin to record them.
+ */
+export function appendAlertLog(
+  state: { get(key: string): unknown; set(key: string, value: unknown): void },
+  inputs: readonly FiredAlertInput[],
+): void {
+  if (!inputs.length) return;
+  let entries = readFiredAlerts(state.get(FIRED_LOG_KEY));
+  for (const input of inputs) entries = appendFiredAlert(entries, input);
+  state.set(FIRED_LOG_KEY, entries);
+}
+
 /** 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) => {

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

@@ -1,8 +1,12 @@
-import { isDailyMetric } from "./metric-model";
+import { closeBasis, metricReadingText, rotationQuadrant } from "./metric-model";
 import { formatMarketPrice } from "../../../market-data/market/format";
+import { formatShortDate } from "../../../utils/datetime-format";
 import { formatQuoteAgeWithSource } from "../../../market-data/quotes/time";
 import type { AlertCondition, AlertRule } from "./types";
 
+/** What a list says of an alert no check has read yet. */
+export const NOT_CHECKED_YET = "not checked yet";
+
 export function relativeTime(ts: number): string {
   const diff = Date.now() - ts;
   const seconds = Math.floor(diff / 1000);
@@ -15,10 +19,16 @@ export function relativeTime(ts: number): string {
   return `${days}d ago`;
 }
 
+/** A price ratio to four decimals, as GR states the latest ratio. */
+const formatRatio = (value: number) => value.toFixed(Math.abs(value) >= 100 ? 2 : 4);
+
 export function formatCurrentPrice(alert: AlertRule, maxWidth = 9): string {
   if (alert.lastCheckError) return !alert.metric ? "No quote"
     : /US listing|US equities|calendar/.test(alert.lastCheckError) ? "US only"
-    : /missing|bars|history/i.test(alert.lastCheckError) ? "Bar gap" : "No data";
+    : /missing|bars|history|weekly closes/i.test(alert.lastCheckError) ? "Bar gap" : "No data";
+  // The quadrant the latest weekly strength and momentum place it in.
+  if (alert.metric?.kind === "rrg") return rotationQuadrant(alert.lastCheckedPrice, alert.lastCheckedTarget) ?? "-";
+  if (alert.metric?.kind === "rs_ratio" && alert.lastCheckedPrice != null) return formatRatio(alert.lastCheckedPrice);
   return alert.lastCheckedPrice == null
     ? "-"
     : formatMarketPrice(alert.lastCheckedPrice, {
@@ -30,6 +40,8 @@ export function formatCurrentPrice(alert: AlertRule, maxWidth = 9): string {
 export function formatAlertTargetPrice(alert: AlertRule, maxWidth = 9): string {
   if (alert.metric?.kind === "ma_cross") return `${alert.metric.slowPeriod}-day MA`;
   if (alert.metric?.kind === "close_ma") return `${alert.metric.period}-day MA`;
+  if (alert.metric?.kind === "rrg") return `${alert.metric.quadrant[0]!.toUpperCase()}${alert.metric.quadrant.slice(1)}`;
+  if (alert.metric?.kind === "rs_ratio") return formatRatio(alert.targetPrice);
   return formatMarketPrice(alert.targetPrice, {
     maxWidth,
     minimumFractionDigits: 2,
@@ -38,7 +50,7 @@ export function formatAlertTargetPrice(alert: AlertRule, maxWidth = 9): string {
 
 export function formatAlertDistance(alert: AlertRule): string {
   const currentPrice = alert.lastCheckedPrice;
-  if (alert.lastCheckError) return "-";
+  if (alert.lastCheckError || alert.metric?.kind === "rrg") return "-";
   if (currentPrice == null || !Number.isFinite(currentPrice) || currentPrice === 0) {
     return "-";
   }
@@ -52,7 +64,12 @@ export function formatAlertDistance(alert: AlertRule): string {
 
 /** 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.metric && isDailyMetric(alert.metric)) return "on daily close";
+  const basis = alert.metric ? closeBasis(alert.metric) : null;
+  // A settled close reads as the session it is from: Oct 26 close, Oct 23 weekly.
+  if (basis && alert.lastDailyClose && !alert.lastCheckError) {
+    return `${formatShortDate(alert.lastDailyClose, { year: false, utc: true })} ${basis === "weekly close" ? "weekly" : "close"}`;
+  }
+  if (basis) return `on ${basis}`;
   if (alert.lastCheckError) return /\bstale\b/i.test(alert.lastCheckError) ? "Stale" : "No quote";
   if (alert.lastQuoteUpdatedAt) {
     return formatQuoteAgeWithSource({
@@ -61,7 +78,60 @@ export function formatQuoteChecked(alert: AlertRule): string {
     });
   }
   if (alert.lastCheckedAt) return relativeTime(alert.lastCheckedAt);
-  return "-";
+  return NOT_CHECKED_YET;
+}
+
+/** A time as lists and exports give it: ISO 8601 in UTC, to the second (2026-10-27T06:35:12Z); empty for none. */
+export function isoUtc(value: number | null | undefined): string {
+  return value != null && Number.isFinite(value) && value > 0 ? new Date(value).toISOString().replace(/\.\d{3}Z$/, "Z") : "";
+}
+
+/**
+ * The listing an alert is checked on: `EWG:ARCA`, its own exchange, or the
+ * venue its last quote came from for a rule set by symbol alone; the symbol
+ * until it has been checked.
+ */
+export function alertListing(alert: Pick<AlertRule, "symbol" | "exchange" | "lastQuoteExchange">): string {
+  const venue = alert.exchange || alert.lastQuoteExchange;
+  return venue && !alert.symbol.includes(":") ? `${alert.symbol}:${venue}` : alert.symbol;
+}
+
+/** A listing with the currency its prices are in: `EWG:ARCA (USD)`; the listing alone until a quote has said it. */
+export function listingWithCurrency(listing: string, currency: string | null | undefined): string {
+  return currency ? `${listing} (${currency})` : listing;
+}
+
+/** The unit of an alert's reading: the listing's currency for a price or an average, `x` for a multiple, none for RSI. */
+function readingUnit(alert: AlertRule): string {
+  const kind = alert.metric?.kind;
+  if (kind === "pe" || kind === "ps") return "x";
+  if (kind === "rsi" || kind === "rs_ratio" || kind === "rrg") return "";
+  return alert.lastQuoteCurrency ?? "";
+}
+
+/** When the last reading is from: the quote's own time, or the daily close's; null with none. */
+export function alertReadingAt(alert: AlertRule): number | null {
+  if (alert.lastCheckError || alert.lastCheckedPrice == null) return null;
+  return alert.lastQuoteUpdatedAt ?? alert.lastCheckedAt ?? null;
+}
+
+/**
+ * The last reading an alert was checked on, with its unit and when it is
+ * from: `37.12 USD as of 2026-10-27T14:31Z`, `61.23 on the 2026-10-26 close`
+ * for a daily rule, why the last check read nothing, or `not checked yet`.
+ */
+export function alertReadingText(alert: AlertRule): string {
+  if (alert.lastCheckError) return `no reading: ${alert.lastCheckError.replace(/\.$/, "")}`;
+  const value = alert.lastCheckedPrice;
+  if (value == null || !Number.isFinite(value)) return NOT_CHECKED_YET;
+  const unit = readingUnit(alert);
+  const figure = alert.metric?.kind === "rrg" ? metricReadingText(alert.metric, { value, target: alert.lastCheckedTarget ?? Number.NaN })
+    : alert.metric?.kind === "rs_ratio" ? formatRatio(value)
+    : `${alert.metric ? value.toFixed(2) : String(value)}${unit === "x" ? "x" : unit ? ` ${unit}` : ""}`;
+  const basis = alert.metric ? closeBasis(alert.metric) : null;
+  if (basis && alert.lastDailyClose) return `${figure} on the ${alert.lastDailyClose} ${basis === "weekly close" ? "weekly close" : "close"}`;
+  const at = alertReadingAt(alert);
+  return at ? `${figure} as of ${isoUtc(at).replace(/:\d{2}Z$/, "Z")}` : figure;
 }
 
 export function conditionLabel(condition: AlertCondition): string {

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

@@ -1,4 +1,4 @@
-import { isDailyMetric, metricName } from "./metric-model";
+import { closeBasis, metricName, metricReadingText } from "./metric-model";
 /**
  * `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,
@@ -13,6 +13,8 @@ import { ALERT_TABS, ALERTS_PLUGIN_ID } from "./constants";
 import { ruleState } from "./event-rows";
 import { eventAlertTarget, type EventAlertRule } from "./events";
 import {
+  alertListing,
+  isoUtc,
   conditionLabel,
   formatAlertDistance,
   formatAlertTargetPrice,
@@ -54,15 +56,26 @@ const PRICE_COLUMNS: HeadlessPaneColumn[] = [
   { key: "awayPercent", header: "Away", align: "right", format: percent, textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
   { key: "condition", header: "Trigger", format: (value, row) => {
     const metric = asAlert(row).metric;
-    return metric?.kind === "ma_cross" ? `Cross ${metric.direction}` : conditionLabel(value as AlertRule["condition"]);
+    return metric?.kind === "ma_cross" ? `Cross ${metric.direction}` : metric?.kind === "rrg" ? "Enters" : conditionLabel(value as AlertRule["condition"]);
   } },
   { 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) : "-") },
+  // After the columns exports have always had: when the rule was made, and the currency of its listing.
+  // To the second, as `alerts list` and the pane's detail write it: exports draw a stored millisecond time to the millisecond.
+  { key: "created", header: "Created" },
+  { key: "listing", header: "Listing" },
+  { key: "currency", header: "Currency" },
+  // A measure's last reading in words, last so the columns before it keep their places: an RRG quadrant with the strength and momentum that place it.
+  { key: "reading", header: "Reading" },
 ];
 /** 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 PRICE_TEXT_COLUMNS: HeadlessPaneColumn[] = [
+  ...PRICE_COLUMNS.filter((column) => !["quoteSource", "lastCheckedAt", "created", "listing", "currency", "reading"].includes(column.key)),
+  // The day it was made, as the Events table lists its rules.
+  { key: "createdAt", header: "Since", textFormat: (value) => (typeof value === "number" ? isoUtc(value).slice(0, 10) : "") },
+];
 
 const EVENT_COLUMNS: HeadlessPaneColumn[] = [
   { key: "event", header: "Event" },
@@ -98,13 +111,18 @@ const HISTORY_TEXT_COLUMNS = HISTORY_COLUMNS.filter((column) => column.key !== "
 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.lastCheckedTarget ?? alert.targetPrice) - price) / price) * 100;
+  const away = price == null || !Number.isFinite(price) || price === 0 || alert.metric?.kind === "rrg" ? null : (((alert.lastCheckedTarget ?? alert.targetPrice) - price) / price) * 100;
   const quoted = !alert.lastCheckError;
+  const target = alert.lastCheckedTarget ?? alert.targetPrice;
   return {
     ...stored,
     awayPercent: away != null && Number.isFinite(away) ? Number(away.toFixed(2)) : null,
     quoteAt: quoted ? firedAlertTime(alert.lastQuoteUpdatedAt) : null,
-    quoteSource: quoted ? alert.metric && isDailyMetric(alert.metric) ? "daily close" : quoteSourceWords(alert.lastQuoteSource) : null,
+    quoteSource: quoted ? alert.metric && closeBasis(alert.metric) || quoteSourceWords(alert.lastQuoteSource) : null,
+    created: isoUtc(alert.createdAt) || null,
+    listing: alertListing(alert),
+    currency: alert.lastQuoteCurrency ?? null,
+    reading: alert.metric && price != null && Number.isFinite(price) && Number.isFinite(target) ? metricReadingText(alert.metric, { value: price, target }) : null,
   };
 }
 
@@ -234,7 +252,7 @@ export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
   discovery: {
     screenshotReadiness: "live-dom",
     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."],
+    limitations: ["Current price and quote time are what the app or `gloom alerts add` saved at the last check; an alert neither has read says not checked yet."],
   },
   describe: (args) => `Alerts | ${String(args.options.tab ?? "prices")}`,
   async load(args, ctx) {

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

@@ -44,10 +44,11 @@ const upper = (value: unknown) => (typeof value === "string" && value ? value.to
  * symbol, within the time the two take to send it.
  */
 function sameAlert(entry: FiredAlert, item: AlertHistoryItem): boolean {
-  if (item.kind !== entry.kind) return false;
+  // A rule created, re-armed or deleted here is no delivery.
+  if (entry.action || 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" || ["pe", "ps", "rsi", "ma_cross", "close_ma"].includes(entry.kind)) return item.data?.alertId === entry.ruleId && apart <= PRICE_MATCH_MS;
+  if (entry.kind === "price" || ["pe", "ps", "rsi", "ma_cross", "close_ma", "rs_ratio", "rrg"].includes(entry.kind)) 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;
 }

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

@@ -38,7 +38,7 @@ export interface AlertHistory {
 const KIND_LABELS: Record<string, string> = {
   catalyst: "Catalyst",
   price: "Price",
-  pe: "P/E", ps: "P/S", rsi: "RSI", ma_cross: "MA crossover", close_ma: "Close vs MA",
+  pe: "P/E", ps: "P/S", rsi: "RSI", ma_cross: "MA crossover", close_ma: "Close vs MA", rs_ratio: "Ratio", rrg: "RRG quadrant",
   breaking_news: "Breaking news",
   earnings: "Earnings",
   chat: "Chat",

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

@@ -1,9 +1,11 @@
-import { METRIC_CHOICES, metricWizardFields } from "./metric-command";
-import { metricReadings } from "./metric-data";
-import { metricTrigger, isDailyMetric, type MetricReading } from "./metric-model";
+import { METRIC_CHOICES, benchmarkKey, metricWizardFields, parseMetricAlert } from "./metric-command";
+import { firstDailyCheck, metricAvailabilityError, metricReadings } from "./metric-data";
+import { alertLogRule } from "./alert-log";
+import { closeBasis, isDailyMetric, isRelativeMetric, metricReadingText, metricTrigger, validMetricRule, type MetricReading } from "./metric-model";
+import { canonicalExchange } from "../../../utils/exchanges";
 import { startCatalystAlerts } from "./catalysts";
 import { notTheCoinNote } from "../../../cli/commands/crypto-hints";
-import { createFiredAlertRecorder, firedAlertTime, quoteSourceWords } from "./fired-log";
+import { alertChangeEntry, createFiredAlertRecorder, firedAlertTime, quoteSourceWords } from "./fired-log";
 import { checkIvLevelAlertsNow, startIvLevelAlerts } from "./iv-level";
 import { logFailure } from "../../../utils/log-failure";
 import { RESEARCH_FORM_KINDS, RESEARCH_LABELS, researchWizardFields, createResearchAlert } from "./research-builder";
@@ -22,12 +24,15 @@ import { isResearchAlertKind, MAX_LEAD_DAYS } from "./research-rules";
 import { EVENT_ALERT_TEMPLATES, MAX_EVENT_ALERTS, createEventAlert, eventAlertStoreKey, readEventAlertStores, updateEventAlerts } from "./events";
 import { formatMarketPrice } from "../../../market-data/market/format";
 import { settleTypedListingKey } from "../../../tickers/listing-venues";
+import { parseListingArg } from "../../../cli/listing-arg";
+import { notATickerSymbol } from "../../../sources/provider-errors";
 import type { Quote } from "../../../types/financials";
 import type { GloomPlugin } from "../../../types/plugin";
 import {
   createAlert,
   evaluateAlert,
   formatAlertDescription,
+  sameLevelRule,
 } from "./alert-engine";
 import {
   parseAlertCommandValues,
@@ -65,6 +70,16 @@ let alertStream: AlertQuoteStream | null = null;
  */
 const STREAM_PERSIST_MS = 60_000;
 
+/** BTC/USD, BRK/B and EUR/USD are one listing written with a slash, as `alerts add` reads them; XLK/SPY is not. */
+function slashSpellsListing(symbol: string): boolean {
+  try {
+    return parseListingArg(symbol).key !== symbol.toUpperCase();
+  } catch {
+    // Intentional ignore: text the listing reader refuses is no pair to divide, so the quote's own error stands.
+    return true;
+  }
+}
+
 export const alertsPlugin: GloomPlugin = {
   id: "alerts",
   name: "Alerts",
@@ -186,31 +201,75 @@ export const alertsPlugin: GloomPlugin = {
         ...metricWizardFields,
       ],
       async execute(values) {
-        const input = parseAlertCommandValues(values);
+        let input = parseAlertCommandValues(values);
         if (!input) throw new Error("Use a symbol, condition, and target price.");
         // 7203:TSE, typed or from a link, is the venue its symbol trades on, as `alerts add` reads it.
-        const symbol = (await settleTypedListingKey(input.symbol, { store: ctx.tickerRepository, dataProvider: ctx.marketData })).toUpperCase();
-
-        const quote = await resolveAlertQuote(ctx.marketData, symbol);
+        const quoteFor = async (typed: string) => {
+          const key = (await settleTypedListingKey(typed, { store: ctx.tickerRepository, dataProvider: ctx.marketData })).toUpperCase();
+          return { key, quote: await resolveAlertQuote(ctx.marketData, key) };
+        };
+        let resolved: Awaited<ReturnType<typeof quoteFor>>;
+        try {
+          resolved = await quoteFor(input.symbol);
+        } catch (error) {
+          // XLK/SPY is a listing first; only one the service says is no ticker is the ratio of the two, as `alerts add` reads it.
+          // A timeout stays a timeout, and BTC/USD, BRK/B or EUR/USD, one listing written with a slash, keeps its own answer.
+          const pair = !input.metric && /^[^/\s]+\/[^/\s]+$/.test(input.symbol) && notATickerSymbol(error instanceof Error ? error.message : String(error))
+            && !slashSpellsListing(input.symbol) ? parseMetricAlert(`${input.symbol} ratio ${input.condition} ${input.price}`) : null;
+          if (!pair) throw error;
+          input = pair;
+          resolved = await quoteFor(pair.symbol);
+        }
+        const { key: symbol, quote } = resolved;
+        let metric = input.metric;
+        if (metric && isRelativeMetric(metric)) {
+          const reference = (await quoteFor(benchmarkKey(metric))).quote;
+          const benchmarkExchange = canonicalExchange(reference.listingExchangeName || reference.exchangeName || "");
+          const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName || "");
+          const benchmark = reference.symbol || metric.benchmark;
+          if (benchmark === (quote.symbol || symbol) && benchmarkExchange === exchange) throw new Error(`Compare ${benchmark} with another listing.`);
+          metric = { ...metric, benchmark, ...(benchmarkExchange ? { benchmarkExchange } : {}) };
+          // Never save a rule its own list would refuse to read back.
+          if (!validMetricRule({ metric, condition: input.condition, targetPrice: input.price })) throw new Error(`${benchmark} cannot be a benchmark: relative strength alerts compare two US listings.`);
+        }
         // A target ten times away is a slip or another instrument's price, such as bitcoin's on the BTC fund.
         const far = farTargetMessage(symbol, input.price, quote.price, symbol.includes(":") ? null : notTheCoinNote(symbol, quote));
         if (!input.metric && far) throw new Error(far);
 
-        const alert = {
+        const alert: AlertRule = {
           ...createAlert(quote.symbol || symbol, input.condition, input.price),
-          ...(!input.metric ? quoteAlertFields(quote) : { metric: input.metric, exchange: quote.listingExchangeName || quote.exchangeName }),
+          ...(!metric ? quoteAlertFields(quote) : {
+            metric, exchange: quote.listingExchangeName || quote.exchangeName,
+            ...quote.currency ? { lastQuoteCurrency: quote.currency } : {},
+          }),
         };
-        if (input.metric) {
-          const reading = await metricReadings(ctx.marketData)(alert);
-          Object.assign(alert, { lastCheckedPrice: reading.value, lastCheckedTarget: reading.target, lastQuoteUpdatedAt: reading.at });
+        // A close not yet final is read once it is: the rule is kept and says when it is first judged.
+        let firstCheck: string | null = null;
+        if (metric) {
+          const now = Date.now();
+          if (isDailyMetric(metric)) {
+            const check = firstDailyCheck(alert.exchange, now, metric.kind === "rrg");
+            if (check) firstCheck = `first checked on the ${check.day} ${closeBasis(metric) === "weekly close" ? "weekly close" : "close"}, from ${new Date(check.at).toISOString().slice(11, 16)} UTC`;
+          }
+          try {
+            const reading = await metricReadings(ctx.marketData, now)(alert);
+            Object.assign(alert, { lastCheckedPrice: reading.value, lastCheckedTarget: reading.target, lastQuoteUpdatedAt: reading.at,
+              lastCheckedAt: now, ...reading.day ? { lastDailyClose: reading.day } : {} });
+          } catch (error) {
+            if (!isDailyMetric(metric) || metricAvailabilityError(alert)) throw error;
+          }
         }
         const existing = loadAlerts(ctx);
+        // The same rule on the same listing is one alert: adding it again names it and adds nothing.
+        const duplicate = existing.find((entry) => sameLevelRule(entry, alert));
+        if (duplicate) throw new Error(`${formatAlertDescription(alert)} already exists (alert ${duplicate.id}). Nothing was added.`);
         existing.push(alert);
         await saveAlerts(ctx, existing, input.metric ? "metric" : "price");
+        recordFired(alertChangeEntry("created", alertLogRule(alert)));
         alertStream?.sync();
 
         ctx.notify({
-          body: `Alert set: ${formatAlertDescription(alert)}${input.metric ? "" : ` (current ${formatMarketPrice(quote.price, { minimumFractionDigits: 2 })})`}`,
+          body: `Alert set: ${formatAlertDescription(alert)}${input.metric ? firstCheck ? `, ${firstCheck}` : "" : ` (current ${formatMarketPrice(quote.price, { minimumFractionDigits: 2 })})`}`,
           type: "success",
         });
       },
@@ -281,6 +340,7 @@ export const alertsPlugin: GloomPlugin = {
         // An IV level goes in its own list, which released versions never read.
         const key = eventAlertStoreKey(rule);
         await ctx.configState.set(key, updateEventAlerts(ctx.configState.get<string>(key), (rules) => [...rules, rule]));
+        recordFired(alertChangeEntry("created", alertLogRule(rule)));
         ctx.notify({ body: "Event alert saved.", type: "success" });
         if (scheduled) checkScheduledEventAlertsNow();
         if (rule.kind === "iv_level") checkIvLevelAlertsNow();
@@ -335,11 +395,14 @@ export const alertsPlugin: GloomPlugin = {
               const firedAt = Date.now();
               alert.status = "triggered"; alert.triggeredAt = firedAt;
               const description = formatAlertDescription(alert);
+              const readingText = metricReadingText(alert.metric, reading);
               recordFired({ kind: alert.metric.kind, ruleId: alert.id, rule: description, firedAt, value: reading.value,
                 unit: alert.metric.kind === "pe" || alert.metric.kind === "ps" ? "x" : undefined,
-                quoteAt: firedAlertTime(reading.at), source: isDailyMetric(alert.metric) ? "daily close" : null,
+                // An RRG quadrant is two readings; the figure is strength, the detail says both.
+                ...(alert.metric.kind === "rrg" ? { detail: readingText } : {}),
+                quoteAt: firedAlertTime(reading.at), source: closeBasis(alert.metric),
                 symbol: alert.symbol, exchange: alert.exchange });
-              ctx.notify({ body: `${description} triggered at ${Number(reading.value.toFixed(4))}`, type: "success",
+              ctx.notify({ body: alert.metric.kind === "rrg" ? `${description} triggered: ${readingText}` : `${description} triggered at ${readingText}`, type: "success",
                 refId: `price:${alert.id}`, desktop: "always", persistent: true, sound: "Glass",
                 action: { label: "Open", onClick: () => ctx.showPane("alerts") } });
             }