gloomberb 0.16.2 → 0.16.4

package/src/plugins/builtin/options/strike-window.ts

@@ -0,0 +1,183 @@
+import type { OptionsChain } from "../../../types/financials";
+import { calculateOptionGreeks, solveChainVolatilities } from "./analytics";
+import { findNearestStrikeIndex, formatStrikeLabel } from "./table";
+
+/**
+ * Which strikes of an expiry the chain lists. Every strike by default, as
+ * layouts saved before the setting existed showed; or a count either side of
+ * the money; or the strikes whose call or put delta falls in a band, which
+ * reaches deep in-the-money LEAPS without scrolling past the wings.
+ */
+export type StrikeWindow =
+  | { kind: "all" }
+  | { kind: "around"; count: number }
+  | { kind: "delta"; min: number; max: number };
+
+/** The pane setting, and the `fn OMON --strikes` option that sets it. */
+export const STRIKE_WINDOW_SETTING = "strikes";
+export const ALL_STRIKES = "all";
+const MAX_STRIKES_AROUND = 200;
+
+const ALL: StrikeWindow = { kind: "all" };
+
+/** Choices the query bar and the settings dialog offer; the CLI takes any count or band. */
+export const STRIKE_WINDOW_PRESETS: ReadonlyArray<{ value: string; label: string; short: string; description: string }> = [
+  { value: ALL_STRIKES, label: "All strikes", short: "All", description: "Every listed strike." },
+  { value: "10", label: "10 either side of the money", short: "±10", description: "The strike nearest spot and 10 on each side." },
+  { value: "20", label: "20 either side of the money", short: "±20", description: "The strike nearest spot and 20 on each side." },
+  { value: "40", label: "40 either side of the money", short: "±40", description: "The strike nearest spot and 40 on each side." },
+  { value: "0.70-0.90", label: "Delta .70 to .90", short: "Δ .70-.90", description: "In the money: calls below spot, puts above. A stock replacement band." },
+  { value: "0.40-0.60", label: "Delta .40 to .60", short: "Δ .40-.60", description: "Near the money." },
+  { value: "0.10-0.30", label: "Delta .10 to .30", short: "Δ .10-.30", description: "Out of the money on both wings." },
+];
+
+const BAND = /^(-?\d*\.?\d+)(?:-|to|,|:|\.\.)(-?\d*\.?\d+)$/;
+
+/**
+ * A band of absolute deltas as typed: `0.70-0.90`, `.7-.9`, `70-90` (read as
+ * percent), `-0.9--0.7` (a put's signed deltas). Null when it is not one.
+ */
+export function parseDeltaBand(raw: string): { min: number; max: number } | null {
+  const band = BAND.exec(raw.trim().toLowerCase().replace(/\s+/g, "").replace(/^(?:δ|delta:?)/, ""));
+  if (!band) return null;
+  let [low, high] = [Math.abs(Number(band[1])), Math.abs(Number(band[2]))];
+  // 70-90 reads as a percent band, the way traders say it.
+  if (low > 1 || high > 1) [low, high] = [low / 100, high / 100];
+  if (!Number.isFinite(low) || !Number.isFinite(high) || low > 1 || high > 1) return null;
+  return low <= high ? { min: low, max: high } : { min: high, max: low };
+}
+
+function parseWindowText(raw: string): StrikeWindow | null {
+  const text = raw.trim().toLowerCase().replace(/\s+/g, "");
+  if (text === ALL_STRIKES) return ALL;
+  if (/^\d+$/.test(text)) {
+    const count = Number(text);
+    return count >= 1 && count <= MAX_STRIKES_AROUND ? { kind: "around", count } : null;
+  }
+  const band = parseDeltaBand(text);
+  return band ? { kind: "delta", ...band } : null;
+}
+
+/** The window a pane setting holds; a missing or unreadable one is every strike. */
+export function resolveStrikeWindow(value: unknown): StrikeWindow {
+  return typeof value === "string" || typeof value === "number" ? parseWindowText(String(value)) ?? ALL : ALL;
+}
+
+/** The setting's stored text: `all`, `10`, `0.70-0.90`. */
+export function strikeWindowValue(window: StrikeWindow): string {
+  if (window.kind === "all") return ALL_STRIKES;
+  if (window.kind === "around") return String(window.count);
+  return `${window.min.toFixed(2)}-${window.max.toFixed(2)}`;
+}
+
+/** `fn OMON --strikes`: the window as typed, checked, in the setting's text. */
+export function normalizeStrikeWindowOption(raw: string): string {
+  const window = parseWindowText(raw);
+  if (!window) {
+    throw new Error(
+      `Invalid strike window "${raw}". Use all, a count of strikes either side of the money (1 to ${MAX_STRIKES_AROUND}), `
+      + "or a call or put delta band such as 0.70-0.90.",
+    );
+  }
+  return strikeWindowValue(window);
+}
+
+const deltaText = (value: number) => value.toFixed(2).replace(/^0\./, ".");
+
+/** The window on the query bar chip: All, ±10, Δ .70-.90. */
+export function strikeWindowShortLabel(window: StrikeWindow): string {
+  if (window.kind === "all") return "All";
+  if (window.kind === "around") return `±${window.count}`;
+  return `Δ ${deltaText(window.min)}-${deltaText(window.max)}`;
+}
+
+/** The absolute call and put delta at each strike, where the chain values them. */
+export type StrikeDeltas = ReadonlyMap<number, { call?: number; put?: number }>;
+
+/**
+ * Deltas from the same solver and Greeks the chain shows, against one spot.
+ * A strike without a two-sided quote on a side has no delta there.
+ */
+export function chainDeltasByStrike(
+  chain: OptionsChain,
+  spot: number | undefined,
+  dividendYield: number | undefined,
+  now: number = Date.now(),
+): StrikeDeltas {
+  const deltas = new Map<number, { call?: number; put?: number }>();
+  if (spot == null) return deltas;
+  const volatilities = solveChainVolatilities(chain, spot, dividendYield, now);
+  for (const [side, contracts] of [["call", chain.calls], ["put", chain.puts]] as const) {
+    for (const contract of contracts) {
+      const delta = calculateOptionGreeks(contract, side, spot, dividendYield, volatilities)?.delta;
+      if (delta == null || !Number.isFinite(delta)) continue;
+      deltas.set(contract.strike, { ...deltas.get(contract.strike), [side]: Math.abs(delta) });
+    }
+  }
+  return deltas;
+}
+
+export interface StrikeWindowResult {
+  /** The strikes the chain lists, ascending. */
+  strikes: number[];
+  /** Strikes the expiry has. */
+  total: number;
+  /** Why the window could not be applied, so every strike is listed instead. */
+  fallback: "no-price" | "no-delta" | null;
+}
+
+// Displayed deltas round to three places; a strike that reads .700 is in a .70 band.
+const DELTA_TOLERANCE = 5e-4;
+
+/**
+ * The strikes a window keeps. `center` is the price the money is read at (the
+ * held strike, else spot); `keep` is a strike that always stays, the held
+ * contract's. A window that cannot be read without a price or deltas lists
+ * every strike and says why.
+ */
+export function applyStrikeWindow(
+  strikes: readonly number[],
+  window: StrikeWindow,
+  { center = null, deltas = null, keep = null }: {
+    center?: number | null;
+    deltas?: StrikeDeltas | null;
+    keep?: number | null;
+  } = {},
+): StrikeWindowResult {
+  const total = strikes.length;
+  const every = (fallback: StrikeWindowResult["fallback"]): StrikeWindowResult => ({ strikes: [...strikes], total, fallback });
+  if (window.kind === "all" || total === 0) return every(null);
+  const kept = new Set<number>();
+  if (window.kind === "around") {
+    if (center == null || !Number.isFinite(center)) return every("no-price");
+    const index = findNearestStrikeIndex([...strikes], center);
+    for (const strike of strikes.slice(Math.max(0, index - window.count), index + window.count + 1)) kept.add(strike);
+  } else {
+    if (!deltas || deltas.size === 0) return every("no-delta");
+    const inBand = (value: number | undefined) => value != null
+      && value >= window.min - DELTA_TOLERANCE && value <= window.max + DELTA_TOLERANCE;
+    for (const strike of strikes) {
+      const delta = deltas.get(strike);
+      if (inBand(delta?.call) || inBand(delta?.put)) kept.add(strike);
+    }
+  }
+  if (keep != null && strikes.includes(keep)) kept.add(keep);
+  return { strikes: strikes.filter((strike) => kept.has(strike)), total, fallback: null };
+}
+
+/**
+ * What a report says about the strikes it lists: how many of how many, and
+ * the window that chose them.
+ */
+export function strikeWindowNotice(window: StrikeWindow, result: StrikeWindowResult): string {
+  const { strikes, total } = result;
+  const range = strikes.length > 0 ? ` (${formatStrikeLabel(strikes[0]!)} to ${formatStrikeLabel(strikes.at(-1)!)})` : "";
+  const more = " --strikes all lists every strike.";
+  if (result.fallback === "no-price") return `All ${total} strikes${range}: no price to centre the window on.`;
+  if (result.fallback === "no-delta") return `All ${total} strikes${range}: a delta band needs a current underlying quote.`;
+  if (window.kind === "all") return `All ${total} strikes${range}.`;
+  if (window.kind === "around") {
+    return `${strikes.length} of ${total} strikes, ${window.count} either side of the money${range}.${more}`;
+  }
+  return `${strikes.length} of ${total} strikes with a call or put delta of ${window.min.toFixed(2)} to ${window.max.toFixed(2)}${range}.${more}`;
+}

package/src/plugins/builtin/options/table.ts

@@ -5,6 +5,7 @@ import { blendHex, colors } from "../../../theme/colors";
 import { blendForContrast, blendForSeparation, contrastRatio } from "../../../theme/color-utils";
 import { formatCompact } from "../../../utils/format";
 import { formatOptionPrice, optionQuoteSide, optionSpread } from "./market-reference";
+import { formatCarryPercent, formatCostOfSpot } from "./carry";
 import type {
   OptionColumn,
   OptionFieldId,
@@ -20,6 +21,8 @@ type OptionFieldDef = {
   header: string;
   width: number;
   description: string;
+  /** Drawn on the put side of the strike only; the call side leaves it out. */
+  putOnly?: true;
 };
 
 const OPTION_TEXT_MIN_CONTRAST = 4.5;
@@ -36,7 +39,7 @@ const MONEYNESS_MAX_TINT = 0.42;
 export const OPTION_FIELD_DEFS: OptionFieldDef[] = [
   { id: "bid", label: "Bid", header: "BID", width: 7, description: "Best bid price." },
   { id: "ask", label: "Ask", header: "ASK", width: 7, description: "Best ask price." },
-  { id: "spread", label: "Spread", header: "SPRD", width: 6, description: "Bid/ask width as a share of the midpoint, the comparable liquidity read across strikes." },
+  { id: "spread", label: "Spread %", header: "SPRD%", width: 6, description: "Bid/ask width as a percent of the midpoint, the comparable liquidity read across strikes." },
   { id: "last", label: "Last", header: "LAST", width: 7, description: "Last traded price." },
   { id: "delta", label: "Delta", header: "Δ", width: 6, description: "Price sensitivity to a $1 move in the underlying." },
   { id: "gamma", label: "Gamma", header: "Γ", width: 7, description: "Delta sensitivity to a $1 move in the underlying." },
@@ -46,13 +49,57 @@ export const OPTION_FIELD_DEFS: OptionFieldDef[] = [
   { id: "iv", label: "Implied volatility", header: "IV", width: 6, description: "Volatility implied by the contract price." },
   { id: "volume", label: "Volume", header: "VOL", width: 6, description: "Contracts traded in the current session." },
   { id: "openInterest", label: "Open interest", header: "OI", width: 6, description: "Outstanding open contracts." },
+  {
+    id: "extrinsicPerYear",
+    label: "Extrinsic per year",
+    header: "EXT/Y",
+    width: 7,
+    description: "Time value (midpoint less intrinsic) as a percent of spot, divided by years to expiry: the yearly cost of holding the contract instead of the stock.",
+  },
+  {
+    id: "costOfSpot",
+    label: "Cost % of spot",
+    header: "COST%",
+    width: 8,
+    description: "Put side only. The put's midpoint as a percent of the underlying's price: what a protective put costs per share it covers.",
+    putOnly: true,
+  },
 ];
 
 export const DEFAULT_OPTION_FIELD_IDS: OptionFieldId[] = ["bid", "ask", "last", "iv", "delta", "volume", "openInterest"];
 
 const OPTION_FIELDS_BY_ID = new Map(OPTION_FIELD_DEFS.map((field) => [field.id, field]));
 
+function optionFieldToken(value: string): string {
+  return value.trim().toLowerCase().replace(/[\s_%/-]+/g, "");
+}
+
+/** Each field by its id, label and header as typed, any case: `openInterest`, `oi`, `sprd%`, `ext/y`. */
+const OPTION_FIELDS_BY_TOKEN = new Map(OPTION_FIELD_DEFS.flatMap((field) => [
+  [optionFieldToken(field.id), field.id],
+  [optionFieldToken(field.label), field.id],
+  [optionFieldToken(field.header), field.id],
+] as const));
+
+/**
+ * `fn OMON --columns bid,ask,spread,extrinsicPerYear`: the fields mirrored
+ * around the strike, in order, as the pane setting stores them (a put-only
+ * field such as costOfSpot sits on the put side alone). An unknown field
+ * fails, naming the ones there are.
+ */
+export function normalizeOptionColumnsOption(raw: string): string {
+  const tokens = raw.split(/[\s,]+/).filter(Boolean);
+  const unknown = tokens.filter((token) => !OPTION_FIELDS_BY_TOKEN.has(optionFieldToken(token)));
+  if (tokens.length === 0 || unknown.length > 0) {
+    throw new Error(`${unknown.length > 0 ? `Unknown option column ${unknown.join(", ")}` : "No option columns given"}. `
+      + `Use: ${OPTION_FIELD_DEFS.map((field) => field.id).join(", ")}.`);
+  }
+  return resolveOptionFieldIds(tokens.map((token) => OPTION_FIELDS_BY_TOKEN.get(optionFieldToken(token))!)).join(",");
+}
+
 export function resolveOptionFieldIds(value: unknown): OptionFieldId[] {
+  // A report's --columns arrives as the comma-separated text it was typed as.
+  if (typeof value === "string") value = value.split(",");
   if (!Array.isArray(value)) return [...DEFAULT_OPTION_FIELD_IDS];
   const seen = new Set<OptionFieldId>();
   const fields = value.filter((id): id is OptionFieldId => {
@@ -80,7 +127,7 @@ function sideColumn(side: OptionSide, field: OptionFieldId): Omit<OptionColumn,
 export function createOptionColumns(fieldIds: readonly OptionFieldId[]): Array<Omit<OptionColumn, "headerColor">> {
   const fields = resolveOptionFieldIds(fieldIds);
   return [
-    ...fields.map((field) => sideColumn("call", field)),
+    ...fields.filter((field) => !OPTION_FIELDS_BY_ID.get(field)!.putOnly).map((field) => sideColumn("call", field)),
     { id: "strike", field: "strike", side: null, label: "STRIKE", width: 9, align: "right" },
     ...[...fields].reverse().map((field) => sideColumn("put", field)),
   ];
@@ -165,7 +212,8 @@ function optionColumnRole(column: Pick<OptionColumn, "field" | "side">): OptionC
   if (column.field === "strike") return "strike";
   if (column.field === "iv") return "iv";
   if (column.field === "volume" || column.field === "openInterest") return "activity";
-  if (column.field === "bid" || column.field === "ask" || column.field === "spread") return "price";
+  if (column.field === "bid" || column.field === "ask" || column.field === "spread" || column.field === "extrinsicPerYear"
+    || column.field === "costOfSpot") return "price";
   return column.side ?? "strike";
 }
 
@@ -274,6 +322,10 @@ function formatOptionContractCell(
       return formatGreek(greeks?.vegaPerPoint);
     case "rho":
       return formatGreek(greeks?.rhoPerPoint);
+    case "extrinsicPerYear":
+      return formatCarryPercent(column.side === "call" ? row.callExtrinsicPerYear : row.putExtrinsicPerYear);
+    case "costOfSpot":
+      return column.side === "put" ? formatCostOfSpot(row.putCostOfSpot) : "\u2014";
     case "strike":
       return formatStrikeLabel(contract.strike);
   }

package/src/plugins/builtin/options/types.ts

@@ -14,7 +14,9 @@ export type OptionFieldId =
   | "rho"
   | "iv"
   | "volume"
-  | "openInterest";
+  | "openInterest"
+  | "extrinsicPerYear"
+  | "costOfSpot";
 
 type OptionColumnId = "strike" | `${OptionSide}${Capitalize<OptionFieldId>}`;
 
@@ -32,6 +34,11 @@ export interface OptionTableRow {
   impliedVolatility?: number;
   callGreeks?: OptionValuation;
   putGreeks?: OptionValuation;
+  /** Time value as a share of spot per year (see `carry.ts`); null when it cannot be read. */
+  callExtrinsicPerYear?: number | null;
+  putExtrinsicPerYear?: number | null;
+  /** The put's midpoint as a share of spot (see `carry.ts`); null without a two-sided quote or a current spot. */
+  putCostOfSpot?: number | null;
   isPositionStrike: boolean;
 }
 

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

@@ -6,9 +6,12 @@ import { isPlainKey } from "../../../utils/keyboard";
 import { formatCompact, formatPercentRaw } from "../../../utils/format";
 import { formatMarketPrice, formatSignedMarketPrice, liveQuoteFormatOptions } from "../../../market-data/market/format";
 import { formatExpDate, resolveOptionsTarget } from "../../../utils/options";
+import { expiryIsoDate, findListedExpiry, formatDaysToExpiry, daysToExpiry, missingExpiryText, readOptionExpiration } from "../../../utils/option-expiry";
 import { canonicalTickerKey } from "../../../utils/exchanges";
+import { isOptionsUnavailableError, listedOptionsAlternative, optionsUnavailableTitle } from "../../../market-data/options-alternatives";
 import { useChartQueries, useOptionsQuery, useResolvedEntryValue, useTickerFinancials } from "../../../market-data/hooks";
 import {
+  Button,
   DataTableView,
   EmptyState,
   usePaneFooter,
@@ -67,6 +70,19 @@ import type { TickerFinancials } from "../../../types/financials";
 import type { IvStats } from "../iv-history/client";
 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 {
+  ALL_STRIKES,
+  STRIKE_WINDOW_PRESETS,
+  STRIKE_WINDOW_SETTING,
+  applyStrikeWindow,
+  chainDeltasByStrike,
+  resolveStrikeWindow,
+  strikeWindowNotice,
+  strikeWindowShortLabel,
+  strikeWindowValue,
+} from "./strike-window";
 
 /** The summary strip and analytics recompute from live quotes at most this often. */
 const OPTIONS_SUMMARY_THROTTLE_MS = 1_000;
@@ -76,6 +92,10 @@ const EXPIRY_NEXT_KEY = "]";
 /** Switches the cursor row between its call and its put, as clicking either side does. */
 const SIDE_KEY = "x";
 
+function sentenceCase(text: string): string {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 function formatRatio(value: number | null | undefined): string {
   return value == null || !Number.isFinite(value) ? "--" : value.toFixed(2);
 }
@@ -152,7 +172,8 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     [savedTicker, boundSymbol, fallbackExchange, fallbackCurrency]);
   const { createPaneFromTemplate } = usePluginAppActions();
   const liveStreaming = useLiveStreamingSetting();
-  const [seededExpiration] = usePaneSettingValue<number | undefined>("expiration", undefined);
+  // A number from the app, or the date or seconds `fn OMON --expiration` took as text.
+  const [seededSetting] = usePaneSettingValue<unknown>("expiration", undefined);
   const [expirationTargetKey] = usePaneSettingValue<string | null>("expirationTargetKey", null);
   const updatePaneSettings = useUpdatePaneSettings();
   const [calcSide, setCalcSide] = useState<OptionSide | null>(null);
@@ -207,11 +228,18 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   const [chainRefreshMinutes] = usePaneSettingValue<string>("chainRefreshMinutes", "");
   const [storedOptionFieldIds] = usePaneSettingValue<OptionFieldId[]>("optionColumnIds", DEFAULT_OPTION_FIELD_IDS);
   const optionFieldIds = useMemo(() => resolveOptionFieldIds(storedOptionFieldIds), [storedOptionFieldIds]);
+  const [storedStrikeWindow] = usePaneSettingValue<unknown>(STRIKE_WINDOW_SETTING, ALL_STRIKES);
+  const strikeWindow = useMemo(() => resolveStrikeWindow(storedStrikeWindow), [storedStrikeWindow]);
+  const strikeWindowText = strikeWindowValue(strikeWindow);
   const initialChainEntry = useOptionsQuery(baseRequest);
   const initialChain = useResolvedEntryValue(initialChainEntry);
   const initialExpiration = initialChain?.expirationDates.reduce((best, expiration) => (
     parsed && Math.abs(expiration - parsed.expTs) < Math.abs(best - parsed.expTs) ? expiration : best
   ), initialChain.expirationDates[0]!);
+  // A typed date names a day; the catalogue's stamp for that day is the expiry.
+  const seededDate = readOptionExpiration(seededSetting);
+  const seededExpiration = seededDate == null ? undefined
+    : findListedExpiry(seededDate, initialChain?.expirationDates ?? []) ?? seededDate;
   const selectedExpiration = expirationTargetKey == null || expirationTargetKey === selectionTargetKey
     ? seededExpiration ?? initialExpiration : initialExpiration;
   const viewportKey = `${effectiveTicker}:${selectedExpiration ?? "initial"}`;
@@ -257,7 +285,24 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   const expirationPickRef = useRef<(value: string) => void>(() => {});
   const { nativePaneChrome } = useUiCapabilities();
   const selectedExpirationIndex = selectedExpiration == null ? -1 : expirationDates.indexOf(selectedExpiration);
-  const expirationFilters = useMemo<QueryBarFilter[]>(() => [{
+  const strikeWindowOptions = useMemo(() => {
+    const presets = STRIKE_WINDOW_PRESETS.map(({ value, label, short, description }) => ({ value, label, short, description }));
+    // A window typed on the command line that no preset matches still reads on the chip.
+    if (presets.some((preset) => preset.value === strikeWindowText)) return presets;
+    const label = strikeWindowShortLabel(resolveStrikeWindow(strikeWindowText));
+    return [...presets, { value: strikeWindowText, label, short: label, description: "Set from the command line." }];
+  }, [strikeWindowText]);
+  // The window chip leads: the expiry strip after it can run past the edge of the bar.
+  const queryFilters = useMemo<QueryBarFilter[]>(() => [{
+    id: "strikes",
+    label: "Strikes",
+    title: "Strikes",
+    value: strikeWindowText,
+    // Every strike is the default, so any window narrows the chain and the chip says so.
+    defaultValue: ALL_STRIKES,
+    options: strikeWindowOptions,
+    onChange: (value: string) => updatePaneSettings({ [STRIKE_WINDOW_SETTING]: value }),
+  }, {
     id: "expiration",
     label: "Exp",
     inline: true,
@@ -272,7 +317,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
           : index === selectedExpirationIndex + 1 ? EXPIRY_NEXT_KEY : undefined,
     })),
     onChange: (value: string) => expirationPickRef.current(value),
-  }], [expirationDates, selectedExpiration, selectedExpirationIndex]);
+  }], [expirationDates, selectedExpiration, selectedExpirationIndex, strikeWindowOptions, strikeWindowText, updatePaneSettings]);
   // A scheduled refresh of a chain already on screen is quiet: the in-session
   // cadence would otherwise blink the footer every few seconds.
   const loading = (initialChainEntry?.phase === "loading" || initialChainEntry?.phase === "refreshing") && !chain
@@ -280,7 +325,10 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     || (expirationChainEntry?.phase === "refreshing" && strikeChain === null);
   // Refresh failures keep a ready entry with last-good data and an error.
   // Surface that warning even when the cached chain is still usable.
-  const error = (expirationUnavailable ? "Selected expiration unavailable." : null)
+  // The body names the dates nearest the one asked for; the footer only flags it.
+  const unavailableExpiry = expirationUnavailable && selectedExpiration != null
+    ? sentenceCase(missingExpiryText(selectedExpiration, availableExpirations)) : null;
+  const error = (expirationUnavailable ? `Expiry ${expiryIsoDate(selectedExpiration!)} unavailable` : null)
     ?? initialChainEntry?.error?.message ?? expirationChainEntry?.error?.message
     ?? (initialChainEntry?.phase === "error" || expirationChainEntry?.phase === "error"
       ? "Failed to load options" : null);
@@ -316,9 +364,76 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
 
   useEffect(() => {
     userSelectedStrikeRef.current = false;
-  }, [selectedExpiration]);
+  }, [selectedExpiration, strikeWindowText]);
 
-  const strikes = useMemo(() => strikeChain ? buildStrikeList(strikeChain) : [], [strikeChain]);
+  const allStrikes = useMemo(() => strikeChain ? buildStrikeList(strikeChain) : [], [strikeChain]);
+  // The window is read once per chain snapshot, and again when a price first
+  // arrives, so streamed quotes never move strikes in or out under the cursor.
+  const underlyingPrice = underlying?.quote?.price;
+  const windowCenter = useMemo(
+    () => resolveDefaultStrikeTarget(parsed?.strike, underlyingPrice),
+    [strikeChain, parsed?.strike, underlyingPrice == null],
+  );
+  const windowSpot = useMemo(() => spot, [strikeChain, spot == null]);
+  const windowDeltas = useMemo(
+    () => strikeWindow.kind === "delta" && strikeChain ? chainDeltasByStrike(strikeChain, windowSpot, dividendYield) : null,
+    [dividendYield, strikeChain, strikeWindow.kind, windowSpot],
+  );
+  const strikeWindowResult = useMemo(
+    () => applyStrikeWindow(allStrikes, strikeWindow, { center: windowCenter, deltas: windowDeltas, keep: parsed?.strike ?? null }),
+    [allStrikes, parsed?.strike, strikeWindow, windowCenter, windowDeltas],
+  );
+  const strikes = strikeWindowResult.strikes;
+  usePaneNoticeFooter({ registrationId: "options-strike-window", focused,
+    notices: strikeWindowResult.fallback === "no-delta"
+      ? ["The delta window needs a current underlying quote; showing every strike."]
+      : strikeWindowResult.fallback === "no-price" ? ["No price to centre the strike window on; showing every strike."] : [] });
+  // What the chain shows, in every renderer and in its reports: the expiry
+  // and its days left from the chain's as-of, beside the chain's own feed.
+  // Published ahead of the strike window, so a report names the expiry first.
+  const asOfChain = strikeChain ?? chain;
+  const chainAsOfMs = asOfChain?.asOf ? Date.parse(asOfChain.asOf) : Number.NaN;
+  const expiryAsOfMs = Number.isFinite(chainAsOfMs) ? chainAsOfMs : Date.now();
+  const expiryDate = selectedExpiration == null ? "" : expiryIsoDate(selectedExpiration);
+  const expiryDays = selectedExpiration == null ? "" : formatDaysToExpiry(selectedExpiration, expiryAsOfMs);
+  useRemoteUiNode(expiryDate && chain ? {
+    role: "report-notice",
+    label: "Expiry",
+    getMetadata: () => ({
+      text: `Expiry ${expiryDate} (${expiryDays})`,
+      key: "expiry",
+      value: { date: expiryDate, daysToExpiry: daysToExpiry(selectedExpiration!, expiryAsOfMs) },
+    }),
+  } : null);
+  // A refresh that failed keeps the last chain, which is then stale.
+  const asOfEntry = strikeChain == null ? null : strikeChain === expirationChain ? expirationChainEntry : initialChainEntry;
+  const chainDelay = asOfChain?.delayMinutes ?? 0;
+  const chainStatus = asOfEntry?.error != null ? "stale" as const
+    : asOfChain?.dataSource ?? (chainDelay > 0 ? "delayed" as const : undefined);
+  useRemoteUiNode(asOfChain ? {
+    role: "report-freshness",
+    label: "Chain freshness",
+    getMetadata: () => ({
+      ...(asOfChain.asOf ? { asOf: asOfChain.asOf } : {}),
+      ...(chainStatus ? { status: chainStatus } : {}),
+      ...(chainDelay > 0 ? { delayMinutes: chainDelay } : {}),
+    }),
+  } : null);
+  // A report of the pane (`gloomberb fn OMON`) says how many strikes it lists of how many the expiry has.
+  useRemoteUiNode(strikeChain ? {
+    role: "report-notice",
+    label: "Strike window",
+    getMetadata: () => ({
+      text: strikeWindowNotice(strikeWindow, strikeWindowResult),
+      key: "strikes",
+      value: {
+        window: strikeWindowText,
+        shown: strikeWindowResult.strikes.length,
+        total: strikeWindowResult.total,
+        ...(strikeWindowResult.fallback ? { fallback: strikeWindowResult.fallback } : {}),
+      },
+    }),
+  } : null);
   const selectedStrikeIdx = selectedContract ? strikes.indexOf(selectedContract.strike) : strikeIdx;
   // The snapshot's contracts decide which symbols stream; they do not change
   // with the stream itself, so the subscription is stable between refreshes.
@@ -395,6 +510,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
       impliedVolatility: volatilities?.byStrike.get(strike),
       callGreeks: volatilities ? calculateOptionGreeks(call, "call", spot, dividendYield, volatilities) : undefined,
       putGreeks: volatilities ? calculateOptionGreeks(put, "put", spot, dividendYield, volatilities) : undefined,
+      callExtrinsicPerYear: call && volatilities ? optionCarry(call, "call", spot, volatilities.valuationTime)?.extrinsicPerYear ?? null : null,
+      putExtrinsicPerYear: put && volatilities ? optionCarry(put, "put", spot, volatilities.valuationTime)?.extrinsicPerYear ?? null : null,
+      putCostOfSpot: put ? optionCostOfSpot(put, spot) : null,
       isPositionStrike: !!parsed && strike === parsed.strike,
     };
   }), [callsByStrike, dividendYield, parsed, putsByStrike, spot, strikes, volatilities]);
@@ -643,9 +761,23 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   }, { enabled: focused, phase: "before" });
 
   if (!ticker) {
-    return <EmptyState title="No ticker selected." message="Select a ticker to view options." />;
+    return <EmptyState title="Select a ticker." />;
   }
   if (loading && !chain) return <Spinner label="Loading options chain..." />;
+  if (error && !chain && isOptionsUnavailableError(error)) {
+    // A future or commodity with no chain of its own: the listed fund whose options stand in, and OSA on it.
+    const alternative = listedOptionsAlternative(effectiveTicker);
+    return (
+      <EmptyState
+        title={optionsUnavailableTitle(effectiveTicker)}
+        hint={alternative ? `Nearest listed alternative: ${alternative.symbol} (${alternative.name}).` : "OSA builds strategy payoffs on a listed underlying."}
+        actions={alternative ? <>
+          <Button label={`${alternative.symbol} options`} onPress={() => createPaneFromTemplate("options-pane", { symbol: alternative.symbol })} />
+          <Button label={`OSA ${alternative.symbol}`} onPress={() => createPaneFromTemplate("options-scenario-pane", { symbol: alternative.symbol })} />
+        </> : undefined}
+      />
+    );
+  }
   if (error && !chain) return <EmptyState title="Options chain unavailable." message={error} />;
   if (!chain || expirationDates.length === 0) {
     return <EmptyState title={`No options available for ${effectiveTicker}.`} />;
@@ -656,7 +788,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     : 0;
   // The root insets the terminal body, so the band gets the width inside it.
   const statWidth = Math.max(1, width - (nativePaneChrome ? 0 : 2));
-  const statItems = optionsSummaryItems({
+  const figures = optionsSummaryItems({
     spot: spotItem(underlying, isOpt ? undefined : ticker.metadata.assetCategory),
     summary, enrichment, currency: underlying?.quote?.currency || ticker.metadata.currency || "",
     ivRank: showIvRank ? { stats: ivRank } : null,
@@ -665,8 +797,23 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // Slope or IVR detail is the widest cell and would otherwise halve the
   // columns and push the chain down; the detail is cut short instead.
   const statRowBudget = width >= 110 ? 3 : width >= 65 ? 4 : 6;
-  const statColumns = Math.max(statGridColumns(statItems, statWidth), Math.ceil(statItems.length / statRowBudget));
+  const figureColumns = Math.max(statGridColumns(figures, statWidth), Math.ceil(figures.length / statRowBudget));
+  // The expiry leads the band, since the strip above can scroll it out of
+  // view. It joins the figures as one more cell where the row budget leaves a
+  // cell wide enough for all of it, and otherwise takes a row of its own so no
+  // figure is squeezed. Sized for four-digit days, so the band does not
+  // reflow as the chain's as-of arrives or the expiry steps.
+  const expiryItem: StatItem = { id: "expiry", label: "Expiry", value: expiryDate, detail: `(${expiryDays})` };
+  const cellColumns = Math.max(figureColumns, Math.ceil((figures.length + 1) / statRowBudget));
+  const expiryCells = Math.max(...figures.map((item) => item.label.length), expiryItem.label.length) + 1
+    + expiryDate.length + 2 + "(9999d)".length;
+  const expiryInline = Math.floor((statWidth - 2 * (cellColumns - 1)) / cellColumns) >= expiryCells;
+  const statColumns = expiryInline ? cellColumns : figureColumns;
+  const statItems = [expiryInline ? expiryItem : { ...expiryItem, wide: true }, ...figures];
   const summaryRowCount = Math.min(statGridRows(statItems, statWidth, statColumns), Math.max(0, height - 6));
+  // A short band gives up figures from the end; the expiry stays.
+  const shownStatItems = summaryRowCount === 0 ? []
+    : [statItems[0]!, ...figures.slice(0, summaryRowCount * statColumns - (expiryInline ? 1 : statColumns))];
   // No term here follows the selection or the load, so an empty cold-expiry
   // response cannot resize the table: growing it during loading would turn a
   // clamped scroll into apparent user navigation.
@@ -677,10 +824,10 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
 
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={nativePaneChrome ? 0 : 1}>
-      <QueryBar width={Math.max(1, width - 2)} filters={expirationFilters} />
+      <QueryBar width={Math.max(1, width - 2)} filters={queryFilters} />
 
       {summaryRowCount > 0 && (
-        <StatGrid items={statItems.slice(0, summaryRowCount * statColumns)} width={statWidth} columns={statColumns} />
+        <StatGrid items={shownStatItems} width={statWidth} columns={statColumns} />
       )}
 
       {isOpt && parsed && (
@@ -721,7 +868,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
         getItemKey={(row) => String(row.strike)}
         renderCell={renderCell}
         selectedTextOverridesCellColor
-        emptyStateTitle={error && !strikeChain ? "Selected expiration unavailable." : strikesLoading ? "Loading strikes..." : "No strikes available."}
+        emptyStateTitle={unavailableExpiry ?? (error && !strikeChain ? "Selected expiration unavailable." : strikesLoading ? "Loading strikes..."
+          : strikeWindowResult.total > 0 ? "No strikes in this window." : "No strikes available.")}
+        reportEveryRow
         rootWidth={Math.max(1, width - 2 + inset * 2)}
         rootHeight={tableHeight}
         columnGap={0}

package/src/plugins/builtin/options-positioning/headless.ts

@@ -1,4 +1,5 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import { expirationOptionSeconds, expiryIsoDate, OPTION_EXPIRATION_FORMAT, OPTION_EXPIRATION_PLACEHOLDER } from "../../../utils/option-expiry";
 import { loadGamma, loadOpenInterest, positioningSymbol } from "./client";
 import {
   ALL_EXPIRIES,
@@ -39,8 +40,9 @@ export const optionsPositioningHeadless = (initialTab: PositioningTab): Headless
   options: [
     { key: "tab", type: "enum", values: POSITIONING_TABS.map((tab) => ({ value: tab.value })), defaultValue: initialTab,
       settingKey: "tab", description: "View the pane opens on: strikes, expiries or gex" },
-    { key: "expiry", type: "string", settingKey: "expiry",
-      description: "Expiry for the strikes and gamma, YYYY-MM-DD; the busiest near expiry when omitted (all expiries for gamma)" },
+    { key: "expiry", type: "string", settingKey: "expiry", placeholder: OPTION_EXPIRATION_PLACEHOLDER, example: "--expiry 2027-01-15",
+      description: `Expiry for the strikes and gamma, as ${OPTION_EXPIRATION_FORMAT}; the busiest near expiry when omitted (all expiries for gamma)`,
+      normalize: (value) => expiryIsoDate(expirationOptionSeconds(value, "expiry")) },
   ],
   async load(args, ctx) {
     const symbol = positioningSymbol(args.symbols[0] ?? "SPY");

package/src/plugins/builtin/options-scenario/charts.tsx

@@ -3,7 +3,7 @@ import { StaticChartSurface, type StaticChartOverlay } from "../../../components
 import { Box, Text } from "../../../ui";
 import { resolveChartPalette } from "../../../components/chart/core/palette";
 import { useThemeColors } from "../../../theme/theme-context";
-import type { buildScenario } from "./model";
+import { currencyLabel, scenarioValueUnit, type buildScenario } from "./model";
 
 export function ScenarioPayoffChart({ scenario, width, height, focused = false }: {
   scenario: ReturnType<typeof buildScenario>; width: number; height: number; focused?: boolean;
@@ -28,7 +28,7 @@ export function ScenarioPayoffChart({ scenario, width, height, focused = false }
     <Box height={1} paddingX={1} flexDirection="row" gap={3}>
       <Text fg={colors.warning}>{`${scenario.expiryRisk.reason ? "First expiry" : "Expiry"} ${date(scenario.expiryDate)}`}</Text>
       <Text fg={colors.borderFocused}>{`Selected ${date(scenario.controls.date)}`}</Text>
-      <Text fg={colors.textDim}>{`P&L ${scenario.position.currency}`}</Text>
+      <Text fg={colors.textDim}>{`P&L ${currencyLabel(scenario.position.currency)} ${scenarioValueUnit(scenario.position)}`}</Text>
     </Box>
     <StaticChartSurface points={points} overlays={overlays} calendarSpaced
       width={width} height={Math.max(2, height - 1)} colors={{ ...resolveChartPalette(colors), lineColor: colors.warning }}