gloomberb 0.16.3 → 0.16.4

package/src/plugins/builtin/kelly-sizer/headless.ts

@@ -0,0 +1,149 @@
+import type { HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/headless";
+import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { MarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
+import { parseHedgeAmount } from "../options-scenario/hedge";
+import { clipPriceHistoryToRange } from "../../../time-series/history-window";
+import { formatNumber } from "../../../utils/format";
+import { buildBinaryOutcomes, solveKellyFraction } from "./model";
+import {
+  clampKellyHistoryYears,
+  estimateKellyHistoryInputs,
+  KELLY_HISTORY_DEFAULT_YEARS,
+  KELLY_HISTORY_MAX_YEARS,
+  KELLY_HISTORY_MIN_PERIODS,
+  kellyHistoryRange,
+  kellyHistoryRequest,
+  type KellyHistoryInputs,
+} from "./history";
+import { formatPct, formatSignedPct } from "./view";
+
+/** The fractions of full Kelly a report sizes, largest first. */
+const KELLY_FRACTIONS = [
+  { id: "full", label: "Full Kelly", fraction: 1 },
+  { id: "half", label: "Half Kelly", fraction: 0.5 },
+  { id: "quarter", label: "Quarter Kelly", fraction: 0.25 },
+] as const;
+
+/** The inputs a ticker's monthly returns give, as the History tab shows them. */
+function inputEntries(inputs: KellyHistoryInputs, edge: number) {
+  const payoff = inputs.downsideReturn < 0 ? inputs.upsideReturn / -inputs.downsideReturn : null;
+  return [
+    { key: "window", label: "Window", value: { start: inputs.start, end: inputs.end, months: inputs.periods },
+      formatted: `${inputs.start} to ${inputs.end}, ${inputs.periods} monthly returns` },
+    { key: "winRate", label: "Win rate", value: inputs.winProbability,
+      formatted: `${formatPct(inputs.winProbability)} (${inputs.wins} of ${inputs.periods} months up)` },
+    { key: "averageGain", label: "Average gain", value: inputs.upsideReturn, formatted: `${formatSignedPct(inputs.upsideReturn)} a month` },
+    { key: "averageLoss", label: "Average loss", value: inputs.downsideReturn, formatted: `${formatSignedPct(inputs.downsideReturn)} a month` },
+    { key: "payoffRatio", label: "Payoff ratio", value: payoff, formatted: payoff == null ? "no down month" : `${formatNumber(payoff, 2)}x` },
+    { key: "edge", label: "Edge", value: edge, formatted: `${formatSignedPct(edge)} a month` },
+  ];
+}
+
+export const kellyHeadless: HeadlessPaneDefinition<"bundle"> = {
+  shape: "bundle",
+  argument: { kind: "ticker", description: "Ticker to size" },
+  freshness: { source: "Your inputs and Gloom Cloud", status: "not-a-feed", basis: "monthly returns from daily closes", cadence: "daily", oldest: null },
+  description: "Kelly sizing for a ticker from its own monthly returns: win rate, payoff ratio and edge over a lookback, then full, half and quarter Kelly as a share of a bankroll.",
+  describe: (args) => `Kelly sizing | ${args.symbols[0] ?? ""}`,
+  discovery: {
+    dataRequirements: ["Gloom Cloud daily closes over the lookback, and the latest quote for share counts"],
+    limitations: ["Win rate, gain and loss are the ticker's own non-overlapping 21-session returns; past months are not a forecast."],
+  },
+  options: [
+    {
+      key: "bankroll",
+      type: "string",
+      settingKey: "bankroll",
+      placeholder: "amount",
+      example: "--bankroll 250000",
+      description: "Bankroll in your base currency, such as 250000, 250k or 1.5m; sizes each Kelly fraction in money.",
+      normalize: (value) => parseHedgeAmount(value, "bankroll"),
+    },
+    {
+      key: "years",
+      type: "integer",
+      settingKey: "historyYears",
+      minimum: 1,
+      maximum: KELLY_HISTORY_MAX_YEARS,
+      defaultValue: KELLY_HISTORY_DEFAULT_YEARS,
+      description: "Lookback in years for the monthly returns.",
+    },
+  ],
+  async load(args, ctx) {
+    const { symbol, exchange = "" } = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
+    const years = clampKellyHistoryYears(args.options.years);
+    const range = kellyHistoryRange(years);
+    // The quote and the one history window the lookback needs load together, through the
+    // coordinator every chart reads daily closes from (the History tab's request, cache included).
+    const [entry, quote] = await Promise.all([
+      new MarketDataCoordinator(ctx.marketData).loadChart(kellyHistoryRequest({ symbol, exchange }, years), { forceRefresh: ctx.refresh }),
+      ctx.marketData.getQuote(symbol, exchange, ctx.refresh ? { cacheMode: "refresh" } : undefined).catch(() => null),
+    ]);
+    const history = clipPriceHistoryToRange(resolveEntryValue(entry) ?? [], range);
+    ctx.signal.throwIfAborted();
+    const inputs = estimateKellyHistoryInputs(history, years);
+    if (!inputs) {
+      return {
+        complete: false,
+        unavailableSymbols: [symbol],
+        errors: [`${symbol}: fewer than ${KELLY_HISTORY_MIN_PERIODS} monthly returns in the last ${years} year${years === 1 ? "" : "s"}.`],
+        sections: [],
+      };
+    }
+    const solve = solveKellyFraction(buildBinaryOutcomes(inputs.winProbability, inputs.upsideReturn, inputs.downsideReturn));
+    const bankrollValue = args.options.bankroll;
+    const bankroll = typeof bankrollValue === "number" && bankrollValue > 0 ? bankrollValue : null;
+    const baseCurrency = ctx.config.baseCurrency || "USD";
+    const price = quote && quote.price > 0 && Number.isFinite(quote.price) ? quote.price : null;
+    // Shares only when the bankroll and the price are in one currency.
+    const sharePrice = price != null && quote?.currency === baseCurrency ? price : null;
+    const rows: HeadlessPaneRow[] = KELLY_FRACTIONS.map(({ id, label, fraction }) => {
+      const share = solve.fraction * fraction;
+      const position = bankroll == null ? null : share * bankroll;
+      return {
+        id,
+        kelly: label,
+        fraction: share,
+        position,
+        shares: position != null && sharePrice != null ? Math.floor(position / sharePrice) : null,
+      };
+    });
+    const notes = [
+      ...(solve.warning ? [solve.warning] : []),
+      ...(solve.fraction === 0 ? ["No positive edge over this window: every Kelly fraction sizes nothing."] : []),
+      ...(bankroll == null ? [`Add --bankroll <amount> to size each fraction in ${baseCurrency}.`] : []),
+    ];
+    return {
+      complete: true,
+      freshness: { asOf: inputs.end },
+      notes,
+      sections: [
+        { title: "Inputs", entries: inputEntries(inputs, solve.expectedReturn) },
+        {
+          title: bankroll == null ? "Sizing" : `Sizing on ${formatNumber(bankroll, 0)} ${baseCurrency}`,
+          columns: [
+            { key: "kelly", header: "Kelly" },
+            { key: "fraction", header: "% of bankroll", align: "right", format: (value) => typeof value === "number" ? formatPct(value, 2) : "--" },
+            ...(bankroll == null ? [] : [
+              { key: "position", header: `Position ${baseCurrency}`, align: "right" as const,
+                format: (value: unknown) => typeof value === "number" ? formatNumber(value, 0) : "--" },
+              ...(sharePrice == null ? [] : [{ key: "shares", header: "Shares", align: "right" as const,
+                format: (value: unknown) => typeof value === "number" ? formatNumber(value, 0) : "--" }]),
+            ]),
+          ],
+          rows,
+        },
+      ],
+      metadata: {
+        symbol,
+        inputs,
+        expectedReturn: solve.expectedReturn,
+        expectedLogGrowth: solve.expectedLogGrowth,
+        bankroll,
+        currency: baseCurrency,
+        price: price == null ? null : { value: price, currency: quote?.currency ?? null, asOf: quote?.lastUpdated ?? null },
+        method: "Binary Kelly on non-overlapping 21-session returns: win rate, mean gain and mean loss.",
+      },
+    };
+  },
+};

package/src/plugins/builtin/kelly-sizer/history.ts

@@ -0,0 +1,80 @@
+import type { PricePoint } from "../../../types/financials";
+import type { TimeRange } from "../../../time-series/range";
+import type { ChartRequest, InstrumentRef } from "../../../market-data/request-types";
+import { getPricePointTimestamp } from "../../../utils/price-history";
+
+/** Sessions in one holding period: a month of trading days. */
+export const KELLY_HISTORY_PERIOD_SESSIONS = 21;
+export const KELLY_HISTORY_DEFAULT_YEARS = 5;
+export const KELLY_HISTORY_MAX_YEARS = 5;
+/** Fewer monthly returns than this say too little about a win rate to size on. */
+export const KELLY_HISTORY_MIN_PERIODS = 6;
+
+const YEAR_MS = 365.25 * 24 * 60 * 60_000;
+
+/** The binary inputs a ticker's own monthly returns imply over a lookback window. */
+export interface KellyHistoryInputs {
+  winProbability: number;
+  /** Mean return of the up months, as a fraction. */
+  upsideReturn: number;
+  /** Mean return of the down months, as a negative fraction (0 when none fell). */
+  downsideReturn: number;
+  /** Up months over all months. */
+  wins: number;
+  periods: number;
+  /** Close the first return starts from, and the last bar, as YYYY-MM-DD. */
+  start: string;
+  end: string;
+  years: number;
+}
+
+export function clampKellyHistoryYears(value: unknown): number {
+  const years = Math.round(Number(value));
+  return Number.isFinite(years) ? Math.min(KELLY_HISTORY_MAX_YEARS, Math.max(1, years)) : KELLY_HISTORY_DEFAULT_YEARS;
+}
+
+/** The shortest history range that covers the lookback, so a one-year window never loads five. */
+export function kellyHistoryRange(years: number): TimeRange {
+  return clampKellyHistoryYears(years) <= 1 ? "1Y" : "5Y";
+}
+
+/** The daily closes the History tab and the KELLY report both read. */
+export function kellyHistoryRequest(instrument: InstrumentRef, years: number): ChartRequest {
+  return { instrument, bufferRange: kellyHistoryRange(years), granularity: "resolution", resolution: "1d" };
+}
+
+const dateKey = (time: number) => new Date(time).toISOString().slice(0, 10);
+
+/**
+ * Win rate, mean gain and mean loss of non-overlapping 21-session returns,
+ * counted back from the last daily close so the newest month is complete.
+ * Null when the window holds fewer than `KELLY_HISTORY_MIN_PERIODS` of them.
+ */
+export function estimateKellyHistoryInputs(points: readonly PricePoint[], yearsInput: number): KellyHistoryInputs | null {
+  const years = clampKellyHistoryYears(yearsInput);
+  const closes = points
+    .map((point) => ({ time: getPricePointTimestamp(point), close: point.close }))
+    .filter((point) => Number.isFinite(point.time) && Number.isFinite(point.close) && point.close > 0)
+    .sort((left, right) => left.time - right.time);
+  const last = closes.at(-1);
+  if (!last) return null;
+  const cutoff = last.time - years * YEAR_MS;
+  const window = closes.filter((point) => point.time >= cutoff);
+  const picks: typeof window = [];
+  for (let index = window.length - 1; index >= 0; index -= KELLY_HISTORY_PERIOD_SESSIONS) picks.unshift(window[index]!);
+  const returns = picks.slice(1).map((point, index) => point.close / picks[index]!.close - 1);
+  if (returns.length < KELLY_HISTORY_MIN_PERIODS) return null;
+  const gains = returns.filter((value) => value > 0);
+  const losses = returns.filter((value) => value < 0);
+  const mean = (values: number[]) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+  return {
+    winProbability: gains.length / returns.length,
+    upsideReturn: mean(gains),
+    downsideReturn: mean(losses),
+    wins: gains.length,
+    periods: returns.length,
+    start: dateKey(picks[0]!.time),
+    end: dateKey(last.time),
+    years,
+  };
+}

package/src/plugins/builtin/kelly-sizer/index.tsx

@@ -2,6 +2,7 @@ import type { PaneTemplateContext, PaneTemplateCreateOptions } from "../../../ty
 import type { PluginModule } from "../plugin-module";
 import { DEFAULT_FLOATING_SIZE, KELLY_PANE_ID } from "./constants";
 import { KellySizerPane } from "./pane";
+import { kellyHeadless } from "./headless";
 
 function resolveTemplateSymbol(context: PaneTemplateContext, options?: PaneTemplateCreateOptions): string | null {
   return options?.symbol
@@ -40,6 +41,7 @@ export const positionSizerModule: PluginModule = {
         const symbol = resolveTemplateSymbol(context, options);
         return symbol ? { params: { symbol }, placement: "floating" } : null;
       },
+      headless: kellyHeadless,
     },
   ],
 };

package/src/plugins/builtin/kelly-sizer/pane.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Box, useUiCapabilities } from "../../../ui";
 import { useShortcut } from "../../../react/input";
+import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { colors } from "../../../theme/colors";
 import {
   EmptyState,
@@ -17,7 +18,9 @@ import {
   type QueryBarFilter,
 } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
-import { useFxRatesMap } from "../../../market-data/hooks";
+import { useChartQueries, useFxRatesMap, useResolvedEntryValue } from "../../../market-data/hooks";
+import { buildChartKey } from "../../../market-data/selectors";
+import { clipPriceHistoryToRange } from "../../../time-series/history-window";
 import { useLiveTickerFinancials, useLiveTickerFinancialsMap } from "../../../state/hooks/live-ticker-financials";
 import { buildPortfolioFinancialsMap } from "../../../market-data/portfolio-financials";
 import { convertCurrency, formatCurrency } from "../../../utils/format";
@@ -27,6 +30,7 @@ import {
   getFocusedTickerSymbol,
   useAppSelector,
   usePaneInstance,
+  usePaneSettingValue,
   usePaneStateValue,
   usePaneAppConfig,
 } from "../../../state/app/context";
@@ -51,12 +55,20 @@ import {
 } from "./model";
 import {
   DEFAULT_KELLY_DRAFTS,
-  KELLY_MODES,
+  KELLY_PANE_MODES,
+  type KellyPaneMode,
   type KellySizerDraft,
   type KellySizerModeDrafts,
-  type KellySizingMode,
   type PredictionMarketKellyAssumptions,
 } from "./types";
+import {
+  clampKellyHistoryYears,
+  estimateKellyHistoryInputs,
+  KELLY_HISTORY_DEFAULT_YEARS,
+  KELLY_HISTORY_MIN_PERIODS,
+  kellyHistoryRange,
+  kellyHistoryRequest,
+} from "./history";
 import { KELLY_PANE_ID } from "./constants";
 import {
   buildKellyCurveXAxisLabels,
@@ -70,6 +82,7 @@ import type { StaticChartXMarker } from "../../../components/chart/static";
 import {
   KellyCurveSection,
   KellySensitivitySection,
+  buildKellyHistoryItems,
   buildKellyResultItems,
 } from "./sections";
 import { getPortfolioPositionValue, resolveActivePortfolioId, resolveKellyBankroll } from "./portfolio";
@@ -95,7 +108,13 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const commandBarOpen = useAppSelector((state) => state.commandBarOpen);
   const { nativePaneChrome } = useUiCapabilities();
 
-  const [mode, setMode] = usePaneStateValue<KellySizingMode>("mode", "binary");
+  // A pane opened from a KELLY report (fn, shot) sizes from the ticker's own history, as the report does.
+  const [reportYears] = usePaneSettingValue<number | null>("historyYears", null);
+  const [reportBankroll] = usePaneSettingValue<number | null>("bankroll", null);
+  const [mode, setMode] = usePaneStateValue<KellyPaneMode>("mode", reportYears != null ? "history" : "binary");
+  const [historyYears, setHistoryYears] = usePaneStateValue<number>("historyYears", clampKellyHistoryYears(reportYears ?? KELLY_HISTORY_DEFAULT_YEARS));
+  // History reads inputs off the ticker's monthly returns and sizes them as a binary bet.
+  const sizingMode = mode === "history" ? "binary" : mode;
   // A narrow terminal bar has no room for the view switch beside the ticker,
   // price and account (plus the Side and Portfolio filters when shown), so
   // there `s` stays a footer hint.
@@ -105,7 +124,10 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const [drafts, setDrafts] = usePaneStateValue<KellySizerModeDrafts>("drafts", cloneKellyDrafts());
   const [showSensitivity, setShowSensitivity] = usePaneStateValue<boolean>("showSensitivity", false);
   const [selectedPortfolioId, setSelectedPortfolioId] = usePaneStateValue<string | null>("portfolioId", null);
-  const [bankrollOverride, setBankrollOverride] = usePaneStateValue<number | null>("bankrollOverride", null);
+  const [bankrollOverride, setBankrollOverride] = usePaneStateValue<number | null>(
+    "bankrollOverride",
+    typeof reportBankroll === "number" && reportBankroll > 0 ? reportBankroll : null,
+  );
   const [currentValueOverride, setCurrentValueOverride] = usePaneStateValue<number | null>("currentValueOverride", null);
   const [selectedFieldIndex, setSelectedFieldIndex] = useState(0);
   const [activeInputId, setActiveInputId] = useState<string | null>(null);
@@ -256,26 +278,57 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const bankroll = bankrollOverride ?? sourceBankroll;
   const currentValue = currentValueOverride ?? sourceCurrentValue;
   const price = positionFinancials?.quote?.price ?? null;
-  const rawActiveDraft = drafts[mode] ?? DEFAULT_KELLY_DRAFTS[mode];
-  const { commonAssumptions, updateCommon } = useKellyCommonAssumptions(rawActiveDraft);
-  const activeDraft = useMemo(
-    () => applyKellyCommonAssumptions(rawActiveDraft, commonAssumptions),
-    [commonAssumptions, rawActiveDraft],
+  // The same daily closes, through the same request, as the KELLY report reads.
+  const historyRequest = useMemo(
+    () => mode === "history" && ticker
+      ? kellyHistoryRequest({ symbol: ticker.metadata.ticker, exchange: ticker.metadata.exchange ?? "" }, historyYears)
+      : null,
+    [historyYears, mode, ticker?.metadata.exchange, ticker?.metadata.ticker],
+  );
+  const historyEntries = useChartQueries(historyRequest ? [historyRequest] : []);
+  const historyEntry = historyRequest ? historyEntries.get(buildChartKey(historyRequest)) ?? null : null;
+  const historyPoints = useResolvedEntryValue(historyEntry);
+  const historyInputs = useMemo(
+    () => historyPoints
+      ? estimateKellyHistoryInputs(clipPriceHistoryToRange(historyPoints, kellyHistoryRange(historyYears)), historyYears)
+      : null,
+    [historyPoints, historyYears],
   );
+  const rawActiveDraft = drafts[sizingMode] ?? DEFAULT_KELLY_DRAFTS[sizingMode];
+  const { commonAssumptions, updateCommon } = useKellyCommonAssumptions(rawActiveDraft);
+  const activeDraft = useMemo(() => {
+    const draft = applyKellyCommonAssumptions(rawActiveDraft, commonAssumptions);
+    if (mode !== "history") return draft;
+    // Until the history loads there is no edge to size.
+    return {
+      ...draft,
+      winProbability: historyInputs?.winProbability ?? 0,
+      upsideReturn: historyInputs?.upsideReturn ?? 0,
+      downsideReturn: historyInputs?.downsideReturn ?? 0,
+    };
+  }, [commonAssumptions, historyInputs, mode, rawActiveDraft]);
 
   const updateDraft = useCallback((patch: Partial<KellySizerDraft>) => {
     setDrafts((current) => ({
       ...cloneKellyDrafts(current),
-      [mode]: {
-        ...(current[mode] ?? DEFAULT_KELLY_DRAFTS[mode]),
+      [sizingMode]: {
+        ...(current[sizingMode] ?? DEFAULT_KELLY_DRAFTS[sizingMode]),
         ...patch,
       } as KellySizerDraft,
     }));
-  }, [mode, setDrafts]);
+  }, [sizingMode, setDrafts]);
 
-  const fields = useMemo(
-    () => buildModeFields({ mode, draft: activeDraft, updateDraft }),
-    [activeDraft, mode, updateDraft],
+  const fields = useMemo<GridField[]>(
+    () => mode === "history"
+      ? [{
+        id: "history:years",
+        label: "Years",
+        value: historyYears,
+        valueText: String(historyYears),
+        onValue: (value) => setHistoryYears(clampKellyHistoryYears(value)),
+      }]
+      : buildModeFields({ mode: sizingMode, draft: activeDraft, updateDraft }),
+    [activeDraft, historyYears, mode, setHistoryYears, sizingMode, updateDraft],
   );
   const commonFields = useMemo(
     () => buildCommonFields({ common: commonAssumptions, updateCommon }),
@@ -307,35 +360,35 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const selectedField = gridFields[Math.min(selectedFieldIndex, Math.max(0, gridFields.length - 1))] ?? null;
   const result = useMemo(
     () => calculateKellySizing({
-      mode,
+      mode: sizingMode,
       draft: activeDraft,
       bankroll,
       currentValue,
       price,
     }),
-    [activeDraft, bankroll, currentValue, mode, price],
+    [activeDraft, bankroll, currentValue, price, sizingMode],
   );
-  const sensitivity = useMemo(() => buildSensitivityGrid(mode, activeDraft), [activeDraft, mode]);
+  const sensitivity = useMemo(() => buildSensitivityGrid(sizingMode, activeDraft), [activeDraft, sizingMode]);
   const curveMaxFraction = useMemo(
-    () => getKellyCurveMaxFraction(mode, activeDraft, [
+    () => getKellyCurveMaxFraction(sizingMode, activeDraft, [
       result.currentFraction,
       result.clippedFraction,
       result.fullKellyFraction,
     ]),
-    [activeDraft, mode, result.clippedFraction, result.currentFraction, result.fullKellyFraction],
+    [activeDraft, sizingMode, result.clippedFraction, result.currentFraction, result.fullKellyFraction],
   );
   const curvePoints = useMemo(
-    () => buildKellyCurvePoints(mode, activeDraft, curveMaxFraction),
-    [activeDraft, curveMaxFraction, mode],
+    () => buildKellyCurvePoints(sizingMode, activeDraft, curveMaxFraction),
+    [activeDraft, curveMaxFraction, sizingMode],
   );
   const curveXAxisLabels = useMemo(() => buildKellyCurveXAxisLabels(curveMaxFraction), [curveMaxFraction]);
   const currentGrowth = useMemo(
-    () => calculateExpectedLogGrowthAtFraction(mode, activeDraft, result.currentFraction),
-    [activeDraft, mode, result.currentFraction],
+    () => calculateExpectedLogGrowthAtFraction(sizingMode, activeDraft, result.currentFraction),
+    [activeDraft, sizingMode, result.currentFraction],
   );
   const targetGrowth = useMemo(
-    () => calculateExpectedLogGrowthAtFraction(mode, activeDraft, result.clippedFraction),
-    [activeDraft, mode, result.clippedFraction],
+    () => calculateExpectedLogGrowthAtFraction(sizingMode, activeDraft, result.clippedFraction),
+    [activeDraft, sizingMode, result.clippedFraction],
   );
   const curveMarkers = useMemo<StaticChartXMarker[]>(() => {
     if (!Number.isFinite(curveMaxFraction) || curveMaxFraction <= 0) return [];
@@ -406,8 +459,21 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
     }
   }, { enabled: focused });
 
+  // A report or shot of the History tab is as of the last daily close it read, not when it ran.
+  useRemoteUiNode(mode === "history" && historyInputs ? {
+    role: "report-freshness",
+    label: "History freshness",
+    getMetadata: () => ({ asOf: historyInputs.end }),
+  } : null);
+  // History mode says what it is waiting for, or why it has no inputs, before any sizing warning.
+  const historyStatus = mode !== "history" || historyInputs ? null
+    : historyEntry?.error ? { text: historyEntry.error.message, tone: "negative" as const }
+      : historyPoints ? { text: `under ${KELLY_HISTORY_MIN_PERIODS} monthly returns`, tone: "warning" as const }
+        : { text: "loading history", tone: "muted" as const };
   usePaneFooter(KELLY_PANE_ID, () => ({
-    info: bankroll <= 0 && ticker
+    info: historyStatus
+      ? [{ id: "history", parts: [historyStatus] }]
+      : bankroll <= 0 && ticker
       // Every size reads 0% until there is a bankroll; say so where status lives.
       ? [{ id: "bankroll", parts: [{ text: "no bankroll", tone: "warning" as const }] }]
       : result.warnings.length > 0
@@ -421,15 +487,15 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
       { id: "search", key: "/", label: "search", onPress: focusTickerSearch },
       ...(viewInBar ? [] : [{ id: "sensitivity", key: "s", label: showSensitivity ? "ensitivity off" : "ensitivity", onPress: toggleSensitivity }]),
     ],
-  }), [activeInputId, bankroll, editSelectedField, focusTickerSearch, result.clipReasons, result.warnings, selectedField?.id, selectedField?.label, showSensitivity, ticker, toggleSensitivity, viewInBar]);
+  }), [activeInputId, bankroll, editSelectedField, focusTickerSearch, historyStatus?.text, historyStatus?.tone, result.clipReasons, result.warnings, selectedField?.id, selectedField?.label, showSensitivity, ticker, toggleSensitivity, viewInBar]);
 
   const portfolioTabs = useMemo(
     () => config.portfolios.map((portfolio) => ({ label: portfolio.name, value: portfolio.id })),
     [config.portfolios],
   );
-  const modeTabs = useMemo(() => KELLY_MODES.map((entry) => ({ label: entry.label, value: entry.id })), []);
+  const modeTabs = useMemo(() => KELLY_PANE_MODES.map((entry) => ({ label: entry.label, value: entry.id })), []);
   const selectMode = (nextMode: string) => {
-    setMode(nextMode as KellySizingMode);
+    setMode(nextMode as KellyPaneMode);
     setSelectedFieldIndex(0);
     activateInput(null);
   };
@@ -442,14 +508,18 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   });
   const gridColumns = fieldGridColumns(width);
   const gridRows = fieldGridRows(gridFields, gridColumns);
-  const resultItems = buildKellyResultItems({
-    result,
-    baseCurrency: config.baseCurrency,
-    currentGrowth,
-    targetGrowth,
-    width,
-    columns: gridColumns,
-  });
+  const resultItems = [
+    // History's inputs lead: the window and the monthly figures the sizes come from.
+    ...(mode === "history" && historyInputs ? buildKellyHistoryItems(historyInputs) : []),
+    ...buildKellyResultItems({
+      result,
+      baseCurrency: config.baseCurrency,
+      currentGrowth,
+      targetGrowth,
+      width,
+      columns: gridColumns,
+    }),
+  ];
   const resultRows = statGridRows(resultItems, width, gridColumns);
   // Query bar, the mode strip when it is not in the title bar, inputs, results.
   const bodyRows = Math.max(0, height - 1 - tabRows - gridRows - resultRows);

package/src/plugins/builtin/kelly-sizer/sections.tsx

@@ -13,11 +13,25 @@ import { colors, priceColor } from "../../../theme/colors";
 import { Box } from "../../../ui";
 import { displayWidth, formatCurrency, formatNumber } from "../../../utils/format";
 import type { KellySizingResult, SensitivityGrid } from "./types";
+import type { KellyHistoryInputs } from "./history";
 import { formatPct, formatSignedPct } from "./view";
 
 /** The longest result label ("Full growth"), which sets the band's label column. */
 const RESULT_LABEL_CHARS = 11;
 
+/** The inputs History reads off the ticker's monthly returns, ahead of the sizes. */
+export function buildKellyHistoryItems(inputs: KellyHistoryInputs): StatItem[] {
+  const payoff = inputs.downsideReturn < 0 ? inputs.upsideReturn / -inputs.downsideReturn : null;
+  return [
+    // The dates take a row of their own so a narrow pane never cuts them.
+    { id: "window", label: "Window", value: `${inputs.start} to ${inputs.end}`, detail: `${inputs.periods} monthly returns`, wide: true },
+    { id: "winRate", label: "Win rate", value: formatPct(inputs.winProbability, 1), detail: `${inputs.wins}/${inputs.periods}` },
+    { id: "avgGain", label: "Avg gain", value: formatSignedPct(inputs.upsideReturn), color: priceColor(inputs.upsideReturn) },
+    { id: "avgLoss", label: "Avg loss", value: formatSignedPct(inputs.downsideReturn), color: priceColor(inputs.downsideReturn) },
+    { id: "payoff", label: "Payoff", value: payoff == null ? "—" : `${formatNumber(payoff, 2)}x` },
+  ];
+}
+
 /**
  * The sizing result as one band under the inputs, laid out in the FieldGrid's
  * columns: the Kelly fractions, then the move in money, then risk, then log

package/src/plugins/builtin/kelly-sizer/types.ts

@@ -105,7 +105,7 @@ export interface SensitivityGrid {
   cells: SensitivityGridCell[][];
 }
 
-export const KELLY_MODES: Array<{ id: KellySizingMode; label: string }> = [
+const KELLY_MODES: Array<{ id: KellySizingMode; label: string }> = [
   { id: "binary", label: "Binary" },
   { id: "scenario", label: "Scenario" },
   { id: "risk-budget", label: "Risk" },
@@ -113,6 +113,14 @@ export const KELLY_MODES: Array<{ id: KellySizingMode; label: string }> = [
   { id: "asymmetric", label: "Asym" },
 ];
 
+/** The pane's tabs: the sizing modes, and History, which reads a binary bet off the ticker's monthly returns. */
+export type KellyPaneMode = KellySizingMode | "history";
+
+export const KELLY_PANE_MODES: Array<{ id: KellyPaneMode; label: string }> = [
+  ...KELLY_MODES,
+  { id: "history", label: "History" },
+];
+
 export const DEFAULT_KELLY_COMMON_ASSUMPTIONS: KellyCommonAssumptions = {
   kellyFraction: 0.25,
   maxNameFraction: 0.08,

package/src/plugins/builtin/layout-manager/index.tsx

@@ -27,24 +27,32 @@ import {
 
 let dispatchRef: ((action: AppAction) => void) | null = null;
 let getStateRef: (() => { layout: LayoutConfig; termWidth: number; termHeight: number; focusedPaneId: string | null }) | null = null;
+let restoreHiddenRef: ((layout: LayoutConfig) => LayoutConfig) | null = null;
 
+/**
+ * `getState().layout` is the layout on screen. `restoreHidden` puts the panes
+ * it leaves out back into an edit of it before the edit is saved.
+ */
 export function setLayoutManagerDispatch(
   dispatch: (action: AppAction) => void,
   getState: () => { layout: LayoutConfig; termWidth: number; termHeight: number; focusedPaneId: string | null },
+  restoreHidden: (layout: LayoutConfig) => LayoutConfig,
 ) {
   dispatchRef = dispatch;
   getStateRef = getState;
+  restoreHiddenRef = restoreHidden;
 }
 
 function clearLayoutManagerDispatch() {
   dispatchRef = null;
   getStateRef = null;
+  restoreHiddenRef = null;
 }
 
 function persistLayout(layout: LayoutConfig) {
   if (!dispatchRef) return;
   dispatchRef({ type: "PUSH_LAYOUT_HISTORY" });
-  dispatchRef({ type: "UPDATE_LAYOUT", layout });
+  dispatchRef({ type: "UPDATE_LAYOUT", layout: restoreHiddenRef ? restoreHiddenRef(layout) : layout });
 }
 
 function getFocusedPane(layout: LayoutConfig, focusedPaneId: string | null) {

package/src/plugins/builtin/macro-day/client.ts

@@ -1,3 +1,5 @@
+import { apiClient, type CloudMacroReleaseDaysPayload } from "../../../api-client";
+import { createPluginCache } from "../../../data/plugin-cache";
 import { getSharedMarketDataCoordinator, MarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
 import type { InstrumentRef } from "../../../market-data/request-types";
 import { tickerHasListingSuffix } from "../../../sources/listing-symbols";
@@ -6,6 +8,28 @@ import type { PricePoint } from "../../../types/financials";
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
 import { resolveExchangeTimeZone } from "../../../utils/exchanges";
+import { bundledMacroReleases, mergeMacroReleases, type MacroReleaseList } from "./releases";
+
+export const macroReleaseCache = createPluginCache<CloudMacroReleaseDaysPayload>({
+  kind: "macro-release-days", source: "gloom-cloud", schemaVersion: 1,
+  // A release lands at 8:30 or 14:00 ET; the last list read is kept for a terminal that goes offline.
+  policy: { staleMs: 30 * 60_000, expireMs: 90 * 86_400_000 },
+});
+
+/**
+ * The bundled list, extended by the server's when it reaches further. A
+ * failed read keeps the last list read; with none, the bundled list alone.
+ */
+export async function loadMacroReleases(options: { force?: boolean } = {},
+  read: () => Promise<CloudMacroReleaseDaysPayload> = () => apiClient.getCloudMacroReleaseDays()): Promise<MacroReleaseList> {
+  const floor = bundledMacroReleases();
+  try {
+    const result = await macroReleaseCache.load("release-days", read, { force: options.force });
+    return mergeMacroReleases(floor, result.data);
+  } catch {
+    return floor;
+  }
+}
 
 export interface MacroDayHistory {
   history: PricePoint[];