@gloom-sh/terminal 0.18.5 → 0.19.1

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/event-rows.ts

@@ -8,13 +8,34 @@ export function ruleTarget(rule: EventAlertRule): string {
   return `${target} · ${rule.eventDate ?? "date not known yet"}`;
 }
 
+/**
+ * Whether a rule is checked only for a signed-in account: Gloom Cloud checks every event rule but an IV level
+ * and an earnings, CPI, FOMC or calendar date, which the app reads itself, signed in or not, and the app reads
+ * catalysts only with a session. Signed out, such a rule never goes off.
+ */
+export function checkedWhenSignedIn(rule: EventAlertRule): boolean {
+  return rule.kind !== "iv_level" && !readScheduledRule(rule);
+}
+
+/** The state of a waiting rule nothing checks while signed out, as `alerts list` and its CSV write it. */
+export const NEEDS_SIGN_IN = "needs sign-in";
+
+/** What a list of rules says once when some of them need sign-in: what to do about it. */
+export function needsSignInNote(count: number): string {
+  return `${count === 1 ? "1 event alert needs" : `${count} event alerts need`} sign-in: ${count === 1 ? "it is" : "they are"} checked only for a signed-in account. `
+    + "Open the app (gloom) and log in or sign up free from the command bar (Ctrl+P, Log In or Sign Up).";
+}
+
 /**
  * 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.
+ * event, an IV level once its level was reached, until it is re-armed. Signed out, a waiting rule only a
+ * signed-in account gets checked needs sign-in.
  */
-export function ruleState(rule: EventAlertRule, now: number = Date.now()): "Active" | "Paused" | "Alerted" {
+export function ruleState(rule: EventAlertRule, now: number = Date.now(), signedIn = true): "Active" | "Paused" | "Alerted" | "Needs sign-in" {
   const scheduled = readScheduledRule(rule);
   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";
+  if (status === "paused") return "Paused";
+  if (status === "triggered") return "Alerted";
+  return !signedIn && checkedWhenSignedIn(rule) ? "Needs sign-in" : "Active";
 }

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

@@ -31,19 +31,23 @@ import { alertKindLabel, fetchAlertHistory, ruleStateText } from "./history";
 import { isResearchAlertKind } from "./research-rules";
 import { useAsyncResource } from "../../../public/react";
 import { usePlanAccess } from "../../../api-client/plan-access";
+import { apiClient } from "../../../api-client";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 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[] => [
+const columnsFor = (width: number, lastCheck: boolean, needsSignIn: boolean): DataTableColumn[] => [
   { id: "kind", label: "Event", width: 15, align: "left" },
   { id: "target", label: "Following", width: 28, flexGrow: 1, align: "left" },
   ...(lastCheck && width >= 96
     ? [{ id: "last", label: "Last check", width: 34, align: "left" as const }]
     : []),
-  { id: "status", label: "State", width: 8, align: "left" },
+  // Wide enough to say "Needs sign-in" only when a row does.
+  { id: "status", label: "State", width: needsSignIn ? 13 : 8, align: "left" },
   { id: "created", label: "Since", width: 10, align: "left" },
 ];
 
@@ -59,6 +63,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(
@@ -93,10 +99,13 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
   const selectedRule = items[Math.min(selected, Math.max(0, items.length - 1))];
   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();
+  // A saved session counts before its account has loaded, so a signed-in start does not flash "Needs sign-in".
+  const signedIn = access.signedIn || !!apiClient.getSessionToken();
+  const needsSignIn = !signedIn && rules.some((rule) => ruleState(rule, now, false) === "Needs sign-in");
+  const openTarget = useOpenAlertTarget();
+  const selectedTarget = useMemo(() => selectedRule ? alertTarget(eventRuleSubject(selectedRule)) : null, [selectedRule]);
   const session = useResearchCloudSession();
   const hasResearch = rules.some((rule) => isResearchAlertKind(rule.kind) && rule.kind !== "iv_level");
   const stateLoader = useCallback(() => fetchAlertHistory(0), [session.requestKey]);
@@ -106,7 +115,7 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
     [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 columns = columnsFor(width, (hasResearch && !!history.data) || rules.some((rule) => rule.kind === "iv_level"), needsSignIn);
   const add = useCallback(
     () => openPluginCommandWorkflow("set-event-alert"),
     [openPluginCommandWorkflow],
@@ -123,11 +132,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 +155,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) ??
@@ -201,7 +221,9 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
         // 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);
+        const state = ruleState(rule, now, signedIn);
+        // A rule nothing checks while signed out says so in its State, in the warning tone.
+        const waiting = state === "Needs sign-in" && column.id === "status";
         return {
           text:
             column.id === "kind"
@@ -221,6 +243,8 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
             ? colors.selectedText
             : unread && (column.id === "status" || column.id === "last")
               ? colors.negative
+              : waiting
+                ? colors.warning
               : rule.status === "paused"
                 ? colors.textMuted
                 : colors.text,

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,
@@ -10,9 +10,11 @@ import type { HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, H
 import type { PaneLock } from "../../../types/plugin";
 import { refusedLock } from "../shared/cloud-denied";
 import { ALERT_TABS, ALERTS_PLUGIN_ID } from "./constants";
-import { ruleState } from "./event-rows";
+import { needsSignInNote, 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,
   };
 }
 
@@ -123,7 +141,7 @@ function pricesResult(alerts: readonly AlertRule[], error: string | null, events
 }
 
 /** An event alert as the Events table lists it: a scheduled one with its event date and lead time apart. */
-function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLevelCheck>): HeadlessPaneRow {
+function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLevelCheck>, signedIn: boolean): HeadlessPaneRow {
   const scheduled = readScheduledRule(rule);
   return {
     id: rule.id,
@@ -133,22 +151,26 @@ function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLe
     eventDate: scheduled ? rule.eventDate ?? null : null,
     leadDays: scheduled?.leadDays ?? null,
     ...(scheduled?.trigger === "results" ? { when: "results" } : {}),
-    state: ruleState(rule, now),
+    state: ruleState(rule, now, signedIn),
     since: new Date(rule.createdAt).toISOString().slice(0, 10),
     // An IV level's last reading, or why there was none, on its own row.
     ...rule.kind === "iv_level" ? { lastCheck: ivLevelCheckText(rule, checks[rule.id]) } : {},
   };
 }
 
-function eventsResult(rules: readonly EventAlertRule[], error: string | null, checks: Record<string, IvLevelCheck>): HeadlessRowsResult {
+function eventsResult(rules: readonly EventAlertRule[], error: string | null, checks: Record<string, IvLevelCheck>, signedIn: boolean): HeadlessRowsResult {
   const now = Date.now();
   const checked = rules.some((rule) => rule.kind === "iv_level");
+  const rows = [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, now, checks, signedIn));
+  // Signed out, the rules only a signed-in account gets checked say so on their rows, and once what to do.
+  const waiting = rows.filter((row) => row.state === "Needs sign-in").length;
   return {
     // A Last check column only when an IV level rule has a reading to show.
     columns: checked ? [...EVENT_COLUMNS.slice(0, -2), { key: "lastCheck", header: "Last check" }, ...EVENT_COLUMNS.slice(-2)] : EVENT_COLUMNS,
-    rows: [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, now, checks)),
+    rows,
     empty: "No event alerts. Add one with gloom alerts add CRWV earnings --days 3, gloom alerts add CPI --days 1 or gloom alerts add CN PMI.",
     ...(error ? { errors: [error], complete: false } : {}),
+    ...(waiting ? { notes: [needsSignInNote(waiting)] } : {}),
   };
 }
 
@@ -234,7 +256,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) {
@@ -242,7 +264,7 @@ export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
     if (tab === "history") return historyResult(ctx);
     const { alerts, alertsError, events } = readAlertStores(ctx.config);
     return tab === "events"
-      ? eventsResult(events.rules, events.error, readIvLevelChecks(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, IV_LEVEL_CHECKS_KEY)))
+      ? eventsResult(events.rules, events.error, readIvLevelChecks(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, IV_LEVEL_CHECKS_KEY)), !!ctx.apiClient.getSessionToken?.())
       : pricesResult(alerts, alertsError, events.rules.length);
   },
 };

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",