@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/plugins/builtin/options-positioning/pane.tsx

@@ -51,6 +51,7 @@ import {
 } from "./client";
 import {
   ALL_EXPIRIES,
+  axisRatioOfDate,
   chartWindow,
   expiryAxis,
   expiryLabel,
@@ -63,6 +64,7 @@ import {
   formatDistance,
   formatGamma,
   formatLevel,
+  gammaTimesFigure,
   positioningSpotDetail,
   formatPayout,
   formatRatio,
@@ -160,13 +162,18 @@ interface PositioningChartProps {
 
 /** Columns across a numeric axis (strikes, or expiries one slot apart), with spot and the other levels as guide lines. */
 function PositioningChart(props: PositioningChartProps) {
+  // The legend's values are one column's, under the cursor (the last column's
+  // without one), not the totals the figures above show: it names the column.
+  const column = props.formatCursor(props.selection.cursorDate ? axisRatioOfDate(props.selection.cursorDate) : 1);
+  const legendSeries = useMemo(() => column
+    ? props.series.map((entry) => ({ ...entry, label: `${entry.label} at ${column}` })) : undefined, [column, props.series]);
   const xAxis = useMemo(() => ({
     ticks: props.ticks(Math.max(1, props.width - VALUE_GUTTER)),
     markers: props.markers.flatMap((marker) => marker.ratio != null && marker.ratio >= 0 && marker.ratio <= 1
       ? [{ id: marker.id, xRatio: marker.ratio, label: marker.label, color: marker.color }] : []),
     formatCursor: props.formatCursor,
   }), [props.formatCursor, props.markers, props.ticks, props.width]);
-  return <CompositeChart series={props.series} panels={PANELS} width={props.width} height={props.height}
+  return <CompositeChart series={props.series} legendSeries={legendSeries} panels={PANELS} width={props.width} height={props.height}
     focused={false} navigable={false} showLegend showTimeAxis xAxis={xAxis}
     formatValue={(value) => props.formatValue(value)} formatAxisValue={props.formatAxisValue}
     cursorDate={props.selection.cursorDate} onCursorDateChange={props.selection.onCursorDateChange}
@@ -217,7 +224,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   const data = openInterest.data;
   const spot = data?.spot ?? null;
   const venue = data?.venue;
-  const spotStamp = useMemo(() => positioningSpotDetail(spot, data?.spotAsOf, venue), [spot, data?.spotAsOf, venue]);
+  const spotStamp = useMemo(() => positioningSpotDetail(spot, data?.spotAsOf, venue, data?.spotBasis),
+    [spot, data?.spotAsOf, data?.spotBasis, venue]);
   // A coin's options (Deribit's) count open interest in coins, to tenths.
   const coin = isCoinContract(data?.contract);
   const unit = coin ? ` ${data!.contract!.unit}` : "";
@@ -496,6 +504,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   const band = gammaData?.band;
   const shares = band ? `${Math.round(band.shareLow * 100)}-${Math.round(band.shareHigh * 100)}%` : "";
   const walls = useMemo(() => gammaWalls(gammaStrikes), [gammaStrikes]);
+  const gammaTimes = useMemo(() => gammaTimesFigure(gammaData?.gammaAsOf, gammaData?.quotesAsOf),
+    [gammaData?.gammaAsOf, gammaData?.quotesAsOf]);
   const gammaFigures = useMemo<StatItem[]>(() => !gammaData?.total ? [] : [
     { id: "net", label: "Net GEX", value: formatGamma(gammaData.total.net), detail: "$ per 1% move",
       color: gammaData.total.net >= 0 ? colors.positive : colors.negative },
@@ -507,8 +517,11 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
     })),
     ...(band ? [{ id: "band", label: "Dealer range", value: `${formatGamma(band.low)} to ${formatGamma(band.high)}`,
       detail: `${shares} with dealers${gammaData.boxes?.length ? ", boxes out" : ""}` }] : []),
-    { id: "spot", label: "Spot", value: formatLevel(gammaSpot), ...positioningSpotDetail(gammaSpot, gammaData.spotAsOf, gammaData.venue) },
-  ], [band, colors.negative, colors.positive, gammaData, gammaSpot, shares, walls]);
+    { id: "spot", label: "Spot", value: formatLevel(gammaSpot),
+      ...positioningSpotDetail(gammaSpot, gammaData.spotAsOf, gammaData.venue, gammaData.spotBasis) },
+    // Gamma is evaluated at the spot's time; before the open its volatilities are the last session's.
+    ...(gammaTimes ? [{ id: "gamma-at", ...gammaTimes }] : []),
+  ], [band, colors.negative, colors.positive, gammaData, gammaSpot, gammaTimes, shares, walls]);
   // The assumption rides in the legend, where the numbers it changes are read; the
   // dealer range figure names its own share. It gives way before the series name does.
   const assumption = width >= 60 ? "dealers long calls, short puts" : width >= 48 ? "long calls, short puts" : null;
@@ -580,7 +593,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
       onHeaderClick={(id) => setExpirySort((current) => nextHeaderSort(current, id))}
       emptyStateTitle="No listed expiries."
       getExportMetadata={() => [["open interest as of", data?.oiDate ?? ""], ["change since", data?.previousOiDate ?? ""], ["spot", spot ?? ""],
-        ...(hasGamma ? [["net GEX unit", "dollars of dealer delta per 1% move"], ["quotes as of", netGammas ? gamma.data?.quotesAsOf ?? "" : ""]] : [])]}
+        ...(hasGamma ? [["net GEX unit", "dollars of dealer delta per 1% move"], ["gamma at", netGammas ? gamma.data?.gammaAsOf ?? "" : ""],
+          ["vols from", netGammas ? gamma.data?.quotesAsOf ?? "" : ""]] : [])]}
       rootBefore={<ChartTableHeader width={width} height={bodyHeight} figures={ladderFigures}
         tableRows={expiryRows.length} tableChromeRows={chartTableChromeRows(expiryColumnList, width)}
         chart={expiryChart ? {
@@ -619,7 +633,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
                 ["range with boxes high", gammaData.bandWithBoxes.high],
                 ["box legs left out", (gammaData.boxes ?? []).map((leg) => `${leg.expiry} ${leg.strike} x${leg.contracts}`).join("; ")]] : []),
               ["flip", gammaData.flip ?? ""], ["call wall", walls.callWall ?? ""], ["put wall", walls.putWall ?? ""],
-              ["open interest as of", gammaData.oiDate ?? ""], ["quotes as of", gammaData.quotesAsOf ?? ""]]}
+              ["open interest as of", gammaData.oiDate ?? ""], ["gamma at", gammaData.gammaAsOf ?? ""],
+              ["vols from", gammaData.quotesAsOf ?? ""]]}
             rootBefore={<ChartTableHeader width={width} height={bodyHeight} query={query} figures={gammaFigures}
               tableRows={gammaRows.length} tableChromeRows={chartTableChromeRows(GAMMA_COLUMNS, width)}
               chart={gammaChart ? {

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

@@ -384,11 +384,52 @@ export const SCENARIO_STRATEGIES = ["vertical", "straddle", "put", "csp", "colla
 type ScenarioStrategy = typeof SCENARIO_STRATEGIES[number];
 const isScenarioStrategy = (value: unknown): value is ScenarioStrategy => SCENARIO_STRATEGIES.includes(value as ScenarioStrategy);
 
-interface StrategyPricing { spot: number; asOf: number; rate: number; dividendYield: number }
+export interface StrategyPricing { spot: number; asOf: number; rate: number; dividendYield: number }
 
 const usableVolatility = (value: unknown): value is number => positive(value) && value <= 5;
 
-interface StrategyParity { forward: number; daysToExpiry: number }
+export interface StrategyParity { forward: number; daysToExpiry: number }
+
+/**
+ * The contracts a strategy seed picks from: every two-sided quote with the IV
+ * its midpoint implies against its expiry's parity forward (or a usable
+ * provider IV), each side nearest `spot` first. `parityFor` is the forward an
+ * expiry's IVs were solved on, null without a rate to solve them by.
+ */
+export interface QuotedChain {
+  calls: QuotedContract[];
+  puts: QuotedContract[];
+  parityFor(expiration: number): StrategyParity | null;
+}
+
+/** The quoted chain every seed reads, as `scenarioStrategyLegs` describes it. */
+function quoteStrategyChain(chain: OptionsChain, spot: number, pricing: StrategyPricing | null): QuotedChain {
+  const parity = new Map<number, StrategyParity | null>();
+  const parityFor = (expiration: number) => {
+    if (!pricing) return null;
+    if (!parity.has(expiration)) {
+      const daysToExpiry = daysToExpiryFrom(expiration, pricing.asOf);
+      const { forward } = extractImpliedForward(chain.calls.filter((call) => call.expiration === expiration),
+        chain.puts.filter((put) => put.expiration === expiration), pricing.spot, daysToExpiry / 365, pricing.rate,
+        chain.underlyingSymbol);
+      parity.set(expiration, forward == null ? null : { forward, daysToExpiry });
+    }
+    return parity.get(expiration)!;
+  };
+  const quoted = (contracts: OptionsChain["calls"], side: ScenarioLeg["side"]) => contracts.flatMap((contract): QuotedContract[] => {
+    const mid = optionMid(contract);
+    if (!positive(contract.strike) || mid == null) return [];
+    const expiry = parityFor(contract.expiration);
+    // q=r turns the spot pricer into discounted forward pricing.
+    const volatility = expiry ? solveImpliedVolatility({ side, spot: expiry.forward, strike: contract.strike,
+      daysToExpiry: expiry.daysToExpiry, rate: pricing!.rate, dividendYield: pricing!.rate }, mid).volatility : null;
+    if (usableVolatility(volatility)) return [{ contract, side, mid, volatility, solved: true }];
+    return usableVolatility(contract.impliedVolatility) ? [{ contract, side, mid, volatility: contract.impliedVolatility, solved: false }] : [];
+  });
+  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
+    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  return { calls: quoted(chain.calls, "call").sort(nearest), puts: quoted(chain.puts, "put").sort(nearest), parityFor };
+}
 
 /**
  * An explicit strategy request uses only two-sided quotes and enters each leg
@@ -418,33 +459,8 @@ function scenarioStrategyLegs(
   chain: OptionsChain, spot: number, strategy: ScenarioStrategy, pricing: StrategyPricing | null, strike?: number,
   collar: { put?: number; call?: number } = {}, delta?: number, unusable: UnusableChainText = defaultUnusableChainText,
 ): { legs: ScenarioLeg[]; parity: StrategyParity | null } {
-  const parity = new Map<number, StrategyParity | null>();
-  const parityFor = (expiration: number) => {
-    if (!pricing) return null;
-    if (!parity.has(expiration)) {
-      const daysToExpiry = daysToExpiryFrom(expiration, pricing.asOf);
-      const { forward } = extractImpliedForward(chain.calls.filter((call) => call.expiration === expiration),
-        chain.puts.filter((put) => put.expiration === expiration), pricing.spot, daysToExpiry / 365, pricing.rate,
-        chain.underlyingSymbol);
-      parity.set(expiration, forward == null ? null : { forward, daysToExpiry });
-    }
-    return parity.get(expiration)!;
-  };
-  const quoted = (contracts: OptionsChain["calls"], side: ScenarioLeg["side"]) => contracts.flatMap((contract) => {
-    const mid = optionMid(contract);
-    if (!positive(contract.strike) || mid == null) return [];
-    const expiry = parityFor(contract.expiration);
-    // q=r turns the spot pricer into discounted forward pricing.
-    const volatility = expiry ? solveImpliedVolatility({ side, spot: expiry.forward, strike: contract.strike,
-      daysToExpiry: expiry.daysToExpiry, rate: pricing!.rate, dividendYield: pricing!.rate }, mid).volatility : null;
-    if (usableVolatility(volatility)) return [{ contract, mid, volatility, solved: true }];
-    return usableVolatility(contract.impliedVolatility) ? [{ contract, mid, volatility: contract.impliedVolatility, solved: false }] : [];
-  });
-  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
-    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  const { calls, puts, parityFor } = quoteStrategyChain(chain, spot, pricing);
   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 } }[], at = strike, what: string = strategy === "csp" ? "put to sell" : strategy) => {
     if (at == null) return new Error(unusable("strategy"));
     const listed = [...new Set(candidates.map(({ contract }) => contract.strike))]
@@ -455,7 +471,7 @@ function scenarioStrategyLegs(
   };
   if (strategy === "collar") return collarLegs(calls, puts, spot, collar, missing, parityFor, unusable);
   if (strategy === "put" || strategy === "csp") {
-    const put = delta == null ? puts.find(anchored) : nearestDelta(puts, -delta, spot, pricing, parityFor);
+    const put = delta == null ? puts.find(anchored) : nearestDeltaContract(puts, -delta, spot, pricing, parityFor);
     if (!put) throw missing(puts);
     return { legs: [{ id: put.contract.contractSymbol, side: "put", quantity: strategy === "csp" ? -1 : 1, strike: put.contract.strike,
       expiration: put.contract.expiration, price: put.mid, priceSource: "mid", volatility: put.volatility, multiplier: 100,
@@ -480,10 +496,10 @@ function scenarioStrategyLegs(
   return { legs, parity: first.solved || second.solved ? parityFor(first.contract.expiration) : null };
 }
 
-interface QuotedContract { contract: OptionsChain["calls"][number]; mid: number; volatility: number; solved: boolean }
+export interface QuotedContract { contract: OptionsChain["calls"][number]; side: ScenarioLeg["side"]; mid: number; volatility: number; solved: boolean }
 
 /** Why a chain seeds nothing: `what` it has no usable quote for, then the next live expiry to try unless `next` is false. */
-type UnusableChainText = (what: string, next?: boolean) => string;
+export type UnusableChainText = (what: string, next?: boolean) => string;
 const defaultUnusableChainText: UnusableChainText = (what) => `The selected chain has no complete quoted ${what} with usable IV`;
 
 /**
@@ -502,38 +518,91 @@ function unusableChainText(market: ScenarioMarketSnapshot, exchange: string | un
 }
 
 /**
- * A put's spot delta at the IV it trades at: against the parity forward its
- * IV was solved on when it was (forward delta, carried to spot), else at the
- * seed's spot. Null when it cannot be valued.
+ * An option's spot delta at the IV it trades at: against the parity forward
+ * its IV was solved on when it was (forward delta, carried to spot), else at
+ * the seed's spot. Null when it cannot be valued.
  */
-function quotedPutDelta(quoted: QuotedContract, spot: number, pricing: StrategyPricing | null, parity: StrategyParity | null): number | null {
-  const { contract, volatility, solved } = quoted;
+function quotedDelta(quoted: QuotedContract, spot: number, pricing: StrategyPricing | null, parity: StrategyParity | null): number | null {
+  const { contract, side, volatility, solved } = quoted;
   if (!pricing) return null;
   if (solved && parity) {
     // On the forward, with the dividend yield set to the rate so it carries no drift, as the IV was solved.
-    const forwardDelta = valueOption({ side: "put", spot: parity.forward, strike: contract.strike, daysToExpiry: parity.daysToExpiry,
+    const forwardDelta = valueOption({ side, spot: parity.forward, strike: contract.strike, daysToExpiry: parity.daysToExpiry,
       rate: pricing.rate, dividendYield: pricing.rate, volatility }).delta;
     return Number.isFinite(forwardDelta) ? forwardDelta * Math.exp((pricing.rate - pricing.dividendYield) * parity.daysToExpiry / 365) : null;
   }
   const years = daysToExpiryFrom(contract.expiration, pricing.asOf) / 365;
-  return optionDelta({ spot, years, volatility, rate: pricing.rate, dividendYield: pricing.dividendYield }, contract.strike, "put");
+  return optionDelta({ spot, years, volatility, rate: pricing.rate, dividendYield: pricing.dividendYield }, contract.strike, side);
 }
 
-/** The put whose delta is nearest `target` (negative, as a put's delta reads), the lower strike on a tie; null when none can be valued. */
-function nearestDelta(
-  puts: readonly QuotedContract[], target: number, spot: number, pricing: StrategyPricing | null,
+/**
+ * The contract whose delta is nearest `target` (negative for a put, as its
+ * delta reads), the one further out of the money on a tie (the lower strike
+ * of two puts, the higher of two calls); null when none can be valued.
+ */
+export function nearestDeltaContract(
+  candidates: readonly QuotedContract[], target: number, spot: number, pricing: StrategyPricing | null,
   parityFor: (expiration: number) => StrategyParity | null,
 ): QuotedContract | null {
-  let best: { put: QuotedContract; distance: number } | null = null;
-  for (const put of puts) {
-    const delta = quotedPutDelta(put, spot, pricing, put.solved ? parityFor(put.contract.expiration) : null);
+  let best: { quoted: QuotedContract; distance: number } | null = null;
+  for (const quoted of candidates) {
+    const delta = quotedDelta(quoted, spot, pricing, quoted.solved ? parityFor(quoted.contract.expiration) : null);
     if (delta == null) continue;
     const distance = Math.abs(delta - target);
-    if (!best || distance < best.distance - 1e-12 || (Math.abs(distance - best.distance) <= 1e-12 && put.contract.strike < best.put.contract.strike)) {
-      best = { put, distance };
+    const further = quoted.side === "put" ? quoted.contract.strike < (best?.quoted.contract.strike ?? Infinity)
+      : quoted.contract.strike > (best?.quoted.contract.strike ?? -Infinity);
+    if (!best || distance < best.distance - 1e-12 || (Math.abs(distance - best.distance) <= 1e-12 && further)) {
+      best = { quoted, distance };
     }
   }
-  return best?.put ?? null;
+  return best?.quoted ?? null;
+}
+
+/** A seeded leg: `quantity` contracts of a quoted option, entered at its midpoint with the IV that midpoint implies, as every seed enters it. */
+export function seededLeg({ contract, side, mid, volatility, solved }: QuotedContract, quantity: number): ScenarioLeg {
+  return { id: contract.contractSymbol, side, quantity, strike: contract.strike, expiration: contract.expiration, price: mid,
+    priceSource: "mid", volatility, multiplier: 100, ...(solved ? { volatilitySource: "mid" as const } : {}) };
+}
+
+/** What a strategy screen picks from a quoted chain: its legs, and the shares it holds with them (a covered call's). */
+export interface ScreenSeed { legs: ScenarioLeg[]; shares?: number }
+
+/**
+ * A position a strategy screen seeds as OSA seeds `--strategy`: legs picked
+ * from the market's chain (or `merged`, a calendar's two expiries together) at
+ * their quote midpoints, valued at the market's rate and dividend yield from
+ * the spot the first expiry's parity forward implies when a leg's IV was solved
+ * against it. Shares are bought at that spot. `pick` reads the quoted chain
+ * with its pricing, so a leg can be chosen by delta.
+ */
+export function seedScreenPosition(
+  market: ScenarioMarketSnapshot,
+  pick: (quoted: QuotedChain, pricing: StrategyPricing, unusable: UnusableChainText) => ScreenSeed,
+  merged?: OptionsChain,
+): ScenarioPosition {
+  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");
+  }
+  const chain = merged ?? market.chain;
+  if (market.spot == null) throw new Error("A current underlying price is required");
+  if (market.rate == null) throw new Error("Choosing legs by delta needs the Treasury rate");
+  if (market.dividendYield == null) throw new Error("Dividend yield unavailable");
+  const pricing = { spot: market.spot, asOf: market.asOf, rate: market.rate, dividendYield: market.dividendYield };
+  const quoted = quoteStrategyChain(chain, market.spot, pricing);
+  const { legs, shares } = pick(quoted, pricing, unusableChainText(market, market.exchange));
+  const first = Math.min(...legs.map((leg) => leg.expiration));
+  const parity = legs.some((leg) => leg.expiration === first && leg.volatilitySource === "mid") ? quoted.parityFor(first) : null;
+  const spot = parity ? parity.forward * Math.exp(-(pricing.rate - pricing.dividendYield) * parity.daysToExpiry / 365) : market.spot;
+  const position: ScenarioPosition = {
+    symbol: market.symbol, exchange: market.exchange, currency: scenarioCurrency(undefined, market.currency, market.exchange),
+    spot, rate: pricing.rate, dividendYield: pricing.dividendYield, asOf: market.asOf, legs,
+    ...(shares ? { underlying: { quantity: shares, price: spot } } : {}),
+  };
+  const error = validatePosition(position);
+  if (error) throw new Error(error);
+  const contracts = [...chain.calls, ...chain.puts].filter((contract) => legs.some((leg) => leg.id === contract.contractSymbol));
+  if (contracts.some((contract) => contract.currency && contract.currency !== position.currency)) throw new Error("Strategy currency differs from the underlying quote currency");
+  return position;
 }
 
 /** How far out of the money a collar's put and call sit when their strikes are not given. */

package/src/plugins/builtin/options-scenario/csp-screen-headless.ts

@@ -8,6 +8,10 @@ import {
   CSP_SCREEN_DEFAULTS, CSP_SCREEN_LIMIT, cspEarningsText, cspScreenCriteriaText, loadCspScreen, readCspScreenCriteria,
   type CspScreen, type CspScreenRow,
 } from "./csp-screen";
+import {
+  loadStrategyScreen, readStrategyFamily, readStrategyScreenCriteria, STRATEGY_FAMILY_DEFS, strategyFamilyDef,
+  strategyRankedBy, strategyScreenCriteriaText, type ScreenFamily, type StrategyScreen, type StrategyScreenCriteria, type StrategyScreenRow,
+} from "./strategy-screen";
 
 const percentCell = (digits: number) => (value: unknown) => typeof value === "number" ? `${value.toFixed(digits)}%` : "--";
 const priceCell = (value: unknown) => typeof value === "number" ? formatHedgePrice(value) : "--";
@@ -69,42 +73,146 @@ const listText = (items: readonly string[]) => items.length <= 1 ? items.join(""
  * sessions).`), and a bare symbol, which has none to give, is just not ranked
  * yet (`No IV rank for DAL yet.`).
  */
-export function cspScreenNotes(screen: Pick<CspScreen, "criteria" | "missingRanks">): string[] {
+export function cspScreenNotes(
+  screen: { criteria: Pick<CspScreen["criteria"], "maxSpreadPercent">; missingRanks: string[] }, rankedBy = "annualised yield at the bid",
+): string[] {
   const reasoned = screen.missingRanks.filter((entry) => entry.includes(" "));
   const bare = screen.missingRanks.filter((entry) => !entry.includes(" "));
   return [
-    `Ranked by annualised yield at the bid. Wide is a spread over ${screen.criteria.maxSpreadPercent}% of the mid (--max-spread).`,
+    `Ranked by ${rankedBy}. Wide is a spread over ${screen.criteria.maxSpreadPercent}% of the mid (--max-spread).`,
     ...(reasoned.length ? [`No IV rank: ${reasoned.join(", ")}.`] : []),
     ...(bare.length ? [`No IV rank for ${listText(bare)} yet.`] : []),
   ];
 }
 
+const money = (value: number) => value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+
+/**
+ * One name's trade, flat: money (credit or debit, max gain and loss) for one
+ * contract a leg as OSA counts it, break-evens per share, every percent in
+ * percent, reward to risk as a multiple.
+ */
+export type StrategyScreenReportRow = {
+  rank: number | null; symbol: string; expiry: string | null; farExpiry: string | null; days: number | null; trade: string | null;
+  net: number | null; maxGain: number | null; maxLoss: number | null; unlimited: "gain" | "loss" | null;
+  breakEven: number | null; secondBreakEven: number | null; breakEvens: string; pop: number | null; returnToExpiry: number | null;
+  returnPerYear: number | null; rewardRisk: number | null; ivRank: number | null; spread: number | null; wide: boolean | null;
+  earnings: string; earningsBeforeExpiry: boolean | null; earningsDate: string | null; spot: number | null; note: string | null;
+};
+
+export function strategyScreenReportRow(row: StrategyScreenRow): StrategyScreenReportRow {
+  const { trade } = row;
+  return {
+    rank: row.rank, symbol: row.symbol, expiry: trade?.expiry ?? null, farExpiry: trade?.farExpiry ?? null, days: trade?.daysToExpiry ?? null,
+    // The screen keeps only trades whose mids open the way the family does, so the amount is the column's own credit or debit.
+    trade: trade?.text ?? null, net: trade ? Math.abs(trade.netAmount) : null, maxGain: trade?.maxGain ?? null, maxLoss: trade?.maxLoss ?? null,
+    unlimited: trade?.unlimited ?? null, breakEven: trade?.breakEvens[0] ?? null, secondBreakEven: trade?.breakEvens[1] ?? null,
+    breakEvens: trade?.breakEvens.length ? trade.breakEvens.map((value) => value.toFixed(2)).join(" / ") : "--",
+    pop: exportPercent(trade?.probabilityOfProfit), returnToExpiry: exportPercent(trade?.returnToExpiry),
+    returnPerYear: exportPercent(trade?.annualizedReturn), rewardRisk: trade?.rewardToRisk ?? null,
+    ivRank: row.ivRank, spread: exportPercent(trade?.quote?.spreadOfMid), wide: trade?.quote ? row.wideSpread : null,
+    earnings: cspEarningsText(trade), earningsBeforeExpiry: trade ? trade.earnings.beforeExpiry : null, earningsDate: trade?.earnings.date ?? null,
+    spot: trade?.spot ?? null, note: row.note,
+  };
+}
+
+/** A gain or loss for one contract a leg, `unlimited` on the side that has no limit. */
+const riskCell = (side: "gain" | "loss") => (value: unknown, row: Record<string, unknown>) =>
+  typeof value === "number" ? money(value) : row.unlimited === side ? "unlimited" : "--";
+/** `2.68x`, or `unlimited` where the gain has no limit. */
+export const rewardRiskText = (value: unknown, unlimited: unknown) =>
+  typeof value === "number" ? `${value.toFixed(2)}x` : unlimited === "gain" ? "unlimited" : "--";
+
+/** The unit every money column of a trade is in, said once: OSA's own for position money. */
+export const STRATEGY_MONEY_UNIT = "USD per contract";
+
+/**
+ * A family's columns: its money column is `Credit` or `Debit`; an income trade
+ * reads its annualised return and a debit trade its reward to risk. A
+ * calendar's trade names the expiry it buys, which exports also give alone.
+ */
+function strategyScreenColumns(strategy: ScreenFamily): { text: HeadlessPaneColumn[]; exported: HeadlessPaneColumn[] } {
+  const def = strategyFamilyDef(strategy);
+  const lead: HeadlessPaneColumn[] = [COLUMNS[0]!, COLUMNS[1]!, COLUMNS[2]!];
+  const farExpiry: HeadlessPaneColumn[] = strategy === "calendar" ? [{ key: "farExpiry", header: "Bought expiry" }] : [];
+  const body: HeadlessPaneColumn[] = [
+    COLUMNS[3]!,
+    { key: "trade", header: "Trade", format: (value) => typeof value === "string" ? value : "--" },
+    { key: "net", header: def.net === "credit" ? "Credit" : "Debit", align: "right", format: (value) => typeof value === "number" ? money(value) : "--" },
+    { key: "maxGain", header: "Max gain", align: "right", format: riskCell("gain") },
+    { key: "maxLoss", header: "Max loss", align: "right", format: riskCell("loss") },
+  ];
+  const measure: HeadlessPaneColumn = def.net === "credit"
+    ? { key: "returnPerYear", header: "Return/yr", align: "right", format: percentCell(1) }
+    : { key: "rewardRisk", header: "Reward/risk", align: "right", format: (value, row) => rewardRiskText(value, row.unlimited) };
+  const odds: HeadlessPaneColumn[] = [{ key: "pop", header: "PoP", align: "right", format: percentCell(0) }, measure, COLUMNS[12]!, COLUMNS[7]!, COLUMNS[13]!];
+  const breakEven: HeadlessPaneColumn = { key: "breakEven", header: "Break-even", align: "right", format: priceCell,
+    textFormat: (_value, row) => String(row.breakEvens) };
+  const toExpiry: HeadlessPaneColumn[] = def.net === "credit"
+    ? [{ key: "returnToExpiry", header: "Return to expiry", align: "right", format: percentCell(2) }] : [];
+  return {
+    text: [...lead, ...body, breakEven, ...odds, NOTE],
+    exported: [...lead, ...farExpiry, ...body, breakEven, { key: "secondBreakEven", header: "Second break-even", format: priceCell }, ...odds,
+      ...toExpiry, ...EXPORT_ONLY, NOTE],
+  };
+}
+
+function strategyMetadata(screen: StrategyScreen) {
+  return { strategy: screen.criteria.strategy, criteria: screen.criteria, rankedBy: strategyRankedBy(screen.criteria.strategy),
+    unit: `credit, debit, max gain and max loss in ${STRATEGY_MONEY_UNIT} (one contract a leg, 100 shares); break-evens per share; percent; reward/risk as a multiple`,
+    methodology: "docs/research-data.md#options-strategy-screen" };
+}
+
 export const cspScreenHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
   argument: { kind: "tickers", maximum: CSP_SCREEN_LIMIT, description: "US option underlyings to rank" },
   usListingsOnly: "Options data",
   failsWithoutData: true,
-  description: "Cash-secured puts across a list, ranked by annualised yield on cash at the bid: for each name, the put nearest a delta "
-    + "(0.30) on the listed expiry nearest a date or a number of days out (30), with its strike, bid, ask, spread (flagged wide over "
-    + "--max-spread, never left out), delta, distance out of the money, yield at the mid and at the bid, IV rank and whether earnings fall before expiry.",
+  description: "Option strategies across a list, one family at a time (--strategy): cash-secured puts by default, ranked by annualised yield on "
+    + "cash at the bid, the put nearest a delta (0.30) on the listed expiry nearest a date or a number of days out (30), with its strike, bid, ask, "
+    + "spread (flagged wide over --max-spread, never left out), delta, distance out of the money, yield at the mid and at the bid, IV rank and whether "
+    + "earnings fall before expiry. Covered calls, verticals, iron condors, straddles, strangles and calendars pick their legs by delta on the same "
+    + "expiry and show the trade, credit or debit, max gain and loss per contract, break-evens, probability of profit, and an income trade's "
+    + "annualised return or a debit trade's reward to risk.",
   discovery: { screenshotReadiness: "live-dom", dataRequirements: ["Current option chains", "Cloud stored implied volatility", "Earnings calendar"],
-    limitations: ["Assignment, margin and the interest the cash earns are not modelled."] },
+    limitations: ["Assignment, margin and the interest the cash earns are not modelled.",
+      "Probability of profit is the Black-Scholes chance at each break-even's nearest leg IV, not a forecast."] },
   describe: (_args, result) => {
-    const criteria = (result?.metadata as { criteria?: CspScreen["criteria"] } | undefined)?.criteria;
-    return ["Cash-secured puts", ...(criteria ? [cspScreenCriteriaText(criteria, Date.now())] : [])].join(" · ");
+    const metadata = result?.metadata as { criteria?: CspScreen["criteria"] | StrategyScreenCriteria; strategy?: ScreenFamily } | undefined;
+    const criteria = metadata?.criteria;
+    if (metadata?.strategy && criteria) {
+      return [strategyFamilyDef(metadata.strategy).title, strategyScreenCriteriaText(criteria as StrategyScreenCriteria, Date.now()), STRATEGY_MONEY_UNIT]
+        .join(" · ");
+    }
+    return ["Cash-secured puts", ...(criteria ? [cspScreenCriteriaText(criteria as CspScreen["criteria"], Date.now())] : [])].join(" · ");
   },
   options: [
+    { key: "strategy", type: "enum", example: "--strategy iron-condor",
+      values: STRATEGY_FAMILY_DEFS.map((def) => ({ value: def.id, ...(def.aliases.length ? { aliases: def.aliases } : {}) })),
+      description: "The strategy each name trades, a cash-secured put (csp) when not given; also cc, put-credit, call-credit, call-debit, "
+        + "put-debit, ic and call-calendar" },
     { key: "delta", type: "string", placeholder: "0.30", example: "--delta 0.20",
-      description: `Each name's put is the one whose delta is nearest this, as a put's delta reads without its sign. Default ${CSP_SCREEN_DEFAULTS.delta.toFixed(2)}` },
+      description: `Each name's put is the one whose delta is nearest this, as a put's delta reads without its sign. Default ${CSP_SCREEN_DEFAULTS.delta.toFixed(2)}. `
+        + "Other strategies pick their legs the same way: a covered call's call, a vertical's leg nearer the money, a condor's or a strangle's put and call, "
+        + "a calendar's call, each strategy at its own default (0.30; 0.50 for debit verticals and calendars; 0.20 for condors and short strangles)" },
+    { key: "wingDelta", aliases: ["wing-delta"], type: "string", placeholder: "0.15", example: "--strategy iron-condor --wing-delta 0.05",
+      description: "A vertical's or an iron condor's legs further out of the money are the ones whose delta is nearest this: the legs a credit spread "
+        + "buys and a debit spread sells. Default 0.15 (0.30 for debit verticals, 0.10 for condors), or half --delta when that is not below it" },
     { key: "days", type: "string", placeholder: "days", example: "--days 45",
       description: `Each name's expiry is its listed one nearest this many calendar days out. Default ${CSP_SCREEN_DEFAULTS.days}` },
     { key: "expiration", type: "string", placeholder: OPTION_EXPIRATION_PLACEHOLDER, example: "--expiration 2026-11-20",
       description: `Each name's expiry is its listed one nearest this date, in place of --days, as ${OPTION_EXPIRATION_FORMAT}`,
       normalize: (value) => expirationOptionSeconds(value) },
     { key: "maxSpread", aliases: ["max-spread"], type: "string", placeholder: "percent", example: "--max-spread 15",
-      description: `A put whose bid/ask spread is over this percent of its mid is marked wide; it is still ranked. Default ${CSP_SCREEN_DEFAULTS.maxSpreadPercent}` },
+      description: "A put whose bid/ask spread is over this percent of its mid is marked wide; it is still ranked. A strategy of several legs adds "
+        + `their spreads up against its net mid. Default ${CSP_SCREEN_DEFAULTS.maxSpreadPercent}` },
   ],
   async load(args, ctx) {
+    const strategy = readStrategyFamily(args.options.strategy);
+    if (strategy !== "csp") return loadStrategyReport(strategy, args, ctx);
+    if (args.options.wingDelta != null && args.options.wingDelta !== "") {
+      throw new Error("--wing-delta sets the far legs of a vertical or an iron condor; a cash-secured put has none");
+    }
     const criteria = readCspScreenCriteria(args.options);
     const instruments = await Promise.all(args.symbols.map((symbol) => resolveHeadlessInstrument(ctx, symbol)));
     const screen = await loadCspScreen(instruments, criteria, {
@@ -125,3 +233,27 @@ export const cspScreenHeadless: HeadlessPaneDefinition<"rows"> = {
     };
   },
 };
+
+/** `fn CSP --strategy <family>`: each name's trade of the family, ranked, with its own columns. */
+async function loadStrategyReport(
+  strategy: ScreenFamily, args: Parameters<HeadlessPaneDefinition["load"]>[0], ctx: Parameters<HeadlessPaneDefinition["load"]>[1],
+) {
+  const criteria = readStrategyScreenCriteria(strategy, args.options);
+  const instruments = await Promise.all(args.symbols.map((symbol) => resolveHeadlessInstrument(ctx, symbol)));
+  const screen = await loadStrategyScreen(instruments, criteria, {
+    scenario: createScenarioDependencies(ctx.marketData, ctx.apiClient), earnings: ctx.marketData, ivApi: ctx.apiClient,
+  }, ctx.signal);
+  const unavailable = screen.rows.filter((row) => !row.trade);
+  const columns = strategyScreenColumns(strategy);
+  return {
+    freshness: screen.freshness,
+    columns: columns.exported,
+    textColumns: columns.text,
+    rows: screen.rows.map(strategyScreenReportRow),
+    complete: unavailable.length === 0 && !screen.ivRankError,
+    unavailableSymbols: unavailable.map((row) => row.symbol),
+    errors: screen.ivRankError ? [`IV rank unavailable: ${screen.ivRankError}`] : [],
+    notes: cspScreenNotes(screen, strategyRankedBy(strategy)),
+    metadata: strategyMetadata(screen),
+  };
+}