gloomberb 0.16.2 → 0.16.4

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";
@@ -35,6 +39,7 @@ import { getSharedRegistry } from "../../registry";
 import { resolveTickerOpenTarget } from "../../../tickers/open-target";
 import { calculatePortfolioSummaryTotals } from "../portfolio-list/metrics";
 import { resolvePortfolioNetLiquidation } from "../portfolio-list/account-metrics";
+import { resolvePortfolioCash } from "../portfolio-list/allocation";
 import {
   buildTrackedCurrencies,
   getCollectionTickersFromConfig,
@@ -50,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,
@@ -69,9 +82,10 @@ import type { StaticChartXMarker } from "../../../components/chart/static";
 import {
   KellyCurveSection,
   KellySensitivitySection,
+  buildKellyHistoryItems,
   buildKellyResultItems,
 } from "./sections";
-import { getPortfolioPositionValue, resolveActivePortfolioId } from "./portfolio";
+import { getPortfolioPositionValue, resolveActivePortfolioId, resolveKellyBankroll } from "./portfolio";
 import { useKellyCommonAssumptions } from "./state";
 
 export function KellySizerPane({ focused, width, height }: PaneProps) {
@@ -94,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.
@@ -104,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);
@@ -214,9 +237,11 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
     ? portfolioFinancials.get(requestedSymbol!) ?? null
     : financials;
   const { accountState } = usePortfolioAccountState(activePortfolio, { brokerAccounts, config });
+  // Cash entered by hand counts toward a manual portfolio's bankroll; a broker's is in its Net Liq.
+  const manualCash = accountState ? null : resolvePortfolioCash(activePortfolio, null);
   const trackedCurrencies = useMemo(
-    () => buildTrackedCurrencies(portfolioTickers, portfolioFinancials, accountState, config.baseCurrency),
-    [accountState, config.baseCurrency, portfolioFinancials, portfolioTickers],
+    () => buildTrackedCurrencies(portfolioTickers, portfolioFinancials, accountState, config.baseCurrency, manualCash?.currency),
+    [accountState, config.baseCurrency, manualCash?.currency, portfolioFinancials, portfolioTickers],
   );
   const exchangeRates = useFxRatesMap(trackedCurrencies);
   const portfolioSummary = useMemo(
@@ -237,9 +262,12 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
     (value) => convertCurrency(value, accountState?.account.currency ?? "", config.baseCurrency, exchangeRates),
     accountState?.snapshotBasis,
   );
-  const sourceBankroll = netLiquidation != null && Number.isFinite(netLiquidation)
-    ? netLiquidation
-    : portfolioSummary.totalMktValue ?? 0;
+  const sourceBankroll = resolveKellyBankroll({
+    netLiquidation,
+    brokerPortfolio: !!activePortfolio?.brokerInstanceId,
+    holdings: portfolioSummary.allocationHoldings ?? [],
+    cashValue: manualCash ? convertCurrency(manualCash.amount, manualCash.currency, config.baseCurrency, exchangeRates) : null,
+  });
   const sourceCurrentValue = getPortfolioPositionValue({
     ticker,
     financials: positionFinancials,
@@ -250,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 }),
@@ -301,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 [];
@@ -400,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
@@ -415,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);
   };
@@ -436,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/portfolio.ts

@@ -2,6 +2,7 @@ import type { AppConfig } from "../../../types/config";
 import type { TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import { convertCurrency } from "../../../utils/format";
+import { allocationTotal, type AllocationHolding } from "../portfolio-list/allocation";
 import { getCollectionTypeFromConfig } from "../portfolio-list/pane/data";
 import { getPortfolioPositionMetrics, getPortfolioQuoteDisplay, resolvePortfolioMarketValue } from "../portfolio-list/position-metrics";
 
@@ -41,6 +42,30 @@ export function getPortfolioPositionValue({
     ?? (metrics.positionCount > 0 ? Number.NaN : 0);
 }
 
+/**
+ * What the portfolio is worth to bet with: its equity. A broker account's is
+ * its Net Liq. Otherwise it is the priced holdings at net value plus the cash
+ * entered for the portfolio, the portfolio header's Total. A broker portfolio
+ * with neither has no known equity: its positions alone are its gross, which
+ * margin puts above the equity, so it gives no bankroll.
+ */
+export function resolveKellyBankroll({
+  netLiquidation,
+  brokerPortfolio,
+  holdings,
+  cashValue,
+}: {
+  netLiquidation: number | null;
+  brokerPortfolio: boolean;
+  holdings: readonly AllocationHolding[];
+  /** Cash entered by hand, in the bankroll currency; NaN when it cannot be converted. */
+  cashValue: number | null;
+}): number {
+  if (netLiquidation != null && Number.isFinite(netLiquidation)) return netLiquidation;
+  if (brokerPortfolio && cashValue == null) return 0;
+  return allocationTotal(holdings, cashValue) ?? 0;
+}
+
 export function resolveActivePortfolioId({
   requestedPortfolioId,
   activeCollectionId,

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[];

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

@@ -1,8 +1,8 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
-import { loadMacroDayHistory } from "./client";
+import { loadMacroDayHistory, loadMacroReleases } from "./client";
 import { projectMacroDays, type MacroDayStats } from "./model";
-import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_RELEASE_BASIS } from "./releases";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_RELEASE_SOURCES, staleMacroReleasesNotice } from "./releases";
 
 // A mean that rounds to zero reads 0.00%, never -0.00%.
 const percent = (value: unknown) => typeof value !== "number" ? "--" : /[1-9]/.test((value * 100).toFixed(2)) ? `${(value * 100).toFixed(2)}%` : "0.00%";
@@ -11,12 +11,12 @@ const share = (value: unknown) => typeof value === "number" ? `${Math.round(valu
 
 export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
-  // Dated by the maintained release list as much as by the closes, so no session schedule applies.
+  // Dated by the release list (releasesThrough) as much as by the closes, so no session schedule applies.
   freshness: { status: "not-a-feed", basis: "release-day study on daily closes" },
   describe: (args) => `MDAY ${args.symbols[0] ?? ""}`,
   discovery: { screenshotReadiness: "live-dom", limitations: [
     "US listings; close-to-close on the release day.",
-    `Published CPI, jobs and FOMC days through ${MACRO_RELEASE_BASIS.coveredThrough}.`,
+    "Published CPI, jobs and FOMC days; sessions after the list's last covered day (releasesThrough) are left out.",
   ] },
   options: [
     { key: "release", type: "enum", values: [{ value: "all" }, ...MACRO_EVENT_KINDS.map((value) => ({ value }))], defaultValue: "all",
@@ -25,9 +25,11 @@ export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
   ],
   async load(args, ctx) {
     const instrument = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
-    const history = await loadMacroDayHistory({ instrument, signal: ctx.signal }, ctx.marketData);
+    const [history, releases] = await Promise.all([loadMacroDayHistory({ instrument, signal: ctx.signal }, ctx.marketData), loadMacroReleases()]);
     ctx.signal.throwIfAborted();
-    const model = projectMacroDays(history.history, { symbol: instrument.symbol, lookbackYears: Number(args.options.lookbackYears) || 5 });
+    const model = projectMacroDays(history.history, { symbol: instrument.symbol, lookbackYears: Number(args.options.lookbackYears) || 5,
+      releases: releases.releases, coveredThrough: releases.coveredThrough });
+    const releasesNotice = staleMacroReleasesNotice(releases);
     const row = (label: string, stats: MacroDayStats) => ({ label, ...stats });
     const release = String(args.options.release ?? "all");
     const events = release === "all" ? model.events : model.events.filter((event) => event.kind === release);
@@ -42,11 +44,12 @@ export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
           { key: "session", header: "Session" }, { key: "move", header: "Move", format: percent }, { key: "multiple", header: "vs normal", format: multiple }],
         rows: events.map((event) => ({ ...event, event: MACRO_EVENT_LABELS[event.kind] })) },
       ],
-      complete: !history.stale && !history.error && model.events.length > 0,
+      complete: !history.stale && !history.error && !releasesNotice && model.events.length > 0,
       unavailableSymbols: model.events.length ? [] : [instrument.symbol],
       errors: history.error ? [history.error] : [],
+      ...(releasesNotice ? { notes: [releasesNotice] } : {}),
       metadata: { unit: "decimal return, close to close on the release day", start: model.start, asOf: model.asOf,
-        releasesThrough: MACRO_RELEASE_BASIS.coveredThrough, releaseSources: MACRO_RELEASE_BASIS.sources,
+        releasesThrough: releases.coveredThrough, releaseSources: Object.values(MACRO_RELEASE_SOURCES),
         stale: history.stale, fetchedAt: history.fetchedAt, methodology: "docs/research-data.md#macro-day-reaction" },
     };
   },

package/src/plugins/builtin/macro-day/index.tsx

@@ -1,5 +1,6 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+import { macroReleaseCache } from "./client";
 import { macroDayHeadless } from "./headless";
 import { LOOKBACK_OPTIONS, MacroDayPane } from "./pane";
 
@@ -18,4 +19,6 @@ export const macroDayModule: PluginModule = {
     keywords: ["mday", "macro day", "cpi day", "fomc day", "jobs day", "nfp", "payrolls", "event study", "release reaction"],
     shortcut: "MDAY", publicShare: true,
   }), headless: macroDayHeadless }],
+  setup(ctx) { macroReleaseCache.attach(ctx.persistence); },
+  dispose() { macroReleaseCache.reset(); },
 };

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

@@ -1,6 +1,6 @@
 import type { PricePoint } from "../../../types/financials";
 import { zonedDateTimeParts } from "../../../utils/zoned-date-time";
-import { MACRO_EVENT_KINDS, MACRO_RELEASE_BASIS, macroReleases, type MacroEventKind, type MacroRelease } from "./releases";
+import { MACRO_EVENT_KINDS, type MacroEventKind, type MacroRelease } from "./releases";
 
 const DAY_MS = 86_400_000;
 /** Longest calendar gap between two closes that is still one session apart: Thursday to Monday over a Friday holiday. */
@@ -71,10 +71,11 @@ function stats(moves: number[], normalAbs: number | null): MacroDayStats {
 export function projectMacroDays(history: readonly PricePoint[], options: {
   symbol: string;
   lookbackYears: number;
-  releases?: readonly MacroRelease[];
-  coveredThrough?: string;
+  releases: readonly MacroRelease[];
+  /** The release list's last covered day. */
+  coveredThrough: string;
 }): MacroDayModel {
-  const coveredThrough = options.coveredThrough ?? MACRO_RELEASE_BASIS.coveredThrough;
+  const { coveredThrough } = options;
   const byDate = new Map<string, number>();
   for (const point of history) {
     const time = new Date(point.date).getTime();
@@ -90,7 +91,11 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   // Sessions after the published lists end may be unlisted release days, so they are left out of both sides.
   const end = last < coveredThrough ? last : coveredThrough;
   const startYear = Number(end.slice(0, 4)) - Math.max(1, options.lookbackYears);
-  const start = `${startYear}${end.slice(4)}`;
+  const nominalStart = `${startYear}${end.slice(4)}`;
+  // The history can begin after the nominal start (daily bars reach back five years from today, the list's end is older).
+  // The first bar has no close before it, so the window opens there: a release before it falls outside the stated start.
+  const firstSession = sessions[0]!;
+  const start = firstSession > nominalStart ? firstSession : nominalStart;
   /** Session date -> close-to-close move from the session before, when the two are one session apart. */
   const moves = new Map<string, number>();
   for (let index = 1; index < sessions.length; index++) {
@@ -101,7 +106,7 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
 
   const reactionSessions = new Set<string>();
   const found: Omit<MacroDayEvent, "multiple">[] = [];
-  for (const release of options.releases ?? macroReleases()) {
+  for (const release of options.releases) {
     if (release.date <= start || release.date > end || !isWeekday(release.date)) continue;
     const at = sessions.findIndex((date) => date >= release.date);
     if (at < 1) continue;

package/src/plugins/builtin/macro-day/pane.tsx

@@ -9,9 +9,9 @@ import { useAutoRefresh } from "../../../react/auto-refresh";
 import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
-import { loadMacroDayHistory } from "./client";
+import { loadMacroDayHistory, loadMacroReleases } from "./client";
 import { projectMacroDays, type MacroDayEvent, type MacroDayModel } from "./model";
-import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, type MacroEventKind } from "./releases";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, staleMacroReleasesNotice, type MacroEventKind } from "./releases";
 
 export const LOOKBACK_OPTIONS = [{ value: "1", label: "1Y" }, { value: "2", label: "2Y" }, { value: "3", label: "3Y" }, { value: "5", label: "5Y" }];
 const RELEASE_OPTIONS = [{ value: "all", label: "All" }, ...MACRO_EVENT_KINDS.map((kind) => ({ value: kind, label: MACRO_EVENT_LABELS[kind] }))];
@@ -64,22 +64,26 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
   const loader = useCallback(async (force: boolean) => {
     controller.current?.abort();
     controller.current = new AbortController();
-    const snapshot = await loadMacroDayHistory({ instrument: instrument!, forceRefresh: force, signal: controller.current.signal });
+    const [snapshot, releases] = await Promise.all([
+      loadMacroDayHistory({ instrument: instrument!, forceRefresh: force, signal: controller.current.signal }),
+      loadMacroReleases({ force }),
+    ]);
     if (!snapshot.history.length && snapshot.error) throw new Error(snapshot.error);
-    return snapshot;
+    return { ...snapshot, releases };
   }, [instrumentKey]);
   const history = useAsyncResource(instrument ? loader : null);
   useEffect(() => () => controller.current?.abort(), [loader]);
   useAutoRefresh(history.updatedAt, history.load);
   usePaneRefreshKey(() => { void history.reload(); }, { focused });
 
-  const model = useMemo(() => history.data ? projectMacroDays(history.data.history, { symbol: symbol ?? "", lookbackYears: Number(lookback) || 5 }) : null,
-    [history.data, lookback, symbol]);
+  const model = useMemo(() => history.data ? projectMacroDays(history.data.history, { symbol: symbol ?? "", lookbackYears: Number(lookback) || 5,
+    releases: history.data.releases.releases, coveredThrough: history.data.releases.coveredThrough }) : null, [history.data, lookback, symbol]);
+  const releasesNotice = history.data ? staleMacroReleasesNotice(history.data.releases) : null;
   const rows = useMemo(() => model ? model.events.filter((event) => release === "all" || event.kind === release) : [], [model, release]);
   const stats = useMemo(() => model?.events.length ? figures(model, release) : [], [model, release]);
 
   usePaneNoticeFooter({ registrationId: "macro-day-notices", focused,
-    notices: [...new Set([identityError, history.error, history.data?.error].filter((value): value is string => !!value))] });
+    notices: [...new Set([identityError, history.error, history.data?.error, releasesNotice].filter((value): value is string => !!value))] });
   usePaneFooter("macro-day", () => ({ info: [
     ...(history.loading ? [{ id: "loading", parts: [{ text: "loading history", tone: "muted" as const }] }] : []),
     ...(history.data?.stale ? [{ id: "stale", parts: [{ text: "stale history", tone: "warning" as const }] }] : []),
@@ -102,7 +106,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
       { id: "release", label: "Release", value: release, options: RELEASE_OPTIONS, onChange: setRelease, inline: true },
       { id: "lookback", label: "Lookback", value: String(lookback), options: LOOKBACK_OPTIONS, onChange: setLookback },
     ]} />
-    {!symbol ? <EmptyState title="Choose a ticker." /> : <PaneStatusBody subject="macro-day moves" loading={history.loading && !model}
+    {!symbol ? <EmptyState title="Select a ticker." /> : <PaneStatusBody subject="macro-day moves" loading={history.loading && !model}
       error={!model ? history.error ?? identityError ?? null : null} empty={!!model && !model.events.length}>
       {model ? <>
         <StatGrid items={stats} width={width} />