@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/company-kpis/pane.tsx

@@ -5,6 +5,7 @@ import type { KpiObservation } from "../../../api-client/company-kpis";
 import { listingAbroad } from "../../../api-client/paths";
 import { ChartTableHeader, DataTableStackView, DetailScrollBody, EmptyState, KeyValueRow, PaneStatusBody, QueryBar, SectionHeading,
   useChartTableSelection, usePaneMenuItems, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs, type DataTableCell, type PaneHint } from "../../../components";
+import { useCompanyDataFooter } from "../../../components/layout/pane/status-footer";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginAppActions, usePluginPaneState } from "../../../public/react";
 import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
@@ -20,7 +21,7 @@ import { Blurred, LockedOverlay, UpgradeLabel } from "../shared/locked-rows";
 import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
 import { cachedCompanyData, loadCompanyData, KPI_UNAVAILABLE, validateCompanyData, type CompanyDataset, type CompanyMode } from "./client";
 import { useCompanyEvidence } from "./screenshot-evidence";
-import { allGuidance, allObservations, basisLabel, changeText, changeTone, companyCellText, companyColumns, dimensionLabel, directionLabel, directionTone, guideGroupKey, guidanceSeries, fiscalLabel,
+import { allGuidance, allObservations, basisLabel, changeText, changeTone, companyCellText, companyColumns, companyEmptyState, dimensionLabel, directionLabel, directionTone, fitCompanyColumns, guideGroupKey, guidanceSeries, fiscalLabel,
   isGuidance, exactObservation, observationValue, observationChange, observationChart, periodOrder, outcomeLabel, QUIET_COLUMNS, rangeText, scopeWords, seriesDetail, seriesLabel, seriesLabels, seriesName,
   seriesOrder, unitLabel, valueText, companyPreviewNote, type CompanyRow } from "./model";
 import { PriceSparkline } from "../../../components/price-sparkline/view";
@@ -47,7 +48,7 @@ function DisclosureEvidence({ row, sourceId, onSource, width }: { row: CompanyRo
     <KeyValueRow label="Revision" value={`${row.revision}${row.current ? " · current" : " · superseded"}${!isGuidance(row) && (row.conflict || row.contested) ? " · conflicting disclosures" : ""}`} labelWidth={18} />
     {row.revisionReason ? <KeyValueRow label="Correction" value={row.revisionReason} labelWidth={18} /> : null}
     {isGuidance(row) ? <>
-      <KeyValueRow label="Issued" value={row.issuedDate} detail={directionLabel(row.direction)} labelWidth={18} />
+      <KeyValueRow label="Issued" value={row.issuedDate} detail={directionLabel(row)} labelWidth={18} />
       <KeyValueRow label="Source range" value={row.rangeText} labelWidth={18} />
       {row.conditions ? <KeyValueRow label="Conditions" value={row.conditions} labelWidth={18} /> : null}
       <KeyValueRow label="Later actual" value={row.actual ? valueText(row, row.actual.value) : "Pending"} detail={row.actual ? outcomeLabel(row) : undefined} labelWidth={18} />
@@ -130,7 +131,7 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
         : sort.column === "actual" ? guide?.actual?.value ?? null : sort.column === "outcome" ? guide ? outcomeLabel(guide) : null
         : sort.column === "basis" ? row.basis : sort.column === "unit" ? unitLabel(row) : sort.column === "scope" ? dimensionLabel(row.dimensions)
         : sort.column === "published" ? row.evidence[0]!.publishedAt : sort.column === "revision" ? row.revision
-        : sort.column === "quote" ? row.evidence[0]!.quote : sort.column === "change" ? guide ? guide.direction : observationChange(row as KpiObservation, observations).value
+        : sort.column === "quote" ? row.evidence[0]!.quote : sort.column === "change" ? guide ? directionLabel(guide) : observationChange(row as KpiObservation, observations).value
         : periodOrder(row);
     };
     const direction = sort.direction === "asc" ? 1 : -1;
@@ -158,8 +159,13 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
     }
     return map;
   }, [kpis]);
-  const columns = useMemo(() => withoutQuietColumns(companyColumns(mode === "guidance", tab === "evidence", tab === "history", mode === "kpis" && tab === "table" && trends.size > 0 && width >= 100, desktop),
-    rows, (row, id) => id === "basis" ? basisLabel(row.basis) : id === "scope" ? dimensionLabel(row.dimensions) || "Consolidated" : "", QUIET_COLUMNS), [mode, tab, trends, rows, width, desktop]);
+  const columns = useMemo(() => {
+    const shown = withoutQuietColumns(companyColumns(mode === "guidance", tab === "evidence", tab === "history", mode === "kpis" && tab === "table" && trends.size > 0 && width >= 100, desktop),
+      rows, (row, id) => id === "basis" ? basisLabel(row.basis) : id === "scope" ? dimensionLabel(row.dimensions) || "Consolidated" : "", QUIET_COLUMNS);
+    // Evidence is a wide ledger that scrolls; the other tabs fit the pane.
+    return tab === "evidence" ? shown : fitCompanyColumns(shown, width, tab === "history");
+  }, [mode, tab, trends, rows, width, desktop]);
+  const emptyState = companyEmptyState(mode, symbol ?? "", { tab, hasRows: allRows.length > 0 });
   const metricOptions = useMemo(() => [{ value: "all", label: "All metrics" }, ...[...new Map(allRows.map((row) => [row.metricId, { value: row.metricId, label: row.metric.name }])).values()]], [allRows]);
   const kpiChart = useMemo(() => observationChart(rows.filter((row): row is KpiObservation => !isGuidance(row)), colors.warning), [rows, colors.warning]);
   const series = useMemo(() => tab !== "chart" ? [] : mode === "kpis" ? kpiChart.series
@@ -190,6 +196,8 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
   usePaneNoticeFooter({ registrationId: "company-kpis:notices", focused, notices: [resource.data?.refreshError,
     data?.truncated && data.access === "full" ? "The response reached its stored-record limit. Narrow the metric or date range in a CLI or REST query." : null,
     data?.coverage.conflicts ? "Conflicting disclosures are retained in Evidence and excluded from comparable trends." : null].filter((value): value is string => !!value) });
+  // A receipt's or foreign line's disclosures are its company's, read from the home line.
+  useCompanyDataFooter(data?.companyFrom);
   if (!symbol) return <EmptyState title="Select a ticker." />;
   if (signInWall) return <SignInWall placement="company-kpis-signin" action={mode === "guidance" ? "view company guidance" : "view company KPIs"} needsVerification={session.needsVerification} />;
   const bodyHeight = Math.max(3, height - tabRows);
@@ -212,7 +220,7 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
       return { text: "", content: <PriceSparkline priceHistory={points} width={column.width} period="all" trend={tone === "muted" ? "neutral" : tone} /> };
     }
     if (column.id === "change") {
-      if (guide) return { text: directionLabel(guide.direction), color: toneColor(directionTone(guide.direction), colors), keepColorWhenSelected: guide.direction === "raised" || guide.direction === "cut" };
+      if (guide) return { text: directionLabel(guide), color: toneColor(directionTone(guide), colors), keepColorWhenSelected: guide.direction === "raised" || guide.direction === "cut" };
       const change = observationChange(row as KpiObservation, observations);
       return { text: changeText(change), value: change.value, color: toneColor(changeTone(row as KpiObservation, change.value), colors) };
     }
@@ -244,7 +252,7 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
         detailScrollRef={detailScrollRef} detailContent={openRow ? <DetailScrollBody ref={detailScrollRef} resetScrollKey={openRow.id}><DisclosureEvidence row={openRow} sourceId={sourceId} onSource={setSource} width={width} /></DetailScrollBody> : null}
         sortColumnId={sort.column} sortDirection={sort.direction} onHeaderClick={(column) => setSort((previous) => ({ column, direction: previous.column === column && previous.direction === "desc" ? "asc" : "desc" }))}
         resetScrollKey={`${mode}:${symbol}:${tab}:${metric}:${activePlot}`}
-        emptyStateTitle={tab === "history" ? "Actuals have not been matched to these guidance periods yet." : "No disclosed observations for this selection yet."}
+        emptyStateTitle={emptyState.title} emptyStateHint={emptyState.hint}
         rootBefore={<ChartTableHeader width={width} height={bodyHeight} tableRows={items.length} tableColumns={columns} query={query}
           chart={tab === "chart" ? { series, ...(mode === "kpis" ? { xAxis: kpiChart.xAxis, viewport: kpiChart.viewport } : {}), empty: preview ? "Full history is available with Pro." : "History is accumulating. Two comparable disclosures are needed for a trend.",
             formatValue: (value) => selected ? `${valueText(selected, value)}${selected.currency ? ` ${unitLabel(selected)}` : ""}` : String(value),

package/src/plugins/builtin/composite-plugins.ts

@@ -14,6 +14,7 @@ import { portfolioAnalyticsModule } from "./analytics";
 import { brokerTradingModule } from "./broker-trading";
 import { brokerManagerModule } from "./broker-manager";
 import { changelogModule } from "./changelog";
+import { roadmapModule } from "./roadmap";
 import { connectionsModule } from "./connections";
 import { pluginMarketplaceModule } from "./plugin-marketplace";
 import { relativeRotationModule } from "./relative-rotation";
@@ -116,7 +117,7 @@ import { FIXED_INCOME_HOSTS } from "./fixed-income/model";
 
 export const applicationPlugin = composeBuiltinPlugin({
   ...applicationPluginMeta,
-  modules: [layoutManagerModule, pluginMarketplaceModule, helpModule, changelogModule, connectionsModule, docsModule],
+  modules: [layoutManagerModule, pluginMarketplaceModule, helpModule, changelogModule, connectionsModule, docsModule, roadmapModule],
 });
 
 export const portfolioPlugin = composeBuiltinPlugin({

package/src/plugins/builtin/correlation/headless.ts

@@ -8,8 +8,9 @@ import { buildCorrelationMatrix, buildCorrelationSeries, buildGeoCorrelationSeri
 import { geoSeriesToken, loadGeoCorrelationHistory } from "./geo";
 import { buildRelationshipAnalysis, DEFAULT_RELATIONSHIP_SECOND_SYMBOL } from "./relationship/model";
 import { paneSchemas } from "./headless-schema";
-import { CORRELATION_RETURN_BASIS, GEO_CORRELATION_CHANGE_BASIS, loadCorrelationHistory } from "./history";
+import { CORRELATION_RETURN_BASIS, GEO_CORRELATION_CHANGE_BASIS, loadCorrelationHistory, unfinishedBarFreshness } from "./history";
 import type { HeadlessPaneContext } from "../../../types/headless";
+import type { PricePoint } from "../../../types/financials";
 import { newestReportTime } from "../../../utils/utc-time";
 import { DAILY_CLOSES } from "../shared/report-freshness";
 
@@ -34,9 +35,13 @@ async function loadListedHistory(ctx: HeadlessPaneContext, key: string, range: T
 }
 
 /** A ticker's daily closes, or a map series' daily values read straight from the Cloud client. */
-async function loadCorrelationInput(ctx: HeadlessPaneContext, key: string, range: TimeRange): Promise<CorrelationSeries> {
+async function loadCorrelationInput(ctx: HeadlessPaneContext, key: string, range: TimeRange, onBars?: (bars: PricePoint[]) => void): Promise<CorrelationSeries> {
   const geo = geoSeriesToken(key);
-  if (!geo) return buildCorrelationSeries(key, await loadHistory(ctx, key, range));
+  if (!geo) {
+    const bars = await loadHistory(ctx, key, range);
+    onBars?.(bars);
+    return buildCorrelationSeries(key, bars);
+  }
   const request = <T,>(path: string, init?: RequestInit) => ctx.apiClient.geo<T>(path, { ...init, signal: init?.signal ?? ctx.signal });
   return buildGeoCorrelationSeries(key, await loadGeoCorrelationHistory(request, geo, range, ctx.signal));
 }
@@ -53,7 +58,8 @@ export const correlationHeadless: HeadlessPaneDefinition<"rows"> = {
   ],
   async load({ symbols, options }, ctx) {
     const range = (options.rangePreset ?? "1Y") as TimeRange;
-    const loaded = await loadHeadlessSymbols(symbols, ctx, (symbol) => loadCorrelationInput(ctx, symbol, range));
+    const bars = new Map<string, PricePoint[]>();
+    const loaded = await loadHeadlessSymbols(symbols, ctx, (symbol) => loadCorrelationInput(ctx, symbol, range, (points) => bars.set(symbol, points)));
     const bySymbol = new Map(loaded.entries.map(({ symbol, data }) => [symbol, data]));
     const matrix = buildCorrelationMatrix(symbols, bySymbol);
     const rows = symbols.flatMap((left, index) => symbols.slice(index + 1).map((right) => {
@@ -68,8 +74,9 @@ export const correlationHeadless: HeadlessPaneDefinition<"rows"> = {
         ? "Inconsistent OHLC history"
         : row.sampleSize < 5 ? "Insufficient shared return observations" : "Zero return variance",
     }));
+    const asOf = newestReportTime(symbols.map((symbol) => bySymbol.get(symbol)?.prices.at(-1)?.dateKey));
     return {
-      freshness: { asOf: newestReportTime(symbols.map((symbol) => bySymbol.get(symbol)?.prices.at(-1)?.dateKey)) },
+      freshness: { asOf, ...unfinishedBarFreshness([...bars.values()], asOf?.slice(0, 10)) },
       rows, unavailableSymbols,
       errors: [
         ...loaded.errors,
@@ -132,6 +139,7 @@ export const relationshipHeadless: HeadlessPaneDefinition<"series"> = {
         })),
         { key: "returnCount", label: "Shared returns", value: analysis.stats?.sampleSize ?? analysis.returns.length },
       ],
+      freshness: unfinishedBarFreshness([...histories.values()], analysis.aligned.at(-1)?.dateKey) ?? {},
       unavailableSymbols: [...new Set(unavailableSymbols)],
       errors: [...loaded.errors, ...(analysis.unavailableReason ? [analysis.unavailableReason] : []),
         ...(analysis.correlationUnavailableReason ? [analysis.correlationUnavailableReason] : [])],

package/src/plugins/builtin/correlation/history.ts

@@ -2,6 +2,9 @@ import type { AssetDataProvider, MarketDataRequestContext } from "../../../types
 import type { TimeRange } from "../../../time-series/range";
 import type { ManualChartResolution } from "../../../time-series/resolution";
 import { clipPriceHistoryToRange } from "../../../time-series/history-window";
+import { DAY_SO_FAR_TEXT } from "../../../time-series/session-bar";
+import type { PricePoint } from "../../../types/financials";
+import type { HeadlessPaneFreshness } from "../../../types/headless";
 
 /** Risk views need daily closes even when a chart preset defaults to intraday or weekly bars. */
 export const CORRELATION_HISTORY_RESOLUTION: ManualChartResolution = "1d";
@@ -16,6 +19,25 @@ export async function loadCorrelationHistory(
   return clipPriceHistoryToRange(points, range);
 }
 
+/**
+ * What an analysis of daily closes says when its newest day is a bar the source
+ * has not finished: a coin's UTC day or a future's session under way
+ * (`partial`), or a future's last trade before its settlement (`unsettled`).
+ * That day is no close, so the line calls the bars daily bars and says so, as
+ * `history` does, instead of dating a close by it. Nothing when `day` (the
+ * newest date the analysis uses) is a finished bar in every history.
+ */
+export function unfinishedBarFreshness(
+  histories: ReadonlyArray<ReadonlyArray<Pick<PricePoint, "date" | "partial" | "unsettled">> | undefined>,
+  day: string | null | undefined,
+): Pick<HeadlessPaneFreshness, "basis" | "note"> | null {
+  if (!day) return null;
+  const bars = histories.flatMap((history) => history?.filter((point) => new Date(point.date).toISOString().slice(0, 10) === day) ?? []);
+  if (bars.some((bar) => bar.partial)) return { basis: "daily bars", note: `the newest bar is ${DAY_SO_FAR_TEXT}` };
+  if (bars.some((bar) => bar.unsettled)) return { basis: "daily bars", note: "the newest bar is not yet settled" };
+  return null;
+}
+
 export const CORRELATION_RETURN_BASIS = "Local-price close-to-close returns between shared UTC dates; cash distributions and FX conversion are excluded, and exchange closing times may differ.";
 
 export const GEO_CORRELATION_CHANGE_BASIS = "Map series (GEO:) use the change in daily value between the same shared UTC dates, because counts such as transits can be zero.";

package/src/plugins/builtin/cot/client.ts

@@ -1,5 +1,5 @@
 import { apiClient } from "../../../api-client";
-import type { CotBoardPayload, CotClass, CotClassSummary, CotContractPayload, CotFamily, CotPayloadBase } from "../../../api-client/cot";
+import type { CotBoardPayload, CotClass, CotClassSummary, CotContractPayload, CotFamily, CotPayloadBase, CotPositions } from "../../../api-client/cot";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import type { PricePoint } from "../../../types/financials";
@@ -12,8 +12,8 @@ const date = (value: unknown): value is string => typeof value === "string" && /
 const number = (value: unknown) => value === null || typeof value === "number" && Number.isFinite(value);
 const count = (value: unknown) => value === null || typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 const code = (value: unknown) => typeof value === "string" && /^[0-9A-Z]{5}[0-9A-Z+]$/.test(value);
-function base(data: CotPayloadBase, family: CotFamily) {
-  if (!data || data.source !== "CFTC" || data.scope !== "futures-only" || data.reportFamily !== family
+function base(data: CotPayloadBase, family: CotFamily, positions: CotPositions) {
+  if (!data || data.source !== "CFTC" || data.scope !== positions || data.reportFamily !== family
     || !Array.isArray(data.gaps) || !data.gaps.every((gap) => typeof gap === "string")
     || !Array.isArray(data.classes) || data.classes.some((row) => !COT_CLASSES[family].some((option) => option.value === row.id))
     || data.asOf !== null && !date(data.asOf) || !Number.isFinite(Date.parse(data.generatedAt))
@@ -33,8 +33,8 @@ function summary(row: CotClassSummary, family: CotFamily) {
     }
   }
 }
-function validateCotBoard(data: CotBoardPayload, family: CotFamily, traderClass: CotClass) {
-  base(data, family);
+function validateCotBoard(data: CotBoardPayload, family: CotFamily, traderClass: CotClass, positions: CotPositions) {
+  base(data, family, positions);
   if (!Array.isArray(data.rows) || data.traderClass !== traderClass) throw new Error("The server returned an invalid COT board");
   const seen = new Set<string>();
   for (const row of data.rows) {
@@ -44,8 +44,8 @@ function validateCotBoard(data: CotBoardPayload, family: CotFamily, traderClass:
   }
   return data;
 }
-export function validateCotContract(data: CotContractPayload, family: CotFamily, contractCode: string) {
-  base(data, family);
+export function validateCotContract(data: CotContractPayload, family: CotFamily, contractCode: string, positions: CotPositions = "futures-only") {
+  base(data, family, positions);
   if (data.contract !== null && data.contract.contractCode !== contractCode || !Array.isArray(data.positions) || !Array.isArray(data.history)) {
     throw new Error("The server returned an invalid COT contract");
   }
@@ -63,30 +63,34 @@ export function validateCotContract(data: CotContractPayload, family: CotFamily,
   return data;
 }
 const unavailable = (error: unknown) => unavailableOnServer(error, "COT history is not available yet.", [404, 503]);
-export async function fetchCotBoard(family: CotFamily, traderClass: CotClass, client: Pick<typeof apiClient, "getCloudCotBoard"> = apiClient) {
-  try { return validateCotBoard(await client.getCloudCotBoard(family, traderClass), family, traderClass); }
+export async function fetchCotBoard(family: CotFamily, traderClass: CotClass, client: Pick<typeof apiClient, "getCloudCotBoard"> = apiClient, positions: CotPositions = "futures-only") {
+  try { return validateCotBoard(await client.getCloudCotBoard(family, traderClass, positions), family, traderClass, positions); }
   catch (error) { throw unavailable(error); }
 }
-const cotBoardKey = (family: CotFamily, traderClass: CotClass) => `${family}:${traderClass}`;
+// Futures-only boards keep the key they always had, so a cached board still opens.
+const cotBoardKey = (family: CotFamily, traderClass: CotClass, positions: CotPositions) =>
+  positions === "combined" ? `${family}:${traderClass}:combined` : `${family}:${traderClass}`;
 const presentCotBoard = (payload: CotBoardPayload, stale: boolean, refreshError: string | null) => ({
   ...payload, gaps: [...payload.gaps, ...(refreshError ? [refreshError] : [])],
   status: stale && payload.status === "available" ? "partial" as const : payload.status,
 });
-export function cachedCotBoard(family: CotFamily, traderClass: CotClass) {
-  const cached = cachedCloudResource(cotBoardCache, cotBoardKey(family, traderClass), (payload) => validateCotBoard(payload, family, traderClass));
+export function cachedCotBoard(family: CotFamily, traderClass: CotClass, positions: CotPositions = "futures-only") {
+  const cached = cachedCloudResource(cotBoardCache, cotBoardKey(family, traderClass, positions), (payload) => validateCotBoard(payload, family, traderClass, positions));
   return cached ? presentCotBoard(cached.payload, false, null) : null;
 }
-export async function loadCotBoard(family: CotFamily, traderClass: CotClass, force = false) {
-  const { payload, stale, refreshError } = await loadCloudResource(cotBoardCache, cotBoardKey(family, traderClass), () => fetchCotBoard(family, traderClass), { force });
+export async function loadCotBoard(family: CotFamily, traderClass: CotClass, force = false, positions: CotPositions = "futures-only") {
+  const { payload, stale, refreshError } = await loadCloudResource(cotBoardCache, cotBoardKey(family, traderClass, positions),
+    () => fetchCotBoard(family, traderClass, apiClient, positions), { force });
   return presentCotBoard(payload, stale, refreshError);
 }
-export async function fetchCotContract(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract"> = apiClient) {
-  try { return validateCotContract(await client.getCloudCotContract(contractCode, family), family, contractCode); }
+export async function fetchCotContract(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract"> = apiClient, positions: CotPositions = "futures-only") {
+  try { return validateCotContract(await client.getCloudCotContract(contractCode, family, positions), family, contractCode, positions); }
   catch (error) { throw unavailable(error); }
 }
 export interface CotDetailData { payload: CotContractPayload; price: PricePoint[]; priceSymbol: string | null; priceAsOf: string | null; priceWarning: string | null }
-export async function loadCotDetail(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract" | "getCloudHistory"> = apiClient): Promise<CotDetailData> {
-  const payload = await fetchCotContract(contractCode, family, client);
+export async function loadCotDetail(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract" | "getCloudHistory"> = apiClient,
+  positions: CotPositions = "futures-only"): Promise<CotDetailData> {
+  const payload = await fetchCotContract(contractCode, family, client, positions);
   const mapping = cotPriceMapping(contractCode);
   // An unmapped market simply has no price panel; that is not a data failure.
   if (!mapping?.priceSymbol) return { payload, price: [], priceSymbol: null, priceAsOf: null, priceWarning: null };

package/src/plugins/builtin/cot/headless.ts

@@ -1,7 +1,7 @@
 import type { CotClass, CotClassSummary, CotContractPayload, CotHistoryPoint } from "../../../api-client/cot";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchCotBoard, fetchCotContract } from "./client";
-import { COT_MAJOR_CODES, COT_SCOPES, cotClass, cotContractCode, cotContractUnitText, cotInteger, cotMarketName, cotScope, cotUnknownMarketMessage } from "./model";
+import { COT_CLASSES, COT_FAMILIES, COT_MAJOR_CODES, COT_POSITIONS, COT_SCOPES, cotClass, cotContractCode, cotContractUnitText, cotFamily, cotInteger, cotMarketName, cotPositions, cotPositionsText, cotScope, cotUnknownMarketMessage } from "./model";
 import { COMMODITIES_VIEW_STATE } from "../commodities-energy/view-state";
 import { REPORT_ROWS } from "../shared/headless-options";
 
@@ -24,9 +24,11 @@ function cotPositionRow(row: CotClassSummary) {
  */
 function cotContractTitle(data: CotContractPayload, code: string): string {
   const units = cotContractUnitText(data.contract?.contractUnits);
-  return [data.contract ? cotMarketName(data.contract.marketName) : code, data.asOf ? `report date ${data.asOf}` : null, units]
-    .filter(Boolean).join("  ·  ");
+  return [data.contract ? cotMarketName(data.contract.marketName) : code, data.asOf ? `report date ${data.asOf}` : null, units,
+    data.scope === "combined" ? cotPositionsText(data.scope) : null].filter(Boolean).join("  ·  ");
 }
+/** Every trader class of every report, each once, in the reports' order. */
+const TRADER_CLASSES = [...new Set(Object.values(COT_CLASSES).flat().map(({ value }) => value))];
 
 /** The weekly reports newest first, the newest `limit` of them when given. */
 function cotWeeklyRows(history: readonly CotHistoryPoint[], limit: number | null): CotHistoryPoint[] {
@@ -47,22 +49,25 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
   // Tuesday positions published the Friday after; two weeks without a new report means one was missed.
   freshness: { source: "CFTC", status: "not-a-feed", basis: "weekly report", maxAgeMinutes: 14 * 24 * 60 },
   argument: { kind: "free-text", optional: true, placeholder: "code or name", description: "Futures root (KC), commodity name (coffee) or CFTC market code; omit for the extremes board." },
-  options: [{ key: "report", type: "enum", values: [{ value: "legacy" }, { value: "disaggregated" }], defaultValue: "legacy", description: "CFTC report family." },
-    { key: "traderClass", type: "enum", values: ["noncommercial", "commercial", "producer", "swap", "managed-money", "other-reportable", "nonreportable"].map((value) => ({ value })), description: "Trader class for the extremes board; defaults by report family.",
+  options: [{ key: "report", type: "enum", values: COT_FAMILIES.map(({ value }) => ({ value })), defaultValue: "legacy", description: "CFTC report: legacy, disaggregated, or tff (Traders in Financial Futures)." },
+    { key: "traderClass", type: "enum", values: TRADER_CLASSES.map((value) => ({ value })), description: "Trader class for the extremes board; defaults by report family.",
       pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "class" } },
+    { key: "positions", type: "enum", values: COT_POSITIONS.map(({ value }) => ({ value })), defaultValue: "futures-only", description: "Futures positions only, or futures and options combined, as in the pane.",
+      pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "positions" } },
     { key: "scope", type: "enum", values: COT_SCOPES.map(({ value }) => ({ value })), defaultValue: "major", description: "Markets on the extremes board, as in the pane.",
       pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "scope" } },
     // Weekly reports come newest first, so --tail asks for the same newest n as --limit.
     { key: "limit", type: "integer", aliases: ["tail", "weeks", "rows"], minimum: 1, maximum: 2000, shot: REPORT_ROWS,
       description: "Newest weekly reports a market lists; every one by default." }],
-  discovery: { aliases: ["COT", "CFTC"], dataRequirements: ["Gloom Cloud CFTC history"], limitations: ["Futures-only positions aggregate all maturities.", "Legacy and disaggregated classes differ.", "Observation date is not publication date.", "Some markets have short or suppressed histories."] },
+  discovery: { aliases: ["COT", "CFTC"], dataRequirements: ["Gloom Cloud CFTC history"], limitations: ["Positions aggregate all maturities; combined adds options, delta-adjusted.", "Legacy, disaggregated and TFF classes differ.", "Observation date is not publication date.", "Some markets have short or suppressed histories."] },
   describe: "CFTC positioning",
   async load(args, ctx) {
-    const family = args.options.report === "disaggregated" ? "disaggregated" : "legacy";
+    const family = cotFamily(args.options.report);
+    const positions = cotPositions(args.options.positions);
     if (args.argument) {
       const code = cotContractCode(args.argument);
       if (!code) throw new Error(cotUnknownMarketMessage(args.argument));
-      const data = await fetchCotContract(code, family, ctx.apiClient);
+      const data = await fetchCotContract(code, family, ctx.apiClient, positions);
       const classes = data.positions.map((row) => row.id);
       const limit = args.options.limit == null ? null : Number(args.options.limit);
       const weeks = cotWeeklyRows(data.history, limit);
@@ -80,9 +85,9 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
     const traderClass = cotClass(family, args.options.traderClass);
     if (args.options.traderClass && traderClass !== args.options.traderClass) throw new Error("Trader class does not belong to this report family");
     const scope = cotScope(args.options.scope);
-    const data = await fetchCotBoard(family, traderClass, ctx.apiClient);
+    const data = await fetchCotBoard(family, traderClass, ctx.apiClient, positions);
     const rows = data.rows.filter((row) => scope === "all" || COT_MAJOR_CODES.has(row.contractCode));
-    return { sections: [{ title: "Positioning extremes",
+    return { sections: [{ title: positions === "combined" ? `Positioning extremes  ·  ${cotPositionsText(positions)}` : "Positioning extremes",
       columns: [{ key: "marketName", header: "Market" }, { key: "contractCode", header: "Code" }, ...POSITION_COLUMNS,
         { key: "openInterest", header: "Open interest", align: "right", format: count }, { key: "reportDate", header: "As of" }],
       rows: rows.map((row) => ({ contractCode: row.contractCode, marketName: cotMarketName(row.marketName), reportDate: row.reportDate, openInterest: row.openInterest, ...cotPositionRow(row.position) })) }],

package/src/plugins/builtin/cot/model.ts

@@ -1,4 +1,4 @@
-import type { CotClass, CotContractPayload, CotFamily, CotHistoryPoint } from "../../../api-client/cot";
+import type { CotClass, CotContractPayload, CotFamily, CotHistoryPoint, CotPositions } from "../../../api-client/cot";
 import { staticSeries } from "../../../components/chart/static/series";
 import type { ResolvedSeries } from "../../../time-series/types";
 import type { PricePoint } from "../../../types/financials";
@@ -10,7 +10,20 @@ import { bestNameMatch, FUTURES_CONTRACTS, futuresBoardContract, futuresBoardCon
 export const COT_CLASSES: Record<CotFamily, Array<{ value: CotClass; label: string }>> = {
   legacy: [{ value: "noncommercial", label: "Noncommercial" }, { value: "commercial", label: "Commercial" }, { value: "nonreportable", label: "Nonreportable" }],
   disaggregated: [{ value: "managed-money", label: "Managed Money" }, { value: "producer", label: "Producer/Merchant" }, { value: "swap", label: "Swap Dealers" }, { value: "other-reportable", label: "Other Reportables" }, { value: "nonreportable", label: "Nonreportable" }],
+  tff: [{ value: "leveraged-funds", label: "Leveraged Funds" }, { value: "asset-manager", label: "Asset Manager/Institutional" }, { value: "dealer", label: "Dealer/Intermediary" }, { value: "other-reportable", label: "Other Reportables" }, { value: "nonreportable", label: "Nonreportable" }],
 };
+/** The three CFTC reports, as the pane's tabs and `--report` name them. */
+export const COT_FAMILIES: ReadonlyArray<{ value: CotFamily; label: string }> = [
+  { value: "legacy", label: "Legacy" }, { value: "disaggregated", label: "Disaggregated" }, { value: "tff", label: "Financial (TFF)" },
+];
+export function cotFamily(value: unknown): CotFamily { return value === "disaggregated" || value === "tff" ? value : "legacy"; }
+/** Futures alone, as before, or futures and options combined. */
+export const COT_POSITIONS: ReadonlyArray<{ value: CotPositions; label: string }> = [
+  { value: "futures-only", label: "Futures only" }, { value: "combined", label: "Futures + options" },
+];
+export function cotPositions(value: unknown): CotPositions { return value === "combined" ? "combined" : "futures-only"; }
+/** How a status line names the positions counted: "futures only" or "futures + options". */
+export const cotPositionsText = (positions: CotPositions) => positions === "combined" ? "futures + options" : "futures only";
 const ROOTS: Record<string, { code: string; exchange: string; priceSymbol: string | null; name: string; crypto?: true }> = {
   ZN: { code: "043602", exchange: "CBT", priceSymbol: "ZN=F", name: "10-Year T-Note" },
   ZQ: { code: "045601", exchange: "CBT", priceSymbol: "ZQ=F", name: "30-Day Fed Funds" },

package/src/plugins/builtin/cot/pane.tsx

@@ -6,16 +6,15 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import type { ResolvedSeries } from "../../../time-series/types";
 import type { CompositeAxisDomain } from "../../../components/chart/composite/types";
-import type { CotBoardRow, CotClass, CotClassSummary, CotFamily } from "../../../api-client/cot";
+import type { CotBoardRow, CotClass, CotClassSummary, CotFamily, CotPositions } from "../../../api-client/cot";
 import { isAccessDenied } from "../../../api-client/errors";
 import { Box } from "../../../ui";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { compareSortValues, nextHeaderSort, type SortPreference } from "../../../utils/sort-values";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { cachedCotBoard, loadCotBoard, loadCotDetail } from "./client";
-import { COT_CLASSES, COT_MAJOR_CODES, COT_SCOPES, cotChartSeries, cotClass, cotContractUnitText, cotInteger, cotLegendValue, cotMarketName, cotScope, type CotScope } from "./model";
+import { COT_CLASSES, COT_FAMILIES, COT_MAJOR_CODES, COT_POSITIONS, COT_SCOPES, cotChartSeries, cotClass, cotContractUnitText, cotFamily, cotInteger, cotLegendValue, cotMarketName, cotPositions, cotPositionsText, cotScope, type CotScope } from "./model";
 
-const FAMILIES = [{ value: "legacy", label: "Legacy" }, { value: "disaggregated", label: "Disaggregated" }];
 const BOARD_COLUMNS: DataTableColumn[] = [
   { id: "name", label: "MARKET", width: 30, align: "left", flexGrow: 1 },
   { id: "code", label: "CODE", width: 7, align: "left" },
@@ -44,8 +43,9 @@ const cotDetailTitle = (name: string | undefined, code: string | null) => name ?
 
 export function CotPane(props: PaneProps) {
   const pane = usePaneInstance();
-  const [family, setFamily] = usePluginPaneState<CotFamily>("report", pane?.settings?.report === "disaggregated" ? "disaggregated" : "legacy");
-  const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: FAMILIES, activeValue: family, onSelect: (value) => setFamily(value as CotFamily), focused: props.focused, dense: true });
+  const [storedFamily, setFamily] = usePluginPaneState<CotFamily>("report", cotFamily(pane?.settings?.report));
+  const family = cotFamily(storedFamily);
+  const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: [...COT_FAMILIES], activeValue: family, onSelect: (value) => setFamily(value as CotFamily), focused: props.focused, dense: true });
   return <Box width={props.width} height={props.height} flexDirection="column">
     {tabStrip}
     <CotBoard key={family} {...props} height={Math.max(3, props.height - tabRows)} family={family} initialCode={pane?.params?.code ?? null} />
@@ -63,14 +63,18 @@ function CotBoard({ width, height, focused, family, initialCode }: PaneProps & {
   const open = storedOpen || null;
   const [storedScope, setScope] = usePluginPaneState<CotScope>("scope", "major");
   const scope = cotScope(storedScope);
+  // Futures only, as the pane always read, unless futures and options combined is picked.
+  const [storedPositions, setPositions] = usePluginPaneState<CotPositions>("positions", "futures-only");
+  const positions = cotPositions(storedPositions);
   const [query, setQuery] = useState("");
   const { active: searching, focus: focusSearch, searchProps } = useQueryBarSearch();
   const [sort, setSort] = useState<SortPreference<string>>({ columnId: null, direction: "desc" });
   const control = useRef<SelectControl>(null);
   const scopeControl = useRef<SelectControl>(null);
-  const loader = useCallback((force: boolean) => loadCotBoard(family, traderClass, force), [family, traderClass, session.requestKey]);
-  const resource = useAsyncResource(loader, { initialData: () => cachedCotBoard(family, traderClass), clearOnError: isAccessDenied });
-  const data = resource.data?.traderClass === traderClass ? resource.data : null;
+  const positionsControl = useRef<SelectControl>(null);
+  const loader = useCallback((force: boolean) => loadCotBoard(family, traderClass, force, positions), [family, traderClass, positions, session.requestKey]);
+  const resource = useAsyncResource(loader, { initialData: () => cachedCotBoard(family, traderClass, positions), clearOnError: isAccessDenied });
+  const data = resource.data?.traderClass === traderClass && resource.data.scope === positions ? resource.data : null;
   const rows = useMemo(() => {
     // A typed query searches every market; the scope only shapes the unsearched board.
     const result = (data?.rows ?? []).filter((row) => query ? `${row.marketName} ${row.contractCode}`.toLowerCase().includes(query.toLowerCase())
@@ -90,15 +94,17 @@ function CotBoard({ width, height, focused, family, initialCode }: PaneProps & {
     if (!boardShown) return;
     if (event.name === "c") { event.preventDefault(); control.current?.open(); }
     if (event.name === "s") { event.preventDefault(); scopeControl.current?.open(); }
+    if (event.name === "p") { event.preventDefault(); positionsControl.current?.open(); }
   });
   usePaneFooter("cot:actions", () => ({ hints: boardShown ? [
     { id: "class", key: "c", label: "class", onPress: () => control.current?.open() },
     { id: "scope", key: "s", label: "cope", onPress: () => scopeControl.current?.open() },
+    { id: "positions", key: "p", label: "ositions", onPress: () => positionsControl.current?.open() },
     { id: "search", key: "/", label: "search", onPress: focusSearch },
   ] : [] }), [boardShown, focusSearch]);
   usePaneNoticeFooter({ registrationId: "cot:board-notices", focused, enabled: !open, notices: data?.gaps ?? [] });
   usePaneStatusFooter({ registrationId: "cot:board", enabled: !open, loading: resource.loading, error: resource.error,
-    info: data ? [{ id: "as-of", parts: [{ text: `CFTC futures only · ${data.asOf ?? "--"} · contracts`, tone: "muted" }] }] : [] });
+    info: data ? [{ id: "as-of", parts: [{ text: `CFTC ${cotPositionsText(positions)} · ${data.asOf ?? "--"} · contracts`, tone: "muted" }] }] : [] });
   // A class change reloads under the query bar, which stays.
   return <DataTableStackView<CotBoardRow> columns={BOARD_COLUMNS} items={rows} focused={focused && !searching}
     status={data ? undefined : { loading: resource.loading, error: resource.error, empty: !resource.loading && !resource.error, subject: "COT history" }}
@@ -118,11 +124,12 @@ function CotBoard({ width, height, focused, family, initialCode }: PaneProps & {
       filters={[
         { id: "class", label: "Class", value: traderClass, options: COT_CLASSES[family], onChange: setClass, controlRef: control },
         { id: "scope", label: "Scope", value: scope, defaultValue: "major", options: [...COT_SCOPES], onChange: setScope, controlRef: scopeControl },
+        { id: "positions", label: "Positions", value: positions, defaultValue: "futures-only", options: [...COT_POSITIONS], onChange: setPositions, controlRef: positionsControl },
       ]} />}
     emptyStateTitle={data ? query ? "No matching COT markets." : "No major markets in this report; switch the scope to all markets." : ""} detailOpen={!!open} onBack={() => setOpen("")}
     detailTitle={cotDetailTitle(data?.rows.find((row) => row.contractCode === open)?.marketName, open)}
-    detailContent={open ? <CotDetail key={`${family}:${open}`} width={width} height={Math.max(3, height - 1)} focused={focused}
-      code={open} family={family} traderClass={traderClass} onClassChange={setClass} /> : null} />;
+    detailContent={open ? <CotDetail key={`${family}:${positions}:${open}`} width={width} height={Math.max(3, height - 1)} focused={focused}
+      code={open} family={family} positions={positions} traderClass={traderClass} onClassChange={setClass} /> : null} />;
 }
 
 /**
@@ -147,10 +154,10 @@ function CotChart({ series, width, height }: { series: ResolvedSeries[]; width:
     remoteKind="cot-history" />;
 }
 
-function CotDetail({ width, height, focused, code, family, traderClass, onClassChange }: Pick<PaneProps, "width" | "height" | "focused"> & { code: string; family: CotFamily; traderClass: CotClass; onClassChange: (value: CotClass) => void }) {
+function CotDetail({ width, height, focused, code, family, positions, traderClass, onClassChange }: Pick<PaneProps, "width" | "height" | "focused"> & { code: string; family: CotFamily; positions: CotPositions; traderClass: CotClass; onClassChange: (value: CotClass) => void }) {
   const colors = useThemeColors();
   const session = useResearchCloudSession();
-  const loader = useCallback(() => loadCotDetail(code, family), [code, family, session.requestKey]);
+  const loader = useCallback(() => loadCotDetail(code, family, undefined, positions), [code, family, positions, session.requestKey]);
   const resource = useAsyncResource(loader, { clearOnError: isAccessDenied });
   const data = resource.data;
   const payload = data?.payload;
@@ -178,7 +185,8 @@ function CotDetail({ width, height, focused, code, family, traderClass, onClassC
   usePaneNoticeFooter({ registrationId: "cot:detail-notices", focused, notices: [...(payload?.gaps ?? []), ...(data?.priceWarning ? [data.priceWarning] : []), ...partialRanks] });
   usePaneStatusFooter({ registrationId: "cot:detail", loading: resource.loading, error: resource.error,
     // The unit the net is counted in, as `fn COT` titles it: what one contract is, where the report says.
-    info: payload ? [{ id: "as-of", parts: [{ text: `CFTC ${payload.asOf ?? "--"} · ${cotContractUnitText(payload.contract?.contractUnits) ?? "contracts"}${data?.priceAsOf ? ` · ${data.priceSymbol} ${data.priceAsOf}` : ""}`, tone: "muted" }] }] : [] });
+    // Futures and options combined says so; futures only reads as it always has.
+    info: payload ? [{ id: "as-of", parts: [{ text: `CFTC ${positions === "combined" ? `${cotPositionsText(positions)} · ` : ""}${payload.asOf ?? "--"} · ${cotContractUnitText(payload.contract?.contractUnits) ?? "contracts"}${data?.priceAsOf ? ` · ${data.priceSymbol} ${data.priceAsOf}` : ""}`, tone: "muted" }] }] : [] });
   return <PaneStatusBody loading={resource.loading && !data} error={!data ? resource.error : null} empty={!!payload && !payload.contract} subject="COT contract">
     {payload && data ? <DataTableView columns={POSITION_COLUMNS} items={payload.positions} focused={focused} rootWidth={width} rootHeight={height}
       rootBefore={<ChartTableHeader width={width} height={height} tableRows={payload.positions.length} chart={chart}

package/src/plugins/builtin/credit-boards/client.ts

@@ -5,7 +5,9 @@ import type {
   SovrBoardPayload,
 } from "../../../api-client/credit-boards";
 import { createPluginCache } from "../../../data/plugin-cache";
+import { createTtlCache } from "../../../data/ttl-cache";
 import type { PricePoint } from "../../../types/financials";
+import { logFailure } from "../../../utils/log-failure";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { currencyMoveFromHistory, currencyPair } from "./model";
 
@@ -84,18 +86,12 @@ export type PriceHistoryLoader = (symbol: string) => Promise<PricePoint[]>;
 const FX_HISTORY_TTL_MS = 30 * 60_000;
 /** Twenty-odd currencies at once; a few requests at a time keep the feed from refusing them. */
 const FX_HISTORY_CONCURRENCY = 4;
-const fxMoves = new Map<string, { at: number; move: Promise<number | null> }>();
+const fxMoves = createTtlCache<number | null>({ ttlMs: FX_HISTORY_TTL_MS });
 
+/** A load that fails reads as unknown for everyone waiting on it and is asked again next time, never remembered as unknown. */
 function currencyMove(symbol: string, dollarsPerUnit: boolean, loadHistory: PriceHistoryLoader): Promise<number | null> {
-  const cached = fxMoves.get(symbol);
-  if (cached && Date.now() - cached.at <= FX_HISTORY_TTL_MS) return cached.move;
-  const move = loadHistory(symbol).then((history) => currencyMoveFromHistory(history, dollarsPerUnit));
-  fxMoves.set(symbol, { at: Date.now(), move });
-  // A failed load is retried next time rather than remembered as unknown.
-  return move.catch(() => {
-    fxMoves.delete(symbol);
-    return null;
-  });
+  return fxMoves.load(symbol, async () => currencyMoveFromHistory(await loadHistory(symbol), dollarsPerUnit))
+    .catch(logFailure("credit-boards", "Read a currency's price history failed", null));
 }
 
 /**

package/src/plugins/builtin/credit-conditions/headless.ts

@@ -7,7 +7,7 @@ import {
   type CreditConditionsLoadResult,
   type CreditSeriesLoader,
 } from "./client";
-import { creditRegion, creditSeriesIn } from "./model";
+import { creditRegion, creditSeriesIn, type CreditConditionRow } from "./model";
 
 const COLUMNS = [
   { key: "label", header: "Index" },
@@ -22,6 +22,11 @@ const COLUMNS = [
   { key: "date", header: "As of" },
 ];
 
+/** What the publisher caps the indexes' history at, said once for the report. */
+function historyLimits(rows: readonly CreditConditionRow[]): string[] {
+  return [...new Set(rows.flatMap((row) => row.historyLimit ? [row.historyLimit] : []))];
+}
+
 interface CreditConditionsHeadlessDependencies {
   load(args: HeadlessPaneLoadArgs, loader: CreditSeriesLoader): Promise<CreditConditionsLoadResult>;
 }
@@ -57,7 +62,8 @@ function createCreditConditionsHeadless(
       );
       return {
         // The year of history feeds the pane's chart and rank, not the report rows.
-        rows: result.rows.map(({ history: _history, ...row }) => row),
+        rows: result.rows.map(({ history: _history, historyLimit: _historyLimit, ...row }) => row),
+        notes: historyLimits(result.rows),
         errors: result.errors,
         metadata: { stale: result.stale },
       };

package/src/plugins/builtin/credit-conditions/index.tsx

@@ -110,10 +110,14 @@ export function CreditConditionsPane({ paneId, focused, width, height }: PanePro
   const partial = rows.length > 0 && rows.length < series.length;
   // Each row carries its own date in the AS OF column; a spread between
   // indexes from different sessions is a limitation behind the warning.
+  const historyLimits = useMemo(() => [...new Set(rows.flatMap((row) => row.historyLimit ? [row.historyLimit] : []))], [rows]);
   usePaneNoticeFooter({
     registrationId: "credit-conditions:notices",
     focused,
-    notices: mixedDates ? ["The indexes carry different observation dates, so the spreads are not one session."] : [],
+    notices: [
+      ...mixedDates ? ["The indexes carry different observation dates, so the spreads are not one session."] : [],
+      ...historyLimits,
+    ],
   });
   const footerInfo = useMemo<PaneFooterSegment[]>(() => [
     ...(rows.length > 0 ? [DELAYED_SEGMENT] : []),

package/src/plugins/builtin/credit-conditions/model.ts

@@ -1,5 +1,6 @@
 import type { CloudFredSeriesPayload } from "../../../api-client";
 import { historyStatistics } from "../../../components/chart/curve/model";
+import { fredHistoryLimitNotice } from "../../../time-series/economic";
 import { ICE_SPREAD_SERIES, type IceCreditSeries } from "../../../time-series/ice-credit";
 
 export type CreditSeriesDefinition = Pick<IceCreditSeries, "seriesId" | "label" | "region">;
@@ -30,6 +31,8 @@ export interface CreditConditionRow {
   dailyChangeBp: number | null;
   date: string;
   stale: boolean;
+  /** The publisher's cap on how far back the series goes, when FRED states one. */
+  historyLimit: string | null;
   /** Observations in the year to `date`, in basis points, oldest first. */
   history: Array<{ date: string; valueBp: number }>;
   /** Midrank of the latest spread within that year. */
@@ -85,6 +88,7 @@ export function normalizeCreditSeries(
     dailyChangeBp: previous ? roundTenth((latest.value - previous.value) * 100) : null,
     date: latest.date,
     stale,
+    historyLimit: fredHistoryLimitNotice(definition.seriesId, info),
     history,
     // One observation ranks nothing.
     percentile1Y: year.count >= 2 ? year.percentile : null,