gloomberb 0.18.4 → 0.19.0

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

@@ -1,3 +1,5 @@
+import { metricFormInput, metricShortcut, parseMetricAlert } from "./metric-command";
+import { isRelativeMetric, type AlertMetric } from "./metric-model";
 import type { AlertCondition } from "./types";
 import { readAlertPrice } from "./price";
 import { normalizeAlertSymbol } from "./quotes";
@@ -6,6 +8,7 @@ export interface AlertCommandInput {
   symbol: string;
   condition: AlertCondition;
   price: number;
+  metric?: AlertMetric;
 }
 
 function parseAlertCondition(value: string | undefined): AlertCondition | null {
@@ -34,6 +37,8 @@ export function parseAlertShortcutValues(
   input: string,
   context?: { activeTicker: string | null },
 ): Record<string, string> {
+  const metric = parseMetricAlert(input);
+  if (metric) return metricShortcut(metric);
   const parts = input.trim().split(/\s+/).filter(Boolean);
   if (parts.length === 0) {
     const activeTicker = normalizeAlertSymbol(context?.activeTicker);
@@ -73,9 +78,35 @@ export function parseAlertCommandValues(
     };
   }
 
+  const metric = values ? metricFormInput(values) : null;
+  if (metric) return metric;
   const symbol = values?.symbol?.trim().toUpperCase();
   const condition = parseAlertCondition(values?.condition);
   const priceStr = values?.price?.trim();
   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/constants.ts

@@ -3,7 +3,7 @@ export const ALERTS_KEY = "alerts";
 
 /** The Alerts pane's tabs: what `ALRT --tab` takes, and the pane state `tab` holds. */
 export const ALERT_TABS = [
-  { label: "Prices", value: "prices" },
+  { label: "Levels", value: "prices" },
   { label: "Events", value: "events" },
   { label: "History", value: "history" },
 ];

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

@@ -1,20 +1,29 @@
 import type { PluginResumeState } from "../../../types/plugin";
 import type { QuoteDataSource } from "../../../types/financials";
+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;
   /** When the app fired it, ISO. */
   firedAt: string;
-  /** The rule's kind: `price`, `iv_level`, `earnings_date`, `macro_event`. */
+  /** The rule's kind: `price`, `iv_level`, `earnings_date`, `macro_event`, `live_scan`. */
   kind: string;
   ruleId: string;
   /** The rule as it read when it went off: `BTC above 85000`, `IBIT · 30d ATM IV above 50%`. */
@@ -31,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;
@@ -56,14 +85,90 @@ 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)));
 }
 
-/** `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[] {
+function firedAlertEntry(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);
+  return { id, firedAt: firedAlertTime(firedAt) ?? new Date().toISOString(), ...rest };
+}
+
+/**
+ * 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 capAlertLog([...entries, firedAlertEntry(input, id)]);
+}
+
+/** `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 (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 = counted(entry) ? over.get(entry.kind) ?? 0 : 0;
+    if (extra <= 0) return true;
+    over.set(entry.kind, extra - 1);
+    return false;
+  });
+}
+
+/**
+ * Records an alert another plugin fired (a live scan's new matches) in this
+ * log, through the runtime's access to the alerts plugin's resume state.
+ * `keepAtMost` bounds how many entries of the recorded kinds the shared log
+ * keeps, so a busy source cannot push the price and event alerts out.
+ */
+export function recordFiredAlertFor(
+  runtime: { getResumeState(pluginId: string, key: string): unknown; setResumeState(pluginId: string, key: string, value: unknown): void },
+  inputs: readonly FiredAlertInput[],
+  onError: (error: unknown) => void,
+  keepAtMost?: number,
+): void {
+  if (!inputs.length) return;
+  try {
+    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, 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. */

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

@@ -1,7 +1,12 @@
+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);
@@ -14,8 +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 "No quote";
+  if (alert.lastCheckError) return !alert.metric ? "No quote"
+    : /US listing|US equities|calendar/.test(alert.lastCheckError) ? "US only"
+    : /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, {
@@ -25,6 +38,10 @@ 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,
@@ -33,11 +50,11 @@ 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 "-";
   }
-  const percent = ((alert.targetPrice - currentPrice) / currentPrice) * 100;
+  const percent = (((alert.lastCheckedTarget ?? alert.targetPrice) - currentPrice) / currentPrice) * 100;
   if (!Number.isFinite(percent)) return "-";
   // One decimal at any distance, so the column holds still as the price moves;
   // a distance that rounds to zero is unsigned (0.0%, never -0.0%).
@@ -47,6 +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 {
+  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({
@@ -55,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,3 +1,4 @@
+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,
@@ -12,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,
@@ -47,17 +50,32 @@ const instant = (value: unknown) => (typeof value === "number" ? firedAlertTime(
 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: "metric", header: "Measure", format: (_value, row) => asAlert(row).metric ? metricName(asAlert(row).metric!) : "Price" },
   { 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", format: percent, textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
-  { key: "condition", header: "Trigger", format: (value) => conditionLabel(value as AlertRule["condition"]) },
+  { key: "condition", header: "Trigger", format: (value, row) => {
+    const metric = asAlert(row).metric;
+    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" },
@@ -93,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.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 ? 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,
   };
 }
 
@@ -111,7 +134,7 @@ function pricesResult(alerts: readonly AlertRule[], error: string | null, events
     columns: PRICE_COLUMNS,
     textColumns: PRICE_TEXT_COLUMNS,
     rows: [...active, ...triggered].map(priceRow),
-    empty: "No price alerts. Add one with gloom alerts add AAPL above 250.",
+    empty: "No level 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: gloom fn ALRT --tab events`] } : {}),
   };
@@ -214,7 +237,7 @@ async function historyResult(ctx: HeadlessPaneContext): Promise<HeadlessRowsResu
 
 export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
-  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.",
+  description: "Your alerts: price, valuation and daily technical 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: [{
@@ -229,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") 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;
 }
@@ -63,7 +64,10 @@ function firedRow(entry: FiredAlert, delivered: AlertHistoryItem | undefined): A
 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,
+    value: typeof item.data?.value === "number" ? item.data.value : null,
+    unit: typeof item.data?.unit === "string" ? item.data.unit : null,
+    quoteAt: typeof item.data?.quoteAt === "string" ? item.data.quoteAt : null,
+    source: item.data?.dailyClose ? "daily close" : null, detail: item.body, delivered: item,
   };
 }
 

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

@@ -38,12 +38,14 @@ 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", rs_ratio: "Ratio", rrg: "RRG quadrant",
   breaking_news: "Breaking news",
   earnings: "Earnings",
   chat: "Chat",
   thesis: "Thesis",
   congress_trade: "Congress",
   thirteenf_filing: "13F filing",
+  live_scan: "Live scan",
 };
 export const alertKindLabel = (kind: string) =>
   isResearchAlertKind(kind) ? RESEARCH_LABELS[kind] : (KIND_LABELS[kind] ?? kind.replaceAll("_", " "));