gloomberb 0.18.4 → 0.18.5

package/src/market-data/quotes/resolution.ts

@@ -221,6 +221,8 @@ function assignDailyChangeFields(
   }
 
   assignField(target, provenance, "previousClose", referenceProvider);
+  // The day that close is from comes with it, from the same source.
+  if (referenceProvider.previousCloseDate) target.previousCloseDate = referenceProvider.previousCloseDate;
   const price = target.price;
   const previousClose = target.previousClose;
   if (!finitePositiveNumber(price) || !finitePositiveNumber(previousClose)) {
@@ -500,6 +502,7 @@ export function resolveCanonicalQuote(
     // What that move is from when it is not previousClose; absent when it is.
     ...(resolved.changeBasis ? { changeBasis: resolved.changeBasis } : {}),
     previousClose: resolved.previousClose as Quote["previousClose"],
+    ...(resolved.previousCloseDate ? { previousCloseDate: resolved.previousCloseDate } : {}),
     regularClose: priceProvider?.regularClose,
     regularCloseSessionDate: priceProvider?.regularClose != null ? priceProvider.regularCloseSessionDate : undefined,
     regularChange: priceProvider?.regularClose != null ? priceProvider.regularChange : undefined,

package/src/market-data/selectors.ts

@@ -6,6 +6,7 @@ import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
 import { normalizePriceHistory } from "../utils/price-history";
 import { resolveTickerFinancialsQuoteState } from "./quotes/resolution";
 import { instrumentIdentityKey } from "../utils/instrument-identity";
+import { withSavedCopyMarkOf } from "../data/saved-copies";
 
 export function toMarketDataContext(instrument: InstrumentRef): MarketDataRequestContext {
   return {
@@ -123,6 +124,8 @@ export function buildTickerFinancialsSnapshot(
 
   return {
     ...resolved,
+    // The quote shown is a saved copy when the newest quote answered was one.
+    ...(resolved.quote ? { quote: withSavedCopyMarkOf(resolved.quote, quote ?? snapshot?.quote) } : {}),
     priceHistory: normalizePriceHistory(priceHistory ?? snapshot?.priceHistory ?? []),
   };
 }

package/src/notifications/notification-log.ts

@@ -6,22 +6,24 @@ export const NOTIFICATION_LOG_LIMIT = 300;
 
 /**
  * The notices worth finding again after their toast is gone: a price alert or
- * a catalyst that fired, a high-impact economic print, and a team card. Chat
+ * a catalyst that fired, a high-impact economic print, a team card, and new
+ * matches of a live scan with its alerts on. Chat
  * keeps its own unread state on the account, and plain info, success and
  * error toasts are not logged.
  */
-export type MissedNoticeKind = "price" | "catalyst" | "econ" | "team";
+export type MissedNoticeKind = "price" | "catalyst" | "econ" | "team" | "scan";
 
 const KIND_PREFIXES: ReadonlyArray<readonly [MissedNoticeKind, string]> = [
   ["price", "price:"],
   ["catalyst", "catalyst:"],
   ["econ", "econ:"],
   ["team", "team:"],
+  ["scan", "scan:"],
 ];
 
 export interface NotificationLogEntry {
   id: string;
-  /** `price:<alertId>`, `catalyst:<eventId>`, `econ:<eventId>` or `team:<cardId>`. A later notice with the same ref updates this row. */
+  /** `price:<alertId>`, `catalyst:<eventId>`, `econ:<eventId>`, `team:<cardId>` or `scan:<paneId>`. A later notice with the same ref updates this row. */
   refId: string;
   title?: string;
   body: string;
@@ -137,7 +139,7 @@ export function unreadNotificationLogCount(log: readonly NotificationLogEntry[]
 
 /**
  * Records a notice whose `refId` names a price alert, a catalyst, an economic
- * release or a team card; anything else returns null and is not kept. The same ref replaces its
+ * release, a team card or a live scan; anything else returns null and is not kept. The same ref replaces its
  * row: a price alert that fires again is new and unread again.
  */
 export function appendNotificationLog(

package/src/plugins/builtin/alerts/alert-engine.ts

@@ -1,3 +1,4 @@
+import { metricDescription, readAlertMetric, validMetricRule } from "./metric-model";
 import type { AlertCondition, AlertRule } from "./types";
 import { logFailure } from "../../../utils/log-failure";
 
@@ -42,6 +43,7 @@ export function editAlert(
     armedAt: Date.now(),
     status: "active",
     message: alert.message,
+    ...(alert.metric ? { metric: alert.metric } : {}),
   };
 }
 
@@ -50,7 +52,7 @@ export function rearmAlert(alert: AlertRule): AlertRule {
 }
 
 export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
-  if (alert.status !== "active") return false;
+  if (alert.metric || alert.status !== "active") return false;
 
   switch (alert.condition) {
     case "above":
@@ -69,6 +71,7 @@ export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
 }
 
 export function formatAlertDescription(alert: AlertRule): string {
+  if (alert.metric) return metricDescription(alert);
   const prefix = alert.condition === "above" ? ">"
     : alert.condition === "below" ? "<" : "↕";
   return `${alert.symbol} ${prefix} ${alert.targetPrice}`;
@@ -94,6 +97,7 @@ function readAlerts(json: unknown): { alerts: AlertRule[]; error: string | null
       a != null && typeof a.id === "string" && !!a.id && typeof a.symbol === "string" && !!a.symbol
       && typeof a.condition === "string" && !!a.condition && typeof a.targetPrice === "number"
       && (a.exchange == null || typeof a.exchange === "string")
+      && (a.metric == null || (readAlertMetric(a.metric) != null && validMetricRule(a)))
     ));
     return {
       alerts,

package/src/plugins/builtin/alerts/calendar-events.ts

@@ -5,6 +5,7 @@
 // two cases of the same alert, whose dates come from their own calendars.
 import { dateKey, eventCountry, matchesCountry, type CountryFilter } from "../econ/calendar-model";
 import { isAllDayEvent, hasNoReleaseTime, type EconEvent, type EconImpact } from "../econ/types";
+import { RENAMED_RELEASES } from "../shared/macro-releases";
 import { MACRO_EVENT_NAMES } from "./research-builder";
 import type { MacroAlertEvent } from "./research-rules";
 
@@ -52,6 +53,39 @@ export function calendarNameWords(name: string): string[] {
 
 const nameKey = (name: string) => calendarNameWords(name).join(" ");
 
+/** A release series' former name a typed name used, read as its current one. */
+export interface ReleaseRename {
+  former: string;
+  current: string;
+  since: string;
+}
+
+/**
+ * A name's words with a renamed series' former name put as its current one
+ * (`caixin pmi` as `ratingdog pmi`), and the rename; null for a name that
+ * carries none.
+ */
+function withCurrentName(words: readonly string[]): { words: string[]; rename: ReleaseRename } | null {
+  for (const { former, current, since } of RENAMED_RELEASES) {
+    for (const name of former) {
+      const old = calendarNameWords(name);
+      for (let at = 0; at + old.length <= words.length; at += 1) {
+        if (!old.every((word, index) => words[at + index] === word)) continue;
+        return {
+          words: [...words.slice(0, at), ...calendarNameWords(current), ...words.slice(at + old.length)],
+          rename: { former: name, current, since },
+        };
+      }
+    }
+  }
+  return null;
+}
+
+/** "Caixin releases were renamed RatingDog from the August 2025 survey." */
+export function releaseRenameNote({ former, current, since }: ReleaseRename): string {
+  return `${former} releases were renamed ${current} from ${since}.`;
+}
+
 /** The UTC day the calendar lists a row under. */
 const utcDay = (time: number) => new Date(time).toISOString().slice(0, 10);
 
@@ -121,13 +155,17 @@ function calendarChoices(events: readonly EconEvent[], now: number): RankedChoic
 }
 
 /** What a typed release names in the calendar. */
-export type CalendarEventMatch =
+export type CalendarEventMatch = (
   /** One release, the best of those the words name, and the others they name in the same country. */
   | { kind: "match"; choice: CalendarEventChoice; others: CalendarEventChoice[] }
   /** The words name releases in several countries: the best of each. */
   | { kind: "countries"; choices: CalendarEventChoice[] }
   /** Nothing the words name; the nearest names, best first. */
-  | { kind: "none"; suggestions: CalendarEventChoice[] };
+  | { kind: "none"; suggestions: CalendarEventChoice[] }
+) & {
+  /** The former name the words used, read as the series' current one (`Caixin PMI` as RatingDog's). */
+  renamed?: ReleaseRename;
+};
 
 /** Character pairs of a name, for how near a slip is to it. */
 function pairs(text: string): Map<string, number> {
@@ -186,7 +224,8 @@ function oneSlipApart(left: string, right: string): boolean {
  * then the closest name and the soonest date, so `NBS PMI` is the headline
  * NBS Manufacturing PMI and an old name listed only in the past never beats
  * the live one. Several countries ask which; no match offers the nearest
- * names.
+ * names. A series' former name reads as its current one (`Caixin PMI` is
+ * RatingDog's), and the match says so.
  */
 export function matchCalendarEvent(
   query: string,
@@ -194,7 +233,18 @@ export function matchCalendarEvent(
   events: readonly EconEvent[],
   now: number,
 ): CalendarEventMatch {
-  const words = calendarNameWords(query);
+  const typedWords = calendarNameWords(query);
+  const current = withCurrentName(typedWords);
+  const match = matchCalendarWords(current?.words ?? typedWords, country, events, now);
+  return current ? { ...match, renamed: current.rename } : match;
+}
+
+function matchCalendarWords(
+  words: readonly string[],
+  country: CountryFilter | null,
+  events: readonly EconEvent[],
+  now: number,
+): CalendarEventMatch {
   const choices = calendarChoices(country ? events.filter((event) => matchesCountry(event, country)) : events, now);
   const exact = choices.filter((choice) => choice.words.join(" ") === words.join(" "));
   const naming = (typed: readonly string[], loose: boolean) => typed.length === 0 ? [] : choices.filter((choice) =>
@@ -266,9 +316,10 @@ function renamedBy(words: readonly string[], other: readonly string[]): number |
  */
 function releaseRows(target: CalendarReleaseTarget, events: readonly EconEvent[]): EconEvent[] {
   const words = calendarNameWords(target.event);
-  const key = words.join(" ");
+  // An alert kept under a series' former name follows the rows under its current one.
+  const keys = new Set([words.join(" "), withCurrentName(words)?.words.join(" ")]);
   const own = events.filter((event) => eventCountry(event) === target.country);
-  const named = own.filter((event) => nameKey(event.event) === key);
+  const named = own.filter((event) => keys.has(nameKey(event.event)));
   if (!target.publisher) return named;
   const namedDays = new Set(named.map((event) => dateKey(event.date)));
   const renamed = own.flatMap((event) => {

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

@@ -1,3 +1,6 @@
+import { metricDescription } from "./metric-model";
+import { parseMetricAlert, type MetricAlertInput } from "./metric-command";
+import { metricReadings } from "./metric-data";
 import { withConfigData, withMarketData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
@@ -24,11 +27,13 @@ import {
   macroEventNamed,
   matchCalendarEvent,
   releaseInstant,
+  releaseRenameNote,
   releaseRowOn,
   type CalendarEventChoice,
+  type ReleaseRename,
 } from "./calendar-events";
-import { createAlert, rearmAlert, serializeAlerts } from "./alert-engine";
-import { ALERTS_KEY, ALERTS_PLUGIN_ID } from "./constants";
+import { createAlert, rearmAlert } from "./alert-engine";
+import { ALERTS_PLUGIN_ID } from "./constants";
 import { MAX_EVENT_ALERTS, eventAlertTarget, toggleEventAlert, writeEventAlertStores, type EventAlertRule } from "./events";
 import { alertKindLabel } from "./history";
 import { IV_LEVEL_CHECKS_KEY, readIvLevelChecks, rearmIvLevelAlert, type IvLevelCheck } from "./iv-level";
@@ -58,7 +63,7 @@ import {
   type ScheduledEventTarget,
 } from "./scheduled";
 import { scheduledEventSources } from "./scheduled-sources";
-import { readAlertStores } from "./storage";
+import { readAlertStores, writeLevelAlertStores } from "./storage";
 import type { AlertCondition, AlertRule } from "./types";
 
 /**
@@ -78,6 +83,7 @@ const COUNTRY_RULE = "--country is for an alert on a calendar event, such as ale
 
 /** What `alerts add` was asked for, before any listing or date is looked up. */
 export type AlertAddRequest =
+  | ({ kind: "metric" } & MetricAlertInput)
   | {
     kind: "price"; symbol: string; condition: AlertCondition; price: number;
     /** A price typed as 81.000, which the last price may show was 81000 with a dot between thousands. */
@@ -151,6 +157,11 @@ export function parseAlertAddArgs(
   const [first, second, third, ...rest] = args;
   if (!first) throw new Error(ADD_USAGE);
   const countryFilter = readCountryOption(country);
+  const metric = parseMetricAlert(args.join(" "));
+  if (metric) {
+    if (days !== undefined || country !== undefined) throw new Error("Valuation and daily technical alerts take neither --days nor --country.");
+    return { kind: "metric", ...metric };
+  }
   const research = parseResearchAddArgs(args);
   if (research) {
     if (days !== undefined) throw new Error("--days is for earnings and calendar event alerts, not news, flow or IV alerts.");
@@ -346,7 +357,7 @@ type AlertListRow = Record<string, unknown> & {
 };
 
 function priceRow(alert: AlertRule): AlertListRow {
-  return { ...alert, kind: "price", target: alert.exchange ? `${alert.symbol}:${alert.exchange}` : alert.symbol };
+  return { ...alert, kind: alert.metric?.kind ?? "price", rule: alert.metric ? metricDescription(alert) : undefined, target: alert.exchange ? `${alert.symbol}:${alert.exchange}` : alert.symbol };
 }
 
 function eventRow(rule: EventAlertRule, now: number, eventDate: string | null | undefined, check?: IvLevelCheck): AlertListRow {
@@ -380,11 +391,11 @@ function textRow(row: AlertListRow): Record<string, unknown> {
     id: row.id,
     kind: price ? "Price" : alertKindLabel(row.kind),
     target: row.target,
-    trigger: price
+    trigger: row.rule ?? (price
       ? `${row.condition} ${row.targetPrice}`
       : typeof row.leadDays === "number"
         ? scheduledTriggerText({ leadDays: row.leadDays, trigger: row.when === "results" ? "results" : "date", prints: row.onRelease === true })
-        : "",
+        : ""),
     eventDate: typeof row.leadDays === "number" ? row.eventDate ?? "not known" : "",
     status: row.status,
     lastCheckedPrice: row.lastCheckedPrice,
@@ -455,10 +466,16 @@ function releaseData(choice: CalendarEventChoice) {
 const choiceList = (choices: readonly CalendarEventChoice[]) => choices.map((choice) => calendarEventLabel({ event: choice.name, country: choice.country }));
 
 /** What a name read as, and what else it names in that country: said beside the alert added. */
-function releaseReadNotes(query: string, choice: CalendarEventChoice, others: readonly CalendarEventChoice[]): string[] {
+function releaseReadNotes(
+  query: string,
+  choice: CalendarEventChoice,
+  others: readonly CalendarEventChoice[],
+  renamed?: ReleaseRename,
+): string[] {
   const notes: string[] = [];
   if (calendarNameWords(query).join(" ") !== calendarNameWords(choice.name).join(" ")) {
-    notes.push(`Read "${query}" as ${calendarEventLabel({ event: choice.name, country: choice.country })}, ${choice.impact} impact.`);
+    notes.push(`Read "${query}" as ${calendarEventLabel({ event: choice.name, country: choice.country })}, ${choice.impact} impact.`
+      + (renamed ? ` ${releaseRenameNote(renamed)}` : ""));
   }
   if (others.length > 0) {
     const shown = choiceList(others.slice(0, 4));
@@ -482,9 +499,15 @@ function calendarUnavailableMessage(query: string, country: CountryFilter | null
 }
 
 /** The refusal of a name nothing in the calendar matches: the nearest names, and every form `alerts add` takes. */
-function noReleaseMessage(query: string, country: CountryFilter | null, suggestions: readonly CalendarEventChoice[]): string {
+function noReleaseMessage(
+  query: string,
+  country: CountryFilter | null,
+  suggestions: readonly CalendarEventChoice[],
+  renamed?: ReleaseRename,
+): string {
   const near = suggestions.length > 0 ? ` Did you mean ${choiceList(suggestions).join(", ")}?` : "";
-  return `No release in the economic calendar matches "${query}"${country ? ` in ${country.split(",").join(", ")}` : ""}.${near} `
+  return `No release in the economic calendar matches "${query}"${country ? ` in ${country.split(",").join(", ")}` : ""}.`
+    + `${renamed ? ` ${releaseRenameNote(renamed)}` : ""}${near} `
     + `${ADD_FORMS} gloom econ --country <code> lists the calendar.`;
 }
 
@@ -511,12 +534,15 @@ async function requireEventDate(
 export const alertsCliCommand: CliCommandDef = {
   name: "alerts",
   aliases: ["alert"],
-  description: "List, add, and remove price alerts, alerts before earnings and any economic calendar release (CPI, FOMC, NBS PMI), and news, options flow and IV alerts",
+  description: "List, add, and remove price, valuation and daily technical alerts, alerts before earnings and any economic calendar release (CPI, FOMC, NBS PMI), and news, options flow and IV alerts",
   help: {
     group: CLI_COMMAND_GROUPS.portfolios,
     usage: [
       "alerts list",
       "alerts add <symbol> <above|below|crosses> <price>",
+      "alerts add <symbol> <pe|ps|rsi(14)> <above|below> <level>",
+      "alerts add <symbol> ma(50) crosses <above|below> ma(200)",
+      "alerts add <symbol> closes <above|below> ma(200)",
       "alerts add <symbol> earnings [--days <n> | results]",
       "alerts add <calendar event> [--country <code>] [--days <n>]",
       "alerts add [symbol] news <keyword>",
@@ -534,6 +560,11 @@ export const alertsCliCommand: CliCommandDef = {
     examples: [
       "alerts",
       "alerts add AAPL above 250",
+      "alerts add AAPL pe below 25",
+      "alerts add AAPL ps above 8",
+      'alerts add NVDA "rsi(14)" under 30',
+      'alerts add SPY "ma(50)" crosses above "ma(200)"',
+      'alerts add TSLA closes below "ma(200)"',
       "alerts add SAN:EPA below 70",
       "alerts add CRWV earnings --days 3",
       "alerts add CRWV earnings results",
@@ -568,7 +599,7 @@ export const alertsCliCommand: CliCommandDef = {
     };
     const request = action === "add" ? parseAdd() : null;
     const research = request && isResearchRequest(request) ? request : null;
-    const listedSymbol = request?.kind === "price" ? request.symbol
+    const listedSymbol = (request?.kind === "price" || request?.kind === "metric") ? request.symbol
       : research && research.kind !== "iv_spike" ? research.symbol : null;
     // A price alert is kept for the listing `quote` prints for the symbol, and for no symbol that quotes nothing;
     // a news, flow or IV rule on a symbol follows that listing too, and only in the US, where their data is.
@@ -588,6 +619,12 @@ export const alertsCliCommand: CliCommandDef = {
       })
       : null;
     const priceListing = priced?.listing ?? null;
+    if (request?.kind === "metric" && priced) {
+      const exchange = canonicalExchange(priced.listing.exchange || priced.quote.listingExchangeName || priced.quote.exchangeName);
+      const preview = { ...createAlert(priced.listing.symbol, request.condition, request.price, exchange), metric: request.metric };
+      await withMarketData(ctx, market => metricReadings(market.dataProvider)(preview)).catch(error => ctx.fail(error instanceof Error ? error.message : String(error)));
+      priced.listing.exchange = exchange;
+    }
     if (request?.kind === "price" && request.thousandsDot && priced) {
       const question = thousandsDotMessage(request, priced.listing.key, lastPrice(priced.quote), exchangeOption);
       if (question) ctx.fail(question);
@@ -628,7 +665,7 @@ export const alertsCliCommand: CliCommandDef = {
       const match = matchCalendarEvent(request.query, request.country, events, now);
       if (match.kind !== "match") {
         return ctx.fail(match.kind === "none"
-          ? noReleaseMessage(request.query, request.country, match.suggestions)
+          ? noReleaseMessage(request.query, request.country, match.suggestions, match.renamed)
           : severalCountriesMessage(request.query, match.choices));
       }
       const { choice, others } = match;
@@ -638,7 +675,7 @@ export const alertsCliCommand: CliCommandDef = {
         read = [`Read "${request.query}" as the ${MACRO_EVENT_NAMES[macroEvent]} alert, which follows ${calendarEventLabel({ event: choice.name, country: choice.country })}.`];
       } else {
         newRelease = choice;
-        read = releaseReadNotes(request.query, choice, others);
+        read = releaseReadNotes(request.query, choice, others, match.renamed);
         const target: ScheduledEventTarget = { kind: "release", event: choice.name, country: choice.country, ...(choice.publisher ? { publisher: choice.publisher } : {}) };
         try {
           newEventRule = createScheduledAlert(target, request.leadDays, choice.next ? dateKey(choice.next.date) : null);
@@ -714,16 +751,18 @@ export const alertsCliCommand: CliCommandDef = {
     }
 
     await withConfigData(ctx, async (config) => {
-      const { pluginState, alerts, alertsError, events } = readAlertStores(config.config);
+      const { pluginState, alerts, alertsError, levelErrors, events } = readAlertStores(config.config);
       const save = async (next: { alerts?: AlertRule[]; events?: EventAlertRule[] }) => {
-        if (next.alerts && alertsError) ctx.fail(alertsError);
+        if (next.alerts) for (const [key, value] of Object.entries(writeLevelAlertStores(next.alerts))) {
+          if (levelErrors[key] && value !== "[]") ctx.fail(levelErrors[key]!);
+        }
         const nextConfig = {
           ...config.config,
           pluginConfig: {
             ...config.config.pluginConfig,
             [ALERTS_PLUGIN_ID]: {
               ...pluginState,
-              ...(next.alerts ? { [ALERTS_KEY]: serializeAlerts(next.alerts) } : {}),
+              ...(next.alerts ? Object.fromEntries(Object.entries(writeLevelAlertStores(next.alerts)).filter(([key]) => !levelErrors[key])) : {}),
               // Each list keeps what it holds of kinds this version does not know; IV levels go in their own.
               ...(next.events ? writeEventAlertStores(events.lists, next.events) : {}),
             },
@@ -737,14 +776,14 @@ export const alertsCliCommand: CliCommandDef = {
         return events.rules;
       };
 
-      if (request?.kind === "price") {
+      if (request?.kind === "price" || request?.kind === "metric") {
         const { condition, price } = request;
         const symbol = requireArg(priceListing?.key, ADD_USAGE, ctx);
-        const alert = createAlert(symbol, condition, price, priceListing?.exchange);
+        const alert = { ...createAlert(symbol, condition, price, priceListing?.exchange), ...(request.kind === "metric" ? { metric: request.metric } : {}) };
         await save({ alerts: [...alerts, alert] });
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert }, ...(read.length > 0 ? { warnings: read } : {}) }, {
           // The delivery, as docs/usage.md states it, before any full stop, which after the price would read as part of it (below 81.).
-          text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price} (${PRICE_DELIVERY}).${dryRunNote(data.dryRun)}`,
+          text: (data) => `Added alert ${data.alert.id}: ${data.alert.metric ? metricDescription(data.alert) : `${symbol} ${condition} ${price}`} (${PRICE_DELIVERY}).${dryRunNote(data.dryRun)}`,
         });
         return;
       }

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

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

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

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

package/src/plugins/builtin/alerts/fired-log.ts

@@ -1,5 +1,6 @@
 import type { PluginResumeState } from "../../../types/plugin";
 import type { QuoteDataSource } from "../../../types/financials";
+import { ALERTS_PLUGIN_ID } from "./constants";
 
 /**
  * The alerts this device's app fired, kept on the device (plugin resume
@@ -14,7 +15,7 @@ export interface FiredAlert {
   id: string;
   /** When the app fired it, ISO. */
   firedAt: string;
-  /** The rule's kind: `price`, `iv_level`, `earnings_date`, `macro_event`. */
+  /** The rule's kind: `price`, `iv_level`, `earnings_date`, `macro_event`, `live_scan`. */
   kind: string;
   ruleId: string;
   /** The rule as it read when it went off: `BTC above 85000`, `IBIT · 30d ATM IV above 50%`. */
@@ -59,11 +60,51 @@ export function readFiredAlerts(value: unknown): FiredAlert[] {
     && optionalText(entry.unit) && optionalText(entry.detail) && optionalText(entry.symbol) && optionalText(entry.exchange));
 }
 
+function firedAlertEntry(input: FiredAlertInput, id: string = crypto.randomUUID()): FiredAlert {
+  const { firedAt, ...rest } = input;
+  return { id, firedAt: firedAlertTime(firedAt) ?? new Date().toISOString(), ...rest };
+}
+
 /** `entries` with one more at the end, the oldest dropped past the cap. */
 export function appendFiredAlert(entries: readonly FiredAlert[], input: FiredAlertInput, id: string = crypto.randomUUID()): FiredAlert[] {
-  const { firedAt, ...rest } = input;
-  const entry: FiredAlert = { id, firedAt: firedAlertTime(firedAt) ?? new Date().toISOString(), ...rest };
-  return [...entries, entry].slice(-MAX_FIRED_ALERTS);
+  return [...entries, firedAlertEntry(input, id)].slice(-MAX_FIRED_ALERTS);
+}
+
+/** `entries` keeping only the newest `max` of each kind in `kinds`; other kinds are untouched. */
+function capFiredAlertKinds(entries: readonly FiredAlert[], kinds: ReadonlySet<string>, max: number): FiredAlert[] {
+  const over = new Map<string, number>();
+  for (const entry of entries) if (kinds.has(entry.kind)) over.set(entry.kind, (over.get(entry.kind) ?? 0) + 1);
+  for (const [kind, count] of over) over.set(kind, count - max);
+  // Oldest first: the first entries of a kind over its cap are the ones to drop.
+  return entries.filter((entry) => {
+    const extra = over.get(entry.kind) ?? 0;
+    if (extra <= 0) return true;
+    over.set(entry.kind, extra - 1);
+    return false;
+  });
+}
+
+/**
+ * Records an alert another plugin fired (a live scan's new matches) in this
+ * log, through the runtime's access to the alerts plugin's resume state.
+ * `keepAtMost` bounds how many entries of the recorded kinds the shared log
+ * keeps, so a busy source cannot push the price and event alerts out.
+ */
+export function recordFiredAlertFor(
+  runtime: { getResumeState(pluginId: string, key: string): unknown; setResumeState(pluginId: string, key: string, value: unknown): void },
+  inputs: readonly FiredAlertInput[],
+  onError: (error: unknown) => void,
+  keepAtMost?: number,
+): void {
+  if (!inputs.length) return;
+  try {
+    let entries = [...readFiredAlerts(runtime.getResumeState(ALERTS_PLUGIN_ID, FIRED_LOG_KEY)), ...inputs.map((input) => firedAlertEntry(input))];
+    // The source's own oldest entries go first, before the log's cap reaches anyone else's.
+    if (keepAtMost != null) entries = capFiredAlertKinds(entries, new Set(inputs.map((input) => input.kind)), keepAtMost);
+    runtime.setResumeState(ALERTS_PLUGIN_ID, FIRED_LOG_KEY, entries.slice(-MAX_FIRED_ALERTS));
+  } catch (error) {
+    onError(error);
+  }
 }
 
 /** Records a fired alert in the device's log. A log that cannot be written never stops the alert itself. */

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

@@ -1,3 +1,4 @@
+import { isDailyMetric } from "./metric-model";
 import { formatMarketPrice } from "../../../market-data/market/format";
 import { formatQuoteAgeWithSource } from "../../../market-data/quotes/time";
 import type { AlertCondition, AlertRule } from "./types";
@@ -15,7 +16,9 @@ export function relativeTime(ts: number): string {
 }
 
 export function formatCurrentPrice(alert: AlertRule, maxWidth = 9): string {
-  if (alert.lastCheckError) return "No quote";
+  if (alert.lastCheckError) return !alert.metric ? "No quote"
+    : /US listing|US equities|calendar/.test(alert.lastCheckError) ? "US only"
+    : /missing|bars|history/i.test(alert.lastCheckError) ? "Bar gap" : "No data";
   return alert.lastCheckedPrice == null
     ? "-"
     : formatMarketPrice(alert.lastCheckedPrice, {
@@ -25,6 +28,8 @@ export function formatCurrentPrice(alert: AlertRule, maxWidth = 9): string {
 }
 
 export function formatAlertTargetPrice(alert: AlertRule, maxWidth = 9): string {
+  if (alert.metric?.kind === "ma_cross") return `${alert.metric.slowPeriod}-day MA`;
+  if (alert.metric?.kind === "close_ma") return `${alert.metric.period}-day MA`;
   return formatMarketPrice(alert.targetPrice, {
     maxWidth,
     minimumFractionDigits: 2,
@@ -37,7 +42,7 @@ export function formatAlertDistance(alert: AlertRule): string {
   if (currentPrice == null || !Number.isFinite(currentPrice) || currentPrice === 0) {
     return "-";
   }
-  const percent = ((alert.targetPrice - currentPrice) / currentPrice) * 100;
+  const percent = (((alert.lastCheckedTarget ?? alert.targetPrice) - currentPrice) / currentPrice) * 100;
   if (!Number.isFinite(percent)) return "-";
   // One decimal at any distance, so the column holds still as the price moves;
   // a distance that rounds to zero is unsigned (0.0%, never -0.0%).
@@ -47,6 +52,7 @@ export function formatAlertDistance(alert: AlertRule): string {
 
 /** The Quote cell: the quote's age and feed, or, on the row of an alert that got none, why (a stale quote, or none). */
 export function formatQuoteChecked(alert: AlertRule): string {
+  if (alert.metric && isDailyMetric(alert.metric)) return "on daily close";
   if (alert.lastCheckError) return /\bstale\b/i.test(alert.lastCheckError) ? "Stale" : "No quote";
   if (alert.lastQuoteUpdatedAt) {
     return formatQuoteAgeWithSource({

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

@@ -1,3 +1,4 @@
+import { isDailyMetric, metricName } from "./metric-model";
 /**
  * `gloom fn ALRT`: the Alerts pane's three tabs as reports. Prices lists
  * the price alerts as the pane's table does, Events the event alerts (earnings,
@@ -47,10 +48,14 @@ const instant = (value: unknown) => (typeof value === "number" ? firedAlertTime(
 const PRICE_COLUMNS: HeadlessPaneColumn[] = [
   { key: "status", header: "State", format: (value) => (value === "triggered" ? "Triggered" : "Active") },
   { key: "symbol", header: "Symbol", format: (value, row) => (row.exchange ? `${text(value)}:${text(row.exchange)}` : text(value)) },
+  { key: "metric", header: "Measure", format: (_value, row) => asAlert(row).metric ? metricName(asAlert(row).metric!) : "Price" },
   { key: "lastCheckedPrice", header: "Current", align: "right", textFormat: (_value, row) => formatCurrentPrice(asAlert(row), 14) },
   { key: "targetPrice", header: "Target", align: "right", textFormat: (_value, row) => formatAlertTargetPrice(asAlert(row), 14) },
   { key: "awayPercent", header: "Away", align: "right", format: percent, textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
-  { key: "condition", header: "Trigger", format: (value) => conditionLabel(value as AlertRule["condition"]) },
+  { key: "condition", header: "Trigger", format: (value, row) => {
+    const metric = asAlert(row).metric;
+    return metric?.kind === "ma_cross" ? `Cross ${metric.direction}` : conditionLabel(value as AlertRule["condition"]);
+  } },
   { key: "quoteAt", header: "Quote", textFormat: (_value, row) => formatQuoteChecked(asAlert(row)) },
   { key: "quoteSource", header: "Quote source" },
   { key: "lastCheckedAt", header: "Checked", format: instant },
@@ -93,13 +98,13 @@ const HISTORY_TEXT_COLUMNS = HISTORY_COLUMNS.filter((column) => column.key !== "
 function priceRow(alert: AlertRule): HeadlessPaneRow {
   const { lastQuoteProviderId: _provider, ...stored } = alert;
   const price = alert.lastCheckError ? null : alert.lastCheckedPrice;
-  const away = price == null || !Number.isFinite(price) || price === 0 ? null : ((alert.targetPrice - price) / price) * 100;
+  const away = price == null || !Number.isFinite(price) || price === 0 ? null : (((alert.lastCheckedTarget ?? alert.targetPrice) - price) / price) * 100;
   const quoted = !alert.lastCheckError;
   return {
     ...stored,
     awayPercent: away != null && Number.isFinite(away) ? Number(away.toFixed(2)) : null,
     quoteAt: quoted ? firedAlertTime(alert.lastQuoteUpdatedAt) : null,
-    quoteSource: quoted ? quoteSourceWords(alert.lastQuoteSource) : null,
+    quoteSource: quoted ? alert.metric && isDailyMetric(alert.metric) ? "daily close" : quoteSourceWords(alert.lastQuoteSource) : null,
   };
 }
 
@@ -111,7 +116,7 @@ function pricesResult(alerts: readonly AlertRule[], error: string | null, events
     columns: PRICE_COLUMNS,
     textColumns: PRICE_TEXT_COLUMNS,
     rows: [...active, ...triggered].map(priceRow),
-    empty: "No price alerts. Add one with gloom alerts add AAPL above 250.",
+    empty: "No level alerts. Add one with gloom alerts add AAPL above 250.",
     ...(error ? { errors: [error], complete: false } : {}),
     ...(events > 0 ? { notes: [`${plural(events, "event alert")} not listed here: gloom fn ALRT --tab events`] } : {}),
   };
@@ -214,7 +219,7 @@ async function historyResult(ctx: HeadlessPaneContext): Promise<HeadlessRowsResu
 
 export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
-  description: "Your alerts: price alerts with current price and distance to target, event alerts (earnings, CPI, FOMC and other economic calendar releases, filings, news, IV levels, market moves) or the alerts that went off, from this app and, signed in, Gloom Cloud.",
+  description: "Your alerts: price, valuation and daily technical alerts with current price and distance to target, event alerts (earnings, CPI, FOMC and other economic calendar releases, filings, news, IV levels, market moves) or the alerts that went off, from this app and, signed in, Gloom Cloud.",
   freshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
   argument: { kind: "none" },
   options: [{