gloomberb 0.18.3 → 0.18.5

package/src/plugins/builtin/econ-statistics/headless.ts

@@ -3,6 +3,7 @@ import type {
   HeadlessPaneDefinition,
   HeadlessPaneEntry,
 } from "../../../types/plugin";
+import { fredSourceLabel } from "../../../sources/gloomberb-cloud/fred-series";
 import { formatBasisPoints, toBasisPoints } from "../../../utils/basis-points";
 import { formatNumber } from "../../../utils/format";
 import type { StatDef } from "./defs";
@@ -13,6 +14,7 @@ import {
 } from "./client";
 import { historyStartNotice } from "../shared/history-span";
 import { formatMoveRank } from "../shared/move-rank";
+import type { StatPoint } from "../shared/stat-transform";
 import { formatSigma } from "../shared/trend";
 import { STAT_CATEGORIES } from "./defs";
 import { DEFAULT_STAT_ID, resolveStatArg, STATS } from "./stats";
@@ -23,20 +25,26 @@ function reportFormat(stat: StatDef): (value: number) => string {
   return stat.basisPoints ? (value) => formatBasisPoints(value) : stat.formatValue;
 }
 
-/** `cutoffShown`: the status line names when in the day the reading was taken, so the period does not repeat it. */
-function detailEntries(view: StatViewModel, cutoffShown: boolean): HeadlessPaneEntry[] {
+/**
+ * `cutoffShown`: the status line names when in the day the reading was taken, so the period does not repeat it.
+ * `text` is the report's text lines, where Previous says its period beside it; exports give the period a line of its own.
+ */
+function detailEntries(view: StatViewModel, cutoffShown: boolean, text: boolean): HeadlessPaneEntry[] {
   const format = reportFormat(view.stat);
   return [
     { label: "Latest", value: view.latest.value, formatted: format(view.latest.value) },
     {
       label: "Previous",
       value: view.previous?.value ?? null,
-      formatted: view.previous ? format(view.previous.value) : "-",
+      formatted: view.previous ? `${format(view.previous.value)}${text && view.previousReading ? ` (${view.previousReading})` : ""}` : "-",
+      ...earlierDating(view, view.previous),
     },
+    ...!text && view.previous ? [{ label: "Previous period", value: view.previous.date, formatted: view.previousReading ?? view.previous.date, ...earlierDating(view, view.previous) }] : [],
     {
       label: "1Y ago",
       value: view.yearAgo?.value ?? null,
       formatted: view.yearAgo ? format(view.yearAgo.value) : "-",
+      ...earlierDating(view, view.yearAgo),
     },
     { label: "Mean", value: view.mean, formatted: format(view.mean) },
     {
@@ -70,8 +78,9 @@ function detailEntries(view: StatViewModel, cutoffShown: boolean): HeadlessPaneE
     })),
     // FRED dates a monthly reading at the month's first day; the text says which period it is.
     // A Treasury yield adds when in the day it was taken, so it is not read against ^TNX's earlier close.
-    { label: "Period", value: view.latest.date, formatted: view.stat.cutoff && !cutoffShown ? `${view.reading} ${view.stat.cutoff}` : view.reading },
-    { label: "Source", value: `FRED ${view.stat.seriesId}` },
+    // A figure dated by its period also says when it was released: "Sep 2026, released Tue 20 Oct".
+    { label: "Period", value: view.latest.date, formatted: view.stat.cutoff && !cutoffShown ? `${view.reading} ${view.stat.cutoff}` : view.readingReleased },
+    { label: "Source", value: fredSourceLabel(view.stat.seriesId) },
   ];
 }
 
@@ -82,6 +91,29 @@ const PERCENTILE_WINDOW: Record<StatRangeId, string> = {
   ALL: "the full history",
 };
 
+/**
+ * An earlier reading's own dating (previous, a year ago): its period, no release (the server dates only the
+ * latest print's), and its own day for as-of when the series is observed daily or weekly. A reading there is
+ * none of is of no period, never the latest's.
+ */
+function earlierDating(view: StatViewModel, point: StatPoint | null): Pick<HeadlessPaneEntry, "period" | "released" | "asOf"> {
+  return { period: point?.date ?? null, released: null, asOf: point && !view.periodicity ? point.date : null };
+}
+
+/** The period a statistic's lines cover and the day they were released, for the `period` and `released` of each exported line. */
+function exportDating(view: StatViewModel): { period: string; released?: string; asOf: string | null } {
+  return { period: view.latest.date, ...(view.releasedOn ? { released: view.releasedOn } : {}), asOf: exportAsOf(view) };
+}
+
+/**
+ * What an exported row is as of: the day its figure was released, else its own
+ * day when it is observed daily or weekly (a Treasury yield), and nothing when
+ * the date only starts the period it covers.
+ */
+function exportAsOf(view: StatViewModel): string | null {
+  return view.releasedOn ?? (view.periodicity ? null : view.latest.date);
+}
+
 export function projectStatsHeadlessBundle(
   bundle: StatsBundle,
   range: StatRangeId,
@@ -92,30 +124,45 @@ export function projectStatsHeadlessBundle(
   const sections = STAT_CATEGORIES.flatMap((category) => {
     const categoryViews = views.filter((view) => view.stat.category === category.id);
     if (categoryViews.length === 0) return [];
+    // The text table keeps the columns a terminal has room for; exports add what each figure is of.
+    const columns = (text: boolean) => [
+      { key: "indicator", header: "Indicator" },
+      {
+        key: "latest",
+        header: "Latest",
+        align: "right" as const,
+        format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedLatest),
+      },
+      {
+        key: "previous",
+        header: "Previous",
+        align: "right" as const,
+        format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedPrevious),
+      },
+      // Which period Previous is: exports carry it beside the figure, the text table has its Period column for the latest.
+      ...text ? [] : [{ key: "previousPeriod", header: "Previous period" }],
+      {
+        key: "percentile",
+        header: "%ile",
+        align: "right" as const,
+        format: (value: unknown) => formatNumber(Number(value), 0),
+      },
+      // `period` and `released` are the names every dated export gives these (`econ`, `fred`).
+      { key: "asOf", header: "period", literalHeader: true, textHeader: "Period", format: (_value: unknown, row: Record<string, unknown>) => String(row.reading) },
+      {
+        key: "releasedOn",
+        header: "released",
+        literalHeader: true,
+        textHeader: "Released",
+        format: (_value: unknown, row: Record<string, unknown>) => typeof row.released === "string" ? row.released.replace(/^released /, "") : "",
+      },
+    ];
     return [{
       title: category.label,
-      columns: [
-        { key: "indicator", header: "Indicator" },
-        {
-          key: "latest",
-          header: "Latest",
-          align: "right" as const,
-          format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedLatest),
-        },
-        {
-          key: "previous",
-          header: "Previous",
-          align: "right" as const,
-          format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedPrevious),
-        },
-        {
-          key: "percentile",
-          header: "%ile",
-          align: "right" as const,
-          format: (value: unknown) => formatNumber(Number(value), 0),
-        },
-        { key: "asOf", header: "Period", format: (_value: unknown, row: Record<string, unknown>) => String(row.reading) },
-      ],
+      columns: columns(false),
+      textColumns: columns(true),
+      // `as_of` is the release; a figure with none stated is as of its own day when it is observed daily or weekly, never its period's first day.
+      rowAsOfKey: "exportAsOf",
       rows: categoryViews.map((view) => ({
         id: view.stat.id,
         indicator: view.stat.shortLabel,
@@ -123,14 +170,20 @@ export function projectStatsHeadlessBundle(
         formattedLatest: reportFormat(view.stat)(view.latest.value),
         previous: view.previous?.value ?? null,
         formattedPrevious: view.previous ? reportFormat(view.stat)(view.previous.value) : "-",
+        previousPeriod: view.previous?.date ?? null,
         // A spread's values stay in percentage points; these carry the figures its text shows.
         ...(view.stat.basisPoints ? {
           latestBasisPoints: toBasisPoints(view.latest.value),
           previousBasisPoints: view.previous ? toBasisPoints(view.previous.value) : null,
         } : {}),
         percentile: view.percentile,
+        // The period the figure covers; `releasedOn` is when it was published, which the report is as of.
         asOf: view.latest.date,
+        releasedOn: view.releasedOn,
+        exportAsOf: exportAsOf(view),
+        ...(view.periodicity ? { periodicity: view.periodicity } : {}),
         reading: view.reading,
+        released: view.released,
         stale: view.observationStale || view.cacheStale,
         fetchedAt: view.fetchedAt,
         cacheStale: view.cacheStale,
@@ -148,7 +201,12 @@ export function projectStatsHeadlessBundle(
     ...(cutoff ? { freshness: { ...ECST_FRESHNESS, schedule: cutoff } } : {}),
     sections: [
       ...sections,
-      ...(selected ? [{ title: selected.stat.label, entries: detailEntries(selected, cutoff != null) }] : []),
+      ...(selected ? [{
+        title: selected.stat.label,
+        entries: detailEntries(selected, cutoff != null, false),
+        textEntries: detailEntries(selected, cutoff != null, true),
+        ...exportDating(selected),
+      }] : []),
     ],
     errors: bundle.errors,
     notes: [
@@ -176,6 +234,7 @@ const ECST_FRESHNESS = { source: "FRED", status: "not-a-feed", basis: "published
 export const econStatisticsHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
   freshness: ECST_FRESHNESS,
+  exportDated: true,
   argument: {
     kind: "free-text",
     placeholder: "statistic",

package/src/plugins/builtin/econ-statistics/index.tsx

@@ -23,15 +23,15 @@ export const econStatisticsModule: PluginModule = {
     paneId: ECON_STATISTICS_PANE_ID,
     label: "Economic Statistics",
     description: "Inflation, labour, growth, housing and rates against their own history.",
-    keywords: [
+    keywords: [...new Set([
       "economic",
       "statistics",
       "macro",
       "indicators",
       "data",
       ...STAT_CATEGORIES.map((entry) => entry.label.toLowerCase()),
-      ...STATS.map((entry) => entry.shortLabel.toLowerCase()),
-    ],
+      ...STATS.flatMap((entry) => [entry.shortLabel, ...entry.keywords ?? []].map((keyword) => keyword.toLowerCase())),
+    ])],
     shortcut: {
       prefix: "ECST",
       argPlaceholder: "statistic",

package/src/plugins/builtin/econ-statistics/pane.tsx

@@ -63,6 +63,7 @@ function matchesQuery(view: StatViewModel, query: string): boolean {
     view.stat.seriesId,
     categoryLabel(view.stat.category),
     view.stat.note,
+    ...view.stat.keywords ?? [],
   ].join(" ").toLowerCase();
   return query.split(/\s+/).every((token) => haystack.includes(token));
 }
@@ -150,7 +151,7 @@ export function EconStatisticsPane({ focused, width, height }: PaneProps) {
     // A Treasury yield names when in the day it was taken, as GC does, so it is not read against ^TNX's earlier close.
     const cutoff = selected.stat.cutoff ? ` ${selected.stat.cutoff}` : "";
     const info: PaneFooterSegment[] = [
-      { id: "as-of", parts: [{ text: `reading for ${selected.reading}${cutoff}`, tone: "muted" }] },
+      { id: "as-of", parts: [{ text: `reading for ${cutoff ? selected.reading : selected.readingReleased}${cutoff}`, tone: "muted" }] },
     ];
     // The cached first paint is being replaced; its age only counts once that load fails.
     const seeding = resource.loading && resource.updatedAt === null && !selected.refreshError;

package/src/plugins/builtin/econ-statistics/stats.ts

@@ -5,6 +5,9 @@ import type { StatDef } from "./defs";
 const DAY_MS = 24 * 60 * 60 * 1000;
 const DAILY = 6 * DAY_MS;
 const WEEKLY = 21 * DAY_MS;
+// GDPNow is dated at quarter start but updated through the following month's
+// advance GDP release; allow that ~120-day span plus two weeks.
+const NOWCAST_QUARTERLY = 135 * DAY_MS;
 // FRED dates a print at the start of its period, so an on-time print is two
 // periods plus the release lag old just before the next one lands. Each limit
 // adds about two weeks to the slowest normal lag of its group.
@@ -16,11 +19,14 @@ const QUARTERLY = 235 * DAY_MS; // GDP, productivity: two quarters plus a lag up
 const pct = (value: number) => `${formatNumber(value, 1)}%`;
 const pct2 = (value: number) => `${formatNumber(value, 2)}%`;
 const plain = (value: number) => formatNumber(value, 1);
+const index2 = (value: number) => formatNumber(value, 2);
 /** FRED reports payrolls and claims in thousands already. */
 const thousands = (value: number) => `${formatNumber(value / 1000, value >= 10_000 ? 1 : 2)}M`;
 const signedThousands = (value: number) =>
   `${value > 0 ? "+" : ""}${formatNumber(value, 0)}k`;
 const billions = (value: number) => `${formatNumber(value, 0)}B`;
+/** A spread already scaled to basis points; the label says the unit. */
+const basisPoints = (value: number) => formatNumber(value, 0);
 
 function stat(def: StatDef): StatDef {
   return def;
@@ -249,6 +255,69 @@ export const STATS: readonly StatDef[] = [
     limit: 500,
   }),
 
+  // ---- Nowcasts & conditions --------------------------------------------
+  stat({
+    id: "gdpnow",
+    measurementBasis: "Estimate · q/q annualized",
+    label: "Atlanta Fed GDPNow",
+    shortLabel: "GDPNow",
+    category: "nowcasts",
+    seriesId: "GDPNOW",
+    transform: "level",
+    direction: "higher-is-good",
+    axisUnit: "%",
+    formatValue: pct,
+    reference: { value: 0, label: "flat" },
+    staleAfterMs: NOWCAST_QUARTERLY,
+    note: "Atlanta Fed model estimate of real GDP growth, updated within the quarter. Already an annualized percentage change, not a GDP level.",
+    keywords: ["nowcast", "GDP nowcast"],
+  }),
+  stat({
+    id: "nfci",
+    measurementBasis: "Weekly · index",
+    label: "Chicago Fed Financial Conditions",
+    shortLabel: "Chicago NFCI",
+    category: "nowcasts",
+    seriesId: "NFCI",
+    transform: "level",
+    direction: "higher-is-bad",
+    axisUnit: "",
+    formatValue: index2,
+    reference: { value: 0, label: "average" },
+    staleAfterMs: WEEKLY,
+    note: "Chicago Fed National Financial Conditions Index. Positive values mean tighter-than-average conditions; negative values mean looser conditions.",
+  }),
+  stat({
+    id: "financial-stress",
+    measurementBasis: "Weekly · index",
+    label: "St. Louis Fed Financial Stress",
+    shortLabel: "St. Louis FSI",
+    category: "nowcasts",
+    seriesId: "STLFSI4",
+    transform: "level",
+    direction: "higher-is-bad",
+    axisUnit: "",
+    formatValue: index2,
+    reference: { value: 0, label: "average" },
+    staleAfterMs: WEEKLY,
+    note: "St. Louis Fed Financial Stress Index, current fourth version. Positive values mean above-average stress; negative values mean below-average stress.",
+  }),
+  stat({
+    id: "median-cpi",
+    measurementBasis: "m/m annualized · seasonally adjusted",
+    label: "Cleveland Fed Median CPI",
+    shortLabel: "Median CPI",
+    category: "nowcasts",
+    seriesId: "MEDCPIM158SFRBCLE",
+    transform: "level",
+    direction: "higher-is-bad",
+    axisUnit: "%",
+    formatValue: pct,
+    reference: null,
+    staleAfterMs: MONTHLY_EARLY,
+    note: "Cleveland Fed weighted median consumer price change. Published as an annualized monthly percentage change, not a year-over-year inflation rate.",
+  }),
+
   // ---- Consumer --------------------------------------------------------
   stat({
     id: "retail-sales",
@@ -378,6 +447,41 @@ export const STATS: readonly StatDef[] = [
     note: "Newly built homes sold, at an annual rate.",
     limit: 900,
   }),
+  stat({
+    id: "mortgage-30y",
+    measurementBasis: "Weekly · Freddie Mac PMMS",
+    label: "30-Year Mortgage Rate",
+    shortLabel: "30Y mortgage rate",
+    category: "housing",
+    seriesId: "MORTGAGE30US",
+    transform: "level",
+    direction: "neutral",
+    axisUnit: "%",
+    formatValue: pct2,
+    reference: null,
+    staleAfterMs: WEEKLY,
+    note: "Freddie Mac's weekly average 30-year fixed mortgage rate, what a home purchase is financed at.",
+    keywords: ["mortgage rates", "PMMS", "Freddie Mac", "homebuilders"],
+  }),
+  stat({
+    id: "mortgage-spread",
+    measurementBasis: "30Y mortgage minus 10Y Treasury on the PMMS date",
+    label: "Mortgage–10Y Spread (bp)",
+    shortLabel: "Mortgage–10Y (bp)",
+    category: "housing",
+    seriesId: "MORTGAGE30US10Y",
+    derivedFrom: ["mortgage-30y", "ten-year"],
+    transform: "level",
+    // Gloom Cloud serves it in percentage points, as FRED does its spreads.
+    scale: 100,
+    direction: "neutral",
+    axisUnit: "",
+    formatValue: basisPoints,
+    reference: null,
+    staleAfterMs: WEEKLY,
+    note: "The 30-year mortgage rate less the 10-year Treasury yield on each survey date, how much mortgages pay over Treasuries.",
+    keywords: ["mortgage spread", "PMMS", "homebuilders"],
+  }),
   // ---- Rates & money ---------------------------------------------------
   stat({
     id: "fed-funds",

package/src/plugins/builtin/econ-statistics/view.ts

@@ -2,6 +2,7 @@ import { historySpan, type HistorySpan } from "../shared/history-span";
 import { latestMoveRank, MOVE_HORIZONS, type MoveRank } from "../shared/move-rank";
 import { periodsPerYear, type StatPoint } from "../shared/stat-transform";
 import { sigmaVsTrend } from "../shared/trend";
+import { periodReleasedText, periodStartPeriodicity, releasedText } from "../../../utils/release-date";
 import type { StatBuild } from "./client";
 import type { StatDef } from "./defs";
 
@@ -23,8 +24,18 @@ export interface StatViewModel {
   period: string;
   /** What the latest print is a reading of, in full: "Aug 2026", "Q2 2026", "week ending 2026-10-03", "2026-10-09". */
   reading: string;
+  /** The day the latest print was released (`YYYY-MM-DD`), when FRED says; null for a daily rate. */
+  releasedOn: string | null;
+  /** `released Tue 20 Oct`, or null when the release is not known. */
+  released: string | null;
+  /** The reading and its release, as every macro pane says it: "Sep 2026, released Tue 20 Oct". */
+  readingReleased: string;
+  /** How often a print dated by its period's first day publishes; null for weekly and daily prints. */
+  periodicity: "monthly" | "quarterly" | "annual" | null;
   /** The print before this one, for the direction of the last move. */
   previous: StatPoint | null;
+  /** What that print is a reading of, as `reading` says the latest's: "Aug 2026"; null with no previous print. */
+  previousReading: string | null;
   yearAgo: StatPoint | null;
   changeOnPrevious: number | null;
   /** Where the current reading sits within the selected range. */
@@ -130,14 +141,21 @@ export function projectStat(
   // High, low, mean and percentile describe the selected window, like the chart.
   const visible = sliceByRange(points, range);
   const atOrBelow = visible.filter((point) => point.value <= latest.value).length;
+  const reading = formatStatReading(latest.date, perYear);
+  const releasedOn = build.releasedOn ?? null;
 
   return {
     stat,
     range,
     latest,
     period: formatStatPeriod(latest.date, perYear),
-    reading: formatStatReading(latest.date, perYear),
+    reading,
+    releasedOn,
+    released: releasedText(releasedOn, latest.date),
+    readingReleased: periodReleasedText(reading, releasedOn, latest.date),
+    periodicity: periodStartPeriodicity(latest.date, perYear),
     previous,
+    previousReading: previous ? formatStatReading(previous.date, perYear) : null,
     yearAgo,
     changeOnPrevious: previous ? latest.value - previous.value : null,
     percentile: visible.length === 0 ? 0 : (100 * atOrBelow) / visible.length,

package/src/plugins/builtin/equity-screener/client.ts

@@ -6,7 +6,9 @@ import type {
   ScreenPayload,
   ScreenQuery,
   SavedScreen,
+  ScreenCheckPayload,
 } from "../../../api-client/equity-screener";
+import { screenCheckTicker, validateScreenCheck } from "./screen-check";
 
 type ScreenerClient = Pick<typeof apiClient, "equityScreener">;
 const json = (method: string, body: unknown, init: RequestInit = {}): RequestInit => ({
@@ -22,7 +24,8 @@ export const screenerApi = {
   fields: (signal?: AbortSignal) => apiClient.equityScreener<ScreenFieldsResponse>("fields?include=social,research,attention,hiring-apps,kpis,volatility,dividends", { signal }),
   export: (definition: ScreenDefinition, snapshotId: string) =>
     apiClient.equityScreener<ScreenExportResponse>("export", json("POST", { ...definition, snapshotId }, { headers: { Accept: "application/json" } })),
-  saved: async () => (await apiClient.equityScreener<{ screens: SavedScreen[] }>("saved")).screens,
+  saved: async (signal?: AbortSignal, client: ScreenerClient = apiClient) =>
+    (await client.equityScreener<{ screens: SavedScreen[] }>("saved", { signal })).screens,
   create: async (name: string, definition: ScreenDefinition) =>
     (await apiClient.equityScreener<{ screen: SavedScreen }>("saved", json("POST", { name, definition }))).screen,
   update: async (id: string, revision: number, name: string, definition: ScreenDefinition) =>
@@ -75,9 +78,24 @@ export function validateSavedScreen(screen: SavedScreen): SavedScreen {
   parseScreenDefinition(screen.definition);
   return screen;
 }
-export async function fetchSavedScreens() {
-  const rows = await screenerApi.saved();
+export async function fetchSavedScreens(signal?: AbortSignal, client: ScreenerClient = apiClient) {
+  const rows = await screenerApi.saved(signal, client);
   if (!Array.isArray(rows) || rows.length > 50)
     throw new Error("Invalid saved screen collection.");
   return rows.map(validateSavedScreen);
 }
+
+export async function fetchScreenCheck(
+  definition: ScreenDefinition,
+  tickerText: string,
+  snapshotId?: string,
+  signal?: AbortSignal,
+  client: ScreenerClient = apiClient,
+): Promise<ScreenCheckPayload> {
+  const ticker = screenCheckTicker(tickerText);
+  const parsed = parseScreenDefinition(definition);
+  const payload = await client.equityScreener<ScreenCheckPayload>("check", json("POST", {
+    ...parsed, ...ticker, ...(snapshotId ? { snapshotId } : {}),
+  }, { signal }));
+  return validateScreenCheck(payload, parsed, ticker, snapshotId);
+}

package/src/plugins/builtin/equity-screener/headless.ts

@@ -11,12 +11,13 @@ import { EXTENDED_SESSION_LABELS, type ExtendedSession } from "../../../market-d
 import { buildQuoteKey } from "../../../market-data/selectors";
 import type { Quote } from "../../../types/financials";
 import { formatCurrency, formatPercentRaw } from "../../../utils/format";
-import { fetchScreen } from "./client";
+import { fetchSavedScreens, fetchScreen, fetchScreenCheck } from "./client";
+import { checkRows, screenCheckSummary, screenCheckTicker } from "./screen-check";
 import { overlayScreenQuotes, screenExtendedSessions, sortLiveScreenRows } from "./live";
 import {
   DEFAULT_SCREEN,
   EXAMPLE_SCREEN_DEFINITION,
-  formatScreenValue,
+  formatScreenMetric,
   metricDate,
   parseScreenDefinition,
   screenColumnLabel,
@@ -72,7 +73,7 @@ function extendedColumn(session: ExtendedSession): HeadlessPaneColumn {
 
 /** A typed `--definition`, checked; every error points at the worked example. */
 function readDefinition(text: string): ScreenDefinition {
-  const pointer = "The example in gloomberb catalog EQS is a valid definition to start from.";
+  const pointer = "The example in gloom catalog EQS is a valid definition to start from.";
   let value: unknown;
   try {
     value = JSON.parse(text);
@@ -91,6 +92,26 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
   freshness: { status: "not-a-feed", basis: "screener snapshot" },
   argument: { kind: "none" },
   options: [
+    {
+      key: "check",
+      type: "string",
+      placeholder: "ticker",
+      description: "Check one ticker against every criterion, including the screen's currency filter.",
+      example: "--check NVDA",
+      shot: { reportOnly: "checks a ticker against the screen; use Check ticker in the EQS pane" },
+      normalize: (value) => {
+        screenCheckTicker(value);
+        return value.trim();
+      },
+    },
+    {
+      key: "saved",
+      type: "string",
+      placeholder: "id-or-name",
+      description: "Use a saved screen by ID or exact name. Cannot be combined with --definition.",
+      shot: { reportOnly: "opens a saved screen for the report; open it from Saved in the EQS pane" },
+      replaces: ["definition"],
+    },
     {
       key: "definition",
       type: "string",
@@ -124,9 +145,50 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
     ],
   },
   async load(args, ctx) {
-    const definition = args.options.definition
+    if (args.options.saved && args.options.definition) throw new Error("Choose --saved or --definition, not both.");
+    let definition = args.options.definition
       ? readDefinition(String(args.options.definition))
       : DEFAULT_SCREEN;
+    let savedName: string | undefined;
+    if (args.options.saved) {
+      const screens = await fetchSavedScreens(ctx.signal, ctx.apiClient);
+      const wanted = String(args.options.saved).trim();
+      const byId = screens.find((screen) => screen.id === wanted);
+      const matches = byId ? [byId] : screens.filter((screen) => screen.name.toLowerCase() === wanted.toLowerCase());
+      if (matches.length !== 1) throw new Error(matches.length
+        ? `More than one saved screen is named ${JSON.stringify(wanted)}. Use its ID with --saved.`
+        : `Saved screen ${JSON.stringify(wanted)} was not found. Open Saved in EQS to see your screens.`);
+      definition = matches[0]!.definition;
+      savedName = matches[0]!.name;
+    }
+    if (args.options.check) {
+      const data = await fetchScreenCheck(definition, String(args.options.check), undefined, ctx.signal, ctx.apiClient);
+      return {
+        freshness: { asOf: data.snapshot.assembledAt },
+        complete: data.status === "available" && data.warnings.length === 0,
+        errors: data.warnings,
+        sections: data.criteria.length === 0 ? [{
+          title: data.row ? `${data.row.symbol}:${data.row.exchange}` : data.symbol,
+          entries: [{ label: "Result", value: screenCheckSummary(data) }],
+        }] : [{
+          title: `${data.row ? `${data.row.symbol}:${data.row.exchange}` : data.symbol} · ${screenCheckSummary(data)}`,
+          columns: [
+            { key: "criterion", header: "Criterion" },
+            { key: "value", header: "Value", align: "right" as const },
+            { key: "result", header: "Result" },
+            { key: "asOf", header: "As of" },
+            { key: "state", header: "State" },
+            { key: "reason", header: "Reason", underRow: true },
+          ],
+          rows: checkRows(data),
+        }],
+        metadata: {
+          definition: data.definition, snapshot: data.snapshot, symbol: data.symbol,
+          listing: data.row, matches: data.matches, status: data.status,
+          criteria: data.criteria, ...(savedName ? { savedScreen: savedName } : {}),
+        },
+      };
+    }
     const data = await fetchScreen(definition, null, ctx.signal, ctx.apiClient);
     const metric = (args.options.metric ?? "marketCap") as NumericField;
     // Last, Chg% and market cap are the regular session, as `quote` and the
@@ -147,7 +209,7 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
     const empty = currencyEmpty
       ? [
         `${currencyEmpty.title} ${currencyEmpty.detail}`,
-        `In the base currency, ${currencyEmpty.base.currency}: gloomberb fn EQS --definition '${spacedJson(currencyEmpty.base)}'${metric === "marketCap" ? "" : ` --metric ${metric}`}`,
+        `In the base currency, ${currencyEmpty.base.currency}: gloom fn EQS --definition '${spacedJson(currencyEmpty.base)}'${metric === "marketCap" ? "" : ` --metric ${metric}`}`,
       ].join("\n")
       : null;
     // Payload status also counts ordinary per-field sparsity; only generation
@@ -190,7 +252,7 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
               extendedPrice: row.extended?.price ?? null,
               extendedChangePercent: row.extended?.changePercent ?? null,
               ...(row.extended?.mark ? { extendedMark: true } : {}),
-              value: formatScreenValue(metric, observation.value),
+              value: formatScreenMetric(metric, observation),
               unit: observation.unit,
               percentile:
                 observation.percentile.value == null

package/src/plugins/builtin/equity-screener/live.ts

@@ -119,7 +119,7 @@ const LIVE_SORT_FIELDS: ReadonlySet<string> = new Set(["price", "changePercent",
  * Rows in the screen's order by the figures they show. A sort on a field the
  * quotes move (price, change, volume, market cap) is redone on the overlaid
  * values, so the column reads monotone: GRAB's snapshot cap, two closes old,
- * kept it above MANH after its quote moved it below (GLO-754). Rows without a
+ * kept it above MANH after its quote moved it below. Rows without a
  * value stay last, and ties keep the snapshot's order. Any other sort is the
  * snapshot's, which the overlay does not touch.
  */

package/src/plugins/builtin/equity-screener/model.ts

@@ -21,6 +21,7 @@ import { yearToDateBaseLabel } from "../../../market-data/market/year-to-date";
 import { canonicalExchange } from "../../../utils/exchanges";
 import { LATEST_DISTRIBUTION, TRAILING_DIVIDEND_BASIS } from "../../../utils/forward-dividend";
 import { formatCompact, formatNumber } from "../../../utils/format";
+import { formatPriceEarnings, NOT_MEANINGFUL } from "../../../utils/price-earnings";
 import { kpiFreeLimitNote } from "../company-kpis/model";
 
 /**
@@ -135,6 +136,11 @@ export function formatScreenValue(field: NumericField, value: number | null): st
   return SIGNED.has(field) && value > 0 && fixed !== "0.0" ? `+${fixed}` : fixed;
 }
 
+/** A row's metric as a cell prints it: N/M for a multiple that is not meaningful, as RV and `valuation` print it. */
+export function formatScreenMetric(field: NumericField, metric: Pick<ScreenMetric, "value" | "notMeaningful">): string {
+  return metric.value == null && metric.notMeaningful ? formatPriceEarnings(NOT_MEANINGFUL) : formatScreenValue(field, metric.value);
+}
+
 /**
  * A row's dividend yield basis, in the words `ticker` and `DVD` use. Gloom
  * Cloud serves each row's statistics yield as it is stated, forward for most