@gloom-sh/terminal 0.18.5 → 0.19.0

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

@@ -264,6 +264,7 @@ function HelpPane({ focused, width, height }: PaneProps) {
         entry("zoom-tool", ["Shift+Z", "Shift+Drag"], "Pick the zoom tool, then drag a time range."),
         entry("ruler", ["Shift+M", "Alt+Drag"], "Pick the ruler, then drag to measure a move."),
         entry("draw", ["Shift+D", "Shift+P"], "Draw a trend line or a freehand shape."),
+        entry("shapes", ["Shift+J", "Shift+B", "Shift+F"], "Draw a horizontal ray, a rectangle or a Fib retracement."),
         entry("place", ["Enter", "Arrows"], "With a tool picked, Enter starts it at the cursor, the arrows move its end, and Enter finishes it."),
         entry("drawings", ["[", "]"], "With a drawing tool picked, pick a drawing."),
         entry("colour", ["c", "Backspace"], "Cycle the drawing colour, or delete the picked drawing (the last one while a drawing tool is picked)."),

package/src/plugins/builtin/help/shortcut-model.ts

@@ -18,7 +18,7 @@ export function resolveWindowTemplates(registry: SharedRegistry): HelpShortcutEn
   const allPlugins = registry.allPlugins ?? new Map<string, { name?: string }>();
 
   return [...registry.paneTemplates.values()]
-    .filter((template) => template.shortcut)
+    .filter((template) => template.shortcut && template.listed !== false)
     .filter((template) => {
       const pluginId = registry.getPaneTemplatePluginId?.(template.id);
       return !pluginId || !disabledPlugins.has(pluginId);

package/src/plugins/builtin/holders/fund-holders.ts

@@ -0,0 +1,51 @@
+import type { Quote } from "../../../types/financials";
+import { quoteTradingExchange } from "../../../market-data/quotes/metadata";
+import { isUsListingExchange } from "../../../utils/exchanges";
+import { isFundType } from "../../../utils/sec";
+import { isNoSourceAnswer } from "../../../sources/provider-errors";
+import { logFailure } from "../../../utils/log-failure";
+import { fetchFunds } from "../members/client";
+import { coveredFund } from "../members/model";
+
+type FundQuote = Pick<Quote, "instrumentType" | "tradingExchangeName" | "listingExchangeName" | "exchangeName">;
+
+/** What a holder report says for a fund in place of its holders: the reason, and the commands that read the fund. */
+export interface FundHoldersAnswer {
+  message: string;
+  /** One command a line, each for what it reads; empty for a fund abroad, which those do not cover. */
+  details: string[];
+}
+
+/**
+ * What `holders`, `13f` and `fn HDS` say for a fund no holder source has an
+ * ownership breakdown of (XLE, SPY, EWJ), in place of the source's bare
+ * NO_DATA: that it is a fund, and for a US-listed one the commands that read
+ * it, each only where it runs: the 13F filers that hold it (`fn 13F`), what it
+ * holds where `fn MEMB` covers it, and its fund facts (`fn ETF`). Null for a
+ * listing that is not a fund, or a failure that is no answer (a timeout).
+ */
+export async function fundHoldersAnswer(
+  symbol: string,
+  error: unknown,
+  quote: FundQuote | null | undefined,
+  client: NonNullable<Parameters<typeof fetchFunds>[0]>,
+): Promise<FundHoldersAnswer | null> {
+  if (!isNoSourceAnswer(error) || !quote || !isFundType(quote.instrumentType)) return null;
+  const fund = symbol.split(":")[0]!.trim().toUpperCase();
+  const message = `${fund} is a fund: there is no ownership breakdown for funds.`;
+  if (!isUsListingExchange(quoteTradingExchange(quote))) return { message, details: [] };
+  // A covered-fund list that cannot be read names no fn MEMB, which may not run for this fund.
+  const funds = await fetchFunds(client).then((payload) => payload.funds)
+    .catch(logFailure("holders.fund-holders", "Read the funds fn MEMB covers failed", null));
+  const covered = !!funds && !!coveredFund(funds, fund);
+  // Shares of an exchange-traded fund are 13F securities; a mutual fund's are not.
+  const traded = !/MUTUAL/i.test(quote.instrumentType ?? "");
+  return {
+    message,
+    details: [
+      ...traded ? [`13F filers that hold it: gloom fn 13F ${fund}`] : [],
+      ...covered ? [`What it holds: gloom fn MEMB ${fund}`] : [],
+      `Fund facts: gloom fn ETF ${fund}`,
+    ],
+  };
+}

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

@@ -33,6 +33,7 @@ import {
   holderReportUnits,
 } from "./report-rows";
 import { REPORT_ROWS } from "../shared/headless-options";
+import { fundHoldersAnswer } from "./fund-holders";
 import {
   HOLDER_ROWS_MAX,
   indexedHoldersPartialNote,
@@ -224,11 +225,27 @@ export function createHoldersHeadless(
         .catch(logFailure("holders.headless", "Resolve the listing's venue for the 13F holder index failed", null)))?.exchange ?? "";
       const indexTicker = indexHolderTicker(symbol, exchange);
       const [snapshot, index] = await Promise.all([
-        dependencies.loadSnapshot(symbol, args, ctx),
+        dependencies.loadSnapshot(symbol, args, ctx).catch(async (error: unknown) => {
+          const quote = await ctx.marketData.getQuote(symbol)
+            .catch(logFailure("holders.headless", "Read the quote of a listing with no holders failed", null));
+          const fund = await fundHoldersAnswer(symbol, error, quote, ctx.apiClient);
+          if (fund) return fund;
+          throw error;
+        }),
         indexTicker
           ? dependencies.loadIndexedHolders(indexTicker, limit, ctx).catch(logFailure("holders.headless", "Load 13F holder index failed", null))
           : null,
       ]);
+      // A fund has no ownership breakdown: the report says so in place of rows, with what reads it, and fails as no data.
+      if ("message" in snapshot) {
+        return {
+          columns: HOLDER_REPORT_COLUMNS,
+          rows: [],
+          empty: [snapshot.message, ...snapshot.details].join("\n"),
+          unavailableSymbols: [symbol],
+          metadata: { symbol },
+        };
+      }
       const { marketCap } = snapshot;
       const indexed = !!index?.rows.length && indexHolderTicker(symbol, exchange, snapshot.data) != null;
       const partialNote = indexed ? indexedHoldersPartialNote(index, limit) : null;

package/src/plugins/builtin/iv-history/client.ts

@@ -5,10 +5,18 @@ import type { ChartRequest, InstrumentRef } from "../../../market-data/request-t
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
 import type { PricePoint } from "../../../types/financials";
-import { realizedVolatility, realizedVolatilityCadenceIssue } from "../shared/volatility";
+import { realizedVolatilityCadenceIssue, rollingRealizedVolatility } from "../shared/volatility";
 import { NO_FATE, type ListingFate } from "../../../tickers/listing-fate";
 
 export type IvMethod = "quote-mid" | "trade-close";
+/**
+ * Which prices a trade-close reading was solved from: each option's closing
+ * print, kept because it sat inside the closing two-sided quote (`print`), the
+ * quote midpoint, used where a print sat outside it (`mid`), or both
+ * (`mixed`). Absent when no closing quote was stored to check the prints
+ * against, as for most history before the checks began.
+ */
+export type IvCloseBasis = "print" | "mid" | "mixed";
 export type IvCoverageStatus = "ready" | "backfilling" | "queued" | "unavailable";
 export interface IvPoint {
   sessionDate: string;
@@ -27,11 +35,14 @@ export interface IvPoint {
    */
   put25_30?: number | null;
   call25_30?: number | null;
+  /** Prices a trade close was solved from; see `IvCloseBasis`. Absent from older servers. */
+  basis?: IvCloseBasis | null;
 }
 export interface IvStats {
   value: number;
   date: string;
   method: IvMethod;
+  basis?: IvCloseBasis | null;
   rank: number | null;
   percentile: number | null;
   low: number | null;
@@ -54,6 +65,7 @@ interface IvReading {
   iv90: number | null;
   iv180: number | null;
   iv365: number | null;
+  basis?: IvCloseBasis | null;
 }
 export interface IvHistoryPayload {
   version: 1;
@@ -155,6 +167,37 @@ export function createHvDependencies(marketData?: DataProvider): HvDependencies
 /** Screen rows with no reading whose symbol's fate is looked up; a long list of them is a backfill, not a lookup. */
 const MAX_FATE_LOOKUPS = 10;
 
+/**
+ * A symbol's realized volatility over one window: the newest, and after every
+ * session's close, so a reading is divided by the HV of its own date and not
+ * of today.
+ */
+export interface ScreenHv {
+  /** HV over the newest window of closes. */
+  value: number | null;
+  /** Date of the newest daily bar: the newest session the symbol's prices reach. */
+  date: string | null;
+  /** HV after each session's close, oldest first; sessions without a full window are left out. */
+  series: ReadonlyArray<readonly [date: string, value: number]>;
+}
+
+const barDay = (value: Date) => new Date(value).toISOString().slice(0, 10);
+
+/** `ScreenHv` from daily closes; a provider that fell back to weekly or intraday bars would misstate daily HV, so it has none. */
+export function screenHv(history: readonly PricePoint[], window: number): ScreenHv {
+  if (realizedVolatilityCadenceIssue(history)) return { value: null, date: null, series: [] };
+  const rolling = rollingRealizedVolatility(history, { windows: [window] });
+  const series = rolling.flatMap((point) => {
+    const value = point.values[window];
+    return value == null ? [] : [[barDay(point.date), value] as const];
+  });
+  const newest = history.reduce<string | null>((latest, point) => {
+    const date = barDay(point.date);
+    return latest == null || date > latest ? date : latest;
+  }, null);
+  return { value: rolling.at(-1)?.values[window] ?? null, date: newest, series };
+}
+
 /**
  * HV for a screen's symbols (`loadRealizedVolatilities`), started at once,
  * and what became of the ones its rows have no reading for, at most
@@ -166,11 +209,11 @@ const MAX_FATE_LOOKUPS = 10;
  */
 export async function loadScreenVolatilities(
   instruments: readonly InstrumentRef[], rows: Promise<readonly IvScreenRow[]>, window: number,
-  options: { signal?: AbortSignal; onValue?: (symbol: string, value: number | null) => void; onFates?: (fates: ReadonlyMap<string, ListingFate>) => void } = {},
+  options: { signal?: AbortSignal; onValue?: (symbol: string, value: ScreenHv | null) => void; onFates?: (fates: ReadonlyMap<string, ListingFate>) => void } = {},
   dependencies: HvDependencies = createHvDependencies(),
-): Promise<{ hv: Map<string, number | null>; fates: Map<string, ListingFate> }> {
+): Promise<{ hv: Map<string, ScreenHv | null>; fates: Map<string, ListingFate> }> {
   const moved = new Set<string>();
-  const onValue = options.onValue && ((symbol: string, value: number | null) => { if (!moved.has(symbol)) options.onValue!(symbol, value); });
+  const onValue = options.onValue && ((symbol: string, value: ScreenHv | null) => { if (!moved.has(symbol)) options.onValue!(symbol, value); });
   const [hv, fates] = await Promise.all([
     loadRealizedVolatilities(instruments, window, { ...options, onValue }, dependencies),
     rows.then(async (screened) => {
@@ -189,20 +232,18 @@ export async function loadScreenVolatilities(
 
 /** Close-to-close HV over one window for each symbol from one year of daily closes, four at a time. */
 async function loadRealizedVolatilities(
-  instruments: readonly InstrumentRef[], window: number, options: { signal?: AbortSignal; onValue?: (symbol: string, value: number | null) => void } = {},
+  instruments: readonly InstrumentRef[], window: number, options: { signal?: AbortSignal; onValue?: (symbol: string, value: ScreenHv | null) => void } = {},
   dependencies: HvDependencies = createHvDependencies(),
-): Promise<Map<string, number | null>> {
-  const result = new Map<string, number | null>();
+): Promise<Map<string, ScreenHv | null>> {
+  const result = new Map<string, ScreenHv | null>();
   let next = 0;
   const worker = async () => {
     while (next < instruments.length && !options.signal?.aborted) {
       const instrument = instruments[next++]!;
-      let value: number | null = null;
+      let value: ScreenHv | null = null;
       try {
         const entry = await dependencies.loadChart({ instrument, bufferRange: "1Y", granularity: "resolution", resolution: "1d" });
-        const history = resolveEntryValue(entry) ?? [];
-        // A provider that fell back to weekly or intraday bars would misstate daily HV.
-        value = realizedVolatilityCadenceIssue(history) ? null : realizedVolatility(history, window);
+        value = screenHv(resolveEntryValue(entry) ?? [], window);
       } catch { value = null; }
       result.set(instrument.symbol, value);
       options.onValue?.(instrument.symbol, value);

package/src/plugins/builtin/iv-history/format.ts

@@ -1,26 +1,32 @@
-import type { IvMethod } from "./client";
-import type { IvStatRow, IvStatUnit, RichCheap, RichCheapDates } from "./model";
+import type { IvCloseBasis, IvMethod } from "./client";
+import { readingSource, type IvStatRow, type IvStatUnit, type RichCheap, type RichCheapDates } from "./model";
 
 /**
  * VCA's sign conventions, and what VIX is beside an at-the-money IV30, one
- * line each: under the table, in the shot and in the report's notes. The skew
- * is the stored 25-delta put and call IVs at a 30-day constant maturity, from
- * the latest quote capture; both differences are decimal IV shown in points.
+ * line each: under the table, in the shot and in the report's notes. The risk
+ * reversal is the stored 25-delta call and put IVs at a 30-day constant
+ * maturity, from the latest quote capture, signed as OVDV signs it; both
+ * differences are decimal IV shown in points. Its line is there only while a
+ * risk reversal column is.
  */
-export const VCA_DEFINITIONS = [
-  "25D skew: 30-day 25-delta put IV minus 25-delta call IV, in vol points; positive means puts are richer. 30-90: IV30 minus IV90.",
-  "VIX is Cboe's 30-day S&P 500 implied vol from the whole SPX strike strip, skew included; IV30 here is at the money, so VIX usually reads higher.",
-] as const;
+export function vcaDefinitions({ skew }: { skew: boolean }): string[] {
+  return [
+    ...(skew ? ["25D RR: 30-day 25-delta call IV minus 25-delta put IV, in vol points, as OVDV's risk reversal; positive means calls are richer."] : []),
+    "30-90: IV30 minus IV90. IV/HV: IV30 over the HV20 of the same date.",
+    "VIX is Cboe's 30-day S&P 500 implied vol from the whole SPX strike strip, skew included; IV30 here is at the money, so VIX usually reads higher.",
+  ];
+}
 
 /** Words for implied volatility that are no function's code: `fn IVOL` names HIVG and OVDV, which list them as `suggestFor`. */
 export const IMPLIED_VOL_WORDS = ["IVOL", "IV", "OVOL", "IMPVOL", "IMPLIEDVOL"];
 
 /**
- * A skew column's header names its sign, since the conventions differ: the
- * 25-delta skew is put minus call (HIVG, VCA), the risk reversal call minus
- * put (OVDV). "skew25d put-call (pts)": the stem a script keys on, the
- * sign, and vol points in the unit's usual place, as in "IV30 (%)". No
- * comma, so a CSV header needs no quoting.
+ * A skew column's header names its sign. The risk reversal is call minus put
+ * wherever it is shown (OVDV, VCA, HIVG's rr25d), so positive means calls are
+ * richer; HIVG's skew25d keeps the put-minus-call sign it was first exported
+ * with, the negative of that. "rr25d call-put (pts)": the stem a script keys
+ * on, the sign, and vol points in the unit's usual place, as in "IV30 (%)".
+ * No comma, so a CSV header needs no quoting.
  */
 export const skewHeader = (stem: string, sign: string) => `${stem} ${sign} (pts)`;
 
@@ -43,22 +49,29 @@ export function formatStat(value: number | null | undefined, unit: IvStatUnit):
 /**
  * How a stored reading was taken. A quote capture is the option quote mids
  * from the minutes before the close, taken once a session and never updated:
- * it is not a live feed, so it is not called live.
+ * it is not a live feed, so it is not called live. A close solved from quote
+ * midpoints, where its prints were off the market, says so.
+ */
+export function statSource(row: Pick<IvStatRow, "method"> & { basis?: IvCloseBasis | null }): string {
+  return row.method === "prices" ? "closes" : row.method ? readingSource(row.method, row.basis) : "";
+}
+/**
+ * "2026-10-09 quote": the session a reading belongs to and how it was taken.
+ * A stale reading says so instead, "2026-05-18 close, stale", and in the short
+ * form "05-18 stale".
  */
-const readingSource = (method: IvMethod | null | undefined) => method === "quote-mid" ? "quote" : "close";
-export function statSource(row: Pick<IvStatRow, "method">): string {
-  return row.method === "prices" ? "closes" : row.method ? readingSource(row.method) : "";
+export function readingLabel(date: string, method: IvMethod | null | undefined, short = false,
+  extra: { basis?: IvCloseBasis | null; stale?: boolean } = {}): string {
+  if (extra.stale) return short ? `${shortDate(date)} stale` : `${date} ${readingSource(method, extra.basis)}, stale`;
+  return `${short ? shortDate(date) : date} ${readingSource(method, extra.basis)}`;
 }
-/** "2026-10-09 quote": the session a reading belongs to and how it was taken. */
-export const readingLabel = (date: string, method: IvMethod | null | undefined, short = false) =>
-  `${short ? shortDate(date) : date} ${readingSource(method)}`;
 /**
  * The dates every row agrees on, said once: the reading's, and the trade close
  * its rank is measured on. `short` is for a footer with little room: month and
  * day, and no window.
  */
 export function sharedDates({ reading, rank }: Pick<RichCheapDates, "reading" | "rank">, short = false): string[] {
-  if (reading?.method === "trade-close" && reading.date === rank) return [readingLabel(reading.date, reading.method, short)];
-  return [reading && `IV30 ${readingLabel(reading.date, reading.method, short)}`,
+  if (reading?.method === "trade-close" && reading.date === rank) return [readingLabel(reading.date, reading.method, short, { basis: reading.basis })];
+  return [reading && `IV30 ${readingLabel(reading.date, reading.method, short, { basis: reading.basis })}`,
     rank && (short ? `IVR/IVP ${shortDate(rank)} close` : `IVR/IVP vs 52 weeks to ${rank} close`)].filter((part): part is string => !!part);
 }

package/src/plugins/builtin/iv-history/headless.ts

@@ -2,8 +2,8 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { createRealizedVolatilityDependencies, loadRealizedVolatilityHistory } from "../realized-vol/client";
 import { createHvDependencies, loadIvHistory, loadIvScreen, loadScreenVolatilities } from "./client";
-import { formatPoints, formatRank, formatSpot, formatStat, formatVol, IMPLIED_VOL_WORDS, readingLabel, sharedDates, skewHeader, VCA_DEFINITIONS, verdictLabel } from "./format";
-import { HV_WINDOWS, type HvWindow, type IvLookback, type IvStatRow, projectIvHistory, projectRichCheap, type RichCheapRow, richCheapDates, screenCoverage, VCA_LIMIT, VCA_PRESETS } from "./model";
+import { formatPoints, formatRank, formatSpot, formatStat, formatVol, IMPLIED_VOL_WORDS, readingLabel, sharedDates, skewHeader, statSource, vcaDefinitions, verdictLabel } from "./format";
+import { HV_WINDOWS, type HvWindow, type IvLookback, type IvStatRow, projectIvHistory, projectRichCheap, type RichCheapRow, richCheapDates, screenCoverage, screenStaleNote, VCA_LIMIT, VCA_PRESETS } from "./model";
 import { vcaUniverse } from "./universe";
 import { offsetText, releaseOffsetRows } from "./events";
 import { loadMacroReleases } from "../macro-day/client";
@@ -16,6 +16,7 @@ import type { HeadlessPaneContext } from "../../../types/headless";
 import { zonedDateKey } from "../../../utils/zoned-date-time";
 import { listingFateNotes, listingFateReport, loadListingFate, MovedSymbolError } from "../../../tickers/listing-fate";
 import { startTickerChangeLookup } from "../../../tickers/ticker-changes";
+import { fxVolatilityRefusal } from "../../../market-data/options-alternatives";
 
 const METHODOLOGY = "docs/research-data.md#implied-volatility-history";
 const percent = (value: unknown) => typeof value === "number" ? formatVol(value) : "--";
@@ -24,6 +25,7 @@ const points = (value: unknown) => typeof value === "number" ? formatPoints(valu
 export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "US option underlying" },
   usListingsOnly: "Implied volatility history",
+  refuseSymbol: fxVolatilityRefusal("HIVG"),
   freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date", oldest: null },
   describe: (args) => `HIVG ${args.symbols[0] ?? ""}`,
   discovery: { aliases: ["HIVG"], suggestFor: IMPLIED_VOL_WORDS, screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
@@ -79,7 +81,7 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
     // With nothing served, the fate is why: no "not a ticker" or missing-history errors beside it.
     const { notes: fateNotes, errors } = listingFateReport(fate, { served },
       [prices.error, ...model.warnings].filter((value): value is string => !!value));
-    const notes = [...fateNotes, ...[model.oneYearNote, model.skewNote].filter((note): note is string => !!note)];
+    const notes = [...fateNotes, ...[model.oneYearNote, model.skewNote, model.staleNote].filter((note): note is string => !!note)];
     if (event && releases) {
       const lookback = String(args.options.lookback) as IvLookback;
       const label = MACRO_EVENT_LABELS[event];
@@ -117,18 +119,27 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
           releaseSource: MACRO_RELEASE_SOURCES[event], unit: "decimal annualized volatility", methodology: METHODOLOGY },
       };
     }
+    // The text report dates a stale measure "stale"; exports keep the bare date and say it in `stale`.
+    const statColumns = [
+      { key: "label", header: "Measure" },
+      { key: "value", header: "Current", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
+      { key: "date", header: "As of" }, { key: "method", header: "Method" },
+      { key: "low", header: "52w low", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
+      { key: "high", header: "52w high", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
+      { key: "rank", header: "Rank", format: (value: unknown) => formatRank(value as number | null) },
+      { key: "percentile", header: "Pctl", format: (value: unknown) => formatRank(value as number | null) },
+      { key: "samples", header: "Sessions" },
+    ];
+    const statTextColumns = statColumns.map((column) => column.key === "date"
+      ? { ...column, textFormat: (value: unknown, row: unknown) => typeof value !== "string" ? "-" : (row as IvStatRow).stale ? `${value} stale` : value }
+      : column.key === "method"
+        // The wording the pane's source column uses; exports keep the raw method and carry the basis.
+        ? { ...column, textFormat: (value: unknown, row: unknown) => typeof value !== "string" ? "-" : statSource(row as IvStatRow) }
+        : column);
     return {
       sections: [
-        { title: "Statistics", columns: [
-          { key: "label", header: "Measure" },
-          { key: "value", header: "Current", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
-          { key: "date", header: "As of" }, { key: "method", header: "Method" },
-          { key: "low", header: "52w low", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
-          { key: "high", header: "52w high", format: (value: unknown, row?: unknown) => formatStat(value as number | null, (row as IvStatRow).unit) },
-          { key: "rank", header: "Rank", format: (value: unknown) => formatRank(value as number | null) },
-          { key: "percentile", header: "Pctl", format: (value: unknown) => formatRank(value as number | null) },
-          { key: "samples", header: "Sessions" },
-        ], rows: model.stats.map((row) => ({ ...row })) },
+        { title: "Statistics", columns: [...statColumns, { key: "basis", header: "Basis" }, { key: "stale", header: "Stale" }], textColumns: statTextColumns,
+          rows: model.stats.map((row) => ({ ...row })) },
         // Exports always carry the skew columns, so a script's header never moves; the text table drops them when none has a value.
         { title: "Daily history", columns: [...historyColumns, ...skewColumns], rows,
           ...(rows.some((row) => row.skew25d != null) ? {} : { textColumns: historyColumns }) },
@@ -151,6 +162,7 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
   freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date" },
   argument: { kind: "symbol-list", optional: true, maximum: VCA_LIMIT, description: "US option underlyings; defaults to index and sector ETFs." },
   usListingsOnly: "Implied volatility",
+  refuseSymbol: fxVolatilityRefusal("VCA"),
   options: [{ key: "preset", type: "enum", values: [{ value: "etfs" }, { value: "megacaps" }], defaultValue: "etfs", description: "Preset when no symbols are given" }],
   describe: "Volatility rich/cheap",
   // The pane names its universe `scope`; symbols typed open their own (custom), which a preset does not replace.
@@ -180,14 +192,15 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
     // A listing that stopped trading has its row's note, not a line saying it has no options history.
     const coverage = screenCoverage(rows, { explained: new Set([...noted].filter(([, entry]) => entry.fate.endedOn).map(([symbol]) => symbol)) });
     const dates = richCheapDates(rows);
-    const hasSkew = rows.some((row) => row.skew != null);
+    const hasSkew = rows.some((row) => row.riskReversal != null);
     const hasIv1y = rows.some((row) => row.iv1y != null), hasIv1yRank = rows.some((row) => row.iv1yPercentile != null);
     const dated = (value: unknown) => typeof value === "string" ? value : "--";
     return {
       sections: [{ title: ["Rich/cheap", universe.label, ...sharedDates(dates)].join(" · "), columns: [
         { key: "symbol", header: "Symbol" }, { key: "iv30", header: "IV30", format: percent },
         ...(dates.reading ? [] : [{ key: "date", header: "As of", format: (value: unknown, row?: unknown) =>
-          typeof value === "string" ? readingLabel(value, (row as RichCheapRow).method) : "--" }]),
+          typeof value === "string" ? readingLabel(value, (row as RichCheapRow).method, false,
+            { basis: (row as RichCheapRow).basis, stale: (row as RichCheapRow).stale }) : "--" }]),
         // The underlying price each reading was taken at, on the date the title or the As of column gives.
         { key: "spot", header: "Spot", format: (value: unknown) => typeof value === "number" ? formatSpot(value) : "--" },
         ...(dates.rankApart ? [{ key: "rankDate", header: "Rank as of", format: (value: unknown) => typeof value === "string" ? `${value} close` : "--" }] : []),
@@ -197,16 +210,18 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
         ...(hasIv1y ? [{ key: "iv1y", header: "IV1Y", format: percent }] : []),
         ...(hasIv1yRank ? [{ key: "iv1yPercentile", header: "IVP1Y", format: (value: unknown) => formatRank(value as number | null) }] : []),
         { key: "termSlope", header: "30-90", format: (value: unknown) => formatPoints(value as number | null) },
-        ...(hasSkew ? [{ key: "skew", header: skewHeader("25D skew", "put-call"), format: (value: unknown) => formatPoints(value as number | null) }] : []),
-        ...(hasSkew && dates.skewApart ? [{ key: "skewDate", header: "Skew as of", format: dated }] : []),
+        ...(hasSkew ? [{ key: "riskReversal", header: skewHeader("25D RR", "call-put"), format: (value: unknown) => formatPoints(value as number | null) }] : []),
+        ...(hasSkew && dates.skewApart ? [{ key: "skewDate", header: "RR as of", format: dated }] : []),
         { key: "hv", header: "HV20", format: percent },
+        // Said only where an HV is not the one of its IV's date: a stale reading's, or one a few sessions off.
+        ...(dates.hvApart ? [{ key: "hvDate", header: "HV as of", format: dated }] : []),
         { key: "ivHv", header: "IV/HV", format: (value: unknown) => typeof value === "number" ? value.toFixed(2) : "--" },
         ...(noted.size > 0 ? [{ key: "note", header: "Note", underRow: true }] : []),
       ], rows: rows.map((row) => ({ ...row, ...noted.has(row.symbol) ? { note: noted.get(row.symbol)!.note } : {} })) }],
       // A symbol with no options history is final; only history still to come leaves the screen incomplete.
       complete: !coverage.pending.length && !universe.error, unavailableSymbols: coverage.missing,
       errors: [universe.error].filter((value): value is string => !!value),
-      notes: [...coverage.notes, ...VCA_DEFINITIONS],
+      notes: [...coverage.notes, ...[screenStaleNote(rows)].filter((note): note is string => !!note), ...vcaDefinitions({ skew: hasSkew })],
       metadata: { presets: VCA_PRESETS, methodology: METHODOLOGY },
     };
   },

package/src/plugins/builtin/iv-history/index.tsx

@@ -32,13 +32,13 @@ export const ivHistoryModule: PluginModule = {
     { ...createTickerSurfacePaneTemplate({
       id: "iv-history-pane", paneId: "iv-history", label: "Implied Volatility History",
       description: "30-day, 90-day and one-year ATM implied volatility since 2024 against realized, with IV rank and percentile.",
-      keywords: ["hivg", "implied", "volatility", "history", "iv rank", "ivr", "percentile", "vrp", "iv1y", "leaps"], shortcut: "HIVG", publicShare: true,
+      keywords: ["hivg", "implied", "volatility", "vol", "history", "iv rank", "ivr", "percentile", "vrp", "iv1y", "leaps"], shortcut: "HIVG", publicShare: true,
     }), headless: ivHistoryHeadless },
     {
       id: "iv-screen-pane", paneId: "iv-screen", label: "Volatility Rich/Cheap",
       description: "IV rank, percentile, one-year IV, term slope, skew and IV/HV across a list, ranked rich to cheap.",
       // Where a put seller finds rich premium; CSP and OSA own the exact put-selling phrases and rank first on them.
-      keywords: ["vca", "rich", "cheap", "iv rank", "implied volatility", "screen", "cash-secured puts", "selling puts", "short-put candidates",
+      keywords: ["vca", "vol", "rich", "cheap", "iv rank", "implied volatility", "screen", "cash-secured puts", "selling puts", "short-put candidates",
         "csp candidates", "wheel candidates"],
       shortcut: { prefix: "VCA", argKind: "ticker-list" as const, argOptional: true }, headless: ivScreenHeadless,
       createInstance: (_context, options) => ({