@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/alerts/metric-model.ts

@@ -1,11 +1,19 @@
 // Keep this model identical to the delivery model; the parity fixture checks both copies.
 /** Synced separately from price rules so older clients cannot judge a ratio as a price. */
 export const METRIC_ALERTS_KEY = "metricAlerts";
+/** Relative strength has a list of its own too: a client that reads metricAlerts keeps none of it once it holds a measure it does not know. */
+export const RELATIVE_ALERTS_KEY = "relativeAlerts";
+export const ROTATION_QUADRANTS = ["leading", "weakening", "lagging", "improving"] as const;
+export type RotationQuadrant = typeof ROTATION_QUADRANTS[number];
 export type AlertMetric =
   | { kind: "pe" | "ps" }
   | { kind: "rsi"; period: number }
   | { kind: "close_ma"; period: number }
-  | { kind: "ma_cross"; period: number; slowPeriod: number; direction: "above" | "below" };
+  | { kind: "ma_cross"; period: number; slowPeriod: number; direction: "above" | "below" }
+  /** The listing's settled daily close divided by the benchmark's on the same session. */
+  | { kind: "rs_ratio"; benchmark: string; benchmarkExchange?: string }
+  /** The weekly RRG quadrant against the benchmark, entered on a published weekly close. */
+  | { kind: "rrg"; quadrant: RotationQuadrant; benchmark: string; benchmarkExchange?: string };
 export interface MetricReading {
   value: number;
   target: number;
@@ -25,6 +33,8 @@ export interface MetricRule {
 }
 const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
 const period = (value: unknown): value is number => finite(value) && Number.isInteger(value) && value >= 2 && value <= 200;
+const listing = (value: unknown): value is string => typeof value === "string" && /^[A-Z0-9.^=-]{1,20}$/.test(value);
+const venue = (value: unknown) => value === undefined || (typeof value === "string" && /^[A-Z0-9._-]{1,24}$/.test(value));
 
 export function readAlertMetric(raw: unknown): AlertMetric | null {
   if (!raw || typeof raw !== "object") return null;
@@ -35,13 +45,26 @@ export function readAlertMetric(raw: unknown): AlertMetric | null {
     && (m.direction === "above" || m.direction === "below")) {
     return { kind: m.kind, period: m.period, slowPeriod: m.slowPeriod, direction: m.direction };
   }
+  if ((m.kind === "rs_ratio" || m.kind === "rrg") && listing(m.benchmark) && venue(m.benchmarkExchange)) {
+    const benchmark = { benchmark: m.benchmark, ...(m.benchmarkExchange ? { benchmarkExchange: m.benchmarkExchange as string } : {}) };
+    if (m.kind === "rs_ratio") return { kind: m.kind, ...benchmark };
+    if (ROTATION_QUADRANTS.includes(m.quadrant as RotationQuadrant)) return { kind: m.kind, quadrant: m.quadrant as RotationQuadrant, ...benchmark };
+  }
   return null;
 }
+export function isRelativeMetric(metric: AlertMetric): metric is Extract<AlertMetric, { benchmark: string }> {
+  return metric.kind === "rs_ratio" || metric.kind === "rrg";
+}
+/** The synced list a rule belongs in. */
+export function metricAlertsKey(metric: AlertMetric): string {
+  return isRelativeMetric(metric) ? RELATIVE_ALERTS_KEY : METRIC_ALERTS_KEY;
+}
 
 export function validMetricRule(rule: Pick<MetricRule, "metric" | "condition" | "targetPrice">): boolean {
   const m = readAlertMetric(rule.metric);
   if (!m || !finite(rule.targetPrice)) return false;
-  if (m.kind === "ma_cross") return rule.condition === "crosses" && rule.targetPrice === 0;
+  if (m.kind === "ma_cross" || m.kind === "rrg") return rule.condition === "crosses" && rule.targetPrice === 0;
+  if (m.kind === "rs_ratio") return ["above", "below", "crosses"].includes(rule.condition) && rule.targetPrice > 0;
   if (rule.condition !== "above" && rule.condition !== "below") return false;
   return m.kind === "close_ma" ? rule.targetPrice === 0
     : m.kind === "rsi" ? rule.targetPrice >= 0 && rule.targetPrice <= 100 : rule.targetPrice > 0;
@@ -51,18 +74,62 @@ export function metricName(metric: AlertMetric): string {
   if (metric.kind === "pe") return "P/E (TTM)";
   if (metric.kind === "ps") return "P/S (TTM)";
   if (metric.kind === "rsi") return `RSI(${metric.period})`;
+  if (metric.kind === "rs_ratio") return `Ratio to ${metric.benchmark}`;
+  if (metric.kind === "rrg") return `RRG vs ${metric.benchmark}`;
   return metric.kind === "ma_cross" ? `${metric.period}-day MA` : "Close";
 }
+const quadrantName = (quadrant: RotationQuadrant) => `${quadrant[0]!.toUpperCase()}${quadrant.slice(1)}`;
 export function metricDescription(rule: MetricRule & { symbol: string }): string {
   const m = rule.metric!;
+  const basis = closeBasis(m);
+  const suffix = basis ? ` · on ${basis}` : "";
+  if (m.kind === "rs_ratio") return `${rule.symbol} ratio to ${m.benchmark} ${rule.condition} ${rule.targetPrice}${suffix}`;
+  if (m.kind === "rrg") return `${rule.symbol} ${metricName(m)} enters ${quadrantName(m.quadrant)}${suffix}`;
   const target = m.kind === "ma_cross" ? `${m.slowPeriod}-day MA`
     : m.kind === "close_ma" ? `${m.period}-day MA` : String(rule.targetPrice);
   const condition = m.kind === "ma_cross" ? `crosses ${m.direction}` : rule.condition;
-  return `${rule.symbol} ${metricName(m)} ${condition} ${target}${isDailyMetric(m) ? " · on daily close" : ""}`;
+  return `${rule.symbol} ${metricName(m)} ${condition} ${target}${suffix}`;
 }
+/** Judged on settled closes only, never a forming session; RRG quadrants on weekly ones. */
 export function isDailyMetric(metric: AlertMetric): boolean {
   return metric.kind !== "pe" && metric.kind !== "ps";
 }
+export function closeBasis(metric: AlertMetric): "daily close" | "weekly close" | null {
+  return metric.kind === "rrg" ? "weekly close" : isDailyMetric(metric) ? "daily close" : null;
+}
+/** The reading as alerts state it: 31.2x, 0.2512, or Leading (strength 101.23, momentum 100.40) as RRG words them. */
+export function metricReadingText(metric: AlertMetric, reading: Pick<MetricReading, "value" | "target">): string {
+  if (metric.kind === "rrg") {
+    return `${rotationQuadrant(reading.value, reading.target) ?? "No quadrant"} (strength ${reading.value.toFixed(2)}, momentum ${reading.target.toFixed(2)})`;
+  }
+  return `${Number(reading.value.toFixed(4))}${metric.kind === "pe" || metric.kind === "ps" ? "x" : ""}`;
+}
+
+export type RotationQuadrantName = "Leading" | "Weakening" | "Lagging" | "Improving" | "Neutral";
+export function rotationQuadrant(strength: number | null | undefined, momentum: number | null | undefined): RotationQuadrantName | null {
+  if (strength == null || momentum == null || !finite(strength) || !finite(momentum)) return null;
+  if (Math.abs(strength - 100) < 1e-9 || Math.abs(momentum - 100) < 1e-9) return "Neutral";
+  return strength > 100 ? momentum > 100 ? "Leading" : "Weakening" : momentum > 100 ? "Improving" : "Lagging";
+}
+/**
+ * Weekly strength (RS-Ratio: 100 x the price ratio over its 13-week mean) and momentum (RS-Momentum: 100 x
+ * strength over strength four weeks earlier), as RRG plots them. A missing week breaks both until 13 and 17 contiguous weeks.
+ */
+export function rotationSeries(ratios: readonly (number | null)[]): { strength: number | null; momentum: number | null }[] {
+  const strengths = ratios.map((ratio, index) => {
+    const window = ratios.slice(Math.max(0, index - 12), index + 1);
+    if (ratio == null || window.length !== 13 || window.some((value) => value == null)) return null;
+    const average = (window as number[]).reduce((sum, value) => sum + value, 0) / 13;
+    return (100 * ratio) / average;
+  });
+  return strengths.map((strength, index) => {
+    const previous = index >= 4 ? (strengths[index - 4] ?? null) : null;
+    const contiguous = index >= 4 && strengths.slice(index - 4, index + 1).every((value) => value != null);
+    return { strength, momentum: strength != null && previous != null && contiguous ? (100 * strength) / previous : null };
+  });
+}
+/** Weeks a quadrant change needs: 17 for this week's momentum, and the week before it. */
+export const ROTATION_ALERT_WEEKS = 18;
 
 /** Wilder's initial average of N changes, then (previous * (N - 1) + change) / N. */
 function rsi(closes: readonly number[], window: number): number[] {
@@ -110,24 +177,96 @@ export class DailyMetricCache {
   }
 }
 
-export function dailyMetricReading(
-  rule: MetricRule,
-  bars: readonly { date: string; close: number }[],
-  now: number,
-  session: (day: string) => DailySession | null,
-): MetricReading {
-  const m = rule.metric!;
-  if (!isDailyMetric(m) || !("period" in m)) throw new Error("Expected a daily technical alert.");
-  const latest = latestSettledClose(now, session);
+type DailyBar = { date: string; close: number };
+function closesThrough(bars: readonly DailyBar[], through: string): Map<string, number> {
   const byDay = new Map<string, number>();
   for (const bar of bars) {
     const day = bar.date.slice(0, 10);
-    if (day > latest.day) continue;
+    if (day > through) continue;
     if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !finite(bar.close) || bar.close <= 0 || byDay.has(day)) {
       throw new Error("Daily history contains an invalid or duplicate bar.");
     }
     byDay.set(day, bar.close);
   }
+  return byDay;
+}
+const isoDay = (time: number) => new Date(time).toISOString().slice(0, 10);
+function sessionBefore(day: string, session: (day: string) => DailySession | null): string {
+  for (let offset = 1; offset < 15; offset++) {
+    const previous = isoDay(Date.parse(day) - offset * DAY);
+    const s = session(previous);
+    if (!s) throw new Error("Daily close calendar unavailable for part of the history.");
+    if (s.kind === "session") return previous;
+  }
+  throw new Error(`No session before ${day}.`);
+}
+/** The last session of each Monday-Friday week, oldest first, ending with the newest week whose close has settled. */
+export function settledWeekCloses(now: number, session: (day: string) => DailySession | null, count: number): { day: string; at: number }[] {
+  const latest = latestSettledClose(now, session);
+  const close = (friday: number) => {
+    for (let offset = 0; offset < 5; offset++) {
+      const day = isoDay(friday - offset * DAY);
+      const s = session(day);
+      if (!s) throw new Error("Daily close calendar unavailable for part of the history.");
+      if (s.kind === "session") return { day, at: s.close };
+    }
+    throw new Error(`No session in the week ending ${isoDay(friday)}.`);
+  };
+  const time = Date.parse(latest.day);
+  let friday = time + ((5 - new Date(time).getUTCDay() + 7) % 7) * DAY;
+  // A week whose last session is still ahead or forming has no weekly close yet.
+  if (close(friday).day !== latest.day) friday -= 7 * DAY;
+  return Array.from({ length: count }, (_, index) => close(friday - (count - 1 - index) * 7 * DAY));
+}
+
+/** Both listings' own closes on the same sessions; a session either lacks is never bridged from another day. */
+function relativeMetricReading(
+  rule: MetricRule,
+  m: Extract<AlertMetric, { benchmark: string }>,
+  bars: readonly DailyBar[],
+  benchmarkBars: readonly DailyBar[],
+  now: number,
+  session: (day: string) => DailySession | null,
+): MetricReading {
+  const latest = latestSettledClose(now, session);
+  const own = closesThrough(bars, latest.day), reference = closesThrough(benchmarkBars, latest.day);
+  const ratio = (day: string) => {
+    const close = own.get(day), base = reference.get(day);
+    if (close == null || base == null) {
+      if (day === latest.day) throw new Error(`Waiting for the ${latest.day} ${m.kind === "rrg" ? "weekly" : "daily"} close${close == null ? "" : ` of ${m.benchmark}`}.`);
+      throw new Error(`Daily history is missing ${day}${close == null ? "" : ` for ${m.benchmark}`}.`);
+    }
+    return close / base;
+  };
+  if (m.kind === "rs_ratio") {
+    const value = ratio(latest.day), previousValue = ratio(sessionBefore(latest.day, session));
+    return { value, target: rule.targetPrice, previousValue, previousTarget: rule.targetPrice, day: latest.day, at: latest.at };
+  }
+  const weeks = settledWeekCloses(now, session, ROTATION_ALERT_WEEKS);
+  const [before, last] = rotationSeries(weeks.map((week) => ratio(week.day))).slice(-2);
+  if (before?.strength == null || before.momentum == null || last?.strength == null || last.momentum == null) {
+    throw new Error(`Need ${ROTATION_ALERT_WEEKS} contiguous weekly closes.`);
+  }
+  const week = weeks.at(-1)!;
+  return { value: last.strength, target: last.momentum, previousValue: before.strength, previousTarget: before.momentum, day: week.day, at: week.at };
+}
+
+/** RS ratios and RRG quadrants take the benchmark's completed daily bars as well. */
+export function dailyMetricReading(
+  rule: MetricRule,
+  bars: readonly DailyBar[],
+  now: number,
+  session: (day: string) => DailySession | null,
+  benchmarkBars?: readonly DailyBar[],
+): MetricReading {
+  const m = rule.metric!;
+  if (m.kind === "rs_ratio" || m.kind === "rrg") {
+    if (!benchmarkBars) throw new Error(`Completed daily history for ${m.benchmark} is required.`);
+    return relativeMetricReading(rule, m, bars, benchmarkBars, now, session);
+  }
+  if (!isDailyMetric(m) || !("period" in m)) throw new Error("Expected a daily technical alert.");
+  const latest = latestSettledClose(now, session);
+  const byDay = closesThrough(bars, latest.day);
   const days = [...byDay.keys()].sort();
   if (days.at(-1) !== latest.day) throw new Error(`Waiting for the ${latest.day} daily close.`);
   const needed = m.kind === "close_ma" ? m.period : (m.kind === "ma_cross" ? m.slowPeriod : m.period) + 1;
@@ -165,9 +304,19 @@ export function metricTrigger(rule: MetricRule, reading: MetricReading): "above"
   if (isDailyMetric(rule.metric!)) {
     if (!reading.day || reading.day <= (rule.lastDailyClose ?? "") || reading.at <= (rule.armedAt ?? rule.createdAt ?? Infinity)) return null;
   }
+  const m = rule.metric!;
+  if (m.kind === "rrg") {
+    // Fires on entering the quadrant, not on a week already inside it.
+    const before = rotationQuadrant(reading.previousValue, reading.previousTarget)?.toLowerCase();
+    return before && before !== m.quadrant && rotationQuadrant(reading.value, reading.target)?.toLowerCase() === m.quadrant ? "up" : null;
+  }
   if (rule.condition === "above") return reading.value > reading.target ? "above" : null;
   if (rule.condition === "below") return reading.value < reading.target ? "below" : null;
-  const m = rule.metric!;
+  if (m.kind === "rs_ratio") {
+    if (!finite(reading.previousValue)) return null;
+    if (reading.previousValue <= reading.target && reading.value > reading.target) return "up";
+    return reading.previousValue >= reading.target && reading.value < reading.target ? "down" : null;
+  }
   if (m.kind !== "ma_cross" || !finite(reading.previousValue) || !finite(reading.previousTarget)) return null;
   if (m.direction === "above" && reading.previousValue <= reading.previousTarget && reading.value > reading.target) return "up";
   if (m.direction === "below" && reading.previousValue >= reading.previousTarget && reading.value < reading.target) return "down";

package/src/plugins/builtin/alerts/metric-parity-fixture.json

@@ -1,5 +1,5 @@
 {
-  "modelSha256": "2364694ef384760911a9190f6ebb12bb66442e63c98defd30e16fd0bb731afd4",
+  "modelSha256": "7672569b5c80bb737181cb6a85e72b07e659d706e1792e5a89e8d570ae0ec581",
   "valuations": [
     {
       "name": "regular",

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

@@ -1,9 +1,10 @@
-import { METRIC_ALERTS_KEY, isDailyMetric, metricName } from "./metric-model";
+import { METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY, closeBasis, metricName, metricReadingText } from "./metric-model";
 import { metricAvailabilityError } from "./metric-data";
-import { readLevelAlertStores } from "./storage";
+import { relativeAlertText } from "./metric-command";
+import { levelAlertStoreKey, readLevelAlertStores } from "./storage";
 import { Box, type ScrollBoxRenderable } from "../../../ui";
 import { Button, DetailScrollBody, KeyValueRow, Notice, PaneStatusBody, PaneFooterScope, usePaneTabs } from "../../../components";
-import { usePluginPaneState } from "../../runtime";
+import { usePluginPaneState, usePluginState } from "../../runtime";
 import { EventAlertsPane } from "./events-pane";
 import { AlertHistoryPane } from "./history-pane";
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore, type RefObject } from "react";
@@ -30,16 +31,21 @@ import {
   readAlertsStoreError,
   serializeAlerts,
 } from "./alert-engine";
-import { parseAlertCommandValues } from "./command";
+import { parseAlertEdit } from "./command";
 import { ALERT_TABS, ALERTS_KEY } from "./constants";
 import {
+  alertListing,
   conditionLabel,
   formatAlertDistance,
   formatAlertTargetPrice,
   formatCurrentPrice,
   formatQuoteChecked,
+  isoUtc,
+  listingWithCurrency,
   relativeTime,
 } from "./format";
+import { FIRED_LOG_KEY } from "./fired-log";
+import { withAlertChange } from "./alert-log";
 import type { AlertRule } from "./types";
 import { useQuoteEntries } from "../../../market-data/hooks";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
@@ -57,7 +63,8 @@ type AlertColumnId =
   | "away"
   | "condition"
   | "quote"
-  | "triggered";
+  | "triggered"
+  | "created";
 
 type AlertColumn = DataTableColumn & { id: AlertColumnId };
 
@@ -69,8 +76,11 @@ const ALERT_COLUMNS: AlertColumn[] = [
   { id: "target", label: "Target", width: 11, align: "right" },
   { id: "away", label: "Away", width: 8, align: "right" },
   { id: "condition", label: "Trigger", width: 12, align: "left" },
-  { id: "quote", label: "Quote", width: 14, align: "left" },
+  // Wide enough to say "not checked yet" for an alert no check has read.
+  { id: "quote", label: "Quote", width: 15, align: "left" },
   { id: "triggered", label: "Alerted", width: 8, align: "left" },
+  // The day the alert was made (UTC), as Events lists its rules; the detail gives the instant.
+  { id: "created", label: "Since", width: 10, align: "left" },
 ];
 
 const DETAIL_ROW = { labelWidth: 10, emphasis: false } as const;
@@ -89,20 +99,28 @@ function AlertDetail({ alert, scrollRef }: { alert: AlertRule; scrollRef: RefObj
   const reason = alert.lastCheckError
     ? alert.lastCheckError.includes(alert.symbol) ? alert.lastCheckError : `${alert.symbol}: ${alert.lastCheckError}`
     : null;
+  const basis = alert.metric ? closeBasis(alert.metric) : null;
   return (
     <DetailScrollBody ref={scrollRef} resetScrollKey={alert.id}>
       <Box flexDirection="column">
         {reason ? <Box paddingBottom={1}><Notice tone="warning">{reason}</Notice></Box> : null}
         <KeyValueRow {...DETAIL_ROW} label="State" value={alert.status === "triggered" ? "Triggered" : "Active"} tone={alert.status === "triggered" ? "positive" : "muted"} />
+        <KeyValueRow {...DETAIL_ROW} label="Listing" value={listingWithCurrency(alertListing(alert), alert.lastQuoteCurrency)} />
         {/* With no quote the reason above says why; the price and its distance wait for one. */}
-        {alert.metric && isDailyMetric(alert.metric) ? <KeyValueRow {...DETAIL_ROW} label="Close date" value={alert.lastDailyClose ?? "Awaiting daily close"} /> : null}
+        {basis ? <KeyValueRow {...DETAIL_ROW} label="Close date" value={alert.lastDailyClose ?? `Awaiting ${basis}`} /> : null}
         {reason ? null : <KeyValueRow {...DETAIL_ROW} label="Current" value={formatCurrentPrice(alert, 24)} />}
+        {/* The two readings that place the quadrant, as RRG states them. */}
+        {!reason && alert.metric?.kind === "rrg" && alert.lastCheckedPrice != null && alert.lastCheckedTarget != null ? <>
+          <KeyValueRow {...DETAIL_ROW} label="Strength" value={alert.lastCheckedPrice.toFixed(2)} />
+          <KeyValueRow {...DETAIL_ROW} label="Momentum" value={alert.lastCheckedTarget.toFixed(2)} />
+        </> : null}
         {reason ? null : <KeyValueRow {...DETAIL_ROW} label="Away" value={formatAlertDistance(alert)} />}
         {reason
           ? alert.lastCheckedAt ? <KeyValueRow {...DETAIL_ROW} label="Checked" value={relativeTime(alert.lastCheckedAt)} tone="muted" /> : null
           : <KeyValueRow {...DETAIL_ROW} label="Quote" value={formatQuoteChecked(alert)} tone="muted" />}
         {alert.triggeredAt ? <KeyValueRow {...DETAIL_ROW} label="Alerted" value={relativeTime(alert.triggeredAt)} /> : null}
         <KeyValueRow {...DETAIL_ROW} label="Armed" value={relativeTime(alert.armedAt ?? alert.createdAt)} tone="muted" />
+        <KeyValueRow {...DETAIL_ROW} label="Created" value={isoUtc(alert.createdAt)} tone="muted" />
       </Box>
     </DetailScrollBody>
   );
@@ -144,7 +162,10 @@ export function AlertsPane(props: PaneProps) {
 function PriceAlertsPane({ focused, width, height }: PaneProps) {
   const [alertsJson, setAlertsJson] = usePluginConfigState<unknown>(ALERTS_KEY, "[]");
   const [metricsJson, setMetricsJson] = usePluginConfigState<unknown>(METRIC_ALERTS_KEY, "[]");
+  const [relativeJson, setRelativeJson] = usePluginConfigState<unknown>(RELATIVE_ALERTS_KEY, "[]");
   const { openPluginCommandWorkflow, notify } = usePluginAppActions();
+  // 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 dialog = useDialog();
   const [selectedIdx, setSelectedIdx] = useState(0);
   const [detailOpen, setDetailOpen] = useState(false);
@@ -152,9 +173,11 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
   const detailAlertId = useRef<string | null>(null);
   const detailScrollRef = useRef<ScrollBoxRenderable | null>(null);
   // Keep the rule and daily-close basis visible in a narrow pane; the detail keeps all figures.
-  const columns = width < 106 ? ALERT_COLUMNS.filter(column => column.id !== "away" && column.id !== "triggered") : ALERT_COLUMNS;
+  const columns = width < 106 ? ALERT_COLUMNS.filter(column => column.id !== "away" && column.id !== "triggered" && column.id !== "created")
+    : width < 118 ? ALERT_COLUMNS.filter(column => column.id !== "created") : ALERT_COLUMNS;
   const showHorizontalScrollbar = columns.reduce((sum, column) => sum + column.width + 1, 2) > width;
-  const stores = useMemo(() => readLevelAlertStores(key => key === ALERTS_KEY ? alertsJson : metricsJson), [alertsJson, metricsJson]);
+  const stores = useMemo(() => readLevelAlertStores(key => key === ALERTS_KEY ? alertsJson : key === METRIC_ALERTS_KEY ? metricsJson : relativeJson),
+    [alertsJson, metricsJson, relativeJson]);
   const storeError = stores.error;
 
   const { alerts, rows } = useMemo(() => {
@@ -205,16 +228,17 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
   }), [liveEntries, rows]);
 
   const savePaneAlerts = useCallback((id: string, next: (current: AlertRule[]) => AlertRule[]): string | null => {
-    const key = alerts.find(alert => alert.id === id)?.metric ? METRIC_ALERTS_KEY : ALERTS_KEY;
+    const found = alerts.find(alert => alert.id === id);
+    const key = found ? levelAlertStoreKey(found) : ALERTS_KEY;
     if (stores.errors[key]) return stores.errors[key];
     let error: string | null = null;
-    const setJson = key === METRIC_ALERTS_KEY ? setMetricsJson : setAlertsJson;
+    const setJson = key === METRIC_ALERTS_KEY ? setMetricsJson : key === RELATIVE_ALERTS_KEY ? setRelativeJson : setAlertsJson;
     setJson((currentJson: unknown) => {
       error = readAlertsStoreError(currentJson);
       return error ? currentJson : serializeAlerts(next(deserializeAlerts(currentJson)));
     });
     return error;
-  }, [alerts, setAlertsJson, setMetricsJson, stores]);
+  }, [alerts, setAlertsJson, setMetricsJson, setRelativeJson, stores]);
 
   const deleteAlert = useCallback(async (id: string) => {
     const alert = alerts.find((a) => a.id === id);
@@ -230,15 +254,24 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
       notify({ body: error, type: "error" });
       return;
     }
+    setAlertLog((saved: unknown) => withAlertChange(saved, "deleted", alert));
     setSelectedIdx((prev) => Math.max(0, Math.min(prev, rows.length - 2)));
-  }, [alerts, dialog, notify, rows.length, savePaneAlerts]);
+  }, [alerts, dialog, notify, rows.length, savePaneAlerts, setAlertLog]);
 
   const rearmAlert = useCallback((id: string) => {
-    const error = savePaneAlerts(id,
-      (current) => current.map((a) => (a.id === id ? rebuildAlert(a) : a)),
-    );
-    if (error) notify({ body: error, type: "error" });
-  }, [notify, savePaneAlerts]);
+    // Only an alert that went off is re-armed, as the store reads at the write: one still waiting is left, and not logged.
+    const rearmed: AlertRule[] = [];
+    const error = savePaneAlerts(id, (current) => current.map((a) => {
+      if (a.id !== id || a.status !== "triggered") return a;
+      rearmed.push(a);
+      return rebuildAlert(a);
+    }));
+    if (error) {
+      notify({ body: error, type: "error" });
+      return;
+    }
+    for (const alert of rearmed) setAlertLog((saved: unknown) => withAlertChange(saved, "rearmed", alert));
+  }, [notify, savePaneAlerts, setAlertLog]);
 
   const startAddAlert = useCallback(() => {
     openPluginCommandWorkflow("set-alert");
@@ -276,11 +309,9 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
             description: "SYMBOL above|below|crosses PRICE",
             placeholder: "AAPL above 200",
           }}
-          currentValue={selected.metric ? formatAlertDescription(selected).replace(" (TTM)", "").replace(" · on daily close", "") : `${selected.symbol} ${selected.condition} ${selected.targetPrice}`}
+          currentValue={relativeAlertText(selected) ?? (selected.metric ? formatAlertDescription(selected).replace(" (TTM)", "").replace(" · on daily close", "") : `${selected.symbol} ${selected.condition} ${selected.targetPrice}`)}
           onApply={async (value) => {
-            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.");
+            const parsed = parseAlertEdit(selected, value);
             const error = savePaneAlerts(selected.id, (current) => current.map((alert) => (
               alert.id === selected.id
                 ? { ...editAlert(alert, parsed.symbol, parsed.condition, parsed.price), ...(parsed.metric ? { metric: parsed.metric } : {}) }
@@ -382,6 +413,9 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
       case "current":
         return {
           text: formatCurrentPrice(alert, column.width),
+          // The quadrant word exports with the readings that place it.
+          ...(alert.metric?.kind === "rrg" && !alert.lastCheckError && alert.lastCheckedPrice != null && alert.lastCheckedTarget != null
+            ? { value: metricReadingText(alert.metric, { value: alert.lastCheckedPrice, target: alert.lastCheckedTarget }) } : {}),
           color: alert.lastCheckError ? colors.negative : colors.text,
         };
       case "target":
@@ -392,10 +426,12 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
           color: colors.textDim,
         };
       case "condition":
-        return { text: alert.metric?.kind === "ma_cross" ? `Cross ${alert.metric.direction}` : conditionLabel(alert.condition) };
+        return { text: alert.metric?.kind === "ma_cross" ? `Cross ${alert.metric.direction}` : alert.metric?.kind === "rrg" ? "Enters" : conditionLabel(alert.condition) };
       case "quote":
         return {
           text: formatQuoteChecked(alert),
+          // A settled close exports as its session date.
+          ...(alert.metric && closeBasis(alert.metric) && alert.lastDailyClose && !alert.lastCheckError ? { value: alert.lastDailyClose } : {}),
           color: alert.lastCheckError ? colors.negative : colors.textDim,
         };
       case "triggered":
@@ -403,6 +439,8 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
           text: alert.triggeredAt ? relativeTime(alert.triggeredAt) : "-",
           color: colors.textDim,
         };
+      case "created":
+        return { text: isoUtc(alert.createdAt).slice(0, 10), color: colors.textDim };
     }
   }, []);
 

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

@@ -2,6 +2,7 @@ import type { DataProvider } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
 import { getActiveQuoteDisplay } from "../../../market-data/market/status";
 import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
+import { canonicalExchange } from "../../../utils/exchanges";
 import type { AlertRule } from "./types";
 
 export function normalizeAlertSymbol(value: string | null | undefined): string {
@@ -46,13 +47,18 @@ export function quoteAlertFields(
   | "lastQuoteUpdatedAt"
   | "lastQuoteSource"
   | "lastQuoteProviderId"
+  | "lastQuoteCurrency"
+  | "lastQuoteExchange"
 > & { lastCheckError?: undefined } {
+  const exchange = quote.listingExchangeName || quote.exchangeName;
   return {
     lastCheckedPrice: quote.price,
     lastCheckedAt: checkedAt,
     lastQuoteUpdatedAt: quote.lastUpdated,
     lastQuoteSource: quote.dataSource,
     lastQuoteProviderId: quote.providerId,
+    ...(quote.currency ? { lastQuoteCurrency: quote.currency } : {}),
+    ...(exchange ? { lastQuoteExchange: canonicalExchange(exchange) } : {}),
     lastCheckError: undefined,
   };
 }

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

@@ -1,4 +1,4 @@
-import { METRIC_ALERTS_KEY } from "./metric-model";
+import { METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY, metricAlertsKey } from "./metric-model";
 import type { AppConfig } from "../../../types/config";
 import type { GloomPluginContext } from "../../../types/plugin";
 import {
@@ -21,8 +21,9 @@ export async function saveAlerts(
   scope: "all" | "price" | "metric" = "all",
 ): Promise<void> {
   const stores = readLevelAlertStores((key) => ctx.configState.get<unknown>(key));
-  const entries = Object.entries(writeLevelAlertStores(alerts)).filter(([key]) => scope === "all"
-    || key === (scope === "price" ? ALERTS_KEY : METRIC_ALERTS_KEY));
+  // An unreadable list is never written over; one that has nothing to write does not hold up the others.
+  const entries = Object.entries(writeLevelAlertStores(alerts)).filter(([key, value]) => (scope === "all"
+    || (scope === "price" ? key === ALERTS_KEY : key !== ALERTS_KEY)) && !(stores.errors[key] && value === "[]"));
   for (const [key] of entries) if (stores.errors[key]) throw new Error(stores.errors[key]!);
   for (const [key, value] of entries) {
     if (ctx.configState.get<unknown>(key) !== value) await ctx.configState.set(key, value);
@@ -46,17 +47,20 @@ export function readAlertStores(config: AppConfig) {
 export function readLevelAlertStores(get: (key: string) => unknown): { alerts: AlertRule[]; error: string | null; errors: Record<string, string | null> } {
   const alerts: AlertRule[] = [];
   const errors: Record<string, string | null> = {};
-  for (const key of [ALERTS_KEY, METRIC_ALERTS_KEY]) {
+  for (const key of LEVEL_ALERT_KEYS) {
     const raw = get(key);
     let error = readAlertsStoreError(raw);
     const rows = error ? [] : deserializeAlerts(raw);
-    if (rows.some(a => Boolean(a.metric) !== (key === METRIC_ALERTS_KEY))) error = "Saved alerts contain a rule in the wrong list. Original data has been kept.";
-    errors[key] = key === METRIC_ALERTS_KEY ? error?.replaceAll("price alerts", "valuation and technical alerts") ?? null : error;
+    if (rows.some(a => levelAlertStoreKey(a) !== key)) error = "Saved alerts contain a rule in the wrong list. Original data has been kept.";
+    errors[key] = key === METRIC_ALERTS_KEY ? error?.replaceAll("price alerts", "valuation and technical alerts") ?? null
+      : key === RELATIVE_ALERTS_KEY ? error?.replaceAll("price alerts", "relative strength alerts") ?? null : error;
     if (!error) alerts.push(...rows);
   }
   return { alerts, errors, error: Object.values(errors).filter(Boolean).join(" ") || null };
 }
 export function writeLevelAlertStores(alerts: AlertRule[]): Record<string, string> {
-  return { [ALERTS_KEY]: serializeAlerts(alerts.filter(a => !a.metric)),
-    [METRIC_ALERTS_KEY]: serializeAlerts(alerts.filter(a => a.metric)) };
+  return Object.fromEntries(LEVEL_ALERT_KEYS.map(key => [key, serializeAlerts(alerts.filter(a => levelAlertStoreKey(a) === key))]));
 }
+/** Price, valuation/technical and relative strength rules each keep their own synced list. */
+const LEVEL_ALERT_KEYS = [ALERTS_KEY, METRIC_ALERTS_KEY, RELATIVE_ALERTS_KEY] as const;
+export const levelAlertStoreKey = (alert: Pick<AlertRule, "metric">): string => alert.metric ? metricAlertsKey(alert.metric) : ALERTS_KEY;

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

@@ -23,5 +23,9 @@ export interface AlertRule {
   lastQuoteUpdatedAt?: number;
   lastQuoteSource?: QuoteDataSource;
   lastQuoteProviderId?: string;
+  /** The currency of the quote the alert was last checked on (USD): its listing's, which lists show beside it. */
+  lastQuoteCurrency?: string;
+  /** The venue that quote was from (ARCA), which names the listing of a rule set by symbol alone. */
+  lastQuoteExchange?: string;
   message?: string;
 }

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

@@ -1,6 +1,7 @@
 import { usePaneSettingValue } from "../../../public/react";
 import { PortfolioRiskPane } from "./risk-pane";
 import { portfolioRiskHeadless } from "./risk-headless";
+import { NO_HOLDINGS_HINT } from "./risk-model";
 import { portfolioRiskCache } from "./risk-client";
 import { Box, Text } from "../../../ui";
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -398,7 +399,7 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
                 message={accountsError ?? undefined}
                 hint={accountsError
                   ? "Reconnect the broker in the Brokers pane (BR), then refresh."
-                  : "Add holdings from the Portfolio pane (PF), or connect a broker in BR to sync them."}
+                  : NO_HOLDINGS_HINT}
               />
             </Box>
           ) : historyOnly ? (

package/src/plugins/builtin/analytics/risk-client.ts

@@ -58,7 +58,12 @@ interface RiskMarketHistory {
    * Set when the listing quotes in another currency and its closes were
    * restated in USD at same-date daily FX closes; quote and closeMark are then in USD.
    */
-  converted?: { currency: string; fxAsOf: string } | null;
+  converted?: {
+    currency: string;
+    fxAsOf: string;
+    /** US sessions converted at the FX close before them, the pair having none that day (bridgedFxClose). */
+    fxBridged?: string[];
+  } | null;
   error: string | null;
 }
 export interface RiskMarketSnapshot {
@@ -162,6 +167,8 @@ export function validateRiskHistory(
   closeMark: { price: number; date: string; currency: string } | null;
   /** Latest completed close in the returns' currency, whatever marks the holding. */
   latestClose: { price: number; date: string };
+  /** With a conversion, the US sessions converted at the FX close before them (bridgedFxClose). */
+  fxBridged?: string[];
 } {
   if (
     response.status !== "success" ||
@@ -244,13 +251,14 @@ export function validateRiskHistory(
   if (local.integrity)
     throw new Error("Daily history has inconsistent OHLC observations");
   // A converted series is on the NYSE calendar the basket and SPY share.
-  const series = conversion
+  const usd = conversion
     ? convertClosesToUsd(
         points.map((point) => ({ date: new Date(point.date).toISOString().slice(0, 10), close: point.close })),
         conversion.fx,
         conversion.divisor,
       )
-    : prices;
+    : null;
+  const series = usd ? usd.points : prices;
   const returns = conversion ? resolveDatedReturns(series).returns : local.returns;
   const cadence = qualifySharpeCadence(returns, [
     { symbol: instrument.symbol, exchange: conversion ? "NYSE" : exchange, history: series },
@@ -264,6 +272,7 @@ export function validateRiskHistory(
   };
   return {
     returns,
+    ...(usd?.bridged.length ? { fxBridged: usd.bridged } : {}),
     asOf: latestClose.date,
     // A missing or stale quote is not a current mark; the latest dated close is.
     closeMark:
@@ -591,7 +600,7 @@ export async function fetchPortfolioRiskMarket(
             historyParams,
             signal ? { signal } : undefined,
           );
-          const { latestClose, ...resolved } = validateRiskHistory(
+          const { latestClose, fxBridged, ...resolved } = validateRiskHistory(
             response,
             instrument,
             quote,
@@ -610,7 +619,9 @@ export async function fetchPortfolioRiskMarket(
               quote: current,
               currency: "USD",
               closeMark: current ? null : { ...latestClose, currency: "USD" },
-              converted: { currency: conversion.listingCurrency, fxAsOf: fxCloses.asOf },
+              converted: {
+                currency: conversion.listingCurrency, fxAsOf: fxCloses.asOf, ...(fxBridged?.length ? { fxBridged } : {}),
+              },
               error: null,
             };
             continue;