@gloom-sh/terminal 0.18.5 → 0.19.1

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

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

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

@@ -1,8 +1,9 @@
-import type { AlertMetric } from "./metric-model";
-import { validMetricRule } from "./metric-model";
+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;
@@ -11,10 +12,58 @@ 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]!) });
@@ -27,8 +76,17 @@ export function parseMetricAlert(input: string): MetricAlertInput | null {
   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) } : {}) };
@@ -38,6 +96,11 @@ export function metricFormInput(values: Record<string, string>): MetricAlertInpu
   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"})`
@@ -48,8 +111,18 @@ export function metricFormInput(values: Record<string, string>): MetricAlertInpu
 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").flatMap(({ value: kind }) => {
+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 }] : []),
@@ -58,4 +131,4 @@ export const metricWizardFields: WizardStep[] = METRIC_CHOICES.filter(x => x.val
     ...(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

@@ -5,7 +5,9 @@ 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 { dailyMetricReading, latestSettledClose, DailyMetricCache, isDailyMetric, type MetricReading } from "./metric-model";
+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.
@@ -21,12 +23,43 @@ export function valuationAlertValue(kind: "pe" | "ps", data: TickerFinancials):
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
-export function metricAvailabilityError(rule: AlertRule): string | 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;
-  return getPublishedUsEquitySession(canonicalExchange(rule.exchange ?? ""), new Date().toISOString().slice(0, 10))
-    ? null : "Daily technical alerts need a published US listing calendar; delivery is unavailable for this listing.";
+  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. */
@@ -48,23 +81,31 @@ export function metricReadings(provider: AssetDataProvider, now = Date.now()) {
     }
     const exchange = canonicalExchange(rule.exchange ?? "");
     const session = (day: string) => getPublishedUsEquitySession(exchange, day);
-    if (!session(new Date(now).toISOString().slice(0, 10))) throw new Error("Daily technical alerts need a published US listing calendar; delivery is unavailable for this listing.");
+    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 () => {
+      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(rule.symbol, exchange, start, end, "1 day", { cacheMode: "current" })).points;
-        if (provider.getDetailedPriceHistory) return provider.getDetailedPriceHistory(rule.symbol, exchange, start, end, "1 day", { cacheMode: "current" });
+        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 request = history.get(key) ?? load();
-      history.set(key, request);
-      const points = await request;
-      const bars = points.filter(point => !point.partial).map(point => ({ date: barSessionDay(point.date.getTime(), exchange), close: point.close }));
-      return dailyMetricReading(rule, bars, now, session);
+      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);
     });
   };
 }