@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/portfolio-list/table.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useMemo, useRef } from "react";
-import { QUICK_ADD_KEY } from "./quick-add";
 import {
   TickerListTableView,
   type DataTableKeyEvent,
@@ -111,6 +110,7 @@ export function PortfolioTickerTable({
   onCursorChange,
   financialsMap,
   columnContext,
+  futuresFrontNotes,
   flashSymbols,
   sinceLastSeen,
   onRootKeyDown,
@@ -119,7 +119,7 @@ export function PortfolioTickerTable({
   visibleRangeBuffer,
   resetScrollKey,
   onRowActivate,
-  onAddTicker,
+  addTickerShortcut,
   onOpenPerpetual,
   rootHeight,
 }: {
@@ -134,6 +134,7 @@ export function PortfolioTickerTable({
   onCursorChange?: (ticker: TickerRecord, index: number) => void;
   financialsMap: Map<string, TickerFinancials>;
   columnContext: ColumnContext;
+  futuresFrontNotes?: ReadonlyMap<string, string>;
   flashSymbols: Map<string, QuoteFlashDirection>;
   /** For a few seconds after coming back to the pane, LAST is tinted by each row's move since the user left. */
   sinceLastSeen?: SinceLastSeenRecap | null;
@@ -144,8 +145,8 @@ export function PortfolioTickerTable({
   visibleRangeBuffer?: number;
   resetScrollKey?: unknown;
   onRowActivate?: (ticker: TickerRecord) => void;
-  /** Opens the add row; the empty table offers it as a button. */
-  onAddTicker?: () => void;
+  /** The key of the add row, which the empty table names. The pane shows the row itself, once. */
+  addTickerShortcut?: string;
   /** Opens PERP on a row's stock perpetual: its PERP% and FUND 8H cells link to it. */
   onOpenPerpetual?: (marketId: string) => void;
   rootHeight?: number;
@@ -155,21 +156,26 @@ export function PortfolioTickerTable({
   openPerpetualRef.current = onOpenPerpetual;
   const sparklineVisible = columns.some((column) => column.id === PRICE_SPARKLINE_COLUMN_ID);
   const tableFinancialsMap = useLiveSparklineFinancials(financialsMap, sortedTickers, sparklineVisible);
+  const noteColumnId = columns.some((column) => column.id === "name") ? "name" : "ticker";
+  const hasFrontReference = useMemo(() => sortedTickers.some((ticker) => columnContext.futuresTerms?.get(ticker.metadata.ticker)?.front),
+    [columnContext.futuresTerms, sortedTickers]);
   const resolveCell = useCallback(
     (column: ColumnConfig, ticker: TickerRecord, financials: TickerFinancials | undefined) => {
       const key = `${ticker.metadata.ticker}:${column.id}`;
       const version = buildCellVersion(column, ticker, financials, columnContext);
-      const cell = cellCacheRef.current.get(key, version, () => {
+      const cached = cellCacheRef.current.get(key, version, () => {
         const cell = getColumnValue(column, ticker, financials, columnContext);
         const marketId = PERPETUAL_COLUMN_IDS.has(column.id) ? columnContext.perpetuals?.get(ticker.metadata.ticker)?.marketId : undefined;
         return marketId ? { ...cell, onPress: () => openPerpetualRef.current?.(marketId) } : cell;
       });
+      const note = column.id === noteColumnId ? futuresFrontNotes?.get(ticker.metadata.ticker) : undefined;
+      const cell = note ? { ...cached, note } : cached;
       // LAST keeps its price: a move since the user last looked only tints the cell.
       if (column.id !== "price" || !sinceLastSeen) return cell;
       const move = sinceLastSeen.moves.get(ticker.metadata.ticker);
       return move == null ? cell : { ...cell, backgroundColor: sinceLastSeenTint(move, sinceLastSeen.fading) };
     },
-    [columnContext, sinceLastSeen],
+    [columnContext, futuresFrontNotes, noteColumnId, sinceLastSeen],
   );
   const pnlColumn = columns.find((column) => column.id === "pnl" || column.id === "pnl_pct");
   // Reads the same cached P&L cells the rows show; only changed rows recompute.
@@ -202,7 +208,8 @@ export function PortfolioTickerTable({
     : pnlLabel !== "P&L" && (column.id === "pnl" || column.id === "pnl_pct") ? {
     ...column,
     label: column.id === "pnl_pct" ? pnlLabel.replace("P&L", "%") : pnlLabel,
-  } : column), [columns, grossWeights, hasNonShareQuantity, pnlLabel, sharesWidth, tickerWidth]);
+  } : column).map((column) => hasFrontReference && column.id === noteColumnId ? { ...column, flexGrow: 1 } : column),
+  [columns, grossWeights, hasFrontReference, hasNonShareQuantity, noteColumnId, pnlLabel, sharesWidth, tickerWidth]);
   // The table offers "Sort by…" while it has a sort column. A watchlist starts
   // unsorted and a third header click turns sorting off, so the unsorted state
   // needs its own entry until TickerListTableView takes `sortable`.
@@ -235,8 +242,7 @@ export function PortfolioTickerTable({
       resetScrollKey={resetScrollKey}
       onRowActivate={onRowActivate}
       rowMenuAccelerators={PORTFOLIO_ROW_MENU_KEYS}
-      onAddTicker={onAddTicker}
-      addTickerShortcut={onAddTicker ? QUICK_ADD_KEY : undefined}
+      addTickerShortcut={addTickerShortcut}
       rootHeight={rootHeight}
     />
   );

package/src/plugins/builtin/primary-dealers/client.ts

@@ -1,3 +1,4 @@
+import { createTtlCache } from "../../../data/ttl-cache";
 import { httpFetch } from "../../../utils/http-transport";
 import { isoDateOrNull, numericOrNull, recordOrNull, textOrNull } from "../../../utils/guards";
 import {
@@ -84,20 +85,14 @@ async function readJson(url: string): Promise<unknown> {
 }
 
 /** The series break changes about every two years; one read serves the session. */
-let seriesBreakRead: Promise<string> | null = null;
+const seriesBreaks = createTtlCache<string>({ ttlMs: Infinity });
 
 function currentSeriesBreak(force: boolean): Promise<string> {
-  if (!seriesBreakRead || force) {
-    const read = readJson(`${API}/list/seriesbreaks.json`).then((payload) => {
-      const seriesBreak = newestSeriesBreak(parseSeriesBreaks(payload));
-      if (!seriesBreak) throw new Error("No series break was listed.");
-      return seriesBreak;
-    });
-    seriesBreakRead = read;
-    // A failed read is not kept, so the next one asks again.
-    read.catch(() => { if (seriesBreakRead === read) seriesBreakRead = null; });
-  }
-  return seriesBreakRead;
+  return seriesBreaks.load("current", async () => {
+    const seriesBreak = newestSeriesBreak(parseSeriesBreaks(await readJson(`${API}/list/seriesbreaks.json`)));
+    if (!seriesBreak) throw new Error("No series break was listed.");
+    return seriesBreak;
+  }, { force });
 }
 
 /**
@@ -117,31 +112,11 @@ export async function fetchPrimaryDealers(): Promise<DealerBoard> {
   };
 }
 
-interface SeriesRead {
-  at: number;
-  read: Promise<SeriesPoint[]>;
-  points: SeriesPoint[] | null;
-}
-
-const seriesReads = new Map<string, SeriesRead>();
+const seriesReads = createTtlCache<SeriesPoint[]>({ ttlMs: HISTORY_TTL_MS });
 
 function seriesRead(seriesBreak: string, key: string, force: boolean): Promise<SeriesPoint[]> {
-  const id = `${seriesBreak}:${key}`;
-  const known = seriesReads.get(id);
-  if (known && !force && Date.now() - known.at < HISTORY_TTL_MS) return known.read;
   const url = `${API}/get/${encodeURIComponent(seriesBreak)}/timeseries/${encodeURIComponent(key)}.json`;
-  const entry: SeriesRead = {
-    at: Date.now(),
-    points: null,
-    read: readJson(url).then((payload) => {
-      entry.points = parseSeriesPoints(payload);
-      return entry.points;
-    }),
-  };
-  seriesReads.set(id, entry);
-  // A failed read is not kept, so the next one asks again.
-  entry.read.catch(() => { if (seriesReads.get(id) === entry) seriesReads.delete(id); });
-  return entry.read;
+  return seriesReads.load(`${seriesBreak}:${key}`, async () => parseSeriesPoints(await readJson(url)), { force });
 }
 
 /** A row's history, one read per series behind it, each kept for the session. */
@@ -158,9 +133,9 @@ export async function loadDealerHistory(
 function heldSeries(seriesBreak: string, row: Pick<DealerRow, "keys">): SeriesPoint[][] | null {
   const series: SeriesPoint[][] = [];
   for (const key of row.keys) {
-    const known = seriesReads.get(`${seriesBreak}:${key}`);
-    if (!known?.points || Date.now() - known.at >= HISTORY_TTL_MS) return null;
-    series.push(known.points);
+    const points = seriesReads.peek(`${seriesBreak}:${key}`);
+    if (!points) return null;
+    series.push(points);
   }
   return series;
 }
@@ -178,6 +153,6 @@ export function cachedDealerHistory(seriesBreak: string, row: Pick<DealerRow, "i
 
 /** Forgets what was read, for a test or a refresh that must see the release again. */
 export function resetPrimaryDealersCache(): void {
-  seriesBreakRead = null;
+  seriesBreaks.clear();
   seriesReads.clear();
 }

package/src/plugins/builtin/realized-vol/client.ts

@@ -4,6 +4,7 @@ import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
 import type { PricePoint } from "../../../types/financials";
 import { createSurfaceDependencies, loadVolatilitySurface, type SurfaceLoaderDependencies } from "../vol-surface/client";
+import type { SurfaceSnapshot } from "../vol-surface/model";
 import { projectCurrentAtmIv, type CurrentAtmIvSnapshot } from "./model";
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
@@ -70,7 +71,9 @@ export interface CurrentAtmIvRequest extends RealizedHistoryRequest {
  * Re-read the current reference's own expiry at the live spot: that one chain
  * is refetched and refitted, the catalogue comes from cache, and the other
  * slices of the full load are not touched. When the refreshed slice cannot
- * price an ATM level, the previous dated reference stands.
+ * price an ATM level, the refresh rejects with why ("ATM IV 31d not
+ * refreshed: ..."): the dated reference already shown stays, and the pane
+ * warns that it is not moving.
  */
 export async function refreshCurrentAtmIv(
   request: CurrentAtmIvRequest,
@@ -80,14 +83,19 @@ export async function refreshCurrentAtmIv(
   const reference = previous.reference;
   if (!reference || !(request.spot > 0) || !Number.isFinite(request.spot)) return previous;
   if (request.signal?.aborted) throw abortError(CANCELLED);
+  const notRefreshed = (reason: string) => new Error(`${reference.label} not refreshed: ${reason}`);
+  let surface: SurfaceSnapshot;
   try {
-    const next = projectCurrentAtmIv(await loadVolatilitySurface({ ...request, forceRefresh: true, expiries: [reference.expiration],
-      settings: { ivSource: reference.ivSource } }, dependencies));
-    return next.reference?.expiration === reference.expiration ? { ...previous, reference: next.reference } : previous;
+    surface = await loadVolatilitySurface({ ...request, forceRefresh: true, expiries: [reference.expiration],
+      settings: { ivSource: reference.ivSource } }, dependencies);
   } catch (error) {
     if (request.signal?.aborted || (error instanceof Error && error.name === "AbortError")) throw abortError(CANCELLED);
-    return previous;
+    throw notRefreshed(errorMessage(error));
   }
+  const next = projectCurrentAtmIv(surface);
+  if (next.reference?.expiration === reference.expiration) return { ...previous, reference: next.reference };
+  const reasons = [...new Set(surface.failures.map((failure) => failure.message))];
+  throw notRefreshed(reasons.join("; ") || "no clean quote at the money");
 }
 
 /** Options are independent of daily history and use the existing surface chain cache. */

package/src/plugins/builtin/realized-vol/evidence.ts

@@ -19,9 +19,18 @@ export interface RealizedVolEvidenceStatus {
   source: string | null;
   asOf: string | null;
   errors: string[];
+  /** The errors that are the current IV's alone: a chart missing only its IV point names that, not the symbol. */
+  ivErrors?: string[];
+  /** The windows the history is too short for: their series have no values, and the capture is whole without them. */
+  shortWindows?: number[];
   currentIv: { value: number; date: string; label: string; source: string | null; expiration: number } | null;
 }
 
+/** A series a short history leaves without values: a selected window it is too short for. */
+function shortSeries(id: string, shortWindows: readonly number[] | undefined): boolean {
+  return /^hv-\d+$/.test(id) && (shortWindows ?? []).includes(Number(id.slice(3)));
+}
+
 export interface RealizedVolEvidence extends RealizedVolEvidenceStatus {
   kind: "realized-volatility";
   version: 1;
@@ -38,7 +47,8 @@ export function realizedVolSemanticEvidence(series: readonly ResolvedSeries[], s
   const plottedValueCount = plotted.reduce((sum, entry) => sum + entry.points.filter((point) => isFiniteNumber(point.value)).length, 0);
   return { ...status, kind: "realized-volatility", version: 1, series: plotted, plottedValueCount,
     complete: !status.loading && !status.stale && status.errors.length === 0 && !!status.asOf
-      && plotted.length > 0 && plotted.every((entry) => entry.points.some((point) => isFiniteNumber(point.value)))
+      && plotted.length > 0 && plotted.some((entry) => entry.points.some((point) => isFiniteNumber(point.value)))
+      && plotted.every((entry) => shortSeries(entry.id, status.shortWindows) || entry.points.some((point) => isFiniteNumber(point.value)))
       && (!status.showIv || status.currentIv != null),
   };
 }
@@ -56,12 +66,15 @@ function readRealizedVolEvidence(value: unknown): RealizedVolEvidence | null {
     || !isFiniteNumber(value.lookbackYears) || typeof value.showIv !== "boolean" || typeof value.complete !== "boolean"
     || typeof value.loading !== "boolean" || typeof value.stale !== "boolean" || !isDateString(value.asOf)
     || !isStringArray(value.errors)
+    || (value.shortWindows !== undefined && (!Array.isArray(value.shortWindows) || !value.shortWindows.every(isFiniteNumber)))
+    || (value.ivErrors !== undefined && !isStringArray(value.ivErrors))
     || !Array.isArray(value.series) || !value.series.every((entry) => isRecord(entry) && typeof entry.id === "string"
       && typeof entry.unit === "string" && Array.isArray(entry.points) && entry.points.every((point) => isRecord(point)
         && isDateString(point.date) && (point.value === null || isFiniteNumber(point.value))))) return null;
   const evidence = value as unknown as RealizedVolEvidence;
+  // The IV point is drawn only when there is one: a chart without it matches its data, and is incomplete for it.
   const required = evidence.view === "graph" ? [...evidence.windows.map((window) => `hv-${window}`), "price",
-    ...(evidence.showIv ? ["current-iv"] : [])] : ["min", "max", "mean", "current"];
+    ...(evidence.showIv && evidence.currentIv != null ? ["current-iv"] : [])] : ["min", "max", "mean", "current"];
   if (!required.length || (evidence.view === "graph" && !evidence.windows.length)
     || evidence.series.length !== required.length || new Set(evidence.series.map((entry) => entry.id)).size !== required.length
     || required.some((id) => !evidence.series.some((entry) => entry.id === id))) return null;
@@ -75,10 +88,19 @@ function readRealizedVolEvidence(value: unknown): RealizedVolEvidence | null {
   }
   if (evidence.complete && (evidence.loading || evidence.stale || evidence.errors.length > 0
     || (evidence.showIv && !evidence.currentIv)
-    || evidence.series.some((entry) => !entry.points.some((point) => isFiniteNumber(point.value))))) return null;
+    || evidence.series.some((entry) => !shortSeries(entry.id, evidence.shortWindows) && !entry.points.some((point) => isFiniteNumber(point.value))))) return null;
   return evidence;
 }
 
+/** Drawn, current and whole but for the current IV, whose errors are the only ones. */
+function missingOnlyIv(evidence: RealizedVolEvidence): boolean {
+  const ivErrors = new Set(evidence.ivErrors ?? []);
+  return evidence.view === "graph" && evidence.showIv && evidence.currentIv == null
+    && !evidence.loading && !evidence.stale && evidence.plottedValueCount > 0
+    && evidence.errors.every((error) => ivErrors.has(error))
+    && evidence.series.every((entry) => shortSeries(entry.id, evidence.shortWindows) || entry.points.some((point) => isFiniteNumber(point.value)));
+}
+
 export const realizedVolScreenshotEvidence: PaneScreenshotEvidenceHook<RealizedVolEvidence> = {
   paneId: "realized-vol",
   kind: "realized-volatility",
@@ -98,6 +120,9 @@ export const realizedVolScreenshotEvidence: PaneScreenshotEvidenceHook<RealizedV
   },
   unavailable(evidence, { resolved, payload }) {
     const symbol = payload.financials[0]?.[0] ?? resolved.createOptions?.symbol;
-    return evidence?.complete && !evidence.loading ? [] : [symbol ?? "realized volatility"];
+    if (evidence?.complete && !evidence.loading) return [];
+    // The volatility drawn whole and only the IV point missing: the capture names the IV, not the symbol.
+    if (evidence && missingOnlyIv(evidence)) return [`${symbol ?? evidence.symbol} current ATM IV`];
+    return [symbol ?? "realized volatility"];
   },
 };

package/src/plugins/builtin/realized-vol/headless.ts

@@ -3,7 +3,7 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { createSurfaceDependencies } from "../vol-surface/client";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { createRealizedVolatilityDependencies, loadCurrentAtmIv, loadRealizedVolatilityHistory } from "./client";
-import { projectRealizedVolatility, type CurrentAtmIvSnapshot } from "./model";
+import { atmIvObservedLabel, projectRealizedVolatility, type CurrentAtmIvSnapshot } from "./model";
 import { ESTIMATOR_OPTIONS, selectedWindows } from "./settings";
 import { DAILY_CLOSES } from "../shared/report-freshness";
 import { listingAbroadVenue } from "../../../utils/sec";
@@ -69,13 +69,17 @@ export function realizedVolHeadless(initialView: "graph" | "cone"): HeadlessPane
               formatted: iv?.reference ? new Date(iv.reference.expiration * 1000).toISOString().slice(0, 10) : "--" },
             { label: "Days", value: iv?.reference?.daysToExpiry ?? null,
               formatted: iv?.reference ? String(Math.round(iv.reference.daysToExpiry)) : "--" },
-            { label: "Observed", value: iv?.reference?.date.toISOString() ?? null },
+            // To the minute, as the pane reads it; the JSON keeps the chain's read time whole.
+            { label: "Observed", value: iv?.reference?.date.toISOString() ?? null,
+              formatted: iv?.reference ? atmIvObservedLabel(iv.reference.date) : "--" },
           ] },
         ],
-        complete: model.cone.every((row) => row.current != null) && model.warnings.length === 0 && !history.stale && errors.length === 0
+        // A short history is whole: the windows it is too short for have no estimate yet, and the note says when it starts.
+        complete: model.cone.every((row) => row.current != null || model.shortWindows.includes(row.window))
+          && model.warnings.length === 0 && !history.stale && errors.length === 0
           && (!args.options.showIv || iv?.reference != null || iv?.noOptionChain === true),
         unavailableSymbols: model.history.length ? [] : [instrument.symbol], errors,
-        notes: [barsPerYearLabel(model.barsPerYear)],
+        notes: [barsPerYearLabel(model.barsPerYear), ...model.historyNote ? [model.historyNote] : []],
         metadata: { unit: "decimal annualized volatility", annualization: model.barsPerYear, model, currentIv: iv,
           ...(abroad && args.options.showIv ? { notices: [`Options data covers US listings only, so ${args.symbols[0]} has no current IV.`] } : {}),
           source: history.source, stale: history.stale, fetchedAt: history.fetchedAt,

package/src/plugins/builtin/realized-vol/index.tsx

@@ -21,13 +21,13 @@ export const realizedVolModule: PluginModule = {
     { ...createTickerSurfacePaneTemplate({
       id: "realized-vol-graph-pane", paneId: "realized-vol", label: "Realized Volatility Graph",
       description: "Rolling realized volatility, price and a dated current ATM IV reference.",
-      keywords: ["hvg", "realized", "historical", "volatility", "gv"], shortcut: "HVG", publicShare: true,
+      keywords: ["hvg", "realized", "historical", "volatility", "vol", "gv"], shortcut: "HVG", publicShare: true,
       viewKey: "graph", settings: () => ({ initialView: "graph" }),
     }), headless: realizedVolHeadless("graph") },
     { ...createTickerSurfacePaneTemplate({
       id: "realized-vol-table-pane", paneId: "realized-vol", label: "Realized Volatility Cone",
       description: "Current realized volatility against its historical range and percentile.",
-      keywords: ["hvt", "volatility", "cone", "percentile"], shortcut: "HVT", publicShare: true,
+      keywords: ["hvt", "volatility", "vol", "cone", "percentile"], shortcut: "HVT", publicShare: true,
       viewKey: "cone", settings: () => ({ initialView: "cone" }),
     }), headless: realizedVolHeadless("cone") },
   ],

package/src/plugins/builtin/realized-vol/model.ts

@@ -19,6 +19,24 @@ export interface RealizedVolatilityModel {
   /** What the volatility is annualised at, read from the series' own dates. */
   barsPerYear: BarsPerYear;
   warnings: string[];
+  /**
+   * The windows the history is too short for, longest last: a stock that
+   * listed in May has no 180- or 260-bar estimate yet, and nothing failed.
+   */
+  shortWindows: number[];
+  /**
+   * What a short history leaves out, said once: "History starts 2026-05-07: 121
+   * daily bars so far; the 180- and 260-bar windows need more". Null when the
+   * history covers the lookback and every window.
+   */
+  historyNote: string | null;
+}
+
+/** "the 180-bar window", "the 180- and 260-bar windows", "the 90-, 180- and 260-bar windows". */
+function windowsText(windows: readonly number[]): string {
+  if (windows.length === 1) return `the ${windows[0]}-bar window`;
+  const head = windows.slice(0, -1).map((window) => `${window}-`);
+  return `the ${head.join(", ")} and ${windows.at(-1)}-bar windows`;
 }
 
 export interface RealizedVolatilityProjectionOptions {
@@ -45,6 +63,10 @@ export function projectRealizedVolatility(
   const windows = [...new Set(options.windows ?? REALIZED_VOLATILITY_WINDOWS)]
     .filter((window) => REALIZED_VOLATILITY_WINDOWS.some((standard) => standard === window));
   const warnings: string[] = [];
+  // What follows from a history shorter than the windows and lookback asked for: notes, not failures.
+  let shortLookback = false;
+  let shortWarmup = false;
+  const shortWindows: number[] = [];
   const dates = new Map<number, PricePoint>();
   for (const point of points) {
     const date = new Date(point.date);
@@ -66,24 +88,28 @@ export function projectRealizedVolatility(
   const cone = volatilityCone(cadenceIssue ? [] : history, { estimator, lookbackYears });
   const visible = history.filter((point) => point.date.getTime() > cutoff);
   const visibleSeries = series.filter((point) => point.date.getTime() > cutoff);
-  if (history.length > 0 && history[0]!.date.getTime() > cutoff) {
-    warnings.push(`History covers less than the requested ${lookbackYears}Y lookback`);
-  }
+  if (history.length > 0 && history[0]!.date.getTime() > cutoff) shortLookback = true;
   for (const window of history.length > 0 && !cadenceIssue ? REALIZED_VOLATILITY_WINDOWS : []) {
     const result = realizedVolatilityResult(history, window, estimator);
-    if (result.reason === "insufficient-history") warnings.push(`HV${window} needs more daily history`);
+    if (result.reason === "insufficient-history") shortWindows.push(window);
     else if (result.reason) warnings.push(`HV${window} unavailable: ${result.reason.replaceAll("-", " ")}`);
   }
   const priorWarmup = history.filter((point) => point.date.getTime() <= cutoff).length;
   const requiredWarmup = estimator === "close-to-close" || estimator === "yang-zhang" ? 260 : 259;
   if (history.length > 0 && !cadenceIssue && priorWarmup < requiredWarmup) {
-    warnings.push("Long-window cone estimates do not cover the complete lookback");
+    shortWarmup = true;
   } else if (!cadenceIssue && cone.some((row) => row.sampleSize < visible.length)) {
     warnings.push("Unavailable historical estimates reduce volatility-cone sample coverage");
   }
+  const first = history[0]?.date.toISOString().slice(0, 10);
+  // Where the history starts, never read as the listing date: a source's first bar is not proof of when it listed.
+  const historyNote = !first || (!shortLookback && !shortWarmup && !shortWindows.length) ? null
+    : `History starts ${first}: ${history.length} daily bars so far; ${shortWindows.length
+      ? `${windowsText(shortWindows)} need${shortWindows.length === 1 ? "s" : ""} more`
+      : "the long windows' cone covers part of the lookback"}`;
   return { symbol: options.symbol.trim().toUpperCase(), estimator, lookbackYears, windows,
     history: visible, series: visibleSeries, cone, asOf, barsPerYear: barsPerYear(history.map((point) => point.date)),
-    warnings: [...new Set(warnings)] };
+    warnings: [...new Set(warnings)], shortWindows, historyNote };
 }
 
 interface CurrentAtmIvReference {
@@ -107,6 +133,11 @@ export interface CurrentAtmIvSnapshot {
   noOptionChain?: boolean;
 }
 
+/** When an IV was observed, to the minute in UTC (`2026-10-27 20:14 UTC`), in the pane and the report alike. */
+export function atmIvObservedLabel(date: Date): string {
+  return `${date.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+}
+
 /** A LEAPS ATM IV is not comparable with a 10 to 260 session realized cone. */
 const MAX_CURRENT_ATM_IV_DAYS = 90;
 

package/src/plugins/builtin/realized-vol/pane.tsx

@@ -18,7 +18,7 @@ import { useLiveSessionRefresh } from "../shared/volatility/live-session";
 import type { RealizedVolatilityEstimator, VolatilityConeStatistics } from "../shared/volatility";
 import { loadCurrentAtmIv, loadRealizedVolatilityHistory, refreshCurrentAtmIv } from "./client";
 import type { CurrentAtmIvSnapshot } from "./model";
-import { projectRealizedVolatility } from "./model";
+import { atmIvObservedLabel, projectRealizedVolatility } from "./model";
 import { RealizedVolGraph, VolatilityConeChart } from "./charts";
 import { coneWindowDate } from "./chart-model";
 import type { RealizedVolEvidenceStatus } from "./evidence";
@@ -109,7 +109,7 @@ export function RealizedVolPane({ width, height, focused }: PaneProps) {
   const refreshedCurrent = refreshedIv?.owner === ivLoader && refreshedIv.at > (loadedIv.updatedAt ?? 0) ? refreshedIv.data : null;
   const iv = { ...loadedIv, data: refreshedCurrent ?? loadedIv.data };
   ivDataRef.current = iv.data;
-  useLiveSessionRefresh(refreshIv, ATM_IV_REFRESH_MS, showIv && spotAvailable && !!iv.data?.reference && !loadedIv.loading,
+  const ivRefresh = useLiveSessionRefresh(refreshIv, ATM_IV_REFRESH_MS, showIv && spotAvailable && !!iv.data?.reference && !loadedIv.loading,
     loadedIv.updatedAt);
   const model = useMemo(() => history.data ? projectRealizedVolatility(history.data.history, {
     symbol: history.data.symbol, estimator, windows, lookbackYears: Number(lookback) === 2 ? 2 : 1,
@@ -117,8 +117,8 @@ export function RealizedVolPane({ width, height, focused }: PaneProps) {
   const chartInput = useMemo(() => model ? { history: model.history, rolling: model.series, windows: model.windows,
     priceUnit: priceSeriesUnit(quote?.currency ?? "", quote?.instrumentType), iv: showIv ? iv.data?.reference ?? null : null } : null,
   [model, quote?.currency, quote?.instrumentType, showIv, iv.data]);
-  const notices = [identityError, history.error, history.data?.error, iv.error, iv.data?.error,
-    ...(model?.warnings ?? []), ...(showIv ? iv.data?.warnings ?? [] : []),
+  const notices = [identityError, history.error, history.data?.error, iv.error, ivRefresh.error, iv.data?.error,
+    ...(model?.warnings ?? []), model?.historyNote, ...(showIv ? iv.data?.warnings ?? [] : []),
     ...(showIv && symbol && !spotAvailable ? ["Current ATM IV unavailable: underlying quote is missing or stale"] : []),
   ].filter((value): value is string => !!value);
   usePaneNoticeFooter({ registrationId: "realized-vol-notices", notices: [...new Set(notices)], focused });
@@ -154,15 +154,17 @@ export function RealizedVolPane({ width, height, focused }: PaneProps) {
     role: "report-notice", label: "Chart window",
     getMetadata: () => ({ text: `Chart legend: ${legendWindow}-bar window`, key: "legendWindow", value: legendWindow }),
   } : null);
+  const ivErrors = showIv ? [...new Set([iv.error, ivRefresh.error, iv.data?.error, !iv.data?.reference ? "Current ATM IV unavailable" : null]
+    .filter((value): value is string => !!value))] : [];
   const evidence: RealizedVolEvidenceStatus = {
     symbol: model?.symbol ?? symbol ?? "", view: view === "cone" ? "cone" : "graph", estimator, legendWindow,
-    windows, lookbackYears: Number(lookback) === 2 ? 2 : 1, showIv,
+    windows, lookbackYears: Number(lookback) === 2 ? 2 : 1, showIv, shortWindows: model?.shortWindows ?? [],
     loading: history.loading || (showIv && iv.loading),
     stale: history.data?.stale ?? false, source: history.data?.source ?? null,
     asOf: model?.asOf?.toISOString() ?? null,
-    errors: [...new Set([history.error, history.data?.error, ...(model?.warnings ?? []),
-      ...(showIv ? [iv.error, iv.data?.error, !iv.data?.reference ? "Current ATM IV unavailable" : null] : []),
-    ].filter((value): value is string => !!value))],
+    errors: [...new Set([history.error, history.data?.error, ...(model?.warnings ?? []), ...ivErrors]
+      .filter((value): value is string => !!value))],
+    ivErrors,
     currentIv: showIv && iv.data?.reference ? { value: iv.data.reference.value * 100,
       date: iv.data.reference.date.toISOString(), label: iv.data.reference.label,
       source: iv.data.reference.source, expiration: iv.data.reference.expiration } : null,
@@ -183,7 +185,7 @@ export function RealizedVolPane({ width, height, focused }: PaneProps) {
     <QueryBar width={width} filters={[
       { id: "estimator", label: "Estimator", value: estimator, options: ESTIMATOR_OPTIONS, onChange: (value: string) => setEstimator(value as RealizedVolatilityEstimator) },
       { id: "lookback", label: "Lookback", value: String(lookback), options: [{ value: "1", label: "1Y" }, { value: "2", label: "2Y" }], onChange: setLookback },
-    ]} meta={reference ? `ATM IV observed ${reference.date.toISOString().slice(0, 16).replace("T", " ")} UTC` : "Annualized %"} />
+    ]} meta={reference ? `ATM IV observed ${atmIvObservedLabel(reference.date)}` : "Annualized %"} />
     {!symbol ? <EmptyState title="Select a ticker." /> : <PaneStatusBody subject="realized volatility" loading={history.loading && !model}
       error={!model ? history.error ?? identityError ?? null : null} empty={!!model && !model.history.length}>
       {model && view === "cone" ? <>

package/src/plugins/builtin/relative-rotation/client.ts

@@ -7,6 +7,7 @@ import type {
 } from "../../../api-client/types";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { isAccessDenied } from "../../../api-client/errors";
+import { quoteTradingExchange } from "../../../market-data/quotes/metadata";
 import { cachedCloudResource, loadCloudResource } from "../shared/cloud-resource";
 import {
   buildRotation,
@@ -75,6 +76,10 @@ export function validateRotationHistory(
     throw new Error("Invalid daily history.");
   return response.data;
 }
+/** The venue a quote is for, as `quote` names it; empty when it names none. */
+function listingVenue(quote: CloudQuotePayload | undefined): string {
+  return quote ? quoteTradingExchange(quote) : "";
+}
 export async function fetchRotation(
   benchmark: RotationInstrument,
   instruments: RotationInstrument[],
@@ -106,6 +111,16 @@ export async function fetchRotation(
     if (isAccessDenied(error)) throw error;
     quoteError = "Listing currencies unavailable.";
   }
+  // A benchmark typed without its exchange (ACWI) is the listing its quote is for (ACWI:NASDAQ), as `quote`
+  // reads it: that venue's calendar picks the weekly closes.
+  const venue = benchmark.exchange
+    ? ""
+    : listingVenue(quotes.get(rotationId(benchmark)));
+  const reference = venue ? { ...benchmark, exchange: venue } : benchmark;
+  const requested = unique.map((row) => ({
+    id: rotationId(row),
+    instrument: rotationId(row) === rotationId(benchmark) ? reference : row,
+  }));
   const start = new Date(now);
   start.setUTCFullYear(start.getUTCFullYear() - 3);
   start.setUTCDate(1);
@@ -115,10 +130,9 @@ export async function fetchRotation(
   let next = 0;
   // Bound Cloud history requests; shared server caches batch upstream demand.
   await Promise.all(
-    Array.from({ length: Math.min(4, unique.length) }, async () => {
-      while (next < unique.length) {
-        const instrument = unique[next++]!,
-          id = rotationId(instrument),
+    Array.from({ length: Math.min(4, requested.length) }, async () => {
+      while (next < requested.length) {
+        const { id, instrument } = requested[next++]!,
           currency = quotes.get(id)?.currency ?? null;
         try {
           const response = await client.getCloudHistory(

package/src/plugins/builtin/relative-rotation/headless.ts

@@ -1,6 +1,6 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchRotation } from "./client";
-import { rotationInstruments, sectorRotationInstruments } from "./model";
+import { DEFAULT_ROTATION_BENCHMARK, rotationInstruments, sectorRotationInstruments } from "./model";
 
 /** Same rounding as the pane: ratios to 2 decimals, percentiles whole. */
 const fixed = (value: unknown, digits: number) =>
@@ -21,7 +21,7 @@ export const rotationHeadless: HeadlessPaneDefinition<"bundle"> = {
       key: "benchmark",
       type: "string",
       description: "Benchmark listing.",
-      defaultValue: "SPY:NYSEARCA",
+      defaultValue: DEFAULT_ROTATION_BENCHMARK,
     },
     {
       key: "trail",
@@ -44,7 +44,7 @@ export const rotationHeadless: HeadlessPaneDefinition<"bundle"> = {
   },
   async load(args, ctx) {
     const references = rotationInstruments(
-      String(args.options.benchmark ?? "SPY:NYSEARCA"),
+      String(args.options.benchmark ?? DEFAULT_ROTATION_BENCHMARK),
     );
     if (references.length !== 1) throw new Error("Choose one benchmark.");
     const instruments = args.symbols.length

package/src/plugins/builtin/relative-rotation/index.tsx

@@ -3,6 +3,7 @@ import type { PluginModule } from "../plugin-module";
 import { rotationCache } from "./client";
 import { rotationHeadless } from "./headless";
 import { RelativeRotationPane } from "./pane";
+import { DEFAULT_ROTATION_BENCHMARK } from "./model";
 
 export const relativeRotationModule: PluginModule = {
   panes: [
@@ -41,7 +42,7 @@ export const relativeRotationModule: PluginModule = {
             key: "benchmark",
             label: "Benchmark",
             type: "text",
-            placeholder: "SPY:NYSEARCA",
+            placeholder: DEFAULT_ROTATION_BENCHMARK,
           },
           {
             key: "trail",