gloomberb 0.18.4 → 0.19.0

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

@@ -1,6 +1,11 @@
+import { METRIC_CHOICES, benchmarkKey, metricWizardFields, parseMetricAlert } from "./metric-command";
+import { firstDailyCheck, metricAvailabilityError, metricReadings } from "./metric-data";
+import { alertLogRule } from "./alert-log";
+import { closeBasis, isDailyMetric, isRelativeMetric, metricReadingText, metricTrigger, validMetricRule, type MetricReading } from "./metric-model";
+import { canonicalExchange } from "../../../utils/exchanges";
 import { startCatalystAlerts } from "./catalysts";
 import { notTheCoinNote } from "../../../cli/commands/crypto-hints";
-import { createFiredAlertRecorder, firedAlertTime, quoteSourceWords } from "./fired-log";
+import { alertChangeEntry, createFiredAlertRecorder, firedAlertTime, quoteSourceWords } from "./fired-log";
 import { checkIvLevelAlertsNow, startIvLevelAlerts } from "./iv-level";
 import { logFailure } from "../../../utils/log-failure";
 import { RESEARCH_FORM_KINDS, RESEARCH_LABELS, researchWizardFields, createResearchAlert } from "./research-builder";
@@ -19,12 +24,15 @@ import { isResearchAlertKind, MAX_LEAD_DAYS } from "./research-rules";
 import { EVENT_ALERT_TEMPLATES, MAX_EVENT_ALERTS, createEventAlert, eventAlertStoreKey, readEventAlertStores, updateEventAlerts } from "./events";
 import { formatMarketPrice } from "../../../market-data/market/format";
 import { settleTypedListingKey } from "../../../tickers/listing-venues";
+import { parseListingArg } from "../../../cli/listing-arg";
+import { notATickerSymbol } from "../../../sources/provider-errors";
 import type { Quote } from "../../../types/financials";
 import type { GloomPlugin } from "../../../types/plugin";
 import {
   createAlert,
   evaluateAlert,
   formatAlertDescription,
+  sameLevelRule,
 } from "./alert-engine";
 import {
   parseAlertCommandValues,
@@ -62,11 +70,21 @@ let alertStream: AlertQuoteStream | null = null;
  */
 const STREAM_PERSIST_MS = 60_000;
 
+/** BTC/USD, BRK/B and EUR/USD are one listing written with a slash, as `alerts add` reads them; XLK/SPY is not. */
+function slashSpellsListing(symbol: string): boolean {
+  try {
+    return parseListingArg(symbol).key !== symbol.toUpperCase();
+  } catch {
+    // Intentional ignore: text the listing reader refuses is no pair to divide, so the quote's own error stands.
+    return true;
+  }
+}
+
 export const alertsPlugin: GloomPlugin = {
   id: "alerts",
   name: "Alerts",
   version: "1.0.0",
-  description: "Price, earnings, filing, news and flow alerts",
+  description: "Price, valuation, daily technical and event alerts",
   toggleable: true,
   cliCommands: [alertsCliCommand],
 
@@ -114,7 +132,7 @@ export const alertsPlugin: GloomPlugin = {
       let persist = false;
       let touched = false;
       for (const alert of alerts) {
-        if (alert.status !== "active") continue;
+        if (alert.metric || alert.status !== "active") continue;
         const quote = readStreamedAlertQuote(alert, undefined, now);
         if (!quote) continue;
         // A re-armed or new alert has no stored baseline: judge nothing on this
@@ -136,7 +154,7 @@ export const alertsPlugin: GloomPlugin = {
       }
       if (!persist && !(touched && now - lastStreamPersistAt >= STREAM_PERSIST_MS)) return;
       lastStreamPersistAt = now;
-      void saveAlerts(ctx, alerts).catch(logFailure("alerts.stream", "Save streamed price alerts failed"));
+      void saveAlerts(ctx, alerts, "price").catch(logFailure("alerts.stream", "Save streamed price alerts failed"));
       if (persist) alertStream?.sync();
     };
     alertStream?.dispose();
@@ -144,8 +162,8 @@ export const alertsPlugin: GloomPlugin = {
     ctx.registerCommand({
       id: "set-alert",
       label: "Add Alert",
-      description: "Create a price alert from a symbol, condition, and target price",
-      keywords: ["add", "set", "alert", "price", "trigger", "notify", "alarm", "watch"],
+      description: "Create a price, valuation or daily technical alert",
+      keywords: ["add", "set", "alert", "pe", "ps", "rsi", "moving average", "valuation", "price", "trigger", "notify", "alarm", "watch"],
       category: "data",
       shortcut: "SA",
       shortcutArg: {
@@ -155,6 +173,7 @@ export const alertsPlugin: GloomPlugin = {
       },
       wizardLayout: "form",
       wizard: [
+        { key: "kind", label: "Kind", type: "select", defaultValue: "price", options: METRIC_CHOICES },
         {
           key: "symbol",
           label: "Symbol",
@@ -162,6 +181,7 @@ export const alertsPlugin: GloomPlugin = {
           type: "text",
         },
         {
+          dependsOn: { key: "kind", value: "price" },
           key: "condition",
           label: "Condition",
           type: "select",
@@ -172,34 +192,84 @@ export const alertsPlugin: GloomPlugin = {
           ],
         },
         {
+          dependsOn: { key: "kind", value: "price" },
           key: "price",
           label: "Target Price",
           placeholder: "200.00",
           type: "number",
         },
+        ...metricWizardFields,
       ],
       async execute(values) {
-        const input = parseAlertCommandValues(values);
+        let input = parseAlertCommandValues(values);
         if (!input) throw new Error("Use a symbol, condition, and target price.");
         // 7203:TSE, typed or from a link, is the venue its symbol trades on, as `alerts add` reads it.
-        const symbol = (await settleTypedListingKey(input.symbol, { store: ctx.tickerRepository, dataProvider: ctx.marketData })).toUpperCase();
-
-        const quote = await resolveAlertQuote(ctx.marketData, symbol);
+        const quoteFor = async (typed: string) => {
+          const key = (await settleTypedListingKey(typed, { store: ctx.tickerRepository, dataProvider: ctx.marketData })).toUpperCase();
+          return { key, quote: await resolveAlertQuote(ctx.marketData, key) };
+        };
+        let resolved: Awaited<ReturnType<typeof quoteFor>>;
+        try {
+          resolved = await quoteFor(input.symbol);
+        } catch (error) {
+          // XLK/SPY is a listing first; only one the service says is no ticker is the ratio of the two, as `alerts add` reads it.
+          // A timeout stays a timeout, and BTC/USD, BRK/B or EUR/USD, one listing written with a slash, keeps its own answer.
+          const pair = !input.metric && /^[^/\s]+\/[^/\s]+$/.test(input.symbol) && notATickerSymbol(error instanceof Error ? error.message : String(error))
+            && !slashSpellsListing(input.symbol) ? parseMetricAlert(`${input.symbol} ratio ${input.condition} ${input.price}`) : null;
+          if (!pair) throw error;
+          input = pair;
+          resolved = await quoteFor(pair.symbol);
+        }
+        const { key: symbol, quote } = resolved;
+        let metric = input.metric;
+        if (metric && isRelativeMetric(metric)) {
+          const reference = (await quoteFor(benchmarkKey(metric))).quote;
+          const benchmarkExchange = canonicalExchange(reference.listingExchangeName || reference.exchangeName || "");
+          const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName || "");
+          const benchmark = reference.symbol || metric.benchmark;
+          if (benchmark === (quote.symbol || symbol) && benchmarkExchange === exchange) throw new Error(`Compare ${benchmark} with another listing.`);
+          metric = { ...metric, benchmark, ...(benchmarkExchange ? { benchmarkExchange } : {}) };
+          // Never save a rule its own list would refuse to read back.
+          if (!validMetricRule({ metric, condition: input.condition, targetPrice: input.price })) throw new Error(`${benchmark} cannot be a benchmark: relative strength alerts compare two US listings.`);
+        }
         // A target ten times away is a slip or another instrument's price, such as bitcoin's on the BTC fund.
         const far = farTargetMessage(symbol, input.price, quote.price, symbol.includes(":") ? null : notTheCoinNote(symbol, quote));
-        if (far) throw new Error(far);
+        if (!input.metric && far) throw new Error(far);
 
-        const alert = {
+        const alert: AlertRule = {
           ...createAlert(quote.symbol || symbol, input.condition, input.price),
-          ...quoteAlertFields(quote),
+          ...(!metric ? quoteAlertFields(quote) : {
+            metric, exchange: quote.listingExchangeName || quote.exchangeName,
+            ...quote.currency ? { lastQuoteCurrency: quote.currency } : {},
+          }),
         };
+        // A close not yet final is read once it is: the rule is kept and says when it is first judged.
+        let firstCheck: string | null = null;
+        if (metric) {
+          const now = Date.now();
+          if (isDailyMetric(metric)) {
+            const check = firstDailyCheck(alert.exchange, now, metric.kind === "rrg");
+            if (check) firstCheck = `first checked on the ${check.day} ${closeBasis(metric) === "weekly close" ? "weekly close" : "close"}, from ${new Date(check.at).toISOString().slice(11, 16)} UTC`;
+          }
+          try {
+            const reading = await metricReadings(ctx.marketData, now)(alert);
+            Object.assign(alert, { lastCheckedPrice: reading.value, lastCheckedTarget: reading.target, lastQuoteUpdatedAt: reading.at,
+              lastCheckedAt: now, ...reading.day ? { lastDailyClose: reading.day } : {} });
+          } catch (error) {
+            if (!isDailyMetric(metric) || metricAvailabilityError(alert)) throw error;
+          }
+        }
         const existing = loadAlerts(ctx);
+        // The same rule on the same listing is one alert: adding it again names it and adds nothing.
+        const duplicate = existing.find((entry) => sameLevelRule(entry, alert));
+        if (duplicate) throw new Error(`${formatAlertDescription(alert)} already exists (alert ${duplicate.id}). Nothing was added.`);
         existing.push(alert);
-        await saveAlerts(ctx, existing);
+        await saveAlerts(ctx, existing, input.metric ? "metric" : "price");
+        recordFired(alertChangeEntry("created", alertLogRule(alert)));
         alertStream?.sync();
 
         ctx.notify({
-          body: `Alert set: ${formatAlertDescription(alert)} (current ${formatMarketPrice(quote.price, { minimumFractionDigits: 2 })})`,
+          body: `Alert set: ${formatAlertDescription(alert)}${input.metric ? firstCheck ? `, ${firstCheck}` : "" : ` (current ${formatMarketPrice(quote.price, { minimumFractionDigits: 2 })})`}`,
           type: "success",
         });
       },
@@ -270,6 +340,7 @@ export const alertsPlugin: GloomPlugin = {
         // An IV level goes in its own list, which released versions never read.
         const key = eventAlertStoreKey(rule);
         await ctx.configState.set(key, updateEventAlerts(ctx.configState.get<string>(key), (rules) => [...rules, rule]));
+        recordFired(alertChangeEntry("created", alertLogRule(rule)));
         ctx.notify({ body: "Event alert saved.", type: "success" });
         if (scheduled) checkScheduledEventAlertsNow();
         if (rule.kind === "iv_level") checkIvLevelAlertsNow();
@@ -278,16 +349,16 @@ export const alertsPlugin: GloomPlugin = {
 
     // The poll carries whatever the stream does not: symbols the feed has not
     // delivered lately, and every symbol while the app is hidden.
-    const poll = async () => {
+    const pollLevels = async (metrics: boolean) => {
       alertStream?.sync();
-      const pending = loadAlerts(ctx).filter((alert) => alert.status === "active" && !readStreamedAlertQuote(alert));
+      const pending = loadAlerts(ctx).filter((alert) => Boolean(alert.metric) === metrics && alert.status === "active" && !readStreamedAlertQuote(alert));
       if (pending.length === 0) return;
 
       ctx.log.info("poll", { active: pending.length });
 
       // One batched pass over the distinct symbols: the alerts pane reads the same
       // persisted store, so this is the only place that talks to the provider.
-      const quoteKeys = [...new Set(pending.map((alert) => `${alert.symbol}\0${alert.exchange ?? ""}`))];
+      const quoteKeys = [...new Set(pending.filter(alert => !alert.metric).map((alert) => `${alert.symbol}\0${alert.exchange ?? ""}`))];
       const results = await Promise.all(quoteKeys.map(async (key): Promise<[string, Quote | string]> => {
         const [symbol, exchange = ""] = key.split("\0");
         try {
@@ -297,15 +368,50 @@ export const alertsPlugin: GloomPlugin = {
           return [key, createQuoteErrorMessage(symbol ?? "", err)];
         }
       }));
+      const readMetric = metricReadings(ctx.marketData);
+      const readings = new Map<string, { armedAt: number; reading: MetricReading | string }>();
+      for (const alert of pending.filter(a => a.metric)) {
+        try { readings.set(alert.id, { armedAt: alert.armedAt ?? alert.createdAt, reading: await readMetric(alert) }); }
+        catch (error) { readings.set(alert.id, { armedAt: alert.armedAt ?? alert.createdAt, reading: error instanceof Error ? error.message : String(error) }); }
+      }
       if (generation !== pollGeneration) return;
       const quotes = new Map<string, Quote | string>(results);
 
       // Read the store again: the stream or the pane may have changed an alert
       // while the quotes were in flight, and an alert must trigger only once.
-      const alerts = loadAlerts(ctx);
+      const alerts = loadAlerts(ctx).filter(alert => Boolean(alert.metric) === metrics);
       let changed = false;
       for (const alert of alerts) {
         if (alert.status !== "active") continue;
+        if (alert.metric) {
+          const result = readings.get(alert.id);
+          if (!result || result.armedAt !== (alert.armedAt ?? alert.createdAt)) continue;
+          const reading = result.reading;
+          if (typeof reading !== "string" && reading.day && reading.day === alert.lastDailyClose && !alert.lastCheckError) continue;
+          if (typeof reading === "string" && reading === alert.lastCheckError) continue;
+          if (typeof reading === "string") Object.assign(alert, quoteErrorAlertFields(reading));
+          else {
+            if (metricTrigger(alert, reading)) {
+              const firedAt = Date.now();
+              alert.status = "triggered"; alert.triggeredAt = firedAt;
+              const description = formatAlertDescription(alert);
+              const readingText = metricReadingText(alert.metric, reading);
+              recordFired({ kind: alert.metric.kind, ruleId: alert.id, rule: description, firedAt, value: reading.value,
+                unit: alert.metric.kind === "pe" || alert.metric.kind === "ps" ? "x" : undefined,
+                // An RRG quadrant is two readings; the figure is strength, the detail says both.
+                ...(alert.metric.kind === "rrg" ? { detail: readingText } : {}),
+                quoteAt: firedAlertTime(reading.at), source: closeBasis(alert.metric),
+                symbol: alert.symbol, exchange: alert.exchange });
+              ctx.notify({ body: alert.metric.kind === "rrg" ? `${description} triggered: ${readingText}` : `${description} triggered at ${readingText}`, type: "success",
+                refId: `price:${alert.id}`, desktop: "always", persistent: true, sound: "Glass",
+                action: { label: "Open", onClick: () => ctx.showPane("alerts") } });
+            }
+            Object.assign(alert, { lastCheckedPrice: reading.value, lastCheckedTarget: reading.target,
+              lastDailyClose: reading.day, lastQuoteUpdatedAt: reading.at, lastCheckedAt: Date.now(), lastCheckError: undefined });
+          }
+          changed = true;
+          continue;
+        }
         if (readStreamedAlertQuote(alert)) continue;
         const quote = quotes.get(`${alert.symbol}\0${alert.exchange ?? ""}`);
         if (quote === undefined) continue;
@@ -327,10 +433,17 @@ export const alertsPlugin: GloomPlugin = {
       }
 
       if (changed) {
-        await saveAlerts(ctx, alerts);
+        await saveAlerts(ctx, alerts, metrics ? "metric" : "price");
       }
     };
 
+    // Metric work may span a poll, but cannot delay the next price check or overlap itself.
+    let metricPoll: Promise<void> | null = null;
+    const poll = () => {
+      metricPoll ??= pollLevels(true).catch(logFailure("alerts.metrics", "Check metric alerts failed")).finally(() => { metricPoll = null; });
+      return pollLevels(false);
+    };
+
     // Re-armed each cycle so a change to the pane's Check interval setting takes
     // effect on the next tick without a restart.
     const scheduleNextPoll = () => {
@@ -377,9 +490,9 @@ export const alertsPlugin: GloomPlugin = {
       id: "alerts-pane",
       paneId: "alerts",
       label: "Alerts",
-      description: "Price, earnings, filing, news and flow alerts",
+      description: "Price, valuation, daily technical and event alerts",
       keywords: [
-        "alerts", "alert", "price", "trigger", "alarm", "watch", "notify", "notification",
+        "alerts", "alert", "price", "valuation", "pe", "ps", "rsi", "moving average", "trigger", "alarm", "watch", "notify", "notification",
         "earnings", "cpi", "fomc", "filing", "filings", "sec", "8-k", "13f", "news", "keyword",
         "analyst", "upgrade", "downgrade", "52-week", "unusual volume", "volume", "short interest",
         "insider", "congress", "catalyst", "implied volatility", "iv spike", "options flow", "perps", "funding",

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

@@ -39,11 +39,11 @@ export function streamedAlertQuote(quote: Quote | null | undefined, now = Date.n
 }
 
 export function readStreamedAlertQuote(
-  alert: Pick<AlertRule, "symbol" | "exchange">,
+  alert: Pick<AlertRule, "symbol" | "exchange" | "metric">,
   coordinator: MarketDataCoordinator | null = getSharedMarketDataCoordinator(),
   now = Date.now(),
 ): Quote | null {
-  if (!coordinator) return null;
+  if (alert.metric || !coordinator) return null;
   return streamedAlertQuote(resolveEntryData(coordinator.getQuoteEntry(alertInstrument(alert))), now);
 }
 
@@ -93,7 +93,7 @@ export function createAlertQuoteStream({
     const next = getSharedMarketDataCoordinator();
     const instruments = new Map<string, InstrumentRef>();
     for (const alert of readAlerts()) {
-      if (alert.status !== "active") continue;
+      if (alert.metric || alert.status !== "active") continue;
       const instrument = alertInstrument(alert);
       instruments.set(buildQuoteKey(instrument), instrument);
     }

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

@@ -0,0 +1,134 @@
+import type { AlertMetric, RotationQuadrant } from "./metric-model";
+import { ROTATION_QUADRANTS, validMetricRule } from "./metric-model";
+import { readAlertPrice } from "./price";
+import type { AlertCondition } from "./types";
+import type { WizardStep } from "../../../types/plugin";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
+
+export interface MetricAlertInput { symbol: string; condition: AlertCondition; price: number; metric: AlertMetric }
+const direction = (s: string) => /^(above|over|>)$/i.test(s) ? "above" as const : /^(below|under|<)$/i.test(s) ? "below" as const : null;
+const USAGE = "Use AAPL pe below 25, AAPL ps above 8, NVDA rsi(14) under 30, SPY ma(50) crosses above ma(200), or TSLA closes below ma(200).";
+function checked(input: MetricAlertInput): MetricAlertInput {
+  if (!validMetricRule({ ...input, targetPrice: input.price })) throw new Error("Use a positive multiple, RSI from 0 to 100, and whole MA/RSI periods from 2 to 200 (fast MA shorter than slow MA).");
+  return input;
+}
+// RRG's own default benchmark (relative-rotation/model.ts), kept here so the CLI does not load the RRG pane's model.
+const DEFAULT_ROTATION_BENCHMARK = "SPY:NYSEARCA";
+const RELATIVE_USAGE = "Relative strength alerts take the ratio of two listings or an RRG quadrant: alerts add XLK/SPY above 0.25, or alerts add XLE rrg leading [--benchmark SPY].";
+const QUADRANT_USAGE = "An RRG alert names the quadrant it enters: leading, weakening, lagging or improving, such as alerts add XLE rrg leading [--benchmark SPY].";
+/** A benchmark typed as SPY or SPY:NYSEARCA; its listing is confirmed when the alert is added. */
+function benchmarkListing(text: string): { benchmark: string; benchmarkExchange?: string } {
+  const parsed = parsePublicTickerKey(text.toUpperCase());
+  if (!/^[A-Z0-9.^=-]{1,20}$/.test(parsed.symbol)) throw new Error(`Not a benchmark listing: ${text}.`);
+  return { benchmark: parsed.symbol, ...(parsed.exchange ? { benchmarkExchange: parsed.exchange } : {}) };
+}
+const sameListing = (symbol: string, metric: { benchmark: string }) => parsePublicTickerKey(symbol).symbol === metric.benchmark;
+/**
+ * `XLK/SPY ratio above 0.25` and `XLE rrg leading [vs SPY]`; undefined for anything else. `XLK/SPY above 0.25`
+ * without the word is first a listing (BRK/B, EUR/USD), so `alerts add` reads it as a ratio only once it quotes nothing.
+ */
+function parseRelativeAlert(parts: readonly string[]): MetricAlertInput | undefined {
+  const [first = "", second = "", ...rest] = parts;
+  const kind = second.toLowerCase();
+  if (kind === "rrg") {
+    const [quadrant = "", vs, benchmark, ...extra] = rest;
+    if (first.includes("/")) throw new Error(`Name the benchmark of an RRG alert after it: alerts add ${first.split("/")[0]!.toUpperCase()} rrg ${quadrant.toLowerCase() || "leading"} --benchmark ${first.split("/")[1]!.toUpperCase()}.`);
+    if (!(ROTATION_QUADRANTS as readonly string[]).includes(quadrant.toLowerCase())) throw new Error(QUADRANT_USAGE);
+    if (vs !== undefined && (!/^(vs\.?|versus|against)$/i.test(vs) || !benchmark || extra.length > 0)) throw new Error(QUADRANT_USAGE);
+    const metric = { kind: "rrg" as const, quadrant: quadrant.toLowerCase() as RotationQuadrant, ...benchmarkListing(benchmark ?? DEFAULT_ROTATION_BENCHMARK) };
+    if (sameListing(first, metric)) throw new Error(`An RRG alert compares ${first.toUpperCase()} with another listing: alerts add ${first.toUpperCase()} rrg ${metric.quadrant} --benchmark SPY.`);
+    return checked({ symbol: first.toUpperCase(), condition: "crosses", price: 0, metric });
+  }
+  const pair = /^([^/]+)\/([^/]+)$/.exec(first);
+  if (pair && kind === "ratio") {
+    const [typed = "", level, ...extra] = rest;
+    const condition = direction(typed) ?? (/^(crosses|cross|x)$/i.test(typed) ? "crosses" as const : null);
+    const example = `alerts add ${first.toUpperCase()} above 0.25`;
+    if (!condition || level === undefined || extra.length > 0) throw new Error(`A ratio alert takes above, below or crosses and a ratio: ${example}.`);
+    const metric = { kind: "rs_ratio" as const, ...benchmarkListing(pair[2]!) };
+    if (sameListing(pair[1]!, metric)) throw new Error(`A ratio alert divides one listing by another: ${example}.`);
+    const price = readAlertPrice(level);
+    if (!(price > 0)) throw new Error(`A ratio alert takes a positive ratio: ${example}.`);
+    return checked({ symbol: pair[1]!.toUpperCase(), condition, price, metric });
+  }
+  // `XLE rs above 100`, `XLE vs SPY above 1`, `XLE relative strength leading`: a relative alert typed another way.
+  if (/^(rs|rsr|rs-?ratio|rs_ratio|rs-?momentum|rel|relative|rotation|quadrant|ratio|vs\.?|versus)$/i.test(kind)
+    && rest.some((word) => /^(above|below|over|under|crosses|cross|>|<|leading|weakening|lagging|improving|rrg)$/i.test(word))) {
+    throw new Error(RELATIVE_USAGE);
+  }
+  return undefined;
+}
+/** Parses both compact CLI notation and the words traders type, without swallowing malformed metrics as calendar events. */
+export function parseMetricAlert(input: string): MetricAlertInput | null {
+  const words = input.trim().replace(/\s+/g, " ");
+  const parts = words.split(" ");
+  const relative = parseRelativeAlert(parts);
+  if (relative) return relative;
+  if (!/^(p\/?e|p\/?s|rsi(?:\(|$)|ma(?:\(|$)|\d+-day|closes?$)/i.test(parts[1] ?? "")) return null;
+  const ratio = /^(\S+) (p\/?e|p\/?s) (above|below|over|under|>|<) (\S+)$/i.exec(words);
+  if (ratio) return checked({ symbol: ratio[1]!.toUpperCase(), metric: { kind: ratio[2]!.toLowerCase().replace("/", "") as "pe" | "ps" }, condition: direction(ratio[3]!)!, price: readAlertPrice(ratio[4]!) });
+  const rsi = /^(\S+) rsi(?:\((\d+)\)| (\d+))? (above|below|over|under|>|<) (\S+)$/i.exec(words);
+  if (rsi) return checked({ symbol: rsi[1]!.toUpperCase(), metric: { kind: "rsi", period: Number(rsi[2] ?? rsi[3] ?? 14) }, condition: direction(rsi[4]!)!, price: readAlertPrice(rsi[5]!) });
+  const ma = words.replace(/(?:its|the) /gi, "").replace(/(\d+)-day(?: (?:ma|moving average))?/gi, "ma($1)").replace(/ma (\d+)/gi, "ma($1)");
+  const cross = /^(\S+) ma\((\d+)\) crosses (above|below) ma\((\d+)\)$/i.exec(ma);
+  if (cross) return checked({ symbol: cross[1]!.toUpperCase(), metric: { kind: "ma_cross", period: Number(cross[2]), slowPeriod: Number(cross[4]), direction: direction(cross[3]!)! }, condition: "crosses", price: 0 });
+  const close = /^(\S+) closes? (above|below|over|under) ma\((\d+)\)$/i.exec(ma);
+  if (close) return checked({ symbol: close[1]!.toUpperCase(), metric: { kind: "close_ma", period: Number(close[3]) }, condition: direction(close[2]!)!, price: 0 });
+  throw new Error(USAGE);
+}
+export const benchmarkKey = (metric: { benchmark: string; benchmarkExchange?: string }) => `${metric.benchmark}${metric.benchmarkExchange ? `:${metric.benchmarkExchange}` : ""}`;
+/** A relative alert as `alerts add` takes it, for editing: `XLK/SPY ratio above 0.25`, `XLE rrg leading vs SPY`. */
+export function relativeAlertText(input: { symbol: string; condition: AlertCondition; targetPrice: number; metric?: AlertMetric }): string | null {
+  const m = input.metric;
+  if (m?.kind === "rs_ratio") return `${input.symbol}/${m.benchmark} ratio ${input.condition} ${input.targetPrice}`;
+  return m?.kind === "rrg" ? `${input.symbol} rrg ${m.quadrant} vs ${m.benchmark}` : null;
+}
+export function metricShortcut(input: MetricAlertInput): Record<string, string> {
+  const m = input.metric;
+  if (m.kind === "rs_ratio") return { symbol: input.symbol, kind: m.kind, "rs_ratio:benchmark": benchmarkKey(m), "rs_ratio:condition": input.condition, "rs_ratio:target": String(input.price) };
+  if (m.kind === "rrg") return { symbol: input.symbol, kind: m.kind, "rrg:quadrant": m.quadrant, "rrg:benchmark": benchmarkKey(m) };
+  return { symbol: input.symbol, kind: m.kind, [`${m.kind}:condition`]: m.kind === "ma_cross" ? m.direction : input.condition,
+    [`${m.kind}:target`]: String(input.price), ...("period" in m ? { [`${m.kind}:period`]: String(m.period) } : {}),
+    ...(m.kind === "ma_cross" ? { "ma_cross:slowPeriod": String(m.slowPeriod) } : {}) };
+}
+export function metricFormInput(values: Record<string, string>): MetricAlertInput | null {
+  const kind = values.kind;
+  if (!kind || kind === "price") return null;
+  const symbol = values.symbol?.trim().toUpperCase();
+  if (!symbol) return null;
+  if (kind === "rs_ratio") {
+    const benchmark = values["rs_ratio:benchmark"]?.trim();
+    return benchmark ? parseMetricAlert(`${symbol}/${benchmark} ratio ${values["rs_ratio:condition"] ?? "above"} ${values["rs_ratio:target"] ?? ""}`) : null;
+  }
+  if (kind === "rrg") return parseMetricAlert(`${symbol} rrg ${values["rrg:quadrant"] ?? "leading"} vs ${values["rrg:benchmark"]?.trim() || DEFAULT_ROTATION_BENCHMARK}`);
+  const condition = values[`${kind}:condition`] ?? "below";
+  const window = values[`${kind}:period`] ?? (kind === "rsi" ? "14" : kind === "ma_cross" ? "50" : "200");
+  const text = kind === "ma_cross" ? `${symbol} ma(${window}) crosses ${condition} ma(${values["ma_cross:slowPeriod"] ?? "200"})`
+    : kind === "close_ma" ? `${symbol} closes ${condition} ma(${window})`
+    : `${symbol} ${kind === "rsi" ? `rsi(${window})` : kind} ${condition} ${values[`${kind}:target`] ?? ""}`;
+  return parseMetricAlert(text);
+}
+export const METRIC_CHOICES = [
+  { value: "price", label: "Price" }, { value: "pe", label: "P/E (TTM)" }, { value: "ps", label: "P/S (TTM)" },
+  { value: "rsi", label: "RSI" }, { value: "ma_cross", label: "MA crossover" }, { value: "close_ma", label: "Close vs MA" },
+  { value: "rs_ratio", label: "Ratio to benchmark" }, { value: "rrg", label: "RRG quadrant" },
+];
+const RELATIVE_FIELDS: WizardStep[] = [
+  { key: "rs_ratio:benchmark", label: "Divided by", type: "text", placeholder: "SPY", dependsOn: { key: "kind", value: "rs_ratio" } },
+  { key: "rs_ratio:condition", label: "Condition", type: "select", defaultValue: "above", dependsOn: { key: "kind", value: "rs_ratio" },
+    options: [{ label: "Above", value: "above" }, { label: "Below", value: "below" }, { label: "Crosses", value: "crosses" }] },
+  { key: "rs_ratio:target", label: "Ratio", type: "number", placeholder: "0.25", dependsOn: { key: "kind", value: "rs_ratio" } },
+  { key: "rrg:quadrant", label: "Enters", type: "select", defaultValue: "leading", dependsOn: { key: "kind", value: "rrg" },
+    options: ROTATION_QUADRANTS.map((value) => ({ label: `${value[0]!.toUpperCase()}${value.slice(1)}`, value })) },
+  { key: "rrg:benchmark", label: "Benchmark", type: "text", defaultValue: "SPY", placeholder: "SPY", dependsOn: { key: "kind", value: "rrg" } },
+];
+export const metricWizardFields: WizardStep[] = [...METRIC_CHOICES.filter(x => x.value !== "price" && x.value !== "rs_ratio" && x.value !== "rrg").flatMap(({ value: kind }) => {
+  const dependsOn = { key: "kind", value: kind };
+  return [
+    ...(["rsi", "ma_cross", "close_ma"].includes(kind) ? [{ key: `${kind}:period`, label: kind === "ma_cross" ? "Fast MA (days)" : kind === "rsi" ? "RSI period" : "MA (days)", type: "number" as const, defaultValue: kind === "rsi" ? "14" : kind === "ma_cross" ? "50" : "200", dependsOn }] : []),
+    { key: `${kind}:condition`, label: "Condition", type: "select" as const, defaultValue: "below", dependsOn,
+      options: [{ label: kind === "ma_cross" ? "Crosses above" : "Above", value: "above" }, { label: kind === "ma_cross" ? "Crosses below" : "Below", value: "below" }] },
+    ...(kind === "ma_cross" ? [{ key: "ma_cross:slowPeriod", label: "Slow MA (days)", type: "number" as const, defaultValue: "200", dependsOn }]
+      : kind === "close_ma" ? [] : [{ key: `${kind}:target`, label: kind === "rsi" ? "RSI level" : "Target multiple", type: "number" as const, placeholder: kind === "rsi" ? "30" : kind === "pe" ? "25" : "8", dependsOn }]),
+  ];
+}), ...RELATIVE_FIELDS];

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

@@ -0,0 +1,111 @@
+import type { AssetDataProvider } from "../../../types/data-provider";
+import type { TickerFinancials } from "../../../types/financials";
+import { liveMarketCapitalization, liveTrailingPE } from "../../../market-data/quotes/live-valuation";
+import { comparablePriceEarnings } from "../../../utils/price-earnings";
+import { canonicalExchange } from "../../../utils/exchanges";
+import { getPublishedUsEquitySession } from "../../../market-data/published-us-sessions";
+import { barSessionDay } from "../../../market-data/market/period-return";
+import { finalDailyBars } from "../../../time-series/session-bar";
+import { getPricePointTimestamp } from "../../../utils/price-history";
+import { DAILY_CLOSE_SETTLE_MS, dailyMetricReading, latestSettledClose, DailyMetricCache, isDailyMetric, isRelativeMetric, type MetricReading } from "./metric-model";
+import type { AlertRule } from "./types";
+
+// Keep valuation fixtures in step with the delivery evaluator and the research panes.
+/** Current trailing figures on the same regular-session and currency basis as the research panes. */
+export function valuationAlertValue(kind: "pe" | "ps", data: TickerFinancials): number | null {
+  const { quote, fundamentals: f } = data;
+  if (!quote || quote.stale || !Number.isFinite(quote.price) || quote.price <= 0 || !f || f.stale) return null;
+  if (kind === "pe") return comparablePriceEarnings(liveTrailingPE(quote, f));
+  const cap = liveMarketCapitalization(quote, f);
+  if (!cap || !f.revenue || !Number.isFinite(f.revenue) || f.revenue <= 0
+    || !f.financialCurrency || cap.currency !== f.financialCurrency) return null;
+  const value = cap.value / f.revenue;
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+
+const US_CALENDAR = "Daily technical alerts need a published US listing calendar; delivery is unavailable for this listing.";
+/** Why a rule's listings cannot be judged on settled closes: a benchmark is held to the same US calendar as the listing. */
+export function metricAvailabilityError(rule: AlertRule, now = Date.now()): string | null {
+  if (!rule.metric || !isDailyMetric(rule.metric)) return null;
+  const today = new Date(now).toISOString().slice(0, 10);
+  if (!getPublishedUsEquitySession(canonicalExchange(rule.exchange ?? ""), today)) return US_CALENDAR;
+  return isRelativeMetric(rule.metric) && !getPublishedUsEquitySession(canonicalExchange(rule.metric.benchmarkExchange ?? ""), today)
+    ? `Relative strength alerts compare two US listings; ${rule.metric.benchmark} has no published US listing calendar here.` : null;
+}
+
+/**
+ * The first close a daily technical rule set at `now` is judged on, and when:
+ * the next session to close after it, read once the close has settled
+ * (DAILY_CLOSE_SETTLE_MS). `weekly` (an RRG quadrant) waits for the last
+ * session of that Monday-Friday week, its weekly close. Null when the listing
+ * has no published calendar.
+ */
+export function firstDailyCheck(exchange: string | undefined, now = Date.now(), weekly = false): { day: string; at: number } | null {
+  const venue = canonicalExchange(exchange ?? "");
+  let first: { day: string; close: number } | null = null;
+  for (let offset = 0; offset < 15; offset++) {
+    const time = now + offset * 86_400_000;
+    const day = new Date(time).toISOString().slice(0, 10);
+    // The weekly close is the last session before the weekend after the first close.
+    if (first && new Date(time).getUTCDay() === 6) break;
+    const session = getPublishedUsEquitySession(venue, day);
+    if (!session) return null;
+    if (session.kind !== "session" || session.close <= now) continue;
+    first = { day, close: session.close };
+    if (!weekly) break;
+  }
+  return first ? { day: first.day, at: first.close + DAILY_CLOSE_SETTLE_MS } : null;
+}
+
+/** The bar size the daily rules read, the one `history` and the charts ask for. */
+const DAILY_BARS = "1d";
+
+const dailyCaches = new WeakMap<AssetDataProvider, DailyMetricCache>();
+
+/** A pass shares each listing's reads; there is no second provider or quote subscription. */
+export function metricReadings(provider: AssetDataProvider, now = Date.now()) {
+  const daily = dailyCaches.get(provider) ?? new DailyMetricCache();
+  dailyCaches.set(provider, daily);
+  const financials = new Map<string, Promise<TickerFinancials>>();
+  const history = new Map<string, Promise<Awaited<ReturnType<AssetDataProvider["getPriceHistory"]>> >>();
+  return async (rule: AlertRule): Promise<MetricReading> => {
+    const m = rule.metric!;
+    const key = `${rule.symbol}|${rule.exchange ?? ""}`;
+    if (!isDailyMetric(m)) {
+      const data = financials.get(key) ?? provider.getTickerFinancials(rule.symbol, rule.exchange);
+      financials.set(key, data);
+      const loaded = await data;
+      const value = valuationAlertValue(m.kind as "pe" | "ps", loaded);
+      if (value == null) throw new Error(m.kind === "pe" ? "Trailing P/E is unavailable or not meaningful." : "Trailing P/S is unavailable on a matching currency basis.");
+      return { value, target: rule.targetPrice, at: loaded.quote?.lastUpdated ?? now };
+    }
+    const exchange = canonicalExchange(rule.exchange ?? "");
+    const session = (day: string) => getPublishedUsEquitySession(exchange, day);
+    const unavailable = metricAvailabilityError(rule, now);
+    if (unavailable) throw new Error(unavailable);
+    const latest = latestSettledClose(now, session);
+    const ruleKey = JSON.stringify([rule.id, rule.armedAt ?? rule.createdAt, key, rule.condition, rule.targetPrice, m]);
+    return daily.read(ruleKey, latest.day, now, async () => {
+      const load = async (symbol: string, venue: string) => {
+        // An explicit end at the settled session avoids today's forming-bar quote read.
+        const end = new Date(`${latest.day}T23:59:59Z`);
+        const start = new Date(Date.parse(latest.day) - 366 * 86_400_000);
+        if (provider.getDetailedPriceHistoryWithMetadata) return (await provider.getDetailedPriceHistoryWithMetadata(symbol, venue, start, end, DAILY_BARS, { cacheMode: "current" })).points;
+        if (provider.getDetailedPriceHistory) return provider.getDetailedPriceHistory(symbol, venue, start, end, DAILY_BARS, { cacheMode: "current" });
+        throw new Error("Completed daily history is unavailable from this connection.");
+      };
+      const completed = async (symbol: string, venue: string) => {
+        const listing = `${symbol}|${venue}`;
+        const request = history.get(listing) ?? load(symbol, venue);
+        history.set(listing, request);
+        // Final as `history` shows it: a close it prints without `partial` is one the rule may judge.
+        // Bars read back from the saved cache carry their dates as text.
+        return finalDailyBars(await request, { now, venue }).map(point => ({ date: barSessionDay(getPricePointTimestamp(point), venue), close: point.close }));
+      };
+      const bars = await completed(rule.symbol, exchange);
+      // RS ratios and RRG quadrants read the benchmark's own completed bars, never a quote.
+      const benchmark = isRelativeMetric(m) ? await completed(m.benchmark, canonicalExchange(m.benchmarkExchange ?? "")) : undefined;
+      return dailyMetricReading(rule, bars, now, session, benchmark);
+    });
+  };
+}