@gloom-sh/terminal 0.18.5 → 0.19.0

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,

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

@@ -1,6 +1,6 @@
 import { fredSeriesUrl } from "../../../sources/gloomberb-cloud/fred-series";
 import type { SeriesDefinition } from "../../../series/types";
-import { ICE_CREDIT_SERIES } from "../../../time-series/ice-credit";
+import { ICE_CREDIT_SERIES, ICE_HISTORY_LIMIT_NOTICE } from "../../../time-series/ice-credit";
 
 /** Corporate bond option-adjusted spreads by rating and region, and the effective yields of the US indexes. */
 export const CREDIT_SPREAD_SERIES: readonly SeriesDefinition[] = ICE_CREDIT_SERIES.map((series) => ({
@@ -11,6 +11,8 @@ export const CREDIT_SPREAD_SERIES: readonly SeriesDefinition[] = ICE_CREDIT_SERI
   group: "Credit",
   tags: [series.measure, ...series.tags, "corporate bonds"],
   publisher: "FRED",
+  // A fixed note on every ICE series. G and CRD read the same sentence from each series' FRED notes instead, so there it lapses if FRED lifts the limit.
+  limitation: ICE_HISTORY_LIMIT_NOTICE,
   url: fredSeriesUrl(series.seriesId),
   expression: `FRED:${series.seriesId}`,
 }));

package/src/plugins/builtin/credit-documents/detail.tsx

@@ -6,7 +6,7 @@ import { useThemeColors } from "../../../theme/theme-context";
 import { Box, Text, TextAttributes, useRendererHost, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
 import { quoteBlockStyle } from "../../../components/ui/quote";
 import { fetchCreditInstrument } from "./client";
-import { comparatorSymbol, covenantNumber, covenantTerms, creditPercent, factColumns, factValue, fieldLabel, hasAmendments, headroomTone, NO_VALUE, sentence, structuredFields } from "./model";
+import { comparatorSymbol, covenantNumber, covenantReason, covenantTerms, creditPercent, factColumns, factValue, fieldLabel, hasAmendments, headroomTone, NO_VALUE, sentence, structuredFields } from "./model";
 
 const LABEL_WIDTH = 16;
 const MATCH = { exact: "Exact", whitespace: "Whitespace normalized", nfkc_whitespace: "Unicode and whitespace normalized" } as Record<string, string>;
@@ -83,7 +83,7 @@ export function CreditInstrumentDetail({ symbol, instrument, width, height, focu
   const columns = useMemo(() => factColumns(view, width), [view, width]);
   const query = <QueryBar width={width} view={{ value: view, options: [{ value: "terms", label: "Current terms" }, { value: "history", label: "Amendment history" }], onChange: (value) => { setView(value); setOpen(null); } }} />;
   // Why headroom is missing stays beside the figures it explains.
-  const reason = covenant?.reason && covenant.status !== "compliant" && covenant.status !== "breach" ? covenant.reason : null;
+  const reason = covenant ? covenantReason(covenant, data.facts) : null;
   const header = covenant ? <Box flexDirection="column">
     <ChartTableHeader width={width} height={height - (reason ? 2 : 0)} tableRows={rows.length} tableColumns={columns} query={query} figures={covenantFigures(covenant, data.facts.find((fact) => fact.id === covenant.id))} />
     {reason ? <Box paddingX={1} width={width}><Notice tone="muted">{reason}</Notice></Box> : null}