gloomberb 0.16.3 → 0.16.5

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,
@@ -57,7 +60,7 @@ import {
 import { useOptionsAccessFooter } from "./footer";
 import { AnalyticsAsOfDialog, analyticsAsOfRows } from "./analytics-as-of";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
-import { signedPositionDirection } from "../portfolio-list/position-metrics";
+import { signedPositionDirection } from "../../../portfolio/position-metrics";
 import { optionMarketReference } from "./market-reference";
 import { useOptionsEnrichment } from "./enrichment";
 import type { OptionsEnrichmentSnapshot } from "./enrichment-model";
@@ -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-calculator/inputs.ts

@@ -1,3 +1,4 @@
+import { numberErrorMessage } from "../../../utils/decimal-comma";
 import { DEFAULT_OPTION_CALC_DRAFT, updateOptionCalcDraft, type OptionCalcDraft } from "./model";
 import type { CashDividend } from "./binomial";
 
@@ -5,7 +6,7 @@ const DECIMAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 
 function numberInput(value: unknown, label: string): number {
   if (typeof value !== "number" && (typeof value !== "string" || !DECIMAL.test(value.trim()))) {
-    throw new Error(`${label} must be a finite number.`);
+    throw new Error(numberErrorMessage(`${label} must be a finite number.`, value));
   }
   const result = Number(value);
   if (!Number.isFinite(result)) throw new Error(`${label} must be a finite number.`);

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

@@ -1,5 +1,5 @@
 import { apiClient } from "../../../api-client";
-import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { usListingSymbol } from "../../../utils/sec";
 
 export interface ExpiryOpenInterest {
   date: string;
@@ -78,8 +78,12 @@ export interface GammaPayload {
 
 export type OptionsPositioningApi = Pick<typeof apiClient, "optionsPositioning">;
 
-/** A listing key ("SPY:ARCX") keeps only its symbol; an index keeps its caret (^SPX). */
-export const positioningSymbol = (symbol: string) => parsePublicTickerKey(symbol.trim()).symbol.toUpperCase();
+/**
+ * A US listing key ("SPY:ARCX") keeps only its symbol; an index keeps its
+ * caret (^SPX). A listing abroad is refused: its bare symbol's chain is
+ * another company's (SAN:EPA's would be Banco Santander's).
+ */
+export const positioningSymbol = (symbol: string) => usListingSymbol(symbol, "Options data");
 
 const query = (symbol: string, expiry: string | null) =>
   new URLSearchParams({ symbol: positioningSymbol(symbol), ...(expiry ? { expiry } : {}) }).toString();

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,
@@ -25,6 +26,7 @@ export const optionsPositioningHeadless = (initialTab: PositioningTab): Headless
   shape: "bundle",
   freshness: { status: "not-a-feed", basis: "daily open interest", cadence: "daily" },
   argument: { kind: "ticker", optional: true, description: "US option underlying, or SPX; SPY when omitted" },
+  usListingsOnly: "Options data",
   describe: (args) => `${initialTab === "gex" ? "GEX" : "OPX"} ${args.symbols[0] ?? "SPY"}`,
   discovery: {
     aliases: initialTab === "gex" ? ["GEX"] : ["OPX", "MAXPAIN"],
@@ -39,8 +41,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-positioning/pane.tsx

@@ -34,13 +34,13 @@ import type { ResolvedSeries } from "../../../time-series/types";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, Text } from "../../../ui";
 import { formatCompact } from "../../../utils/format";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { isPlainKey } from "../../../utils/keyboard";
 import { nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { useCloudAccessFooter } from "../shared/cloud-upgrade";
 import {
   loadGamma,
   loadOpenInterest,
-  positioningSymbol,
   type ExpiryOpenInterest,
   type GammaPayload,
   type GammaStrike,
@@ -583,7 +583,7 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   return <Box width={width} height={height} flexDirection="column">
     <PaneStatusBody loading={openInterest.loading && !data} error={!data ? openInterest.error : null}
       empty={!!data && !data.expiries.length} subject="open interest"
-      emptyTitle={`No listed options for ${positioningSymbol(symbol).replace(/^\^/, "")}.`}>
+      emptyTitle={`No listed options for ${parsePublicTickerKey(symbol).symbol.replace(/^\^/, "")}.`}>
       {data?.expiries.length ? <>
         {tabStrip}
         {content}

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 }}

package/src/plugins/builtin/options-scenario/client.ts

@@ -5,10 +5,12 @@ import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
 import type { OptionsChain, Quote, TickerFinancials } from "../../../types/financials";
 import { canonicalExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { numberErrorMessage } from "../../../utils/decimal-comma";
+import { expiryIsoDate, findListedExpiry, missingExpiryText } from "../../../utils/option-expiry";
 import { surfaceTreasuryRate } from "../vol-surface/model";
 import { daysToExpiryFrom, extractImpliedForward, optionMid, solveImpliedVolatility } from "../shared/volatility";
 import type { YieldPoint } from "../yield-curve/treasury-data";
-import { parseLegs, validatePosition, type ScenarioControls, type ScenarioLeg, type ScenarioPosition } from "./model";
+import { parseLegs, scenarioCurrency, validatePosition, type ScenarioControls, type ScenarioLeg, type ScenarioPosition } from "./model";
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
 
@@ -26,6 +28,8 @@ export interface ScenarioMarketSnapshot {
   underlyingQuote: Quote | null;
   rateAsOf: string[];
   warnings: string[];
+  /** Why the requested expiry has no chain, naming the listed dates nearest it. */
+  missingExpiry?: string;
 }
 
 export interface ScenarioLoaderDependencies {
@@ -99,15 +103,31 @@ export async function loadScenarioMarket(
   const validDividend = symbolMatches(financialsSymbol, symbol) && !fundamentals?.stale && !financialsEntry?.error
     && typeof fundamentals?.dividendYield === "number" && Number.isFinite(fundamentals.dividendYield) && fundamentals.dividendYield >= 0;
   if (!validDividend) warnings.push("Dividend yield unavailable; supply an explicit assumption");
-  const chainEntry = entry(chainResult, "Options chain");
+  let chainEntry = entry(chainResult, "Options chain");
   let chain = chainEntry ? resolveEntryValue(chainEntry) : null;
   if (chain && !symbolMatches(chain.underlyingSymbol, symbol)) {
     warnings.push("Options chain does not match the requested ticker"); chain = null;
   }
   const expirationDates = [...new Set((chain?.expirationDates ?? []).filter((expiration) =>
     positive(expiration) && daysToExpiryFrom(expiration, now) > 0))].sort((a, b) => a - b);
-  if (chain && request.expiration != null && (!expirationDates.includes(request.expiration)
-    || [...chain.calls, ...chain.puts].some((contract) => contract.expiration !== request.expiration))) {
+  // A typed date is that day's UTC midnight; the chain's own stamp for the
+  // expiry is matched by calendar date, as OMON matches it.
+  const listedExpiration = request.expiration == null ? undefined : findListedExpiry(request.expiration, expirationDates);
+  const onExpiry = (value: OptionsChain, expiration: number) => [...value.calls, ...value.puts]
+    .every((contract) => expiryIsoDate(contract.expiration) === expiryIsoDate(expiration));
+  if (chain && listedExpiration != null && listedExpiration !== request.expiration && !chain.calls.length && !chain.puts.length) {
+    // A source that keys chains by its exact stamp answered the midnight request empty.
+    chainEntry = await abortable(dependencies.loadOptions({ instrument: request.instrument, expirationDate: listedExpiration }, options)
+      .catch((error: unknown) => { warnings.push(`Options chain: ${errorMessage(error)}`); return null; }), request.signal, CANCELLED);
+    if (request.signal?.aborted) throw abortError(CANCELLED);
+    if (chainEntry?.error) warnings.push(`Options chain: ${chainEntry.error.message}`);
+    chain = chainEntry ? resolveEntryValue(chainEntry) : null;
+  }
+  let missingExpiry: string | undefined;
+  if (chain && request.expiration != null && listedExpiration == null) {
+    missingExpiry = sentence(missingExpiryText(request.expiration, expirationDates, symbol));
+    warnings.push(missingExpiry); chain = null;
+  } else if (chain && listedExpiration != null && !onExpiry(chain, listedExpiration)) {
     warnings.push("Selected expiration unavailable in the returned options chain"); chain = null;
   }
   if (!chain) warnings.push("Options chain unavailable");
@@ -117,15 +137,22 @@ export async function loadScenarioMarket(
   if (curveResult.status === "rejected") warnings.push(`Treasury: ${errorMessage(curveResult.reason)}`);
   const rate = surfaceTreasuryRate(curve, rateExpiration == null ? NaN : daysToExpiryFrom(rateExpiration, now) / 365);
   warnings.push(...rate.warnings);
+  // A currency does not go stale with its quote: the listing's quote, its snapshot, or its contracts name it.
+  const currency = [symbolMatches(quote?.symbol, symbol) ? quote?.currency : undefined,
+    symbolMatches(financialsSymbol, symbol) ? financials?.quote?.currency : undefined,
+    chain?.calls[0]?.currency, chain?.puts[0]?.currency].find((value) => !!value?.trim())?.trim().toUpperCase() ?? "";
   return {
-    symbol, exchange: request.instrument.exchange, spot: quoteCurrent ? quote!.price : null, currency: quoteCurrent ? quote!.currency : "",
+    symbol, exchange: request.instrument.exchange, spot: quoteCurrent ? quote!.price : null, currency,
     asOf: quoteCurrent && positive(quote!.lastUpdated) ? quote!.lastUpdated : now,
     chain, expirationDates, rate: rate.rate, dividendYield: validDividend ? fundamentals!.dividendYield! : null,
     source: quoteCurrent ? quoteEntry?.source ?? quote!.providerId ?? null : null,
     underlyingQuote: quoteCurrent ? quote : null, rateAsOf: rate.asOf, warnings: [...new Set(warnings)],
+    ...(missingExpiry ? { missingExpiry } : {}),
   };
 }
 
+const sentence = (text: string) => text.charAt(0).toUpperCase() + text.slice(1);
+
 function supplied(value: unknown): boolean { return value != null && value !== ""; }
 
 function numericSetting(settings: Record<string, unknown>, key: string): number | undefined {
@@ -133,7 +160,7 @@ function numericSetting(settings: Record<string, unknown>, key: string): number
   if (!supplied(value)) return undefined;
   if ((typeof value !== "string" && typeof value !== "number")
     || (typeof value === "string" && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(value.trim()))
-    || !Number.isFinite(Number(value))) throw new Error(`${key} must be a finite number`);
+    || !Number.isFinite(Number(value))) throw new Error(numberErrorMessage(`${key} must be a finite number`, value));
   return Number(value);
 }
 
@@ -175,13 +202,18 @@ export function scenarioPositionFromSettings(
   const dividendYield = dividendValue == null ? market?.dividendYield : dividendValue / 100;
   const legText = typeof settings.legs === "string" ? settings.legs : "";
   let legs = legText.trim() ? parseLegs(legText) : [];
+  const strike = numericSetting(settings, "strike");
+  if (strike != null && !(strike > 0)) throw new Error("strike must be positive");
+  if (strike != null && !supplied(settings.strategy)) throw new Error("strike picks the strike of --strategy; add --strategy put, vertical or straddle");
   if (!legs.length && supplied(settings.strategy)) {
-    if (settings.strategy !== "vertical" && settings.strategy !== "straddle") throw new Error("strategy must be vertical or straddle");
-    if (!market?.chain || market.warnings.includes("Options chain is stale")) throw new Error("A current options chain is required to seed a strategy");
+    if (!isScenarioStrategy(settings.strategy)) throw new Error("strategy must be vertical, straddle or put");
+    if (!market?.chain || market.warnings.includes("Options chain is stale")) {
+      throw new Error(market?.missingExpiry ?? "A current options chain is required to seed a strategy");
+    }
     if (spot == null) throw new Error("A current underlying price or explicit --spot is required");
     // Leg IVs are solved at the market's own spot and time, never at a what-if override.
     const pricing = market.spot != null && rate != null ? { spot: market.spot, asOf: market.asOf, rate } : null;
-    const seeded = scenarioStrategyLegs(market.chain, spot, settings.strategy, pricing);
+    const seeded = scenarioStrategyLegs(market.chain, spot, settings.strategy, pricing, strike);
     legs = seeded.legs;
     // Mids priced off the parity forward are worth their cost only at the spot
     // that forward implies on the scenario's own rate and dividend yield. The
@@ -198,7 +230,7 @@ export function scenarioPositionFromSettings(
   if (dividendYield == null) throw new Error("Dividend yield unavailable; supply --dividend-yield as an annual percentage");
   const position: ScenarioPosition = {
     symbol, exchange: exchange ?? market?.exchange,
-    currency: String(settings.currency ?? market?.currency ?? "").trim().toUpperCase() || "UNKNOWN",
+    currency: scenarioCurrency(settings.currency, market?.currency, exchange ?? market?.exchange),
     spot, rate, dividendYield, asOf: dateSetting(settings, "asOf") ?? market?.asOf ?? Date.now(), legs,
   };
   const error = validatePosition(position);
@@ -210,6 +242,9 @@ export function scenarioPositionFromSettings(
   return position;
 }
 
+type ScenarioStrategy = "vertical" | "straddle" | "put";
+const isScenarioStrategy = (value: unknown): value is ScenarioStrategy => value === "vertical" || value === "straddle" || value === "put";
+
 interface StrategyPricing { spot: number; asOf: number; rate: number }
 
 const usableVolatility = (value: unknown): value is number => positive(value) && value <= 5;
@@ -230,9 +265,13 @@ interface StrategyParity { forward: number; daysToExpiry: number }
  * keeps a usable provider IV, and without one it is not eligible. `parity` is
  * the forward a seeded leg was solved against, so the caller can start the
  * scenario at the spot it implies.
+ *
+ * Each strategy is anchored at the strike nearest spot, or at `strike` when
+ * one is given: a long put (a protective put), a call vertical from the
+ * anchor to the next listed strike up, or a straddle at the anchor.
  */
 function scenarioStrategyLegs(
-  chain: OptionsChain, spot: number, strategy: "vertical" | "straddle", pricing: StrategyPricing | null,
+  chain: OptionsChain, spot: number, strategy: ScenarioStrategy, pricing: StrategyPricing | null, strike?: number,
 ): { legs: ScenarioLeg[]; parity: StrategyParity | null } {
   const parity = new Map<number, StrategyParity | null>();
   const parityFor = (expiration: number) => {
@@ -256,12 +295,30 @@ function scenarioStrategyLegs(
     if (usableVolatility(volatility)) return [{ contract, mid, volatility, solved: true }];
     return usableVolatility(contract.impliedVolatility) ? [{ contract, mid, volatility: contract.impliedVolatility, solved: false }] : [];
   });
-  const calls = quoted(chain.calls, "call").sort((a, b) => Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot));
-  const puts = quoted(chain.puts, "put");
-  const first = calls.find(({ contract: call }) => strategy === "vertical"
-    ? calls.some(({ contract: other }) => other.expiration === call.expiration && other.strike > call.strike)
-    : puts.some(({ contract: put }) => put.expiration === call.expiration && put.strike === call.strike));
-  if (!first) throw new Error("The selected chain has no complete quoted strategy with usable IV");
+  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
+    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  const anchored = ({ contract }: { contract: { strike: number } }) => strike == null || Math.abs(contract.strike - strike) < 1e-9;
+  const calls = quoted(chain.calls, "call").sort(nearest);
+  const puts = quoted(chain.puts, "put").sort(nearest);
+  const missing = (candidates: { contract: { strike: number } }[]) => {
+    if (strike == null) return new Error("The selected chain has no complete quoted strategy with usable IV");
+    const listed = [...new Set(candidates.map(({ contract }) => contract.strike))]
+      .sort((a, b) => Math.abs(a - strike) - Math.abs(b - strike)).slice(0, 4).sort((a, b) => a - b);
+    return new Error(`The selected chain has no complete quoted ${strategy} at strike ${strike} with usable IV`
+      + (listed.length ? `; nearest quoted strikes: ${listed.join(", ")}` : ""));
+  };
+  if (strategy === "put") {
+    const put = puts.find(anchored);
+    if (!put) throw missing(puts);
+    return { legs: [{ id: put.contract.contractSymbol, side: "put", quantity: 1, strike: put.contract.strike,
+      expiration: put.contract.expiration, price: put.mid, priceSource: "mid", volatility: put.volatility, multiplier: 100,
+      ...(put.solved ? { volatilitySource: "mid" as const } : {}) }],
+    parity: put.solved ? parityFor(put.contract.expiration) : null };
+  }
+  const first = calls.find((entry) => anchored(entry) && (strategy === "vertical"
+    ? calls.some(({ contract: other }) => other.expiration === entry.contract.expiration && other.strike > entry.contract.strike)
+    : puts.some(({ contract: put }) => put.expiration === entry.contract.expiration && put.strike === entry.contract.strike)));
+  if (!first) throw missing(calls);
   const second = strategy === "vertical"
     ? calls.filter(({ contract }) => contract.expiration === first.contract.expiration && contract.strike > first.contract.strike)
       .sort((a, b) => a.contract.strike - b.contract.strike)[0]!
@@ -270,7 +327,7 @@ function scenarioStrategyLegs(
   const legs = [first, second].map(({ contract, mid, volatility, solved }, index): ScenarioLeg => ({
     id: contract.contractSymbol, side: index === 1 && strategy === "straddle" ? "put" : "call",
     quantity: index === 1 && strategy === "vertical" ? -1 : 1, strike: contract.strike,
-    expiration: contract.expiration, price: mid, volatility, multiplier: 100,
+    expiration: contract.expiration, price: mid, priceSource: "mid", volatility, multiplier: 100,
     ...(solved ? { volatilitySource: "mid" as const } : {}),
   }));
   return { legs, parity: first.solved || second.solved ? parityFor(first.contract.expiration) : null };