gloomberb 0.18.2 → 0.18.3

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

@@ -2,10 +2,19 @@ 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, readingLabel, sharedDates, skewHeader, VCA_DEFINITIONS, verdictLabel } from "./format";
+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 { vcaUniverse } from "./universe";
-import { listingFateNotes, loadListingFate, MovedSymbolError } from "../../../tickers/listing-fate";
+import { offsetText, releaseOffsetRows } from "./events";
+import { loadMacroReleases } from "../macro-day/client";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_RELEASE_SOURCES, staleMacroReleasesNotice, type MacroEventKind, type MacroRelease,
+  type MacroReleaseList } from "../macro-day/releases";
+import { lookupScheduledDates } from "../alerts/scheduled";
+import { fetchCpiBoard } from "../cpi/client";
+import { fetchRatePath } from "../rate-path/client";
+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";
 
 const METHODOLOGY = "docs/research-data.md#implied-volatility-history";
@@ -17,23 +26,33 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
   usListingsOnly: "Implied volatility history",
   freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date", oldest: null },
   describe: (args) => `HIVG ${args.symbols[0] ?? ""}`,
-  discovery: { aliases: ["HIVG"], screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
+  discovery: { aliases: ["HIVG"], suggestFor: IMPLIED_VOL_WORDS, screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
     limitations: ["History starts February 2024 (daily option trade closes).", "Rank and percentile use trade-close readings only.",
       "IV1Y needs long-dated trades: it can start later, has gaps, and ranks from 60 prior sessions.",
       "skew25d (put-call) and rr25d (call-put) come from the daily quote captures and are blank before the first one."] },
   options: [
     { key: "lookback", type: "enum", values: [{ value: "1Y" }, { value: "2Y" }, { value: "ALL" }], defaultValue: "1Y", description: "Visible history" },
     { key: "hvWindow", type: "enum", values: HV_WINDOWS.map((window) => ({ value: String(window) })), defaultValue: "20", description: "Realized volatility window in sessions" },
+    { key: "event", type: "enum", aliases: ["release"], values: MACRO_EVENT_KINDS.map((value) => ({ value, ...value === "jobs" ? { aliases: ["nfp", "payrolls"] } : {} })),
+      description: "One row per release of this kind whose session at --offset has closed (the next scheduled FOMC or CPI included), in place of the daily history",
+      example: "--event fomc --offset -6", shot: { reportOnly: "lists the readings around past release days" } },
+    { key: "offset", type: "integer", minimum: -60, maximum: 60, defaultValue: 0,
+      description: "Sessions from each release with --event: 0 is the first session on or after the release day, -6 the sixth session before that",
+      example: "--event cpi --offset -1", shot: { reportOnly: "picks the session read around each release" } },
   ],
   async load(args, ctx) {
+    const event = typeof args.options.event === "string" && args.options.event ? args.options.event as MacroEventKind : null;
+    const offset = Number(args.options.offset) || 0;
+    if (!event && offset !== 0) throw new Error("--offset counts sessions from a release day: add --event fomc, cpi or jobs.");
     const instrument = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
     // What became of the symbol, as `quote` reads it, looked up beside the figures: FB's are the fund listed
     // there now, TWTR stopped trading, and HFC, which became DINO, has none of its own.
     const changes = startTickerChangeLookup(ctx.marketData, instrument.symbol, instrument.exchange);
     const quote = ctx.marketData.getQuote(instrument.symbol, instrument.exchange ?? "").catch(() => null);
-    const [payload, prices] = await Promise.all([
+    const [payload, prices, releases] = await Promise.all([
       loadIvHistory(instrument.symbol, { signal: ctx.signal }, ctx.apiClient),
       loadRealizedVolatilityHistory({ instrument, signal: ctx.signal }, createRealizedVolatilityDependencies(ctx.marketData)),
+      event ? eventReleases(event, ctx) : null,
     ]);
     const fate = await loadListingFate(instrument, ctx.marketData, { quote, changes });
     if (fate.moved) throw new MovedSymbolError(fate.moved);
@@ -57,11 +76,47 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
     const skewColumns = [{ key: "skew25d", header: skewHeader("skew25d", "put-call"), format: points },
       { key: "rr25d", header: skewHeader("rr25d", "call-put"), format: points }];
     const served = model.iv30.length > 0 || prices.history.length > 0;
-    const fateNotes = listingFateNotes(fate, { served });
     // With nothing served, the fate is why: no "not a ticker" or missing-history errors beside it.
-    const errors = !served && fateNotes.length > 0 ? []
-      : [prices.error, ...model.warnings].filter((value): value is string => !!value);
+    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)];
+    if (event && releases) {
+      const lookback = String(args.options.lookback) as IvLookback;
+      const label = MACRO_EVENT_LABELS[event];
+      const offsets = releaseOffsetRows(model, releases.list.releases, event, offset, {
+        lookback, readThrough: payload.coverage?.backfilledThrough ?? null });
+      const plural = (count: number, one: string, many: string) => count === 1 ? one : many;
+      const eventNotes = [
+        offsets.beforeLookback > 0
+          ? `${offsets.beforeLookback} earlier ${label} ${plural(offsets.beforeLookback, "release is", "releases are")} outside the ${lookback} lookback; --lookback ALL adds ${plural(offsets.beforeLookback, "it", "them")}.` : null,
+        // Said once the lookback says nothing: the history's own start is then where the rows stop.
+        offsets.beforeHistory > 0 && offsets.beforeLookback === 0
+          ? `${offsets.beforeHistory} earlier ${label} ${plural(offsets.beforeHistory, "release predates", "releases predate")} the IV history, which starts ${offsets.historyStart}.` : null,
+        offsets.pending.length > 0
+          ? `Left out ${label} ${offsets.pending.join(", ")}: no closing reading yet for ${plural(offsets.pending.length, "its session", "their sessions")} at --offset ${offset}.` : null,
+        releases.upcomingNote,
+        staleMacroReleasesNotice(releases.list),
+      ].filter((note): note is string => !!note);
+      const eventColumns = [{ key: "releaseDate", header: "Release date" }, { key: "session", header: "Session" },
+        ...historyColumns.slice(1), ...skewColumns];
+      return {
+        sections: [{
+          title: `${label} releases, ${offsetText(offset)}`,
+          // The export names the release and the offset on every row, so files of several offsets or releases join.
+          columns: [{ key: "release", header: "Release" }, eventColumns[0]!, { key: "offset", header: "Offset (sessions)" }, ...eventColumns.slice(1)],
+          rows: offsets.rows.map(({ date, ...row }) => ({ ...row, session: date, release: label })),
+          textColumns: offsets.rows.some((row) => row.skew25d != null) ? eventColumns : eventColumns.slice(0, -skewColumns.length),
+        }],
+        complete: payload.status === "ready" && errors.length === 0,
+        unavailableSymbols: offsets.rows.some((row) => row.iv30 != null) ? [] : [instrument.symbol], errors,
+        ...(notes.length + eventNotes.length > 0 ? { notes: [...notes, ...eventNotes] } : {}),
+        // Dated by the history read, not by the newest release's session: an old release is no stale reading.
+        ...(model.asOf ? { freshness: { asOf: model.asOf } } : {}),
+        metadata: { status: payload.status, coverage: payload.coverage, event, offset, releasesThrough: releases.list.coveredThrough,
+          nextRelease: releases.upcoming,
+          releaseSource: MACRO_RELEASE_SOURCES[event], unit: "decimal annualized volatility", methodology: METHODOLOGY },
+      };
+    }
     return {
       sections: [
         { title: "Statistics", columns: [
@@ -153,3 +208,32 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
     };
   },
 };
+
+/**
+ * The releases of `event` HIVG reads around: the days MDAY studies (the list
+ * the app ships with, extended by Gloom Cloud's), and the next one scheduled,
+ * from the CPI board's release calendar or the FOMC meetings WIRP prices, as
+ * scheduled alerts read them. Payrolls have no schedule to read.
+ */
+async function eventReleases(event: MacroEventKind, ctx: HeadlessPaneContext): Promise<{
+  list: MacroReleaseList; upcoming: string | null; upcomingNote: string | null;
+}> {
+  const label = MACRO_EVENT_LABELS[event];
+  const [published, next] = await Promise.all([
+    loadMacroReleases({}, () => ctx.apiClient.getCloudMacroReleaseDays()),
+    event === "jobs" ? null : lookupScheduledDates([{ kind: "macro", event }], {
+      earnings: async () => [],
+      cpi: () => fetchCpiBoard(ctx.apiClient),
+      fomc: async () => (await fetchRatePath(ctx.apiClient)).meetings,
+    }, zonedDateKey(Date.now(), "America/New_York")).then((dates) => dates.get(`macro:${event}`) ?? { date: null }),
+  ]);
+  const upcoming = next && "date" in next ? next.date : null;
+  const listed = upcoming != null && published.releases.some((release) => release.kind === event && release.date === upcoming);
+  const releases: MacroRelease[] = upcoming && !listed ? [...published.releases, { kind: event, date: upcoming }] : published.releases;
+  return {
+    list: { ...published, releases },
+    upcoming,
+    upcomingNote: next == null ? `The next ${label} release is not scheduled here, so it has no row yet.`
+      : "error" in next ? `The next ${label} date could not be loaded (${next.error}), so it has no row.` : null,
+  };
+}

package/src/plugins/builtin/jodi/pane.tsx

@@ -39,7 +39,7 @@ export function JodiPane({ focused, width, height }: PaneProps) {
   const balances = resource.data;
   const gas = balances?.gas ?? null;
   const [storedTab, setTab] = usePluginPaneState<string>("commodity", "oil");
-  const tab: BalanceCommodity = gas && storedTab === "gas" ? "gas" : "oil";
+  const tab: BalanceCommodity = storedTab === "gas" ? "gas" : "oil";
   const board = tab === "gas" ? gas : balances?.oil ?? null;
   const rows = board?.rows ?? EMPTY_ROWS;
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selected", null);
@@ -54,7 +54,7 @@ export function JodiPane({ focused, width, height }: PaneProps) {
   const selectTab = useCallback((value: string) => {
     setTab(value === "gas" ? "gas" : "oil");
   }, [setTab]);
-  const { strip: tabs, rows: tabRows } = usePaneTabs(gas ? {
+  const { strip: tabs, rows: tabRows } = usePaneTabs({
     tabs: TABS,
     activeValue: tab,
     onSelect: selectTab,
@@ -62,7 +62,7 @@ export function JodiPane({ focused, width, height }: PaneProps) {
     compact: true,
     variant: "underline",
     queryBarWidth: width,
-  } : null);
+  });
   const info = useMemo(
     () => (resource.error || !board ? [] : [{ id: "month", parts: [{ text: formatBalanceMonth(board.month) }] }]),
     [board, resource.error],
@@ -139,7 +139,7 @@ export function JodiPane({ focused, width, height }: PaneProps) {
         onRootKeyDown={onRootKeyDown}
         renderCell={renderCell}
         selectedTextOverridesCellColor
-        emptyStateTitle="No balances for this month."
+        emptyStateTitle={board ? "No balances for this month." : tab === "gas" ? "Gas balances unavailable." : "Oil balances unavailable."}
       />
     </Box>
   );

package/src/plugins/builtin/market-movers/client.ts

@@ -5,6 +5,7 @@ import type {
   CloudSessionMoversSide,
 } from "../../../api-client/market-movers";
 import type { DataProvider } from "../../../types/data-provider";
+import { logFailure } from "../../../utils/log-failure";
 import {
   CATEGORY_MAP,
   moverRegularSession,
@@ -63,7 +64,7 @@ async function hydrateTrending(
   if (provider.getQuotesBatch) {
     const results = await provider.getQuotesBatch(
       symbols.map((symbol) => ({ symbol, exchange: "" })),
-    ).catch(() => []);
+    ).catch(logFailure("market-movers", "Trending quote batch failed", []));
     for (const result of results) {
       if (result.quote) bySymbol.set(result.target.symbol, screenerQuoteFromQuote(result.target.symbol, result.quote));
     }
@@ -72,8 +73,8 @@ async function hydrateTrending(
       try {
         const quote = await provider.getQuote(symbol, "");
         bySymbol.set(symbol, screenerQuoteFromQuote(symbol, quote));
-      } catch {
-        // Missing quotes are omitted from a ranked list.
+      } catch (error) {
+        logFailure("market-movers", "Trending quote failed")(error);
       }
     }));
   }

package/src/plugins/builtin/market-movers/screener.ts

@@ -1,6 +1,7 @@
 import type { ScreenerQuote } from "../../../api-client/market-discovery";
 export type { ScreenerQuote } from "../../../api-client/market-discovery";
 import { resolveCurrencyUnit } from "../../../utils/currency-units";
+import { logFailure } from "../../../utils/log-failure";
 import type { PluginPersistence } from "../../../types/plugin";
 import { apiClient } from "../../../api-client";
 import type {
@@ -324,7 +325,7 @@ async function bestEffortMarketMetadata(
   let timeout: ReturnType<typeof setTimeout> | undefined;
   try {
     return await Promise.race([
-      request.then((result) => result.data).catch(() => []),
+      request.then((result) => result.data).catch(logFailure("market-movers", "Market metadata failed", [])),
       new Promise<ScreenerQuote[]>((resolve) => {
         timeout = setTimeout(() => resolve([]), waitMs);
       }),
@@ -392,8 +393,8 @@ export async function fetchPreferredMarketMovers(
         stale: response.stale === true || response.data.stale === true,
       };
     }
-  } catch {
-    // The public backend snapshot remains available when live rankings fail.
+  } catch (error) {
+    logFailure("market-movers", "Live rankings failed")(error);
   }
 
   const fallback = await marketMetadata;

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

@@ -80,7 +80,7 @@ export const notesCliCommand: CliCommandDef = {
           });
           return;
         }
-        warnings.push(...result.skipped.map(describeExportSkip));
+        warnings.push(...(result.warnings ?? []), ...result.skipped.map(describeExportSkip));
         ctx.printResult({
           data: {
             dir: result.dir,

package/src/plugins/builtin/notes/export.ts

@@ -1,4 +1,5 @@
 import { errorMessage } from "../../../utils/errors";
+import { logFailure } from "../../../utils/log-failure";
 import type { NoteFileEntry, QuickNoteEntry } from "./files";
 import type { NotesStore } from "./store";
 import { noteOwnerKey, splitNoteKey } from "./store";
@@ -25,6 +26,8 @@ export interface NotesExportResult {
   /** The sources whose notes were written, in the order given. */
   exported: string[];
   skipped: NotesExportSkip[];
+  /** Notes were written, but some descriptive metadata could not be read. */
+  warnings?: string[];
 }
 
 function safeFileName(value: string): string {
@@ -46,15 +49,21 @@ export async function exportNotesToDirectory(
   let files = 0;
   const exported: string[] = [];
   const skipped: NotesExportResult["skipped"] = [];
+  const warnings: string[] = [];
   for (const source of sources) {
     const folder = sources.length > 1 ? `${dir}/${safeFileName(source.label)}` : dir;
     let entries: NoteFileEntry[];
     let quick: QuickNoteEntry[];
+    let titlesWarning: string | null = null;
     const unreadable: Array<{ key: string; error: unknown }> = [];
     try {
       [entries, quick] = await Promise.all([
         source.store.list({ strict: true, skipped: (key, error) => unreadable.push({ key, error }) }),
-        source.store.loadQuickNotesIndex(),
+        source.store.loadQuickNotesIndex({ strict: true }).catch((error) => {
+          logFailure("notes.export", "Read quick note titles for export failed")(error);
+          titlesWarning = `Quick notes from ${source.label} were exported using ids because their titles could not be read (${errorMessage(error)}).`;
+          return [];
+        }),
       ]);
     } catch (error) {
       skipped.push({ label: source.label, reason: errorMessage(error) });
@@ -74,9 +83,10 @@ export async function exportNotesToDirectory(
       await writeFile(path, entry.text, "utf-8");
       files += 1;
     }
+    if (titlesWarning && entries.some((entry) => splitNoteKey(entry.key).kind === "quick")) warnings.push(titlesWarning);
     exported.push(source.label);
   }
-  return { dir, files, exported, skipped };
+  return { dir, files, exported, skipped, ...(warnings.length > 0 ? { warnings } : {}) };
 }
 
 /** One line per skip, as `notes export` warns and the Export Notes command reports. */
@@ -86,12 +96,13 @@ export function describeExportSkip(skip: NotesExportSkip): string {
     : `Skipped the ${skip.label} note ${skip.note}: it could not be read (${skip.reason}).`;
 }
 
-/** The Export Notes command's notice: the count, then what was skipped. */
+/** The Export Notes command's notice: the count, then warnings and what was skipped. */
 export function exportNotice(result: NotesExportResult): { body: string; type: "success" | "error" } {
   const exported = `Exported ${result.files} ${result.files === 1 ? "note" : "notes"} to ${result.dir}`;
-  if (result.skipped.length === 0) return { body: exported, type: "success" };
-  const shown = result.skipped.slice(0, 3).map(describeExportSkip);
-  const more = result.skipped.length - shown.length;
+  const issues = [...(result.warnings ?? []), ...result.skipped.map(describeExportSkip)];
+  if (issues.length === 0) return { body: exported, type: "success" };
+  const shown = issues.slice(0, 3);
+  const more = issues.length - shown.length;
   return {
     body: [`${exported}.`, ...shown, ...(more > 0 ? [`${more} more could not be read.`] : [])].join(" "),
     type: "error",

package/src/plugins/builtin/notes/files.ts

@@ -29,9 +29,10 @@ export interface NotesFilesIO {
    * Every note's key (its `.md` file name without the extension) and when it
    * was last written. A folder that does not exist yet, or a note gone before
    * it was looked at, lists nothing. Any other failure is logged and that part
-   * left out, or, with `strict`, rejects.
+   * left out, or, with `strict`, rejects. A `skipped` callback receives an
+   * unreadable note instead of rejecting the whole listing.
    */
-  listKeys(options?: { strict?: boolean }): Promise<Array<[string, number]>>;
+  listKeys(options?: NotesListOptions): Promise<Array<[string, number]>>;
 }
 
 const QUICK_NOTES_INDEX_FILE = "__quick-notes-index__.json";
@@ -108,8 +109,9 @@ export function diskNotesFilesIO(dataDir: string): NotesFilesIO {
         } catch (error) {
           // A note deleted since the folder was listed is simply gone.
           if ((error as NodeJS.ErrnoException)?.code === "ENOENT") continue;
-          if (options?.strict) throw error;
+          if (options?.strict && !options.skipped) throw error;
           logFailure("notes.files", "Read when a note was last written failed")(error);
+          options?.skipped?.(name.slice(0, -3), error);
         }
       }
       return keys;
@@ -200,7 +202,16 @@ export function remoteNotesFilesIO(
     read: async (file) => await invoke("read", { dataDir, file }) as string | null,
     write: async (file, text) => { await invoke("write", { dataDir, file, text }); },
     delete: async (file) => { await invoke("delete", { dataDir, file }); },
-    listKeys: async (options) => await invoke("listKeys", { dataDir, ...(options?.strict ? { strict: true } : {}) }) as Array<[string, number]>,
+    async listKeys(options) {
+      const result = await invoke("listKeys", {
+        dataDir, ...(options?.strict ? { strict: true } : {}),
+        ...(options?.skipped ? { reportSkipped: true } : {}),
+      });
+      if (!options?.skipped) return result as Array<[string, number]>;
+      const { keys, skipped } = result as { keys: Array<[string, number]>; skipped: Array<{ key: string; reason: string }> };
+      for (const { key, reason } of skipped) options.skipped(key, new Error(reason));
+      return keys;
+    },
   };
 }
 
@@ -245,7 +256,7 @@ export class NotesFiles implements NotesStore {
 
   /** Every stored note, ticker notes and quick notes alike, newest first. */
   async list(options: NotesListOptions = {}): Promise<NoteFileEntry[]> {
-    const { entries } = await this.readEach(await this.io.listKeys({ strict: options.strict }), options.skipped);
+    const { entries } = await this.readEach(await this.io.listKeys(options), options.skipped);
     return entries.sort((left, right) => right.updatedAt - left.updatedAt);
   }
 

package/src/plugins/builtin/options/enrichment-model.ts

@@ -4,7 +4,7 @@ import { buildOptionsKey, resolveEntryData } from "../../../market-data/selector
 import type { OptionsChain } from "../../../types/financials";
 import { normalizeSymbol, parsePublicTickerKey } from "../../../utils/exchanges";
 import { daysToExpiryFrom, volatilityTermSlope, type ExpectedMove } from "../shared/volatility";
-import { buildSurfaceExpiry, evaluateSurfaceSmile, type SurfaceExpiry } from "../vol-surface/model";
+import { buildSurfaceExpiry, type SurfaceExpiry } from "../vol-surface/model";
 import type { YieldPoint } from "../yield-curve/treasury-data";
 
 export interface OptionsEnrichmentSelection {
@@ -97,8 +97,8 @@ export function optionsEnrichmentSelectionIssue(input: OptionsEnrichmentSelectio
 
 /**
  * Models kept between projections of one selection. The adjacent expiry does
- * not stream, so a live re-projection refits only the selected smile and reads
- * the adjacent ATM level off its existing fit at the current spot.
+ * not stream, so a live re-projection refits only the selected smile and keeps
+ * the adjacent fit, whose ATM-forward level does not move with the spot.
  */
 export interface OptionsEnrichmentCache {
   neighbour?: { chain: OptionsChain; curve: readonly YieldPoint[] | undefined; model: SurfaceExpiry };
@@ -134,17 +134,18 @@ export function projectOptionsEnrichment(input: OptionsEnrichmentProjection, cac
     else if (neighbourChain) {
       const cached = cache?.neighbour?.chain === neighbourChain && cache.neighbour.curve === input.curve
         ? cache.neighbour.model : null;
-      const neighbour = cached ? { ...cached, atmIV: evaluateSurfaceSmile(cached, input.spot) }
-        : buildSurfaceExpiry({ chain: neighbourChain, expiration: neighbourExpiration, spot: input.spot,
-          curve: input.curve ?? [], now: input.now, source: input.neighbourEntry?.source });
+      const neighbour = cached ?? buildSurfaceExpiry({ chain: neighbourChain, expiration: neighbourExpiration, spot: input.spot,
+        curve: input.curve ?? [], now: input.now, source: input.neighbourEntry?.source });
       if (cache && !cached) cache.neighbour = { chain: neighbourChain, curve: input.curve, model: neighbour };
       result.rateAsOf = [...new Set([...result.rateAsOf, ...neighbour.rateAsOf])];
       result.warnings.push(...neighbour.warnings
         .filter((warning) => !(input.curveLoading && warning === "Treasury rate unavailable"))
         .map((warning) => `Adjacent expiry: ${warning}`));
-      if (selected.atmIV != null && neighbour.atmIV != null) {
-        Object.assign(result, optionsEnrichmentTermSlope({ years: selected.years, volatility: selected.atmIV },
-          { years: neighbour.years, volatility: neighbour.atmIV }));
+      // The slope runs between the two expiries' IVs at their forwards, as OVDV's does, so a print
+      // against a closed session's chain does not tilt it.
+      if (selected.skew.atm != null && neighbour.skew.atm != null) {
+        Object.assign(result, optionsEnrichmentTermSlope({ years: selected.years, volatility: selected.skew.atm },
+          { years: neighbour.years, volatility: neighbour.skew.atm }));
         if (new Date(selected.asOf!).toISOString().slice(0, 10) !== new Date(neighbour.asOf!).toISOString().slice(0, 10)) {
           result.warnings.push("Term slope uses option observations from different dates");
         }

package/src/plugins/builtin/options/model-spot.ts

@@ -1,3 +1,4 @@
+import { getExtendedSessionDisplay, type ExtendedSession } from "../../../market-data/market/status";
 import { getPublishedUsEquitySession } from "../../../market-data/published-us-sessions";
 import type { OptionsChain, Quote } from "../../../types/financials";
 import { zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
@@ -82,10 +83,75 @@ export function formatSpotTime(time: number): string {
   return `${WEEKDAYS[date.getUTCDay()]} ${date.getUTCDate()} ${MONTHS[date.getUTCMonth()]} ${date.toISOString().slice(11, 16)} UTC`;
 }
 
-/** How a footer names the spot: `close Mon 12 Oct 20:00 UTC`, `pre-market Tue 13 Oct 12:21 UTC`, `last Tue 13 Oct 14:05 UTC`. */
-export function modelSpotLabel(spot: Pick<OptionModelSpot, "basis" | "session" | "observedAt">): string {
-  const word = spot.basis === "close" ? "close" : spot.session ?? "last";
-  return `${word} ${formatSpotTime(spot.observedAt)}`;
+type SpotStampInput = Pick<OptionModelSpot, "basis" | "session" | "observedAt">;
+
+/**
+ * The stamp every options pane puts beside the spot it priced a chain with
+ * (docs/research-data.md#greeks-spot-and-time): `close Tue 20 Oct` for the
+ * official close of the session the chain was quoted in, `pre-market Wed 21
+ * Oct 09:35 UTC` (`after hours`, `overnight`) for an extended-session print.
+ * Null for the regular session's latest price, which the pane's live or
+ * delayed status already dates.
+ */
+export function modelSpotStamp(spot: SpotStampInput): string | null {
+  const dated = Number.isFinite(spot.observedAt);
+  if (spot.basis === "close") return dated ? `close ${formatCalendarDay(newYorkDate.format(spot.observedAt))}` : "close";
+  return spot.session && dated ? `${spot.session} ${formatSpotTime(spot.observedAt)}` : null;
+}
+
+/**
+ * The stamp's shorter forms, longest first, for a figure with less room
+ * (`StatItem.detailVariants`): `pre-market 09:35 UTC`, then `pre-market`;
+ * `close`. Empty when there is no stamp.
+ */
+export function modelSpotStampVariants(spot: SpotStampInput): string[] {
+  if (!modelSpotStamp(spot)) return [];
+  if (spot.basis === "close") return ["close"];
+  return [`${spot.session} ${new Date(spot.observedAt).toISOString().slice(11, 16)} UTC`, spot.session!];
+}
+
+/** The stamp where a report or footer always dates the spot: `last Wed 21 Oct 14:05 UTC` for the regular session's price. */
+export function modelSpotLabel(spot: SpotStampInput): string {
+  return modelSpotStamp(spot) ?? `last ${formatSpotTime(spot.observedAt)}`;
+}
+
+const HOUR_MS = 60 * 60_000;
+
+/**
+ * A spot known only by its price and when it was observed, such as the one
+ * Gloom Cloud prices dealer gamma at: the session that time falls in on the
+ * listing's calendar. Pre-market from 04:00 New York to the open, after hours
+ * for four hours from the close, overnight between; a day the calendar does
+ * not know reads as the latest price.
+ */
+export function observedModelSpot(price: number, observedAt: number, exchange?: string): OptionModelSpot {
+  const day = Number.isFinite(observedAt) ? getPublishedUsEquitySession(exchange || "NYSE", newYorkDate.format(observedAt)) : null;
+  const session: OptionModelSpot["session"] = day?.kind !== "session" ? null
+    : observedAt < day.open ? (observedAt >= day.open - 5.5 * HOUR_MS ? "pre-market" : "overnight")
+    : observedAt < day.close ? null
+    : observedAt < day.close + 4 * HOUR_MS ? "after hours" : "overnight";
+  return { price, observedAt, valuationTime: observedAt, basis: "last", session };
+}
+
+const EXTENDED_SESSION_WORDS: Record<ExtendedSession, NonNullable<OptionModelSpot["session"]>> = {
+  PRE: "pre-market", POST: "after hours", OVERNIGHT: "overnight",
+};
+
+/**
+ * The underlying's extended-session print beside a spot priced at the close,
+ * named by its session as the stamp names it: `pre-market 770.65`, `after
+ * hours mid 771.10`. Null when the spot is not the close, nothing traded
+ * outside the session, or the print is the spot.
+ */
+export function modelSpotExtendedPrint(
+  quote: Quote | null | undefined,
+  spot: Pick<OptionModelSpot, "basis" | "price">,
+  format: (price: number) => string = formatModelSpotPrice,
+): string | null {
+  if (spot.basis !== "close") return null;
+  const print = getExtendedSessionDisplay(quote);
+  if (!print || !positive(print.price) || format(print.price) === format(spot.price)) return null;
+  return `${EXTENDED_SESSION_WORDS[print.session]}${print.mark ? " mid" : ""} ${format(print.price)}`;
 }
 
 /** A price to the cent, or to the tick it was quoted at below a dollar. */

package/src/plugins/builtin/options/view.tsx

@@ -5,6 +5,7 @@ import { colors, priceColor } from "../../../theme/colors";
 import { isPlainKey } from "../../../utils/keyboard";
 import { formatCompact, formatPercentRaw } from "../../../utils/format";
 import { formatMarketPrice, formatSignedMarketPrice, liveQuoteFormatOptions } from "../../../market-data/market/format";
+import { getRegularSessionDisplay } from "../../../market-data/market/status";
 import { chainOptionContract, formatExpDate, optionContractName, resolveOptionsTarget } from "../../../utils/options";
 import {
   expiryIsoDate, findListedExpiry, formatDaysToExpiry, daysToExpiry, missingExpiryMessage, missingExpiryText, readOptionExpiration,
@@ -76,7 +77,10 @@ import { useIvRank } from "../iv-history/rank";
 import { useOptionsSessionOpen, useThrottledValue } from "../shared/volatility/live-session";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { optionCarry, optionCostOfSpot } from "./carry";
-import { formatModelSpotPrice, modelSpotLabel, optionModelSpot } from "./model-spot";
+import {
+  formatModelSpotPrice, modelSpotExtendedPrint, modelSpotLabel, modelSpotStamp, modelSpotStampVariants, optionModelSpot,
+  type OptionModelSpot,
+} from "./model-spot";
 import { chainOpenInterestAsOf, loadListedOpenInterest, openInterestAsOfLabel, statedOpenInterestAsOf } from "./open-interest-as-of";
 import { useAsyncResource } from "../../../react/async-resource";
 import {
@@ -113,13 +117,35 @@ function transientTicker(symbol: string, exchange: string, currency: string): Ti
 }
 
 /**
- * The underlying's price and day change: the level every strike is read
- * against. A stale quote stays on screen, muted, while the footer says why.
+ * The underlying's price: the level every strike is read against. A chain
+ * priced at a session's close or an extended-session print shows that spot
+ * with its stamp (`modelSpotStamp`), and any extended print after it named by
+ * its session; the regular session's live price shows its day change. A stale
+ * quote stays on screen, muted, while the footer says why.
  */
-function spotItem(underlying: TickerFinancials | null | undefined, assetCategory: string | undefined): StatItem {
+function spotItem(
+  underlying: TickerFinancials | null | undefined,
+  assetCategory: string | undefined,
+  modelSpot: OptionModelSpot | null,
+): StatItem {
   const quote = underlying?.quote;
   if (!quote || !Number.isFinite(quote.price)) return { id: "spot", label: "Spot", value: "--" };
   const options = liveQuoteFormatOptions(quote, quote.currency, assetCategory, underlying?.quoteMetadata?.instrumentType);
+  const stamp = modelSpot ? modelSpotStamp(modelSpot) : null;
+  if (modelSpot && stamp) {
+    const move = modelSpot.basis === "close" ? getRegularSessionDisplay(quote)?.change : quote.change;
+    const extended = modelSpotExtendedPrint(quote, modelSpot, (price) => formatMarketPrice(price, options));
+    // The band keeps its columns: the extended print, then the stamp's day, give way first.
+    const shorter = modelSpotStampVariants(modelSpot);
+    return {
+      id: "spot",
+      label: "Spot",
+      value: formatMarketPrice(modelSpot.price, options),
+      detail: extended ? `${stamp} · ${extended}` : stamp,
+      detailVariants: extended ? [stamp, ...shorter] : shorter,
+      color: quote.stale ? colors.textDim : priceColor(Number.isFinite(move) ? move! : 0),
+    };
+  }
   const change = Number.isFinite(quote.change) ? quote.change : 0;
   return {
     id: "spot",
@@ -552,10 +578,10 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
       putGreeks: volatilities ? calculateOptionGreeks(put, "put", greeksSpot, dividendYield, volatilities) : undefined,
       callExtrinsicPerYear: call && volatilities ? optionCarry(call, "call", greeksSpot, volatilities.valuationTime)?.extrinsicPerYear ?? null : null,
       putExtrinsicPerYear: put && volatilities ? optionCarry(put, "put", greeksSpot, volatilities.valuationTime)?.extrinsicPerYear ?? null : null,
-      putCostOfSpot: put ? optionCostOfSpot(put, spot) : null,
+      putCostOfSpot: put ? optionCostOfSpot(put, greeksSpot) : null,
       isPositionStrike: !!parsed && strike === parsed.strike,
     };
-  }), [callsByStrike, dividendYield, greeksSpot, parsed, putsByStrike, spot, strikes, volatilities]);
+  }), [callsByStrike, dividendYield, greeksSpot, parsed, putsByStrike, strikes, volatilities]);
   // The open interest's session: the chain's own, or for a chain that does not say, OPX's listing of the
   // same expiry, stated only when the counts are OPX's.
   const statedOpenInterest = useMemo(() => strikeChain ? statedOpenInterestAsOf(strikeChain) : undefined, [strikeChain]);
@@ -584,10 +610,12 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   } : null);
   // What IV and the Greeks are valued at, and the open interest's date. In a
   // crowded footer it shortens, then gives way to the contract under the cursor.
-  const basisText = [modelSpot ? `spot ${formatModelSpotPrice(modelSpot.price)} ${modelSpotLabel(modelSpot)}` : null,
+  // A stamped spot (a close, an extended print) is already the Spot figure's.
+  const footerSpot = modelSpot && !modelSpotStamp(modelSpot) ? modelSpot : null;
+  const basisText = [footerSpot ? `spot ${formatModelSpotPrice(footerSpot.price)} ${modelSpotLabel(footerSpot)}` : null,
     strikeChain && !listedOpenInterest.loading ? openInterestAsOfLabel(openInterestAsOf) : null].filter(Boolean).join(" · ");
-  const shortBasisText = [modelSpot ? `${formatModelSpotPrice(modelSpot.price)} ${modelSpot.basis === "close" ? "close" : modelSpot.session ?? "last"} `
-    + `${new Date(modelSpot.observedAt).toISOString().slice(11, 16)} UTC` : null,
+  const shortBasisText = [footerSpot ? `${formatModelSpotPrice(footerSpot.price)} last `
+    + `${new Date(footerSpot.observedAt).toISOString().slice(11, 16)} UTC` : null,
   strikeChain && !listedOpenInterest.loading ? openInterestAsOf?.date ? `OI ${openInterestAsOf.date.slice(5)}` : "OI undated" : null]
     .filter(Boolean).join(" · ");
   usePaneFooter("options-basis", () => ({ info: basisText ? [{ id: "greeks-basis",
@@ -597,9 +625,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // busy stream reads as a steady strip rather than flicker.
   // A new expiry, a refreshed snapshot or the underlying price arriving or
   // going stale shows at once; only the stream itself is paced.
-  const summaryResetKey = useMemo(() => ({}), [strikeSelectionKey, strikeChain, spot == null]);
+  const summaryResetKey = useMemo(() => ({}), [strikeSelectionKey, strikeChain, greeksSpot == null]);
   const summaryInput = useThrottledValue(
-    useMemo(() => ({ chain: liveChain, spot, volatilities }), [liveChain, spot, volatilities]),
+    useMemo(() => ({ chain: liveChain, spot: greeksSpot, volatilities }), [liveChain, greeksSpot, volatilities]),
     OPTIONS_SUMMARY_THROTTLE_MS,
     summaryResetKey,
   );
@@ -613,7 +641,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     instrument: baseRequest?.instrument ?? null, expiration: selectedExpiration,
     selectedEntry: strikeChain === expirationChain ? expirationChainEntry
       : strikeChain === initialChain ? initialChainEntry : null,
-    catalogue: availableExpirations, spot, spotAsOf: underlying?.quote?.lastUpdated,
+    catalogue: availableExpirations, spot: greeksSpot, spotAsOf: modelSpot?.observedAt,
     liveChain: liveChain !== strikeChain ? liveChain : null,
   });
   const enrichment = expirationUnavailable ? null : enrichmentState.snapshot;
@@ -901,7 +929,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // The root insets the terminal body, so the band gets the width inside it.
   const statWidth = Math.max(1, width - (nativePaneChrome ? 0 : 2));
   const figures = optionsSummaryItems({
-    spot: spotItem(underlying, isOpt ? undefined : ticker.metadata.assetCategory),
+    spot: spotItem(underlying, isOpt ? undefined : ticker.metadata.assetCategory, modelSpot),
     summary, enrichment, currency: underlying?.quote?.currency || ticker.metadata.currency || "",
     ivRank: showIvRank ? { stats: ivRank } : null,
   });